泛型练习给任意对象数组排序

案例：

1. 声明泛型方法，可以给任意对象数组按照元素的自然排序实现从小到大排序，用冒泡排序实现

	@Test
    public void test01() {
        Integer[] arr1 = {1, 2,  8, 6, 14, 3, 64, 13};
        String[] arr2 = {"a", "u", "c", "x", "v"};
	    sort(arr1);
        sort(arr2);
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2));
    }
    //声明泛型方法，可以给任意对象数组按照元素的自然排序实现从小到大排序，用冒泡排序实现
    public <T extends Comparable<T>> void sort(T[] arr) {
        boolean flag = false;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 1; j < arr.length - i; j++) {
                if (arr[j - 1].compareTo(arr[j]) > 0) {
                    flag = true;
                    T temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
            if (flag == false) {
                return;
            } else {
                flag = false;
            }
        }
    }

2. 声明泛型方法，可以给任意对象数组按照指定的比较器实现从小到大排序，用冒泡排序实现

	@Test
    public void test02() {
        Integer[] arr1 = {1, 2,  8, 6, 14, 3, 64, 13};
        String[] arr2 = {"a", "u", "c", "x", "v"};
        sort(arr1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        sort(arr2, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2));
    }

    //声明泛型方法，可以给任意对象数组按照指定的比较器实现从小到大排序，用冒泡排序实现
    public <T> void sort(T[] arr, Comparator<T> comparator) {
        boolean flag = false;
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                if (comparator.compare(arr[j],arr[j+1])>0){
                    flag = true;
                    T temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            if (flag == false){
                return;
            }else {
                flag = false;
            }
        }
    }