如何在java中使用泛型方法对每个类型数组进行排序？

当我编译代码时，它显示E不能转换为int

public static <E> void sort(E[] ar){
    int swap;

    for (int i = 0; i < ar.length; i++) {
        for (int j = i; j < ar.length - 1; j++) {
            if (ar[j].compareTo(ar[j + 1])) {
                swap = ar[j];
                ar[j] = ar[j + 1];
                ar[j + 1] = swap;
            }
        }
    }
}

---

Java中的数组是：它们是协变的

这意味着您可以编写一个对数字对象数组进行排序的方法。此方法适用于所有类型的数字对象，包括整数、长

因此：使用泛型无法轻松解决此问题，但使用Number[]作为该方法参数的类型可以很好地解决此问题

当然，交换必须是数字类型

---

当您坚持使用泛型时，您应该将重点放在使用集合类（如ArrayList/List）而不是数组上，然后使用？将数字扩展为泛型类型

Java中的数组是：它们是协变的

这意味着您可以编写一个对数字对象数组进行排序的方法。此方法适用于所有类型的数字对象，包括整数、长

因此：使用泛型无法轻松解决此问题，但使用Number[]作为该方法参数的类型可以很好地解决此问题

当然，交换必须是数字类型

---

当您坚持使用泛型时，您应该将重点放在使用集合类（如ArrayList/List）而不是数组上，然后使用？将数字扩展为泛型类型

首先，编译错误来自交换变量的类型。在线交换=ar[j]；，您试图将E类型的值放入int类型的变量中。这是一个类型错误。要解决此问题，您需要通过以下操作更改交换变量的类型：

E swap;

现在，如果要对泛型类型的对象进行排序，需要知道如何比较它们。在Java中，有两种方法可以做到这一点。要么该类型必须实现Comparable接口，要么需要将Comparator类型的对象作为参数。使用比较器更灵活，因为它使调用者能够轻松地以多种方式对同一类型进行排序，例如按时间顺序和反向时间顺序

要使代码使用可比较的类型，需要在类型参数上放置类型约束。像这样：

public static <E extends Comparable<E>> void sort(E[] ar){
    E swap;

    for (int i = 0; i < ar.length; i++) {
        for (int j = i; j < ar.length - 1; j++) {
            // Now you can use compareTo because E is a Comparable.
            // Also note the "< 0" because compareTo returns an int.
            if (ar[j].compareTo(ar[j + 1]) < 0) {
                swap = ar[j];
                ar[j] = ar[j + 1];
                ar[j + 1] = swap;
            }
        }
    }
}

您可以通过如下方式创建比较器来调用函数：

// Sorting integers in ascending order.
sort(intArr, Comparator.naturalOrder());

// Sorting persons in descending order by age.
sort(personArr, Comparator.comparing(Person::getAge).reversed());

---

注意：您的代码实际上还没有对任何内容进行排序，因为您的算法是错误的。这留给您来解决：

首先，您的编译错误来自交换变量的类型。在线交换=ar[j]；，您试图将E类型的值放入int类型的变量中。这是一个类型错误。要解决此问题，您需要通过以下操作更改交换变量的类型：

E swap;

现在，如果要对泛型类型的对象进行排序，需要知道如何比较它们。在Java中，有两种方法可以做到这一点。要么该类型必须实现Comparable接口，要么需要将Comparator类型的对象作为参数。使用比较器更灵活，因为它使调用者能够轻松地以多种方式对同一类型进行排序，例如按时间顺序和反向时间顺序

要使代码使用可比较的类型，需要在类型参数上放置类型约束。像这样：

public static <E extends Comparable<E>> void sort(E[] ar){
    E swap;

    for (int i = 0; i < ar.length; i++) {
        for (int j = i; j < ar.length - 1; j++) {
            // Now you can use compareTo because E is a Comparable.
            // Also note the "< 0" because compareTo returns an int.
            if (ar[j].compareTo(ar[j + 1]) < 0) {
                swap = ar[j];
                ar[j] = ar[j + 1];
                ar[j + 1] = swap;
            }
        }
    }
}

您可以通过如下方式创建比较器来调用函数：

// Sorting integers in ascending order.
sort(intArr, Comparator.naturalOrder());

// Sorting persons in descending order by age.
sort(personArr, Comparator.comparing(Person::getAge).reversed());

---

注意：您的代码实际上还没有对任何内容进行排序，因为您的算法是错误的。这留给您来解决：

Java通过名为Array的实用程序类在其标准库中提供了这样的方法。它有许多名为sort的重载方法，可以处理大多数广泛使用的数据类型。您可能需要检查API

e、 g

对于没有直接方法的对象或数据类型，将提供泛型方法

公共静态无效并行SORTT[]a，比较器cmp 您所需要做的只是提供一个比较器的实现。检查一下这个样品

public class Sample{
    public String name;
    public int age;
    public Sample(String name, int age){
        this.name = name;
        this.age = age;
    }
    public String toString(){
        return String.format("Name: %s, Age: %s", name, age);
    }
}

public class Demo{
    public static void main(String[] args){
        Sample[] samples = Arrays.asList(new Sample("Sam", 23),
                                             new Sample("Hans", 13),
                                             new Sample("Ben", 53)
                                            ).toArray(new Sample[3]);

        Arrays.sort(samples, (a, b) -> a.age - b.age);
        Arrays.stream(samples).forEach(System.out :: println);
    }
}

---

Java通过名为Array的实用程序类在其标准库中提供了这样一种方法。它有许多名为sort的重载方法，可以处理大多数广泛使用的数据类型。您可能需要检查API

e、 g

对于没有直接方法的对象或数据类型，将提供泛型方法

公共静态无效并行SORTT[]a，比较器cmp 您所需要做的只是提供一个比较器的实现。检查一下这个样品

public class Sample{
    public String name;
    public int age;
    public Sample(String name, int age){
        this.name = name;
        this.age = age;
    }
    public String toString(){
        return String.format("Name: %s, Age: %s", name, age);
    }
}

public class Demo{
    public static void main(String[] args){
        Sample[] samples = Arrays.asList(new Sample("Sam", 23),
                                             new Sample("Hans", 13),
                                             new Sample("Ben", 53)
                                            ).toArray(new Sample[3]);

        Arrays.sort(samples, (a, b) -> a.age - b.age);
        Arrays.stream(samples).forEach(System.out :: println);
    }
}

---

嗯，E不是int。你期望什么？我猜可能是，因为int是一种原始数据类型，而不是一个类。不，我声明如下整数[]数=新整数[]{2,3,1,23,5}；我想将所有这些类型传递到这个printary函数中，以便对Integer[]number=newinteger[]{3,4,1,10,5,20}进行排序；Double[]dnumber=新的Double[]{9.2,1.2,3.4,6.7}；字符串[]str=新字符串[]{usama、tayyab、arsalan、awais}；将交换类型从int更改为EWell，E不是int。您期望什么？我想可能是这样，因为int是一种基本数据类型，而不是类。不，我声明如下整数[]number=new I

---

nteger[]{2,3,1,23,5}；我想将所有这些类型传递到这个printary函数中，以便对Integer[]number=newinteger[]{3,4,1,10,5,20}进行排序；Double[]dnumber=新的Double[]{9.2,1.2,3.4,6.7}；字符串[]str=新字符串[]{usama、tayyab、arsalan、awais}；将交换类型从int更改为E