集合框架

什么是集合框架

Java 集合框架 (Java Collection Framework )，又被称为容器 container ，是定义在 java.util 包下的一组接口 interfaces和其实现类 classes 。

其主要表现为将多个元素 element 置于一个单元中，用于对这些元素进行快速、便捷的存储 store 、检索 retrieve 、管理 manipulate ，即平时我们俗称的增删查改 CRUD 。

类和接口总览

集合框架的重要性

1. 开发中的使用

• 使用成熟的集合框架，有助于我们便捷、快速的写出高效、稳定的代码
• 学习背后的数据结构知识，有助于我们理解各个集合的优缺点及使用场景

2. 笔试及面试题

腾讯-Java后台开发面经

1. HashMap 了解不，介绍一下，如果一个对象为 key 时，hashCode 和 equals 方法的用法要注意什么？
2. HashSet 和 HashMap 的区别是什么？
3. HashMap 是线程安全的么？那需要线程安全需要用到什么？

阿里巴巴-Java后台开发面经

1. ArrayList 和 LinkedList 的区别是什么？
2. 有了解过 HashMap 的具体实现么？
3. HashMap 和 ConcurrentHashMap 哪个效率更高？

今日头条-Java后台开发面经

1. 编程题：判断一个链表是否是一个回文链表。
2. Redis 的 zset 类型对应到 java 语言中大致是什么类型？
3. hashCode 主要是用来做什么用的？

背后所涉及的数据结构以及算法

什么是数据结构

数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合

容器背后对应的数据结构

每个容器其实都是对某种特定数据结构的封装

1. Collection：是一个接口，包含了大部分容器常用的一些方法
2. List：是一个接口，规范了ArrayList 和 LinkedList中要实现的方法
   ArrayList：实现了List接口，底层为动态类型顺序表
   LinkedList：实现了List接口，底层为双向链表
3. Stack：底层是栈，栈是一种特殊的顺序表
4. Queue：底层是队列，队列是一种特殊的顺序表
5. Deque：是一个接口
6. Set：集合，是一个接口，里面放置的是K模型
   HashSet：底层为哈希桶，查询的时间复杂度为O(1)
   TreeSet：底层为红黑树，查询的时间复杂度为O($lo{g}_{2}N$ ),关于key有序的
7. Map：映射，是一个接口,里面存储的是K-V模型的键值对
   HashMap：底层为哈希桶，查询时间复杂度为O(1)
   TreeMap：底层为红黑树，查询的时间复杂度为O($lo{g}_{2}N$ )，关于key有序

相关java知识

1. 泛型 (Generic)
2. 自动装箱 (autobox) 和自动拆箱 (autounbox)
3. Object 的 equals 方法
4. Comparable 和 Comparator 接口

Comparable和Comparator区别参考此文

• 可以把Comparable理解为内部比较器，而Comparator是外部比较器。
• Comparable和Comparator都可以用来进行比较、排序。
• 二者各有优缺点，用Comparable 简单， 实现Comparable 接口的对象直接就成为一个可以比较的对象，但是需要修改源代码。 用Comparator 的好处是不需要修改源代码， 而是另外实现一个比较器， 当某个自定义的对象需要作比较的时候，把比较器和对象一起传递过去就可以比大小了， 并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑，使其可以匹配一些比较简单的对象，那样就可以节省很多重复劳动了。

什么是算法

算法(Algorithm)就是定义良好的计算过程，取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

包装类

在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了一个包装类型。

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

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

装箱和拆箱

int i = 10;
// 装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中
Integer ii = Integer.valueOf(i);
Integer ij = new Integer(i);
// 拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中
int j = ii.intValue();

自动装箱和自动拆箱

可以看到在使用过程中，装箱和拆箱带来不少的代码量，所以为了减少开发者的负担，java 提供了自动机制。

int i = 10;
Integer ii = i; // 自动装箱
Integer ij = (Integer)i; // 自动装箱
int j = ii; // 自动拆箱
int k = (int)ii; // 自动拆箱

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

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);
}

这里只进行了装箱,我们可以打开反汇编看看自动装箱调用了哪个方法

找到目录下的字节码文件(idea是在out目录中)
在上面输入cmd回车

查看汇编的命令：javap -c

问题出在Integer.valueOf()上,我们看下源码

我们发现如果参数 >=IntegerCache.low 并且 <= IntegerCache.high时
返回IntegerCache.cache这个缓存数组中的一个值
在数组中的值没有new一个对象,是一样的

泛型

什么是泛型

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。这种刻板的限制对代码的束缚就会很大。—— 来源《Java编程思想》对泛型的介绍。
泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。

引出泛型

思路：

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

代码示例：

