Java【初识数据结构】

public class Text {
    public static void main(String[] args) {
        int i = 10;
        Integer a = i; //自动的装箱
        Integer b = Integer.valueOf(20); // 显示的装箱
    }
}

2.2拆箱

public class Text {
    public static void main(String[] args) {
        Integer a = 100;
        int i = a; // 自动的拆箱
        int ii = a.intValue(); //显示的拆箱
    }
}

把包装类型转换为简单类型

3.面试题

public class Text {
    public static void main(String[] args) {
        Integer a = 100;
        Integer b = 100;
        System.out.println(a == b);
        Integer aa = 200;
        Integer bb = 200;
        System.out.println(aa == bb);
    }
}
//true
//false

i>=-128&&i<=127

四、泛型

1.什么是泛型

就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化

2.语法

class 泛型类的名称<类型形参列表> {

//~~~

}

//泛型类
//<T>表示当前类是一个泛型类
class MyArry<T> {
    public Object[] array = new Object[3];
    public void setArray(int pos,T val) {
        array[pos] = val;
    }
    public T getArray(int pos) {
        return (T)array[pos];
    }
}

public class Text {
    public static void main(String[] args) {
        MyArry<Integer> myArry1 = new MyArry<Integer>();
        myArry1.setArray(0,10);
        myArry1.setArray(1,20);//在编译时，自动进行类型检查
        Integer val = myArry1.getArray(0);//在编译时，自动进行类型转换
        System.out.println(val);
        
        MyArry<String> myArry2 = new MyArry<String>();
        myArry2.setArray(0,"hello");
        myArry2.setArray(1,"java");
        String str = myArry2.getArray(0);
    }
}

类名后的 <T> 代表占位符，表示当前类是一个泛型类，只能是一个引用类型

E 表示 Element

K 表示 Key

V 表示 Value

N 表示 Number

T 表示 Type

....

泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查

优点：数据类型参数化，编译时自动进行类型检查和转换

3.泛型是如何编译的

在运行的时候，没有泛型的概念，JVM当中就不存在泛型

在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制

4.泛型的上界

在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。

4.1语法

class 泛型类名称<类型形参 extends 类型边界>{

//~~~

}

4.2示例：

public class MyArry<E extends Number> {
   //....
}

只接受Number的子类类型作为E的类型实参

MyArry<Integer> //正常，因为Integer是Number的子类类型 
MyArry<String>  //编译错误，因为String不是Number的子类类型

泛型没有下界，没有指定类型边界，可视为E extends Object

5.泛型与方法

class Alg<T extends Comparable<T>> {
    public T findMax(T[] array) {
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}

class Student implements Comparable<Student> {
    private String name;

    public Student(String name) {
        this.name = name;
    }

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

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

public class Text {
    public static void main(String[] args) {
        Student[] student = {
                new Student("xiaohong"),
                new Student("xiaoming"),
                new Student("xiaoliang"),
        };
        Alg<Student> alg = new Alg<Student>();
        Student ret = alg.findMax(student);
        System.out.println(ret);
    }
}
//Student{name='xiaoming'}