java使用泛型为不同类型数组排序
之前想用Java写一个能够给不同数据类型排序的功能，于是我想到了C++中的泛型，Java同样也具有泛型的特性。
但是，后来我发现在java中实现这个功能那个并不像c++中这么简单，java的泛型和c++还是有比较大的区别的。
我遇到的最主要的一点问题就是：
c++模板在编译时就会知道传入类型参数的类型是什么，从而可以很方便地限定传入参数类型，并可以在模板中使用传入类型的特有功能。
而java因为某些原因并不会这么做，这就意味着java无法在泛型函数（类）中像c++那样使用传入类型的特有功能。
这是让我非常头疼的一点，因为我刚开始并不知道除了这种做法以外还可以怎么实现这样的功能。这也是因为我对java的了解不深导致的。
后来我通过查看Arrays.sort函数的源代码学习到了在java中实现为不同类型数组排序的功能的方式。
原来，可以在泛型函数中将T转换为Comparable接口类型，然后再用Comparable类型引用调用，已经在数组元素类型中实现过的compareTo函数来比较两个T类型的对象中基本类型成员变量的大小。
默认排序规则排序代码如下：
import java.util.Arrays;
import java.util.Comparator;
//排序类
class MySort
{
private MySort() {}
private static <T> void swap (final T arr[], final int i, final int j)
{
final T temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//默认排序算法函数
private static <T> void pSort(final T[] arr, final int left, final int right) {
if (left >= right) return;
int i = left, j = right;
final T base = arr[i];
final Comparable<T> tempComparObj = (Comparable<T>) base; // 临时比较对象
while (i < j) {
while (i < j && tempComparObj.compareTo(arr[j]) < 0) j--; //<0、>=0是为了把int转换为bool
while (i < j && tempComparObj.compareTo(arr[i]) >= 0) i++;
if (i >= j) continue;
swap(arr, i, j);
}
arr[left] = arr[i];
arr[i] = base;
pSort(arr, left, i - 1);
pSort(arr, i + 1, right);
}
// 默认规则排序调用函数
public static <T> void quickSort(final T[] arr)
{
assert arr != null;
// 数组长度为0和1时不用排序
if (arr.length < 2) return;
pSort(arr, 0, arr.length - 1); //默认排序规则函数
}
｝
// 主类
public class My {
public static void main(final String[] args)
//数组定义
final Integer arr[] = new Integer[] { 12, 14, 56, 9, 26, 26, 78, 42, 10 };
//调用默认规则排序函数
MySort.quickSort(arr);
//打印排序后的数组
for(final Integer value : arr)
System.out.print(value + " ");
}
}以上代码是对存储Integer类型元素的数组进行的排序。
因为在Integer类中已经实现了Comparable中的compareTo方法，所以这里可以直接在泛型方法中将T类型对象转换为Comparable类型对象，从而通过Comparable类型引用调用compareTo方法，从而实现对对T类型的方法的基本类型成员进行比较，从而将传入数组进行排序。
另外我们知道在标准库中sort还有这另一种重要的重载形式，自定义排序规则排序。可以通过向sort中传入第二个参数，来指定排序时的规则。
在实现这个功能时，java同样不能采取和c++一样的方式实现，因为java并不支持函数指针和在编译时确定泛型参数类型。
但在java同样的可以通过实现接口来实现这个功能。相关代码如下：
import java.util.Arrays;
import java.util.Comparator;
class MySort
{
private MySort() {}
private static <T> void swap (final T arr[], final int i, final int j)
{
final T temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//自定义排序规则算法函数
private static <T> void pSort(final T[] arr, final int left, final int right, final Comparator<T> c) {
if (left >= right) return;
int i = left, j = right;
final T base = arr[i];
while (i < j) {
while (i < j && c.compare(base, arr[j]) < 0) j--; //使用传入的排序规则
while (i < j && c.compare(base, arr[i]) >= 0) i++;
if (i >= j) continue;
swap(arr, i, j);
}
arr[left] = arr[i];
arr[i] = base;
pSort(arr, left, i - 1, c);
pSort(arr, i + 1, right, c);
}
// 自定义规则排序调用函数
public static <T> void quickSort(final T[] arr, final Comparator<T> comper) {
assert arr != null;
if (arr.length < 2) return;
if (comper == null) quickSort(arr);
pSort(arr, 0, arr.length - 1, comper); //自定义排序规则函数
}
}
// 主类
public class My {
public static void main(final String[] args) {
// 数组定义
final Integer arr[] = new Integer[] { 12, 14, 56, 9, 26, 26, 78, 42, 10 };
//lambda调用自定义规则排序函数
MySort.quickSort(arr, (Integer num1, Integer num2) -> {
return num1 < num2 ? -1 : 0;
});
/*
//匿名内部类调用自定义排序规则函数
MySort.quickSort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer num1, Integer num2) {
return num1 < num2 ? -1 : 0;
}
});
*/
//输出
for(final Integer value : arr)
System.out.print(value + " ");
}
}自定义排序规则函数的第二个参数接收一个实现过Comparator接口方法的子类对象，在排序函数中就可以通过Comparator类型引用和接收到对象调用其compare方法，从而对两个T类型对象的基本类型成员进行比较。
因为Comparator是一个泛型接口，在确定了Comparator中T的类型后，接口中的泛型函数的T的参数类型也就被确定类的T的类型，所以就可以直接向compare中传入和Comparator的T相同的类型的参数，又因为排序函数的形参Comparator的引用指向的对象是在一开始调用sort的时候就传入实现过compare方法的，所以在调用的时候就会再调用我们传入的对象的compare方法。
这样就实现了自定义排序规则给不同类型数组排序。
另外说一下，这里向MySort.quickSort中传入第二个指定排序规则参数的时候，有三种方式可以把实现过Comparator接口的类的对象当做参数传递进去，分别是手动写一个类实现接口后实例化对象传入、匿名内部类传入以及lambda表达式传入。
这三种方式的简洁程度依次递增，但易理解程度是依次递减。
这里在用lambda表达式传入时，我不是很理解编译器是如何判断出我传入的表达式是实现的compare方法，而不是Comparator接口的其他方法。如果有懂这一点的朋友看到了这里还请赐教。
以上的两个例子都是对Integer包装器类型数组进行的排序，但很显然这两个sort函数也可以对其他类型包括我们自己定义的类的类型的对象数组进行排序。
如下：
//自定义学生类
class Student implements Comparable<Student>
{
public int age;
Student(final int age)
{
this.age = age;
}
//重写Comparable比较函数
@Override
public int compareTo(Student o)
{
return age > o.age ? -1 : 0;
}
}
// 主类
public class My {
public static void main(final String[] args) {
Student[] sArr = new Student[10];
for(int i = 0; i < sArr.length; i++)
sArr[i] = new Student(i + 10);
for(final Student stude : sArr) //输出学生信息
System.out.print(stude.age + " ");
//将学生按年龄默认规则排序
// MySort.quickSort(sArr);
//将学生按年龄自定义规则排序
MySort.quickSort(sArr, (Student s1, Student s2) -> {
return s1.age > s2.age ? -1 : 0;
});
System.out.println();
for(final Student stude : sArr) //输出学生信息
System.out.print(stude.age + " ");
}
}运行结果如下：
因为在Student 中实现了Comparable接口的compareTo方法，所以无论是只传入一个数组的默认排序函数还是指定规则的排序函数，都可以对这个存储自定义类型元素的数组进行排序。只是这两种排序的规则实际上都是我们手动指定的。
完整测试和功能代码如下：
import java.util.Arrays;
import java.util.Comparator;
class MySort
{
private MySort() {}
private static <T> void swap (final T arr[], final int i, final int j)
{
final T temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//默认排序算法函数
private static <T> void pSort(final T[] arr, final int left, final int right) {
if (left >= right) return;
int i = left, j = right;
final T base = arr[i];
final Comparable<T> tempComparObj = (Comparable<T>) base; // 临时比较对象
while (i < j) {
while (i < j && tempComparObj.compareTo(arr[j]) < 0) j--; //<0、>=0是为了把int转换为bool
while (i < j && tempComparObj.compareTo(arr[i]) >= 0) i++;
if (i >= j) continue;
swap(arr, i, j);
}
arr[left] = arr[i];
arr[i] = base;
pSort(arr, left, i - 1);
pSort(arr, i + 1, right);
}
//自定义排序规则算法函数
private static <T> void pSort(final T[] arr, final int left, final int right, final Comparator<T> c) {
if (left >= right) return;
int i = left, j = right;
final T base = arr[i];
while (i < j) {
while (i < j && c.compare(base, arr[j]) < 0) j--; //使用传入的排序规则
while (i < j && c.compare(base, arr[i]) >= 0) i++;
if (i >= j) continue;
swap(arr, i, j);
}
arr[left] = arr[i];
arr[i] = base;
pSort(arr, left, i - 1, c);
pSort(arr, i + 1, right, c);
}
// 默认规则排序调用函数
public static <T> void quickSort(final T[] arr)
{
// 断言，表达式为 抛出AssertionError异常，并终止执行
assert arr != null;
// 数组长度为0和1时不用排序
if (arr.length < 2) return;
pSort(arr, 0, arr.length - 1); //默认排序规则函数
}
// 自定义规则排序调用函数
public static <T> void quickSort(final T[] arr, final Comparator<T> comper) {
assert arr != null;
if (arr.length < 2) return;
if (comper == null) quickSort(arr);
pSort(arr, 0, arr.length - 1, comper); //自定义排序规则函数
}
}
//自定义学生类
class Student implements Comparable<Student>
{
public int age;
Student(final int age)
{
this.age = age;
}
//重写Comparable比较函数
@Override
public int compareTo(Student o)
{
return age > o.age ? -1 : 0;
}
}
// 主类
public class My {
public static void main(final String[] args) {
// 数组定义
// final Integer arr[] = new Integer[] { 12, 14, 56, 9, 26, 26, 78, 42, 10 };
// arr[0].compareTo(anotherInteger)
// final Double arr[] = new Double[] { 12.0, 14.0, 56.0, 9.0, 26.0, 26.0, 78.0, 42.0, 10.0 };
Student[] sArr = new Student[10];
for(int i = 0; i < sArr.length; i++)
sArr[i] = new Student(i + 10);
for(final Student stude : sArr) //输出学生信息
System.out.print(stude.age + " ");
//将学生按年龄默认规则排序
// MySort.quickSort(sArr);
//将学生按年龄自定义规则排序
MySort.quickSort(sArr, (Student s1, Student s2) -> {
return s1.age > s2.age ? -1 : 0;
});
System.out.println();
for(final Student stude : sArr) //输出学生信息
System.out.print(stude.age + " ");
/*
// 输出
for (final Integer value : arr)
System.out.print(value + " ");
//调用默认规则排序函数
// MySort.quickSort(arr);
//lambda调用自定义规则排序函数
MySort.quickSort(arr, (Integer num1, Integer num2) -> {
return num1 < num2 ? -1 : 0;
});
//匿名内部类调用自定义排序规则函数
MySort.quickSort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer num1, Integer num2) {
return num1 < num2 ? -1 : 0;
}
});
//lambda调用标准库排序函数
Arrays.sort(arr, (Integer num1, Integer num2) -> {
return num1 < num2 ? -1 : 0;
});
//匿名内部类调用标准库排序函数
Arrays.sort(arr, new Comparator() {
@Override
public int compare(final Object o1, final Object o2) {
final Integer num1 = (Integer) o1, num2 = (Integer) o2;
return num1 < num2 ? -1 : 0;
}
});
//输出
System.out.println();
for(final Integer value : arr) System.out.print(value + " ");
*/
}
}文章中可能会存在一些描述不准确的地方，欢迎指出，感谢支持。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
