Java 数据结构 泛型

数据结构

1. 描述和组织数据的方式
2. 集合和数据结构，集合：把数据结构封装起来，不用我们自己实现，直接使用
3. 集合类

类，接口，抽象类

1. 接口扩展（继承）接口
2. 类实现接口
3. 类继承抽象类，实现抽象类中的方法

时间复杂度和空间复杂度

1. 递归的时间复杂度
   

包装类

1. 为什么要有包装类？
   为了让基本数据类型也能像类一样使用，能够调用库方法，实现类的特性

装箱和拆箱

1. 装箱：将基本数据类型给对应的包装类型
2. 拆箱：将包装类型给对应的基本数据类型

public class test {public static void main(String[] args) {Integer a = 10;// 自动装箱,把基本数据类型给包装类型,隐式调用valueOfInteger b = Integer.valueOf(10);// 显示装箱System.out.println(a);System.out.println(b);// 自动拆箱,把包装类型给基本数据类型Integer c = 10;int d = c;System.out.println(d);// 显示拆箱int aa = a.intValue();System.out.println(aa);double bb = a.doubleValue();System.out.println(bb);}
}

泛型

1. 泛型相当于是一个模版，里面可以放任何类型的数据，只要指定了T
2. 泛型将类型进行了传递

// 泛型
class 类名<T,K,V...>
{}

// <>内部必须是包装类型或者是引用类型,不能是基本数据类型
// <>在前面指定了类型,后面的<>内部可以不写类型
MyArray<Integer> myArray = new MyArray<>;

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

可以实现一个泛型类

泛型是如何编译的

1. 擦除机制：擦成object类型，比如T类型会被擦成object类型
2. java是不允许new一个具体的类型的泛型数组的
3. Java 的泛型在 编译时 存在，但在 运行时 会被擦除（Erasure），替换成 Object 或边界类型
4. 本身T类型在编译时被擦除成了object类型，在运行时不存在T，编译器无法确定T类型
   

// java是不允许new一个具体的类型的泛型数组的
public T[] array = new T[]; 

// 写法一
// 建议这么写,安全写法
public Object[] objects = new Object[10];// 写法二
// 不能new一个泛型类型的数组,因为泛型只在编译时存在
public T[] objects = new T[10];
// 编译上虽然能够通过，但是存在问题
// 如果外部调用 Box<String>，但实际存储的是 Object[]，取出时会尝试将 Object 强转为 String，可能失败。
public T[] objects = (T[]) new Object[10];

泛型的上界

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

class 泛型类名称<类型形参 extends 类型边界>{}
class MyArray<E extends Number>{}

MyArray< Integer> l1, 正常，Integer是Number的子类
MyArray< String > l2，报错，String不是Number的子类
泛型的上界指的时它本身（Number）和它的子类

2. 案例

import java.lang.Object;
import java.lang.reflect.Array;
// 泛型类
class MyArray<T>{// 使用Object类型的数组public Object[] objects = new Object[10];public void setValue(int pos,T val){objects[pos] = val;}public T getValue(int pos){return (T)objects[pos];}
}class Person implements Comparable<Person>{@Overridepublic int compareTo(Person o) {return 0;}
}// 泛型类
class Alg<T extends Comparable<T>>{public T findMax(T arr[]){T max = arr[0];for(int i = 0;i < arr.length;i++){if(max.compareTo(arr[i]) < 0){max = arr[i];}}return max;}
}// 泛型方法
class Alg2{public<T extends Comparable<T>> T findMax(T arr[]){T max = arr[0];for(int i = 0;i < arr.length;i++){if(max.compareTo(arr[i]) < 0){max = arr[i];}}return max;}
}Alg3.findMax(arr);
// 静态的泛型方法,直接用类型调用
class Alg3{public static <T extends Comparable<T>> T findMax(T arr[]){T max = arr[0];for(int i = 0;i < arr.length;i++){if(max.compareTo(arr[i]) < 0){max = arr[i];}}return max;}
}public static void main(String[] args) {// 显示实例化alg2.<Integer>findMax(arr2);        // 类型推导实例化Alg2 alg2 = new Alg2();Integer[] arr2 = {1,2,3};int ret1 = alg2.findMax(arr2);System.out.println(ret1);// 普通引用类型的Alg<Integer> b = new Alg<>();Integer[] arr = {1,2,3,5,6};Integer ret = b.findMax(arr);System.out.println(ret);// 自定义类型的Alg<Person> a = new Alg<>();}public static void main1(String[] args) {MyArray<Integer> myArray1 = new MyArray<>();MyArray<String> myArray2 = new MyArray<>();}
}