Java的泛型编程

泛型编程

Java的泛型编程：
1.所写的代码可以处理任何的类型
2.Java1~Java4时期Java并不支持泛型编程 ————直到Java5开始才支持泛型编程

泛型编程的本质意义：
1.能够检测参数的类型是否正确，合法
2.自动类型转换，避免用户手动类型转换

Java泛型的类型擦除机制
在编译阶段，Java编译器通过泛型类型进行类型检查和自动类型转换，处理完成后，就会把T类型一直往上擦除，直到上届（Object）

实例1：

public class GenericTest<T> {
    // 定义数组
    private T[] array;
    // 定义有效元素的大小
    private int size;

    public GenericTest(int size){
        this.array = (T[])new Object[size];
        this.size = 0;
    }

    public GenericTest(){
        this(10);
    }

    public void add(T data){
        if(this.size == this.array.length){
            this.array = Arrays.copyOf(this.array, this.array.length*2);
        }
        this.array[this.size++] = data;
    }

    public T get(){
        if(this.size == 0){
            return null;
        }
        return this.array[this.size-1];
    }

    public static void main(String[] args) {
     GenericTest<Integer> test = new GenericTest<Integer>();
        test.add(10);
        test.add(30); // Java的泛型可以进行类型的检查
        System.out.println(test);

        int data = test.get(); // Java的泛型可以做类型自动转换
        System.out.println(data);
    }
    }

实例2：

描述: 输出一个泛型的顺序栈实现 构造函数，入栈push，出栈pop，获取栈顶元素peek栈空empty，栈满full

public class GenericStack<T> {
    // 定义存储顺序栈元素的数组
    private T[] stack;
    // 标识栈顶位置的下标
    private int top;

    /**
     * 按传入的参数size初始化数组大小
     *
     * @param size
     */
    public GenericStack(int size) {
        this.stack = (T[]) new Object[size];
        this.top = -1;
    }

    public GenericStack() {
        this(10);
    }

    /**
     * 入栈操作
     *
     * @param val
     */
    public void push(T val) {
        if (full()) {
            this.stack = Arrays.copyOf(this.stack, this.stack.length * 2);
        }
        this.stack[++this.top] = val;
    }

    /**
     * 出栈操作，并返回出栈的元素
     *
     * @return
     */
    public T pop() {
        if (empty()) {
            return null;
        }
        T oldVal = this.stack[this.top];
        this.stack[this.top] = null; // GC能够回收出栈的对象！！！
        --this.top;
        return oldVal;
    }

    /**
     * 查看栈顶元素
     *
     * @return
     */
    public T peek() {
        if (empty()) {
            return null;
        }
        return this.stack[this.top];
    }

    /**
     * 返回栈元素的个数
     *
     * @return
     */
    public int size() {
        return this.top + 1;
    }

    /**
     * 判断栈满
     *
     * @return
     */
    public boolean full() {
        return this.top == this.stack.length - 1;
    }

    /**
     * 判断栈空
     *
     * @return
     */
    public boolean empty() {
        return this.top == -1;
    }

在泛型顺序栈中定义一个class类Student定义一个学生类，提供相应的构造函数重写toString方法 id,name,age信息打印出来成员变量提供get和set的标准方法

class Student implements Comparable<Student> {
    private Integer id;
    private String name;
    private Integer age;

    public Student(Integer id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        return  this.name.compareTo(o.name);
    }
}

通过Comparator接口实现学生信息的不同顺序输出

public static void main(String[] args) throws InterruptedException {
        GenericStack<Student> s = new GenericStack<>();
        s.push(new Student(1000, "zhang san", 26));
        s.push(new Student(3030, "liu bai", 28));
        s.push(new Student(2020, "du fu", 25));

        Student[] stus = new Student[s.size()];
        for (int i = 0; !s.empty(); ++i) {
            stus[i] = s.pop();
        }

        Arrays.sort(stus);
        System.out.println(Arrays.toString(stus));

      Arrays.sort(stus, (a, b)->{return a.getName().compareTo(b.getName());}); // Comparator接口
        System.out.println(Arrays.toString(stus));
        Arrays.sort(stus, (a, b)->{return -a.getAge().compareTo(b.getAge());}); // Comparator接口 int compare(T a, T b)
        System.out.println(Arrays.toString(stus));
        Arrays.sort(stus, (a, b)->{return -a.getId().compareTo(b.getId());}); // Comparator接口 int compare(T a, T b)
        System.out.println(Arrays.toString(stus));
    }