泛型 JAVA语言程设计 第十九章（示例代码2）

程序小白，希望和大家多交流，共同学习

//使用泛型对一个数组进行排序
public class GenericSort
{
    public static void main(String[] args)
    {
        Integer[] intArray = {2, 4, 3};
        Double[] doubleArray = {.4, 1.3, -22.1};
        Character[] charArray = {'a', 'J', 'r'};
        String[] strArray = {"Tom", "Susan", "Kim"};

        sort(intArray);
        sort(doubleArray);
        sort(charArray);
        sort(strArray);

        System.out.println("Sorted Integer objects:");
        printList(intArray);
        System.out.println("Sorted Double objects: ");
        printList(doubleArray);
        System.out.println("Sorted Character objects: ");
        printList(charArray);
        System.out.println("Sorted String objects: ");
        printList(strArray);
    }

    //将继承Comparable类的数组进行排序
    public static<E extends Comparable<E>> void sort(E[] list)
    {
        E currentMin;
        int currentMinIndex;

        int length = list.length;
        for (int i = 0; i < length; i++)
        {
            currentMin = list[i];
            currentMinIndex = i;
            for (int j = i + 1; j < length; j++)
            {
                if (currentMin.compareTo(list[j]) > 0)
                {
                    currentMin = list[j];
                    currentMinIndex = j;
                }
            }

            if (currentMinIndex != i)
            {
                list[currentMinIndex] = list[i];
                list[i] = currentMin;
            }
        }
    }

    public static void printList(Object[] list)
    {
        int length = list.length;
        for (int i = 0; i < length; i++)
        {
            System.out.print(list[i] + " ");
        }
        System.out.println();
    }
}

//泛型方法，可以为静态方法定义静态类型
public class GeneircMethodDemo
{
    public static void main(String[] args)
    {
        Integer[] integers = {1, 2, 3, 4, 5};
        String[] strings = {"London", "Paris", "New York", "Austin"};

        print(integers);
        print(strings);
    }

    public static <E> void print(E[] list)
    {
        int length = list.length;
        for (int i = 0; i < length; i++)
        {
            System.out.print(list[i] + " ");
        }
        System.out.println();
    }
}

//原始类型
//没有指定类型的泛型类和泛型接口称为原始类型，用于和早期的java版本向后兼容
package CompareUseGeneric;

public class Max
{
    public static Comparable max(Comparable o1, Comparable o2)
    {
        if (o1.compareTo(o2) > 0)
        {
            return o1;
        }
        else
            return o2;
    }
}
//javac -Xlint:unchecked Max.java

package CompareUseGeneric;

public class MaxUsingGenericType
{
    public static <E extends Comparable<E>> E max(E o1, E o2)
    {
        if (o1.compareTo(o2) > 0)
        {
            return o1;
        }
        else
            return o2;
    }
}

package CompareUseGeneric;

public class TextMax
{
    public static void main(String[] args)
    {
        Max maxNoGeneric = new Max();
        MaxUsingGenericType maxUseGeneric = new MaxUsingGenericType();

        //maxNoGeneric.max("welcom", 12);
        //两个类型不相同，是不可比较的，但是在编译的时候没有报错，
        //因为两个都是Comparable的子类，这就使得程序安全性低

        maxUseGeneric.max("welcom", 12);
        //这个就会在编译的时候报错，也就是泛型的优点，在编译时而不是在运行时检测类型
    }
}