如何在java中对数组类型列表进行排序？

正如我的问题所描述的，如何在java中对类型数组列表进行排序

这是我的班级

package AlgorithmAndDataStructures;
public class ListClass<T>{
    private static final int MAX_SIZE_OF_LIST = 100;
    /**
     * This class is having definitions for:-
     * Generic List Class Variables
     * Constructor for Creating Class Objects
     * Method: Adding a Element to the End of List
     * Method: Adding a Element at anywhere/ particular place
     * Method: Checking List is full or not.
     * Method: Checking List is Empty or Not.
     * Method: Displaying All Elements of List
     * Method: Making New Space for new element addition.
     * Method: Sorting a List
     */

    // Declaring Array and Variables
    private T[] listArray;
    private int totalElements;

    // Constructor For ListClass
    @SuppressWarnings("unchecked")
    public ListClass(int listSize) { // entered by the user on runtime
        totalElements = 0;
        listArray = (T[]) new Object[listSize];
    }

    // Method For Adding an Element
    public boolean addElement(T newElement)
    {
        boolean isElementAdded = true;
        if(!isListFull()) {
            listArray[totalElements] = newElement;
            totalElements++;
        }
        else
            System.out.println("Sorry, the list is full so, new element can not      be added.");
            isElementAdded = false;
        return isElementAdded;
    }

    // length = totalElements
    // Method for Adding/Inserting Element in any Particular Place
    public boolean addSpecific(int newLocation, T newElement) {
        boolean elementAdded = true;
        if (!isListFull() && (newLocation >= 1) && (newLocation <= totalElements +1) )
        {
            newSpace(newLocation);
            listArray[newLocation -1] = newElement;
            totalElements++;
            }
        else {
            elementAdded = false;
        }
        return elementAdded;
    }

    // Method for Displaying The List Elements
        public void displayListElement() {
            if(isListEmpty())
            {
                System.out.println("Sorry, there is no element in the List!");
            }
            else 
            {
            for(int elements = 0; elements < totalElements; elements++  ) {
                System.out.println((listArray[elements]));
            }
            System.out.println("All elements has been displayed!");

            }
        }

    // Method for Checking if List is Empty or Number of elements = 0
    public boolean isListEmpty() {
        return totalElements == 0;
    }
    // Method for Checking is List is full or not. 
    public boolean isListFull() 
    {
        return totalElements == MAX_SIZE_OF_LIST;
    }

    private void newSpace( int newLocation)
    {
        // assert is a method predefined; indicator for index number
    assert (newLocation >=1) && (newLocation <= totalElements +1);
    int newIndicator = newLocation -1;
    int lastIndicator = totalElements -1;
    /**
     * For Shifting Elements to Next Indexes
     */
    for ( int sign = lastIndicator; sign >= newIndicator; sign--)
    listArray[sign +1] = listArray[sign];
    }


}

包算法结构；
公共类列表类{
私有静态最终整数最大大小列表=100；
/**
*此类具有以下定义：-
*泛型列表类变量
*用于创建类对象的构造函数
*方法：将元素添加到列表末尾
*方法：在任意位置/特定位置添加元素
*方法：检查列表是否已满。
*方法：检查列表是否为空。
*方法：显示列表的所有元素
*方法：为新元素添加留出新空间。
*方法：对列表进行排序
*/
//声明数组和变量
私有T[]列表数组；
私有元素；
//ListClass的构造函数
@抑制警告（“未选中”）
公共ListClass（int listSize）{//由用户在运行时输入
总元素=0；
listArray=（T[]）新对象[listSize]；
}
//添加元素的方法
公共布尔加法元素（T新元素）
{
布尔值isElementAdded=true；
如果（！isListFull（））{
listArray[totalElements]=新元素；
totalElements++；
}
其他的
System.out.println（“对不起，列表已满，无法添加新元素”）；
isElementAdded=假；
返回已实现；
}
//长度=总元素
//在任何特定位置添加/插入元素的方法
公共布尔addSpecific（int newLocation，T newElement）{
布尔元素added=true；
如果（！isListFull（）&&&（newLocation>=1）&&&（newLocation=1）&&（newLocation=newIndicator；符号--）
listArray[sign+1]=listArray[sign]；
}
}

这是我的驾驶员程序

package AlgorithmAndDataStructures;

public class DriverListClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ListClass<Integer> listObjectInt = new ListClass<Integer>(10);
        listObjectInt.addElement(12);
        listObjectInt.addElement(17);
        listObjectInt.addElement(90);
        listObjectInt.addElement(53);
        listObjectInt.addSpecific(3, 56);
        listObjectInt.displayListElement();


        // String List
        ListClass<String> listObjectStr = new ListClass<String>(4);
        listObjectStr.addElement("Suman");
        listObjectStr.addElement("Armaan");
        listObjectStr.addElement("Atif");
        listObjectStr.addElement("Tauseef");
        listObjectStr.displayListElement();
    }

}

包算法结构；
公共类DriverListClass{
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
ListClass ListObjectent=新的ListClass（10）；
ListObjective.addElement（12）；
ListObjective.附录（17）；
ListObjective.addElement（90）；
ListObjective.附录（53）；
addSpecific（3,56）；
listObjectent.displayListElement（）；
//字符串列表
ListClass listObjectStr=新的ListClass（4）；
listObjectStr.addElement（“Suman”）；
listObjectStr.addElement（“ARMAN”）；
listObjectStr.addElement（“Atif”）；
listObjectStr.addElement（“Tauseef”）；
listObjectStr.displayListElement（）；
}
}

---

现在，我希望在ListClass中有一个通用排序方法，可以对任何类型的列表（字符串、整数、双精度、浮点等）进行排序通过驱动程序生成。

您需要为列表中的元素定义一种比较方法。这通常是通过使元素实现类似于

Compariable的接口来实现的：
公共类ListClass
向类中添加排序方法

public void sort() {
    Arrays.sort(listArray, 0, totalElements);
}

并将
class-ListClass
更改为
class-ListClass

如果您想按特定的比较器排序，请添加下面的方法

public void sort(Comparator<T> comparator) {
    Arrays.sort(listArray, 0, totalElements, comparator);
}

公共无效排序（比较器比较器）{
排序（listArray，0，totalElements，comparator）；
}
大多数可排序的元素实现了
Compariable
，您可以将内容强制转换到该类并调用
Comparieto
可能重复的…请在发布之前搜索。好的，我已经实现了与ListClass相当的功能，但是我如何为我的案例编写Comparieto方法。您可以我无法理解ive me，因为它适用于特定的字符串类型。根据对象a和b的顺序，如果ab，函数应返回-1。我已将其实现为接口。但是，我无法理解如何为泛型类型编写compareTo方法。Eclipse已经创建了此
@Override public int compareTo（to）{//TODO自动生成的方法存根返回0；
但它将如何对任何类型的元素进行排序？您需要为任何要排序的类型实现它。大多数类型没有自然的排序顺序，即使是字符串，排序顺序也很大程度上取决于语言。