Java数据结构预备知识

包装类

基本数据类型和对应的包装类

除了 Integer 和 Character， 其余基本类型的包装类都是首字母大写。 

装箱和拆箱

装箱：把基本类型变成引用类型（包装类型）

int a=10;
Integer i1=Integer.valueOf(a);// 显示/手动装箱
Integer i2=a;// 自动装箱 底层也是调用valueOf

总结:通过valueOf装箱 

拆箱：把引用类型变成一个基本类型

Integer i=10;//装箱
int a=i.intValue();// 手动拆箱
double d=i.doubleValue();

【面试题】
下列代码输出什么，为什么？

public static void main(String[] args) {
Integer a = 127;
Integer b = 127;

Integer c = 128;
Integer d = 128;

System.out.println(a == b);
System.out.println(c == d);
}

如果i是在某个范围之内，那么就是去数组取值

相反，不在这个范围之内，就会实例一个新的对象

从-128到127一共有256个数

泛型

主要做的是：把类型参数化。把类型参数化，意味着可以传指定的类型参数。

如何实现呢？

首先我们想到的是Object

引出泛型

实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？

思路：
1. 我们以前学过的数组，只能存放指定类型的元素，例如：int[] array = new int[10]; String[] strs = new String[10];
2. 所有类的父类，默认为Object类。数组是否可以创建为Object?

问题：以上代码实现后 发现
1. 任何类型数据都可以存放
2. 2号下标本身就是字符串，但是确编译报错。必须进行强制类型转换

虽然在这种情况下，当前数组任何数据都可以存放，但是，更多情况下，我们还是希望他只能够持有一种数据类型。而不是同时持有这么多类型。所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。

class MyArray<T>{
    public Object[] array=new Object[10];

    public void setValue(int pos,T x){
        array[pos]=x;
    }

    public T getVal(int pos){
        return (T)array[pos];
    }
}
public class Test {
    public static void main(String[] args) {
        MyArray<Integer> myArray=new MyArray<>();
        myArray.setValue(0,1);
        myArray.setValue(1,2);
        //myArray.setValue(2,"hello");//每次存储数据的时候，会检查你存入的数据是不是和你指定的类型一样
        Integer x= myArray.getVal(0);
        System.out.println(x);//此时不需要我们进行强制类型转换
    }
}

 代码解释：
1. 类名后的 <T> 代表占位符，表示当前类是一个泛型类

2.类型后加入 <Integer> 指定当前类型

3.不需要进行强制类型转换

注意：泛型只能接受类，所有的基本数据类型必须使用包装类！

泛型如何编译的

擦除机制

通过命令：javap -c 查看字节码文件，所有的T都是Object。

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

Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。
 

不能实例化泛型类型数组

public Object[] array=new Object[10];
 

public void setValue(int pos,T x){

     array[pos]=x;

}

public T getVal(int pos){

     return (T)array[pos];

}

泛型的上界

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

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

public class MyArray<E extends Number> {
...
}//只接受 Number 的子类型或者Number自己作为 E 的类型实参

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

复杂示例

public class MyArray<E extends Comparable<E>> {
...//E必须是实现了Comparable接口的
}

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

public class Test {
    public static void main(String[] args) {
        Alg<Integer> alg=new Alg<>();
        Integer[] array={1,2,3,4,5,6,7};
        Integer x=alg.findMax(array);
        System.out.println(x);
    }
}

​​​​​​​