class MyArray {public Object[] array = new Object[10];public Object getPos(int pos) {return this.array[pos];}public void setVal(int pos,Object val) {this.array[pos] = val;}
}
public class TestDemo {public static void main(String[] args) {MyArray myArray = new MyArray();myArray.setVal(0,10);//整型可以存放myArray.setVal(1,"汤姆猫");//字符串也可以存放String ret = myArray.getPos(1);//编译报错System.out.println(ret);}
}

问题：

1. Object任何类型数据都可以存放
2. 1下标对应的值就是字符串，但是取出来会编译报错。必须进行强制类型转换

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

语法

class 泛型类名称<类型形参列表> {// 这里可以使用类型参数
}class ClassName<T1, T2, ..., Tn> {
}class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数列表 */ {// 这里可以使用类型参数
}class ClassName<T1, T2, ..., Tn> extends ParentClass<T1,..., Tn> {// 可以只使用部分类型参数
}

上述代码进行改写如下：

class MyArray<T> {public T[] array = (T[])new Object[10];//1public T getPos(int pos) {return this.array[pos];}public void setVal(int pos,T val) {this.array[pos] = val;}
}
public class Test {public static void main(String[] args) {MyArray<Integer> myArray = new MyArray<>();//2myArray.setVal(0,10);myArray.setVal(1,12);int ret = myArray.getPos(1);//3System.out.println(ret);myArray.setVal(2,"灰太狼");//4:编译报错}
}

代码解释：

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

【规范】类型形参一般使用一个大写字母表示，常用的名称有：

• E 表示 Element
• K 表示 Key
• V 表示 Value
• N 表示 Number
• T 表示 Type
• S, U, V 等等 —— 第二、第三、第四个类型

2. 注释1处，不能new泛型类型的数组

T[] ts = new T[5];//是不对的

因为泛型是编译时期的机制,也意味着运行的时候没有泛型的概念,JVM没有泛型的概念

3. 注释2处，类后面加入 < Integer > 指定当前类型
4. 注释3处，不需要进行强制类型转换
5. 注释4处，代码编译报错，因为在注释2处指定类为Integer，此时在注释4处，编译器会在存放元素的时候帮助我们进行类型检查。

泛型类

泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

示例

MyArray<Integer> list = new MyArray<Integer>()

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

MyArray<int> list = new MyArray<>()//是不对的

类型推导(Type Inference)

当编译器可以根据上下文推导出类型实参时，可以省略类型实参的填写

MyArray<Integer> list = new MyArray<>(); // 可以推导出实例化需要的类型实参为 Integer

泛型的上界(没有下界)

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

语法

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

示例1

public class MyArray<E extends Number> {...
}

只接受 Number 的子类型或者Number本身作为 E 的类型实参

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

PS:如果没有指定类型边界 ，可以视为 E extends Object
示例2

public class MyArray<E extends Comparable<E>> {...
}

E必须是实现了Comparable接口的
引用类不能直接比较,需要实现接口

class Person implements Comparable<Person>{@Overridepublic int compareTo(Person o) {return 0;}
}
class Alg<T extends Comparable<T>> {public T findMaxVal(T[] array) {T max = array[0];for (int i = 1; i < array.length; i++) {if(array[i].compareTo(max) > 0) {max = array[i];}}return max;}
}
public class Test {public static void main(String[] args) {Integer[] array = {1,4,3,8,7,5};Alg<Integer> alg = new Alg<>();System.out.println(alg.findMaxVal(array));Alg<Person> alg2 = new Alg<>();}
}

• 类型实参T实例化为自定义类Person时,需要实现Comparable< T >或Comparator< T >接口
• 而Integer类本身就实现了Comparable接口,不用我们自己重写

泛型方法

语法

方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) { ... }

举个栗子

class Alg {public<T extends Comparable<T>> T findMaxVal(T[] array) {T max = array[0];for (int i = 1; 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 alg = new Alg();Integer[] array = {1,4,3,8,7,5};//不使用类型推导alg.<Integer>findMaxVal(array);//类型自动推导alg.findMaxVal(array);}
}

可以写成静态方法,这样不用实例化类对象也能使用

class Alg {public static <T extends Comparable<T>> T findMaxVal(T[] array) {T max = array[0];for (int i = 1; i < array.length; i++) {if(array[i].compareTo(max) > 0) {max = array[i];}}return max;}
}
public class Test {public static void main(String[] args) {Integer[] array = {1,4,3,8,7,5};//不使用类型推导Alg.<Integer>findMaxVal(array);//类型自动推导Alg.findMaxVal(array);}
}

裸类型(Raw Type)

裸类型是一个泛型类但没有带着类型实参

MyArray list = new MyArray();

注意： 我们不要去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制

小结

1. 泛型是将数据类型参数化，进行传递
2. 使用 < T > 表示当前类是一个泛型类。
3. 泛型目前为止的优点：数据类型参数化，编译时自动进行类型检查和转换

泛型如何编译的

擦除机制

通过命令：javap -c 查看字节码文件，所有的T都被擦除成Object

class MyArray<T> {public T[] array = (T[])new Object[10];public T getPos(int pos) {return this.array[pos];}public void setVal(int pos,T val) {this.array[pos] = val;}
}

在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制。
Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。
有关泛型擦除机制的文章介绍

为什么不能实例化泛型类型数组

class MyArray<T> {public T[] array = (T[]) new Object[10];public T getPos(int pos) {return this.array[pos];}public void setVal(int pos, T val) {this.array[pos] = val;}public T[] getArray() {return array;}
}
public class Test {public static void main(String[] args) {MyArray<Integer> myArray1 = new MyArray<>();Integer[] arr = myArray1.getArray();}
}

将Object[]分配给Integer[]引用，程序报错的原因：

• Object可以强转为Integer,因为有继承关系,是确定的,而数组是没有继承关系的,是不确定的(可能存在其他类型的元素)
• 返回的Object数组里面，存放的可能是其他数据类型，可能是String，可能是自定义类Person，运行的时候，直接转给Integer类型的数组，编译器认为是不安全的。

正确的方式：

import java.lang.reflect.Array;
class MyArray<T> {public T[] array;public MyArray() {}/*** 通过反射创建，指定类型的数组* @param clazz* @param capacity*/public MyArray(Class<T> clazz, int capacity) {array = (T[]) Array.newInstance(clazz, capacity);}public T getPos(int pos) {return this.array[pos];}public void setVal(int pos,T val) {this.array[pos] = val;}public T[] getArray() {return array;}
}
public class Test {public static void main(String[] args) {MyArray<Integer> myArray1 = new MyArray<>(Integer.class,10);Integer[] integers = myArray1.getArray();}
}

反射我也不太会,目前还是用

class MyArray<T> {public Object[] array = new Object[10];public T getPos(int pos) {return (T)array[pos];}public void setVal(int pos,T val) {array[pos] = val;}
}

通配符

? 用在泛型，即为通配符

通配符解决什么问题

示例:

class Message<T> {private T message ;public T getMessage() {return message;}public void setMessage(T message) {this.message = message;}
}
public class Test {public static void main(String[] args) {Message<String> message = new Message<>() ;message.setMessage("光头强");fun(message);}public static void fun(Message<String> temp){System.out.println(temp.getMessage());}
}

以上程序会带来新的问题，如果泛型的类型不是String，而是Integer.

public class Test {public static void main(String[] args) {Message<Integer> message = new Message() ;message.setMessage(99);fun(message); // 出现错误，只能接收String}public static void fun(Message<String> temp){System.out.println(temp.getMessage());}
}

解决方案：可以接收所有的泛型类型，但是又不能够让用户随意修改。这种情况就需要使用通配符"?"来处理

public class Test {public static void main(String[] args) {Message<Integer> message = new Message() ;message.setMessage(55);fun(message);}// 此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改public static void fun(Message<?> temp){//temp.setMessage(100); 无法修改！System.out.println(temp.getMessage());}
}

在"?"的基础上又产生了两个子通配符：

• ? extends 类：设置通配符上限
• ? super 类：设置通配符下限

通配符上界

语法：

<? extends 上界>
<? extends Number>//可以传入的实参类型是Number或者Number的子类

示例

class Food {
}
class Fruit extends Food {
}
class Apple extends Fruit {
}
class Banana extends Fruit {
}
class Message<T> { // 设置泛型private T message ;public T getMessage() {return message;}public void setMessage(T message) {this.message = message;}
}
public class Test {public static void main(String[] args) {Message<Apple> message = new Message<>() ;message.setMessage(new Apple());fun(message);Message<Banana> message2 = new Message<>() ;message2.setMessage(new Banana());fun(message2);}// 此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改public static void fun(Message<? extends Fruit> temp){//temp.setMessage(new Banana()); //仍然无法修改！//temp.setMessage(new Apple()); //仍然无法修改！System.out.println(temp.getMessage());Fruit fruit = temp.getMessage();//Apple apple = temp.getMessage();//报错,因为不知道是哪个子类,但是父类可以接收}
}

无法在fun函数中对temp进行修改，因为temp接收的是Fruit和他的子类，此时存储的元素应该是哪个子类无法确定。所以会报错！但是可以获取元素。

通配符的上界，不能进行写入数据，只能进行读取数据

通配符下界

语法:

<? super 下界>
<? super Integer>//代表 可以传入的实参的类型是Integer或者Integer的父类类型

示例

class Food {
}
class Fruit extends Food {
}
class Apple extends Fruit {
}
class Plate<T> {private T plate ;public T getPlate() {return plate;}public void setPlate(T plate) {this.plate = plate;}
}
public class Test {public static void main(String[] args) {Plate<Fruit> plate1 = new Plate<>();plate1.setPlate(new Fruit());fun(plate1);Plate<Food> plate2 = new Plate<>();plate2.setPlate(new Food());fun(plate2);}public static void fun(Plate<? super Fruit> temp){// 此时可以修改！！添加的是Fruit 或者Fruit的子类temp.setPlate(new Apple());//这个是Fruit的子类temp.setPlate(new Fruit());//这个是Fruit的本身//Fruit fruit = temp.getPlate(); 不能接收，这里无法确定是哪个父类System.out.println(temp.getPlate());//只能直接输出}
}

通配符的下界，不能进行读取数据，只能写入数据。