java的集合基础
一、集合的理解和好处
数组（灵活性不够）
1、长度开始时必须指定，而且一旦指定，不能更改
2、保存的必须为同一类型的元素
3、使用数组进行增加/删除元素比较麻烦
集合
1、可以动态的保存任意多个元素，使用方便，允许类型不一致
2、提供一系列方便的操作对象方法：add、remove、set、get等
3、使用集合添加/删除新元素，很简洁
二、两组集合关系图
单列集合 Collection
List : 有索引 存取有序 数据不唯一
ArrayList ：数组数据结构 特点：查询快 增删慢
LinkedList: 双链表数据结构 特点：查询慢 增删快
Set : 没有索引 存取无序 数据唯一
HashSet ：哈希表 = 数组 + 链表 + 二叉树
双列集合 Map
HashMap<K,V> 键唯一 值不唯一 哈希表控制键
向键位置存储对象所属类必须重写 hashCode equals方法
遍历map集合：
keySet 获取所有键
entrySet 获取键值对 Map.Entry3.
二、Collection接口和常用方法
1、基本介绍
1、collection实现子类可以存放多个元素，每个元素可以是Object
2、有些Collection的实现类可以存放重复元素，有些不可以
3、Collection的实现类有些是有序的（List），有些不是有序的（Set）
4、Collection接口没有实现子类，是通过它的子接口Set和List来实现的
2、常用方法
因为Collection接口本身是不可以实例化的，因此用实现子类ArrayList进行演示
import java.util.ArrayList;
import java.util.List;
public class CollectionMethod {
public static void main(String[] args) {
//创建ArrayList，使用接口接收
List list = new ArrayList();
//add:添加单个元素
list.add("java"); //字符型
list.add(10); //整型 相当于list.add(new Integer(10))
list.add(true); //同上
//现在输出的就是一个一个对象 [java,10,true]
System.out.println("add: list = " + list);
//remove:删除指定元素
list.remove(0);//根据下标删除
list.remove("java");//根据指定对象删除，删除指定元素
System.out.println("remove: list = " + list);
//contains:查找元素是否存在
System.out.println("contains: list = " + list.contains("java"));
//size:返回元素的个数
System.out.println("size: list = " + list.size());
//isEmpty:判断是否为空
System.out.println("isEmpty: list = " + list.isEmpty());
//clear:清空
list.clear();
System.out.println("clear: list = " + list);
//addAll:添加多个元素(可传入一个集合)
ArrayList arrayList = new ArrayList();
arrayList.add("红楼梦");
arrayList.add("三国演义");
list.addAll(arrayList);
System.out.println("addAll: list = " + list);
//containsAll:查找多个元素是否存在(可传入一个集合)
System.out.println("containsAll: list = " + list.containsAll(arrayList));
//removeAll:删除多个元素(可传入一个集合)
list.removeAll(arrayList);
System.out.println("removeAll: list = " + list);
}
}
3、遍历方式
1、使用迭代器Iterator
基本介绍
1、Iterator对象成为迭代器，主要用于遍历Collection集合中的元素
2、所实现了Collection接口的集合类都有一个 iterator() 方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器
3、Iterator的结构
4、Iterator仅用于遍历集合，Iterator本身不存放对象
迭代器原理
迭代器代码
//得到一个集合的迭代器
Iterator iterator = list.iterator();
//判断集合是否还有元素，没有返回false，退出循环
while (iterator.hasNext()){
//打印元素
//next() 1、指针下移 2、将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}
迭代器原理图
注意：在调用it.next()方法之前必须调用it.hasNext()进行检测，如果不调用，且下一条记录无效时，直接调用it.next()方法会抛出NoSuchElementException异常
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionIterator {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(new Book("三国演义","罗贯中",10.1));
collection.add(new Book("红侯梦","曹雪芹",9.1));
collection.add(new Book("三体","刘慈欣",12.1));
//遍历集合
//1、得到集合的迭代器
Iterator iterator = collection.iterator();
//2、使用while进行遍历
while (iterator.hasNext()){
//返回的是object，因为add添加的是一个object
Object obj = iterator.next();
//会去调用toString方法
//object的编译类型是object，运行类型取决于存放的对象，这里存放的是Book对象，所以根据动态绑定机制回去调用toString方法
System.out.println("obj = " + obj);
}
//3、当退出while退出循环后，这时iterator迭代器指向最后一个元素
//iterator.next(); //异常 java.util.NoSuchElementException
//4、需要重新遍历，需要重置迭代器
iterator = collection.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj = " + obj);
}
}
}
class Book{
private String bookName;
private String author;
private double price;
public Book(String bookName, String author, double price) {
this.bookName = bookName;
this.author = author;
this.price = price;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Book() {
}
@Override
public String toString() {
return "Book{" +
"bookName='" + bookName + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
2、增强for循环
增强for循环，可以代替iterator迭代器，特点：增强for就是简化版的iterator，本质一样，只适用于遍历集合和数组
基本语法：
for( 元素类型 元素名 : 集合名或者数组名 ){
访问对象
}
增强for的底层，在ArrayList的源码下
//源码，返回一个迭代器
public Iterator<E> iterator() {
return new Itr();
}
//源码，调用hasNext判断是否是最后一个元素
public boolean hasNext() {
return cursor != size;
}
//源码，使用next()方法进行遍历
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
import java.util.ArrayList;
import java.util.Collection;
public class CollectionFor {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(new Book1("三国演义","罗贯中",10.1));
collection.add(new Book1("红侯梦","曹雪芹",9.1));
collection.add(new Book1("三体","刘慈欣",12.1));
//1、本质与iterator基本一致
//2、底层也是迭代器
//3、可以理解为简化版的迭代器遍历
for (Object o : collection) {
System.out.println(o);
}
//数组使用
int[] ints = {1,2,3,4,5,6,7};
for (int anInt : ints) {
System.out.println(anInt);
}
}
}
class Book1{
private String bookName;
private String author;
private double price;
public Book1(String bookName, String author, double price) {
this.bookName = bookName;
this.author = author;
this.price = price;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Book1() {
}
@Override
public String toString() {
return "Book{" +
"bookName='" + bookName + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
3、迭代器和增强for循环练习
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* 练习
* 创建三个dog对象{name,age}，放入ArrayList中，赋给List引用，
* 用迭代器和增强for循环进行遍历
* 重写toString方法，输出name和age
*/
public class CollectionExercise {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Dog("旺财",10));
list.add(new Dog("狗蛋",12));
list.add(new Dog("大白",8));
list.add(new Dog("小黑",4));
//1、使用迭代器进行遍历
System.out.println("=============迭代器============");
//获取迭代器
Iterator iterator = list.iterator();
//判断是否还有元素
while (iterator.hasNext()) {
Object obj = iterator.next();
//输出元素
System.out.println("obj = " + obj);
}
//2、使用增强for循环进行遍历
System.out.println("==============增强for循环==========");
for (Object obj : list) {
System.out.println("obj = " + obj);
}
}
}
class Dog{
private String name;
private Integer age;
public Dog(String name, Integer age) {
this.name = name;
this.age = age;
}
public Dog() {
}
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 "Dog{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
三、List接口和用方法
1、基本介绍
List接口是Collection接口的子接口
1、List集合类中元素有序（即添加顺序和取出顺序一致），且元素可重复
//1、List集合类中元素有序（即添加顺序和取出顺序一致），且元素可重复
List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
System.out.println("list = "+list);
//结果
list = [1, 2, 3]
2、List集合中的每个元素都有对应的顺序索引，即支持索引
//2、List集合中的每个元素都有对应的顺序索引，即支持索引
//索引从0开始
System.out.println(list.get(0));
3、List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素
4、JDK API中List接口的常用实现类有 ArrayList、LinkedList和Vector
2、常用方法
import java.util.ArrayList;
import java.util.List;
public class ListMethod {
public static void main(String[] args) {
List list = new ArrayList();
list.add("张三丰");
list.add("孙悟空");
//list的常用方法
//void add(int index, Object obj) 在index位置插入obj，在没有加上索引，则会插入最后一个元素
//接口源码 void add(int index, E element);
list.add(1,"刘备");
System.out.println("add: list = " + list);
//boolean addAll(int index, Collection col); 在index位置开始将col中的所有元素进行添加
//接口源码 boolean addAll(int index, Collection<? extends E> c);
List arrayList = new ArrayList();
arrayList.add("喜洋洋");
arrayList.add("美羊羊");
arrayList.add("懒洋洋");
arrayList.add("刘备");
list.addAll(1,arrayList);
System.out.println("addAll: list = " + list);
//Object get(int index): 根据索引获取对应的元素
//接口源码 E get(int index);
System.out.println("get: list = " + list.get(1));
//int indexOf(Object obj): 返回obj在集合中首次出现的位置
//接口源码 int indexOf(Object o)
System.out.println("indexOf: list = " + list.indexOf("刘备"));
//int lastIndexOf(Object obj); : 返回obj在集合中末次出现的位置
//接口源码int lastIndexOf(Object o);
System.out.println("lastIndexOf: list = " + list.lastIndexOf("刘备"));
//Object remove(int index): 移除指定index位置的元素，并返回此元素
//接口源码 E remove(int index);
System.out.println(("remove: list = " + list.remove(1)));
//Object set(int index, Object obj): 设置指定index位置的元素为obj，相当于替换，前提是指定的索引必须存在，否则会抛出下标越界异常
//接口源码 E set(int index, E element);
list.set(1,"牛洋洋");
System.out.println("set: list = " + list);
//List subList(int fromIndex, int toIndex): 返回fromIndex到toIndex位置的子集合
//接口源码 List<E> subList(int fromIndex, int toIndex);
System.out.println("subList: list = " + list.subList(0,2));
}
}
3、List练习
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* 添加10个以上元素（比如 String "hello"），在2号位插入一个 喜洋洋
* 获取第5个元素，删除第6个元素，修改第7个元素，再使用迭代器 进行遍历集合
* 要求：使用List实现类ArrayList完成
*/
public class ListExercise {
public static void main(String[] args) {
List list = new ArrayList();
for (int i = 0; i < 12; i++) {
list.add("hello" + i);
}
System.out.println("list = " + list);
//在2号位添加一个 喜洋洋
System.out.println("============在2号位添加一个 喜洋洋============");
list.add(1,"喜洋洋");
System.out.println("list = " + list);
//获取第5个元素
System.out.println("============获取第5个元素============");
System.out.println("list = " + list.get(4));
//删除第6个元素
System.out.println("============删除第6个元素============");
list.remove(5);
System.out.println("list = " + list);
//修改第7个元素
System.out.println("============修改第7个元素============");
list.set(6,"懒洋洋");
System.out.println("list = " + list);
System.out.println("============使用迭代器遍历============");
Iterator iterator = list.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
System.out.println("obj = " + obj);
}
}
}
4、List的三种遍历方式
只要是List接口的实现子类（ArrayList、Vector、LinkedList），遍历方式一致
-
方式一：使用iterator方式
//迭代器 Iterator iterator = list.iterator(); while (iterator.hasNext()){ Object object = iterator.next(); System.out.println("object = " + object); } -
方式二：增强for循环
//增强for for (Object object : list) { System.out.println("object = " + object); } -
方式三：使用普通的for
//普通for for (int i = 0; i < list.size(); i++) { System.out.println("object = " + list.get(i)); }
5、练习，冒泡排序
创建Book对象
public class Book {
private String name;
private String author;
private double price;
public Book() {
}
public Book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "名称：" + name + "\t\t价格：" + price + "\t\t作者：" + author;
}
}
进行测试
import java.util.ArrayList;
import java.util.List;
public class ListExercise02 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Book("天龙八部","金庸",10));
list.add(new Book("三体","刘慈欣",50));
list.add(new Book("龙族","江南",20));
list.add(new Book("西游记","吴承恩",30));
//遍历
for (Object o : list) {
System.out.println(o);
}
//调用冒泡排序
sort(list);
System.out.println("===============排序过后=================");
//遍历
for (Object o : list) {
System.out.println(o);
}
}
//冒泡排序方法
public static void sort(List list){
int size = list.size();
for (int i = 0; i < size - 1; i++) {
for (int j = 0; j < size - 1 - i; j++) {
//取出对象Book，向下转型
Book book1 = (Book) list.get(j);
Book book2 = (Book) list.get(j + 1);
//比较交换
if (book1.getPrice() > book2.getPrice()){
//如果book1的价格比book2大，那么这两个位置的元素进行交换，使用set方法进行交换
list.set(j, book2);
list.set(j + 1, book1);
}
}
}
}
}
6、ArrayList底层结构和源码分析
ArrayList的注意事项：
-
permits all elements，including null ，ArrayList可以放入null，并且多个
ArrayList arrayList = new ArrayList(); arrayList.add(null); arrayList.add(null); arrayList.add(null); arrayList.add(null); arrayList.add("喜洋洋"); System.out.println(arrayList); -
ArrayList是由数组来实现数组存储的
-
ArrayList基本等同与Vector，除了ArrayList是线程不安全（执行效率高），在多线程情况下，不建议使用ArrayList
//源码 没有加 synchronized， 没有做线程互斥 public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; }
扩容机制
1、ArrayList中维护了一个Object类型的数组elementData， transient Object[] elementData
- Object是一个所有类的父类，什么类型都可以往里面放
- transient表示短暂的，瞬间的，如果有个属性被 transient修饰后，表示该属性不会被序列化
2、当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData的容量为0，第一次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍
3、如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如需要再次扩容，则直接扩容elementData为1.5倍
源码分析：
测试代码：
import java.util.ArrayList;
/**
* ArrayList源码分析
*/
public class ArrayListSource {
public static void main(String[] args) {
//无参构造
ArrayList list = new ArrayList();
//有参构造
//ArrayList list = new ArrayList(8);
//首次添加
for (int i = 0; i <= 10; i++) {
list.add(i);
}
//第二次扩容
for (int i = 11; i <= 15 ; i++) {
list.add(i);
}
//第三次扩容
list.add(100);
list.add(200);
list.add(null);
}
}
无参构造分析源码：
//无参构造
ArrayList list = new ArrayList();
第一步：ArrayList第一次初始化的就是创建一个空数组
/**
* Constructs an empty list with an initial capacity of ten.
*/
public ArrayList() {
//创建空数组
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//空数组定义
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
第二步：执行添加的方法，在添加元素之前，需要进行判断是否要扩容
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
//执行添加元素之前，先确定数组容量是否够，不够就先扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
//容量足够之后再进行添加操作
elementData[size++] = e;
return true;
}
第三步：确定minCapacity最小容量，第一次扩容为10
//该方法用于判断是否扩容
private void ensureCapacityInternal(int minCapacity) {
//这里明确集合是否是真的需要扩容
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//源码
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//判断传进来的数组是否等于空数组
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//不等于就开始进行比较，取最大值
//DEFAULT_CAPACITY的默认值为10
//minCapacity目前集合添加的第几个元素
//如果默认值大于minCapacity，就返回默认的长度
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
//不满足条件则返回需要的容量大小 minCapacity
return minCapacity;
}
第四步：记录当前集合被修改的次数，判断最小容量是否足够，不够就执行扩容方法，每次添加元素都会执行该方法判断是否要扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++; //记录当前集合被修改的次数，每次添加一个元素记录一次
// overflow-conscious code
//使用当前最小容量 减去 数组的长度，如果大于0，说明容量大小真的不够了，直接调用扩容
if (minCapacity - elementData.length > 0)
//进行扩容处理
grow(minCapacity);
}
第五步：进行扩容；使用扩容机制确定扩容大小；第一次newCapacity = 10， 第二次以及以后按照1.5倍扩容；扩容使用的是Arrays.copyOf()，使用Arrays.copyOf()的保留之前的数据，然后再进行扩容
/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity
*/
private void grow(int minCapacity) {
// overflow-conscious code
//将当前数组的长度记录到旧的容量变量中（oldCapacity）
int oldCapacity = elementData.length;
//计算新的容量，使用旧的长度（oldCapacity）加上旧的长度的（oldCapacity）1/2进行扩容，也就是1.5倍，就得到新的容量
//例如 oldCapacity = 10，则 newCapacity = 10 + 10 *（1/2） = 15
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果新的长度减去最小长度小于0，那么最小长度就为新的长度
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//如果新的长度减去规定的最大长度，就调用hugeCapacity()方法重新给新的长度赋值
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//进行扩容，elementData生成扩容的新数组，填充null，
//Arrays.copyOf(elementData, newCapacity);再给数组赋值
elementData = Arrays.copyOf(elementData, newCapacity);
}
第六步：扩容完成后，返回到添加方法
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
//扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
//扩容完毕后，进行赋值
//size++是先赋值后再进行++操作，确保下标为0之前进行赋值，再向下移动下标
elementData[size++] = e;
return true;
}
有参构造分析源码：
//有参构造
ArrayList list = new ArrayList(8);
第一步：对传入的参数进行判断，创建指定大小的elementData数组 new Object[initialCapacity]
/**
* Constructs an empty list with the specified initial capacity.
*
* @param initialCapacity the initial capacity of the list
* @throws IllegalArgumentException if the specified initial capacity
* is negative
*/
public ArrayList(int initialCapacity) {
//判断传入的参数是否大于0
if (initialCapacity > 0) {
//大于0的参数，创建一个指定大小的Object[initialCapacity]
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//如果传入的是0，那么就还是按照无参构造器进行使用，从0开始创建一个大小为10的数组
this.elementData = EMPTY_ELEMENTDATA;
} else {
//小于0的话，直接抛出异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
第二步：与无参构造的执行流程一致，进行比较扩容
小结：如果是有参的构造器，那么第一次扩容就是按照elementData的1.5倍扩容，不会是默认的10个容量大小
7、Vector的底层结构和源码剖析
基本介绍
1、继承关系
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
2、Vector底层也是对象数组
protected Object[] elementData;
3、Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized
源码例子
//源码带有synchronized关键字修饰
public synchronized void addElement(E obj) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = obj;
}
4、在开发中，需要线程同步安全时，考虑使用Vector
Vector与ArrayList比较
| 底层结构 | 版本 | 线程安全（同步）效率 | 扩容倍数 | |
|---|---|---|---|---|
| ArrayList | 可变数组 | jdk1.2 | 不安全，效率高 | 如果是有参构造，那么就是1.5倍；如果是无参构造，第一次是10，第二次以及之后是1.5倍扩容 |
| Vector | 可变数组 | jdk1.0 | 安全，效率不高 | 如果指定大小，每次直接是2倍扩容；如果是无参构造，默认是10，满后，按照2倍扩容 |
源码解读：
//创建集合
Vector vector = new Vector();
for (int i = 0; i < 10; i++) {
vector.add(i);
}
第一步：构建无参构造器，实际上是执行了有参构造器，默认是10
//源码，默认给10的容量，实际上调用的是有参构造器，默认长度是10
public Vector() {
this(10);
}
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
第二步：添加数据
public synchronized boolean add(E e) {
modCount++;//记录集合的修改次数
ensureCapacityHelper(elementCount + 1); //判断扩容
elementData[elementCount++] = e;//给集合赋值
return true;
}
第三步：判断是否需要真的扩容
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
//判断是否需要真正的扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);//扩容处理
}
第四步：执行扩容机制，计算扩容的算法与ArrayList不太一致，Vector使用的是2倍扩容
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//自动增量 capacityIncrement，默认为0，三元运算符，返回的是oldCapacity
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
8、LinkedList的底层结构和源码分析
基本介绍：
1、LinkedList底层实现双向链表和双端队列特点
2、可以添加任意元素（元素可以重复），包括null
3、线程不安全，没有实现线程同步
LinkedList是底层操作机制
1、LinkedList底层维护的是一个双向链表
2、LinkedList中维护了两个属性first和last分别指向首节点和尾结点
3、每个节点（Node对象），里面又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个节点，最终实现双向链表
4、所以LinkedList的元素的添加和删除，不是通过数组实现的，相对来说效率较高。
5、双向链表的模拟实现
/**
* 模拟一个简单的双向链表
*/
public class LinkedListNode {
public static void main(String[] args) {
//创建节点
Node jack = new Node("jack");
Node tom = new Node("tom");
Node lucy = new Node("lucy");
//连接三个节点，形成双向链表
//下面的代码形成的关系 jack -> tom -> lucy
jack.next = tom;
tom.next = lucy;
//下面的代码形成的关系 jack <- tom <- lucy
lucy.pre = tom;
tom.pre = jack;
//让first引用指向jack，就是双向链表的首节点
Node first = jack;
//让last引用指向lucy，就是双向链表的尾节点
Node last = lucy;
System.out.println("==============演示（从头到尾的输出）=============");
//演示从头到尾遍历
while (true){
//如果first（首节点为空，则说明遍历到了最后，退出循环）
if (first == null){
break;
}
//打印首节点指向的元素
System.out.println(first);
//首节点移至下一位，再次循环判断打印
first = first.next;
}
System.out.println("==============演示（从尾到尾到头的输出）=============");
//从尾到头的遍历（原理同上一直）
while (true){
if (last == null){
break;
}
System.out.println(last);
last = last.pre;
}
//演示，双向链表的添加数据
//在tom-----------lucy中添加一个元素（喜洋洋）
//1、创建一个Node节点
Node xyy = new Node("喜洋洋");
//2、让 xyy 的 next 指向lucy，让 xyy 的 pre 指向 tom
xyy.next = lucy;
xyy.pre = tom;
//3、让 lucy 的 pre 指向 xyy，让 tom 的 next 指向 xyy
lucy.pre = xyy;
tom.next = xyy;
//first重新指向首位
first = jack;
System.out.println("==============添加元素后的遍历=============");
//演示从头到尾遍历
while (true){
//如果first（首节点为空，则说明遍历到了最后，退出循环）
if (first == null){
break;
}
//打印首节点指向的元素
System.out.println(first);
//首节点移至下一位，再次循环判断打印
first = first.next;
}
}
}
//定义一个Node类，Node对象表示双向链表的节点，可以被实例化
class Node{
public Object item; //真正存放数据的地方
public Node next;
public Node pre;
public Node(Object item) {
this.item = item;
}
@Override
public String toString() {
return "Node name = " + item;
}
}
LinkedList的源码图解
添加节点的源码：
第一步：
//创建LinkedList
LinkedList linkedList = new LinkedList();
//执行添加
linkedList.add(1);
这时会调用一个无参构造的方法，初始的属性 first = null，last = null，size = 0
//首先会调用无参构造方法（源码）
public LinkedList() {}
第二步：执行add方法
//源码
public boolean add(E e) {
linkLast(e);
return true;
}
linkLast方法的实现，当只有一个元素时，first 和 last 都指向这个节点，元素都是从尾进行插入的，因此刚刚插入的数据都是赋值给last
当第一次添加数据，last = null，就会把新的元素赋值给 last ，根据 if (l == null) ，也将第一个元素赋值给 first
第二次插入元素，last不为空，因为之前已经有一个数据了，所以这个 l.next 指向下一个元素
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null); //赋值，因为last元素没有next，也就是没有下一个元素，所以next为null
last = newNode; //第一个节点，last指向这个节点
if (l == null)
first = newNode;
else
l.next = newNode;
size++; //长度加1
modCount++; //修改次数加1
}
删除第一个节点的源码：
//默认删除的是第一个节点
linkedList.remove();
第一步：调用删除第一个元素的方法
//源码（执行了删除第一个的方法）
public E remove() {
return removeFirst();
}
第二步：判断第一个元素的first是否为空 first == null
//源码
public E removeFirst() {
final Node<E> f = first; //将第一个元素的first赋值给 f
if (f == null) //如果f为空，直接抛出异常
throw new NoSuchElementException();
return unlinkFirst(f); //不为空调用unlinkFirst方法，传入f
}
第三步：执行真正的删除方法
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item; //首先将第一个元素item赋值给element
final Node<E> next = f.next; //再将第一个元素的next赋值给next
f.item = null; //设置第一个元素的item为null
f.next = null; // help GC 设置第一个元素的next设置为null
first = next; //第二行已经给next赋值了，是第二个元素的值，也就是将fist指向第二个元素
if (next == null) //所以这时的next不是空，而是第二个元素
last = null; //跳过这个设置last为null的判断，这时的last是第三个元素
else
next.prev = null; //设置第二个元素的后指向pre为null
size--; //长度减1
modCount++; //修改次数加1
return element; //返回被删除的元素
}
9、ArrayList和LinkedList的比较
| 底层结构 | 增删的效率 | 改查的效率 | |
|---|---|---|---|
| ArrayList | 可变数组 | 较低，数组扩容 | 较高 |
| LinkedList | 双向链表 | 较高，通过链表追加 | 较低 |
如何选择ArrayList和LinkedList：
1、如果我们改查操作多，选择ArrayList
2、如果我们增删操作多，选择LinkedList
3、一般来说，在程序中，80%-90%都是查询，因此大部分情况下会选择ArrayList
4、在一个项目中，根据业务进行灵活选择，也可能这样，一个模块使用ArrayList，另一个模块使用LinkedList
四、Set接口的使用方法
基本介绍：
1、无序（添加和取出的顺序不一致），没有索引
2、不允许重复的元素，所以最多包含一个null
3、jdk API 中Set接口的实现类有HashSet，TreeSet等
-
Set的常用方法：和List接口一样，Set接口也是Collection的子接口，因此，常用方法和Collection接口一样
-
Set接口的遍历方式
同Collection的遍历方式一样，因此Set接口是Collection接口的子接口
1、可以使用迭代器
2、使用增强for
3、不能使用索引的方式来获取
基本演示
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class SetMethod {
public static void main(String[] args) {
//添加
//1、以Set接口的实现类HashSet来讲解Set的方法
//2、set 接口的实现类的对象（set接口对象），不能存放重复的元素，可以添加一个null
//3、set 接口对象存放数据是无序的（即添加的和取出的顺序不一致）
//4、取出的顺序虽然不是添加的顺序，但是顺序是固定的
Set set = new HashSet();
set.add("jack");
set.add("jack");
set.add("tom");
set.add("lucy");
set.add(null);
set.add(null);
System.out.println("set = " + set);
//遍历，使用迭代器
System.out.println("---------------迭代器----------------");
Iterator iterator = set.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
System.out.println("obj = " + obj);
}
//遍历，使用增强for
System.out.println("---------------增强for----------------");
for (Object obj : set) {
System.out.println("obj = " + obj);
}
}
}
1、HashSet的说明
1、HashSet实现了Set接口
2、HashSet实际上是HashMap
//构造器
Set set = new HashSet();
//源码
public HashSet() {
map = new HashMap<>();
}
3、可以存放null值，但是只能有一个null
4、HashSet不保证元素时有序的，取决于hash后，确定索引的结果（不保证存放元素的顺序和取出的顺序一致）
5、不能存放重复元素/对象
演示
import java.util.HashSet;
import java.util.Set;
public class HashSet01 {
public static void main(String[] args) {
Set set = new HashSet();
//1、在执行add方法后，会返回一个boolean值
//2、如果添加成功，返回true，否则返回false
System.out.println(set.add("jack"));
System.out.println(set.add("john"));
System.out.println(set.add("tom"));
System.out.println(set.add("jack"));
System.out.println(set.add("lucy"));
System.out.println(set.add("mary"));
//3、通过remove指定删除一个对象
set.remove("jack");
//输出的顺序不保证与添加的顺序一致
System.out.println("set = " + set);
//重置set集合
set = new HashSet();
System.out.println("重置set = " + set);
set.add("lucy"); //添加成功
set.add("lucy");//添加失败
//两个都添加成功，并且不重复
set.add(new Dog("tom"));
set.add(new Dog("tom"));
System.out.println("添加set = " + set);
//经典面试题，这两个是否添加成功而且不重复
set.add(new String("java"));
set.add(new String("java"));
//结论，只添加了一个java，原理需要看源码的add
System.out.println("面试set = " + set);
}
}
class Dog{
private String name;
public Dog(String name) {
this.name = name;
}
}
2、数组链表的模拟
HashSet底层是HashMap，HashMap底层是（数组+链表+红黑树）
/**
* 需要debug去了解
* 尤其是挂载的位置，next的指向会将这个数据结构变成一个链表
* 每个table的索引上可能会有一条链表
*/
public class HashSetStructure {
public static void main(String[] args) {
//模拟一个HashSet的底层结构（也就是HashMap的底层结构）
//1、创建一个数组，数组类型是Node[]
//2、有些人直接把Node[]数组称为表
Node[] table = new Node[16];
System.out.println("Node = " + table);
//创建节点
Node john = new Node("john", null);
//把节点放到索引为2的位置
table[2] = john;
//再创建一个节点
Node jack = new Node("jack", null);
//将jack挂载到john后面（也就是将jack加到john后面）
john.next = jack;
//再创建一个节点
Node rose = new Node("rose", null);
//将rose节点挂载到jack节点后面
jack.next = rose;
//将lucy放到索引为3的位置
Node lucy = new Node("lucy", null);
table[3] = lucy;
System.out.println("Node = " + table);
}
}
//节点，存储数据，可以指向下一个节点，从而形成链表
class Node{
Object item; //存放数据
Node next; //指向下一个节点
public Node(Object item, Node next) {
this.item = item;
this.next = next;
}
}
3、HashSet扩容解析
结论：
1、HashSet底层是HashMap
2、添加一个元素时，先得到hash值，hash值会转为索引值
3、找到存储数据表table，看到这个索引位置是否已经存放有数据
4、如果没有，则直接存放数据
5、如果有，会调用equals比较，如果相同，就放弃添加，如果不相同，则添加到最后
6、java8中，如果一条链表的元素个数超过TREEIFY_THRESHOLD（默认是8），并且table的大小 >= MIN_TREEEIFY_CAPACITY（默认64），就会进行树化（红黑树）
4、源码解读
第一步：创建HashSet，走的是构造器，HashMap
HashSet set = new HashSet();
//源码
public HashSet() {
map = new HashMap<>();
}
第一次，添加add源码
第二步：添加数据，执行add
set.add("java");
//源码
public boolean add(E e) {
// private static final Object PRESENT = new Object();
//PRESENT是起到占位作用，是一个静态不可改变的Object对象
//e是传进来的值
return map.put(e, PRESENT)==null; //底层的方法，返回的是null，则代表已经添加成功了
}
第三步：执行的是put方法，该方法会执行 hash(key) 得到key对应的hash值，但是得到的不是并不是key真正的 hashCode，为了降低hash冲突的几率，执行了一个算法
//源码
//key是传进来的值
//value是PRESENT，共享的
public V put(K key, V value) {
//hash(key)计算出hash值，确定数据在表里面的索引位置
return putVal(hash(key), key, value, false, true);
}
//源码，计算hash值，key是传进来的元素
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
第四步：执行putVal方法
//源码
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i; //辅助变量
//table 就是HashMap的一个数组，类型是Node[]
if ((tab = table) == null || (n = tab.length) == 0) //第一次添加初始状态table为空，长度等于0
n = (tab = resize()).length; //经过扩容，resize()，提供了16个空间
//1、根据key，得到hash 去计算这个key应该存放在table表的哪个索引位置，并且把这个位置的对象，赋值给 p
//2、再判断这个p是否为空，如果p为空，则表示该位置没有存放元素，就创建 Node(key,value)，其中这个key就是元素，value是占位PRESENT，最后一个null是next，指向下一个元素，hash是为了比较下一个存进来的值的hash是否相等
//3、最后将这个 Node newNode(hash, key, value, null)，放在 tab[i] 位置
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//threshold 通过resize()方法计算出的临界容量
if (++size > threshold)
resize(); //如果size大于临界容量，那么就开始扩容
afterNodeInsertion(evict); //空方法
return null; //代表成功了
}
第二次，添加重复元素
添加调用的方法，与第一次一致，但是执行putVal方法使用的不一致
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k; //声明辅助变量
//如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样
//并且满足下面两个条件之一：
//（1）准备加入的key和p指向的Node结点的key是同一个对象
//（2）p指向的Node结点的key的equals()和准备加入的key比较相同
//则不能加入
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//再判断p是不是一棵红黑树
//是的话就调用putTreeVal进行添加
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果table对应位置，已经是个链表，那么就使用for循环比较
//（1）依次和该链表的每个元素比较后，都不相同，则加入到该链表最后
//注意：在把元素添加到链表后，立即判断该链表是否已经到达8个节点，到达8个就调用treeifyBin()对当前这个链表进行树化（转成红黑树）
//注意：在转成红黑树前需要进行判断，判断条件如下
//tab不为null并且tab的长度不超过64
//if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
//resize();
//如果上述条件成立，先进行table扩容，不成立再进行树化
//（2）依次和该链表的每个元素比较后，如果存在一个相同的，直接break
for (int binCount = 0; ; ++binCount) {//循环比较
//e是链表的第二个元素，p是第一个元素，依次类推，e是第三个元素时，则p是第二个元素
//判断e是否为null，如果是，则直接添加
if ((e = p.next) == null) {
// 链表中，给p的下一个值赋值
p.next = newNode(hash, key, value, null);
//判断是否需要进行树化
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//不是null，进行比较，如果链表上的值与要添加进来的值一致，直接break
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;//再将e的值赋值给p，进行e后移一个元素
}
}
//判断这个e是否为空，不为空则返回的是添加进来的值，说明添加失败
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//size，每加入一个节点Node，就会增加1
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
5、HashSet的扩容和转成红黑树机制
结论：
1、HashSet底层是HashMap，第一次添加时，table数组扩容到16，临界值（threshold）是16*加载因子（loadFactor = 0.75）= 12
2、如果table数组使用到了临界值12，就会扩容到16 * 2 = 32，新的临界值就是32 * 0.75 = 24，以此类推
3、在java8中，涂过一条链表的元素个数达到了 TREEIFY_THRESHOLD（默认是8），并且table的大小 >= MIN_TREEIFY_CAPACITY（默认64），就会进行树化（红黑树），否则仍然采用数组扩容机制
演示代码：
public class HashSetIncrement {
public static void main(String[] args) {
HashSet set = new HashSet();
//1、HashSet底层是HashMap，第一次添加时，table数组扩容到16，临界值（threshold）是16*加载因子（loadFactor = 0.75）= 12
//2、如果table数组使用到了临界值12，就会扩容到16 * 2 = 32，新的临界值就是32 * 0.75 = 24，以此类推
//添加
for (int i = 0; i <= 100; i++) {
set.add(String.valueOf(i));
}
//3、在java8中，涂过一条链表的元素个数达到了 TREEIFY_THRESHOLD（默认是8），
// 并且table的大小 >= MIN_TREEIFY_CAPACITY（默认64），就会进行树化（红黑树），
// 否则仍然采用数组扩容机制
//如何将元素放到同一个链表上，首先保证hash值相同，但是值的内容不同
for (int i = 0; i <= 12; i++) {
set.add(new A(i)); //保证hash一致
}
System.out.println("set = " + set);
}
}
class A{
private int n;
public A(int n) {
this.n = n;
}
@Override
public int hashCode() {
return 100;
}
}
疑问：
set集合中size是否是只是计算链表的第一个元素，还是计算table 中的所有元素?
测试：
import java.util.HashSet;
import java.util.Objects;
public class HashSetIncrement {
public static void main(String[] args) {
HashSet set = new HashSet();
/**
* 判断size是否只是计算table中链表的第一个元素，还是计算所有的元素
* 在添加元素时，底层会将元素封装为一个Node，再加入到table中，就算增加一个元素，size++，不只是table中链表的第一个元素
*/
//先给table中的某条链表添加7个A对象
for (int i = 0; i <= 7; i++){
set.add(new A(i)); //加在同一条链表上
}
//再给table的另一条链表添加7个B对象
for (int i = 0; i <= 7; i++) {
set.add(new B(i)); //加在同一条链表上
}
}
}
class B{
private int n;
public B(int n) {
this.n = n;
}
@Override
public int hashCode() {
return 200;
}
}
class A{
private int n;
public A(int n) {
this.n = n;
}
@Override
public int hashCode() {
return 100;
}
}
结论：
1、在添加元素时，底层会将元素封装为一个Node，再加入到table中，就算增加一个元素，size++，不只是table中链表的第一个元素
2、即使table没有被填满，但是当size到达临界值，也会触发扩容机制，进行扩容
6、HashSet练习
第一题：
要求：
1、定义一个Employee类，该类包含private成员属性name，age
2、创建3个Employee对象，放入HashSet中
3、当name和age值相同时，人为是相同员工，不能添加到HashSet集合中
import java.util.HashSet;
import java.util.Objects;
public class HashSetExercise {
public static void main(String[] args) {
HashSet set = new HashSet();
//经过重写equals和hashCode后，当名字和年龄相同后，hashSet就会认为添加的元素相同，加入不成功
set.add(new Employee("tom",18));
set.add(new Employee("jack",19));
set.add(new Employee("tom",18));
System.out.println("set = " + set);
}
}
class Employee{
private String name;
private int age;
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public Employee() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return age == employee.age &&
Objects.equals(name, employee.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
第二题：
要求：
1、定义一个Employee类，该类包含：private成员属性name，sal，birthday（MyDate类型），其中birthday为MyDate类型（属性包括：year,month,day）
2、创建3个Employee放入HashSet中
3、当name和birthday的值相同时，认为是相同员工，不能添加到HashSet集合中
import java.util.HashSet;
import java.util.Objects;
public class HashSetExercise02 {
public static void main(String[] args) {
HashSet set = new HashSet();
set.add(new Employee02("tom",12,new MyData(2012,12,5)));
set.add(new Employee02("jack",12,new MyData(2012,12,5)));
set.add(new Employee02("tom",12,new MyData(2012,12,5)));
System.out.println("set = " + set);
}
}
class Employee02{
private String name;
private int sal;
private MyData birthday;
public Employee02() {
}
public Employee02(String name, int sal, MyData birthday) {
this.name = name;
this.sal = sal;
this.birthday = birthday;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSal() {
return sal;
}
public void setSal(int sal) {
this.sal = sal;
}
public MyData getBirthday() {
return birthday;
}
public void setBirthday(MyData birthday) {
this.birthday = birthday;
}
@Override
public String toString() {
return "Employee02{" +
"name='" + name + '\'' +
", sal=" + sal +
", birthday=" + birthday +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee02 that = (Employee02) o;
return sal == that.sal &&
Objects.equals(name, that.name) &&
Objects.equals(birthday, that.birthday);
}
@Override
public int hashCode() {
return Objects.hash(name, sal, birthday);
}
}
class MyData{
private int year;
private int month;
private int day;
public MyData(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public MyData() {
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
@Override
public String toString() {
return "MyData{" +
"year=" + year +
", month=" + month +
", day=" + day +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MyData myData = (MyData) o;
return year == myData.year &&
month == myData.month &&
day == myData.day;
}
@Override
public int hashCode() {
return Objects.hash(year, month, day);
}
}
7、LinkedHashSet
介绍：
1、LinkedHashSet是HashSet的子类
2、LinkedHashSet底层是一个LinkedHashMap，底层维护一个 数组 + 双向链表
3、LinkedHashSet根据元素的HashCode值来决定元素的存储位置，同时使用链表维护元素的次序（图），这使得元素看起来是以插入顺序保存的
4、LinkedHashSet不允许有重复元素
说明：
1、在LinkedHashSet中维护了一个hash表和双向链表（LinkedHashSet 有 head 和 tail）
2、每一个节点有 before 和 after 属性，这样可以形成双向链表
3、在添加一个元素时，先求hash值，在求索引，确定该元素在hashtable的位置，然后将添加的元素加入到双向链表（如果已经存在，不添加【原则和HashSet一样】）
tail.next = newElement //简单指定
newElement.pre = tail
tail = newElement;
4、这样的话，我们遍历LinkedHashSet也能确保插入顺序和遍历顺序一致
分析底层：
检测代码：
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetSource {
public static void main(String[] args) {
Set set = new LinkedHashSet();
set.add(new String("AA"));
set.add(456);
set.add(456);
set.add(new Customer("漩涡鸣人",1001));
set.add(123);
set.add("HELLO");
System.out.println("set = " + set);
}
}
class Customer{
private String name;
private int num;
public Customer() {
}
public Customer(String name, int num) {
this.name = name;
this.num = num;
}
@Override
public String toString() {
return "Customer{" +
"name='" + name + '\'' +
", num=" + num +
'}';
}
}
解读：
1、LinkedHashSet 添加和取出元素/数据的顺序是一致的
2、LinkedHashSet底层维护的是一个LinkedHashMap（是HashMap的子类）
3、LinkedHashSet底层结构（数组table + 双向链表）
4、添加第一次时，直接将数组table扩容到16，存放的接待您类型是LinkedHashMap$Entry
5、数组时HashMap$Node[] 存放的元素 / 数据是LinkedHashMap$Entry（数组多态，Entry继承了HashMap的Node，继承关系是在内部类进行完成的）
6、底层的添加方法还是走的HashSet添加方法
add()源码：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
练习：
要求：
Car类（属性：name，price），如果name和price一样，则认为是相同元素，就不添加
需要重写equals方法和hashCode方法
import java.util.LinkedHashSet;
import java.util.Objects;
public class LinkedHashSetExercise {
public static void main(String[] args) {
LinkedHashSet set = new LinkedHashSet();
set.add(new Car("奥迪",100));
set.add(new Car("宝马",110));
set.add(new Car("法拉利",100));
set.add(new Car("奥迪",100));
System.out.println("set = " + set);
}
}
class Car{
private String name;
private int price;
public Car(String name, int price) {
this.name = name;
this.price = price;
}
public Car() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Car car = (Car) o;
return price == car.price &&
Objects.equals(name, car.name);
}
@Override
public int hashCode() {
return Objects.hash(name, price);
}
}
五、Map接口和常用方法
特点介绍：
注意：这里讲的是JDK8的Map接口特点
1、Map与Collection并列存在。用于存放具有映射关系的数据：Key-Value
2、Map中的key和value可以是任何引用类型的数据，会封装HashMap$Node对象中
3、Map中的key不可以重复，原因和HashSet一致（替换机制，会将key相同的旧值替换成新的值）
4、Map中的value可以重复
5、Map的key可以为null，value也可以为null，但是key为null，只能有一个，value为null，可以为多个
6、常用String类作为Map的key，只要是Object的子类都可做key
7、key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value
8、Map存放数据的key-value示意图，一对k-v是放在一个Node中的，有因为Node实现了Entry，有的书上也说一对k-v就是一个Entry
//第8点源码
static class Node<K,V> implements Map.Entry<K,V>
import java.util.HashMap;
import java.util.Map;
public class Map_ {
public static void main(String[] args) {
//实现类的特点
Map map = new HashMap();
//1、Map与Collection并列存在。用于存放具有映射关系的数据：Key-Value（双列元素）
//底层是hash，Node结点
//2、Map中的key和value可以是任何引用类型的数据，会封装HashMap$Node对象中
map.put("num1","hello");//k-v
map.put("num2","world");//k-v
//3、Map中的key不可以重复，原因和HashSet一致，当有相同的key，等价于替换
map.put("num2","hhhh");//k-v
//4、Map中的value可以重复
map.put("num3","hhhh");//k-v
//5、Map的key可以为null，value也可以为null，但是key为null，只能有一个，value为null，可以为多个
map.put(null,null);
map.put(null,"abc");//替换map.put(null,null);中的值
map.put("num4",null);
map.put("num5",null);
//6、常用String类作为Map的key，只要是Object的子类都可做key
map.put(1,"张三");
map.put(new Object(),"李四");
//7、key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value
System.out.println("key = 1 " + map.get(1));
System.out.println(map.get("key = num5 " + map.get("num5")));
System.out.println("map = " + map);
}
}
代码解读：
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapSource_ {
public static void main(String[] args) {
Map map = new HashMap();
map.put("num1","hello");//k-v
map.put("num2","world");//k-v
//1、k-v最后是存在 HashMap$Node node = newNode(hash, key, value, null); 的对象中
//2、k-y为了方便遍历，还会在底层创建一个EntrySet集合，该集合存放元素的数据类型是Entry，
// 而一个Entry对象就有k、v EntrySet<Entry<K,V>> 即：transient Set<Map.Entry<K,V>> entrySet;
//3、在entrySet中，定义的类型是Map.Entry，但是实际上存放的还是 HashMap$Node，因为HashMap$Node实现了Map.Entry的接口
//即 HashMap$Node implements Map.Entry
//4、把 HashMap$Node对象 存放到entrySet就可方便遍历
//因为Map.Entry提供了两个重要方法，即 K getKey(); 和 V getValue();
Set set = map.entrySet();
System.out.println(set.getClass());
for (Object object : set) {
//System.out.println(object.getClass());
//为了从HashMap$Node对象中取出k-v
//1、首先进行向下转型
Map.Entry entry = (Map.Entry) object;
// System.out.println("key = " + entry.getKey());
// System.out.println("value = " + entry.getValue());
System.out.println(entry.getKey() + "-" + entry.getValue());
}
//获取map集合中的所有key
Set keySet = map.keySet();
System.out.println("keySet = " + keySet);
//获取map集合中的所有value
Collection values = map.values();
System.out.println("values = " + values);
}
}
为了方便管理，把底层的每个node封装为一个Entry，再把每个Entry放在EntrySet中，关系如下，每个key和value是通过内存地址指向的
1、Map接口常用方法
import java.util.HashMap;
import java.util.Map;
public class MapMethod {
public static void main(String[] args) {
Map map = new HashMap();
map.put("book",new Book("三国",120));
map.put("雷军","小米");
map.put("任正非","华为");
map.put("库克","苹果");
map.put("马斯克","特斯拉");
map.put("孙悟空",null);
map.put(null,"唐僧");
//remove：根据key删除value，根据键删除映射关系
map.remove(null);
//get：根据键获取值，根据key获取value
System.out.println("get = " + map.get("雷军"));
//size：获取元素个数
System.out.println("size = " + map.size());
//isEmpty：判断集合个数是否为0
System.out.println("isEmpty = " + map.isEmpty());
//containsKey：查找键是否存在，返回boolean值
System.out.println("containsKey = " + map.containsKey("任正非"));
//clear：清除
map.clear();
System.out.println("clear = " + map);
System.out.println("map = " + map);
}
}
class Book{
private String name;
private int price;
public Book(String name, int price) {
this.name = name;
this.price = price;
}
public Book() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
2、Map的遍历方法
import java.util.*;
public class MapFor {
public static void main(String[] args) {
Map map = new HashMap();
map.put("雷军","小米");
map.put("任正非","华为");
map.put("库克","苹果");
map.put("马斯克","特斯拉");
map.put("孙悟空","猪八戒");
map.put("白龙马","唐僧");
//第一组：先取出所有的key，通过key取出所有的value
Set keySet = map.keySet();
System.out.println("=================第一组遍历方式=====================");
//(1)增强for循环
System.out.println("-----------第一种：增强for循环-------------");
for (Object key : keySet) {
System.out.println(key + "-" + map.get(key));
}
//(2)迭代器
System.out.println("-----------第一种：迭代器-------------");
Iterator iterator = keySet.iterator();
while (iterator.hasNext()){
//这个iterator.next()就是一个个的key
Object key = iterator.next();
System.out.println(key + "-" + map.get(key));
}
//第二组：把所有的value取出，value是一种集合，
System.out.println("=================第二组遍历方式=====================");
Collection values = map.values();
//(1)增强for循环
System.out.println("-----------第一种：增强for-------------");
for (Object value : values) {
System.out.println("value = " + value);
}
//(2)迭代器
System.out.println("-----------第二种：迭代器-------------");
Iterator valueIterator = values.iterator();
while (valueIterator.hasNext()){
Object value = valueIterator.next();
System.out.println("value = " + value);
}
//第三组：通过EntrySet来获取key-value
System.out.println("=================第三组遍历方式=====================");
Set entrySet = map.entrySet(); //类型 EntrySet<Entry<k,v>>
//(1)增强for
System.out.println("-----------第一种：增强for-------------");
for (Object entry : entrySet) {
//将 entry 转为 Map.Entry
Map.Entry m = (Map.Entry) entry;
//在进行取值
System.out.println(m.getKey() + "-" + m.getValue());
}
//(2)迭代器
System.out.println("-----------第二种：迭代器-------------");
Iterator entryIterator = entrySet.iterator();
while (entryIterator.hasNext()) {
//这里的next的类型是HashMap$Node，但是Node继承了 Map.Entry
Object next = entryIterator.next();
//所以这里就可以将next转为 Map.Entry
Map.Entry m = (Map.Entry) next;
System.out.println(m.getKey() + "-" + m.getValue());
}
}
}
练习：
要求：
使用HashMap添加3个员工对象
键：员工id
值：员工对象
并且遍历显示工资大于18000的员工（遍历方式不少于两种）
员工类：姓名，工资，员工id
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapExercise {
public static void main(String[] args) {
Map map = new HashMap();
map.put(1001,new Employee("张三",15000,1001));
map.put(1002,new Employee("李四",19000,1002));
map.put(1003,new Employee("王五",20000,1003));
map.put(1004,new Employee("赵六",11000,1004));
map.put(1005,new Employee("孙七",18000,1005));
map.put(1006,new Employee("张八",14000,1006));
//System.out.println("map = " + map);
//获取所有的key
Set keySet = map.keySet();
//遍历方式一
//(1)增强for循环
System.out.println("-----------第一种遍历：增强for-------------");
for (Object key : keySet) {
//根据key获取值，也就是Employee对象
Object object = map.get(key);
//向下转型
Employee employee = (Employee) object;
//判断薪资
if (employee.getSal() > 18000){
System.out.println(employee);
}
}
//(2)迭代器
System.out.println("-----------第二种遍历：迭代器-------------");
Iterator iterator = keySet.iterator();
while (iterator.hasNext()){
//所有的key
Object key = iterator.next();
//根据key获取对应的Employee对象
Object object = map.get(key);
//向下转型
Employee employee = (Employee) object;
//判断薪资
if (employee.getSal() > 18000){
System.out.println(employee);
}
}
//(3)使用EntrySet
System.out.println("-----------第三种遍历：entrySet-------------");
Set entrySet = map.entrySet();
for (Object entry : entrySet) {
//将 entry 转为 Map.Entry
Map.Entry m = (Map.Entry) entry;
//取出Employee对象，并且向下转型，因为Object对象
Employee employee = (Employee) m.getValue();
//判断薪资
if (employee.getSal() > 18000){
System.out.println(employee);
}
}
}
}
class Employee{
private String name;
private int sal;
private int id;
public Employee(String name, int sal, int id) {
this.name = name;
this.sal = sal;
this.id = id;
}
public Employee() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSal() {
return sal;
}
public void setSal(int sal) {
this.sal = sal;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", sal=" + sal +
", id=" + id +
'}';
}
}
3、HashMap小结
1、Map接口的常用实现类：HashMap、Hashtable和Properties
2、HashMap是Map接口使用频率最高的实现类
3、HashMap是以key-value的方式来存储数据（数据类型是HashMap$Node类型）
4、key不能重复，但是值可以重复，允许使用null键和null值
5、如果添加相同的key，则会覆盖原来的key-value，等同于修改（key不会替换，value会替换）
6、与HashSet一样，不保存映射的顺序，因为底层是以hash表方式来存储的（HashMap底层 数组 + 链表 + 红黑树）
7、HashMap没有实现同步，所以线程不安全
4、HashMap的底层机制及源码剖析
示意图：
table表是个数组，数组中放有链表或者是一棵树，每个节点就是一个Node，Node这个类型又实现了Map.Entry接口
1、（k1,v1）是一个Node实现了Map.Entry<K,V>，查看HashMap的源码可以看到
2、jdk7.0的HashMap底层实现 [数组 + 链表]，jdk8.0底层 [数组 + 链表 + 红黑树]
扩容机制：
1、HashMap底层维护了Node类型的数组table，默认为null
2、当创建爱你对象时，将加载因子（loadfactor）初始化为0.75
3、当添加 key-value 时，通过key的哈希值得到在table中的索引，然后判断该索引是否有元素，如果没有元素，直接添加，如果该索引有元素，继续判断该元素的key是否和准备加入的key相等，如果相等，直接替换value；如果不相等需要判断是树结构还是链表结构，做出相应的处理，如果添加时发现容量不够，则需要扩容
4、第1次添加，则需要扩容table容量为16，临界值（threshold）为12
5、以后再扩容，则需要扩容table容量为原来的2倍，临界值为原来的2倍，即24，以此类推
6、在java8中，如果一条链表的元素超过TREEIFY_THRESHOLD（默认为8），并且table的大小 >= MIN_TREEIFY_CAPACITY（默认64），就会进化为红黑树
源码剖析：
测试代码：
import java.util.HashMap;
public class MapSource {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("java",10);
map.put("mysql",10);
map.put("java",11);
System.out.println("map = " + map);
}
}
第一步：执行构造器，初始化加载因子，table数组类型是HashMap$Node类型
HashMap$Node[] table = null;
//源码：初始化加载因子
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//加载因子的值
static final float DEFAULT_LOAD_FACTOR = 0.75f;
第二步：执行put方法
//源码：hash(key)计算key的hash值
public V put(K key, V value) {
//执行putVal方法
//此时的key就是传进来的key，value是传进来的value
return putVal(hash(key), key, value, false, true);
}
//执行的hash()
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
第三步：执行putVal
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i; //辅助变量
//第一步先判断table是否为null，第一次添加时table一定是为null的
if ((tab = table) == null || (n = tab.length) == 0)
//table为null时，首先进行扩容处理，resize()扩容方法
n = (tab = resize()).length;//扩容完毕后，返回一个空的table表，有16个空间
//计算得到了hash值，将这个k-y放到hash值对应的table表索引中，同时将这个值赋值给 p 变量，但是要确保这个索引位置没有元素
if ((p = tab[i = (n - 1) & hash]) == null)
//在table[i]的位置插入该元素，i是根据hash值得到的索引位置，也就是这个元素在table表中的索引位置
//元素的类型是Node
tab[i] = newNode(hash, key, value, null);
else { //当key重复时，就是进入这里
Node<K,V> e; K k; //临时变量
//三种情况
//（1）p的hash值是否与hash值是否相同，这个hash是现在加入的元素的hash值，p.hash是已经存在table中的元素的hash值
//（2）新加入的key是否与p的key是否是同一个对象
//（3）新的key不为空但是内容相同
//这三种情况出现都不在进行添加
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p; //把p赋值给e，辅助变量
else if (p instanceof TreeNode) //如果这个p是树
//按照红黑树方式添加
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//这里是循环数组中的链表，查询现在插入的元素在这条链表上是否有同样的元素
for (int binCount = 0; ; ++binCount) { //这个是死循环，只有满足条件才会跳出
//如果链表上没有相同的元素
if ((e = p.next) == null) {
//直接在链表的末尾插入这个新的元素
p.next = newNode(hash, key, value, null);
//判断链表是否达到了8个元素，如果达到了进行树化，TREEIFY_THRESHOLD = 8
if (binCount >= TREEIFY_THRESHOLD - 1) // 当binCount = 8 时，也就是添加到第9个元素时，开始调用树化方法，但是并不是马上树化（转成红黑树）
treeifyBin(tab, hash); //树化
break;//查询到了链表中有一样的元素，跳出循环，不进行添加
}
//与上面的判断一致
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;//不在执行添加，直接跳出循环
p = e; //将e赋值给p
}
}
//key重复，e不为null
if (e != null) { // existing mapping for key
V oldValue = e.value; //将e的值赋值给旧值oldValue
//判断如果这个旧值oldValue为空或者onlyIfAbsent取反满足条件
if (!onlyIfAbsent || oldValue == null)
//将e的value值替换为新的value
e.value = value;
afterNodeAccess(e);
return oldValue;//返回旧的value
}
}
++modCount;
//++size是添加元素后的size，再与临界值比较，如果达到了临界值，开始扩容
if (++size > threshold)
resize(); //扩容
afterNodeInsertion(evict);
return null;
}
第四步：扩容方法 resize()
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; //声明一个旧的table，将空的table赋值给oldTab
int oldCap = (oldTab == null) ? 0 : oldTab.length; //判断旧的table容量
int oldThr = threshold; //临界值赋值给旧的临界值
int newCap, newThr = 0; //声明新的容量和新的临界值，赋值为0
if (oldCap > 0) { //判断旧的table容量是否大于0
if (oldCap >= MAXIMUM_CAPACITY) { //如果旧的table容量大于额定的容量
threshold = Integer.MAX_VALUE; //给临界值重新赋值
return oldTab; //返回旧的table的容量
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1;
}
else if (oldThr > 0) //判断旧的临界值是否大于0
newCap = oldThr;
else {//当上面条件都满足，则就是给默认的table表额定容容量
newCap = DEFAULT_INITIAL_CAPACITY; //指定容量 16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //计算临界值
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr; //这里就是给定的临界值
@SuppressWarnings({"rawtypes","unchecked"})
//这里则生成已经扩容好的table，容量大小由newCap指定，而table表的类型是Node类型
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
5、Hashtable的扩容机制与源码分析
基本介绍：
1、存放的元素时键值对：k-v
2、Hashtable的键和值不能为null，否则抛出NullPointerException异常
3、Hashtable使用方法基本和HashMap一样
4、Hashtable是线程安全的，HashMap是线程不安全的
5、Hashtable的底层是一个Entry数组
演示代码：
import java.util.Hashtable;
import java.util.Map;
public class HashTableMethod {
public static void main(String[] args) {
Hashtable table = new Hashtable();
table.put("java",100); //ok
table.put(null,100); //异常
table.put("mysql",null); //异常
table.put("redis",20); //ok
table.put("redis",100); //替换上面键相同的元素
System.out.println("table = " + table);
}
}
分析底层：
1、底层有数组 Hashtable$Entry[] ，Entry是Hashtable的内部类，继承了Map.Entry，初始大小为11，临界值为8
//源码，初始化调用无参构造，11为初始大小，0.75为加载因子
public Hashtable() {
this(11, 0.75f);
}
2、执行put方法
public synchronized V put(K key, V value) {
// 这里规定的是value不能为null
if (value == null) {
throw new NullPointerException();
}
// 创建一个Entry类型的数组table
Entry<?,?> tab[] = table;
//计算key的hash
int hash = key.hashCode();
//计算元素应该存放的下标位置
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
//向下转型，取出table在index位置上的Entry元素
Entry<K,V> entry = (Entry<K,V>)tab[index];
//for循环中判断，如果entry不为null，那就需要进行比较，这个entry上的元素是否与现在插入的元素的key一致
for(; entry != null ; entry = entry.next) {
//判断该位置上的key是否相同
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
//进行替换
entry.value = value;
return old;
}
}
//执行真正的添加方法
addEntry(hash, key, value, index);
return null;
}
3、执行真正的添加方法 addEntry
private void addEntry(int hash, K key, V value, int index) {
modCount++; //记录集合修改次数
Entry<?,?> tab[] = table; //创建一个空的table
//判断table表中的总数是否大于或者等于临界值
if (count >= threshold) {
// 如果超过，则进行扩容
rehash();
tab = table;
hash = key.hashCode(); //获取key的hash值
index = (hash & 0x7FFFFFFF) % tab.length; //计算元素在table表中的下标index
}
// Creates the new entry.
@SuppressWarnings("unchecked")
//找到之前元素在table表中的位置
Entry<K,V> e = (Entry<K,V>) tab[index];
//在table表中index位置存放新的Entry类型元素
tab[index] = new Entry<>(hash, key, value, e);
count++;
}
4、扩容rehash()方法
扩容计算机制：oldCapacity * 2 + 1
扩容后临界值计算机制：(int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1) 新的容量 * 加载因子后，与最大容量 + 1 进行取最小值，取扩容后的临界值
protected void rehash() {
//获取当前table的长度
int oldCapacity = table.length;
//声明一个Entry类型数组的table
Entry<?,?>[] oldMap = table;
// overflow-conscious code
//新的容量计算，旧的容量向左移一位，相当于*2，再加上1
int newCapacity = (oldCapacity << 1) + 1;
//判断新的容量如果大于了额定的最大容量
if (newCapacity - MAX_ARRAY_SIZE > 0) {
//再次判断旧的容量是否等于额定的最大容量
if (oldCapacity == MAX_ARRAY_SIZE)
// Keep running with MAX_ARRAY_SIZE buckets
return;
//以最大容量为标准
newCapacity = MAX_ARRAY_SIZE;
}
//按照最新的容量创建一个Entry类型的数组，大小为已经扩容后的大小
Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
modCount++;
//重新计算临界值
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
//将这个新的数组赋值给table表
table = newMap;
//将旧的table表中的元素移动到新的数组上
for (int i = ol dCapacity ; i-- > 0 ;) {
for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
Entry<K,V> e = old;
old = old.next;
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = (Entry<K,V>)newMap[index];
newMap[index] = e;
}
}
}
6、Properties的基本介绍
1、Properties类继承了Hashtable类并且实现了Map接口，也是一种使用键值对类型存储数据
2、使用特点与Hashtable类似
3、Properties还可以用于从 xxx.properties 文件中，加载数据到Properties类对象，进行读取和修改
4、xxx.properties 文件通常作为配置文件
基本使用：
import java.util.Properties;
public class Properties_ {
public static void main(String[] args) {
Properties properties = new Properties();
//添加，k-y
properties.put("java",100);
properties.put("mysql",100);
properties.put("python",100);
properties.put("php",100);
//相同的key，value也会被替换，相当于修改
properties.put("php",300);
//因为 properties 是 Hashtable 的子类，所以key和value都不能为null
//properties.put(null,100); //异常
//properties.put("html",null);//异常
//通过key获取value
System.out.println("get = " + properties.get("java"));
//通过key移除元素
properties.remove("mysql");
System.out.println("remove = " + properties);
System.out.println("properties = " + properties);
}
}
六、总结
在开发中，选择什么样集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择，分析如下：
1、先判断存储类型（一组对象或一组键值对）
2、一组对象 [单列集合]：Collection接口
-
允许重复：List接口实现类
增删操作多：LinkedList [底层维护了一个双向链表]
改查操作多：ArrayList [底层维护 Object 类型的可变数组]
-
不允许重复：Set接口实现类
无序：HashSet [底层是HashMap，维护了一个哈希表，即（数组 + 链表 + 红黑树）]
排序：TreeSet
插入和取出顺序一致：LinkedHashSet，维护数组 + 双向链表
3、一组键值对 [双列集合]：Map接口实现类
键无序：HashMap [底层是：哈希表 jdk7：数组 + 链表，jdk8：数组 + 链表 + 红黑树 ]
键排序：TreeMap
键插入和取出顺序一致：LinkedHashMap
读取文件：Properties
七、TreeSet和TreeMap的源码剖析
1、TreeSet
特点：
1、相比于HashSet来说，可排序
2、使用无参构造器，创建TreeSet时，使用的是自然排序
3、底层使用的是TreeMap，是Entry类型
4、源码区别
//TreeSet的add方法源码
public boolean add(E e) {
//e是存放进来的值，PRESENT是一个空的Object对象
//private static final Object PRESENT = new Object();
return m.put(e, PRESENT)==null;
}
默认排序：
import java.util.TreeSet;
public class TreeSet_ {
public static void main(String[] args) {
TreeSet treeSet = new TreeSet();
treeSet.add("java");
treeSet.add("mysql");
treeSet.add("php");
treeSet.add("python");
System.out.println("treeSet = " + treeSet);
}
}
实现接口的匿名内部类进行排序：
import java.util.Comparator;
import java.util.TreeSet;
public class TreeSet_ {
public static void main(String[] args) {
TreeSet treeSet = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//调用的是String的compareTo方法进行比较
//原理是取出每个字符的长度，进行ASCII码比较
return ((String)o1).compareTo((String)o2);
}
});
treeSet.add("mysql");
treeSet.add("php");
treeSet.add("python");
treeSet.add("java");
System.out.println("treeSet = " + treeSet);
}
}
源码：
第一步：构造器把传入的比较对象（Comparator），赋给了 TreeSet 底层的 TreeMap 属性
//源码
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
第二步：添加元素，添加第一个元素时，不会走比较器
public V put(K key, V value) {
Entry<K,V> t = root; //取出元素，树化
if (t == null) { //只有元素为null时走这里，就是第一次添加时走这里
//传了两个相同的key，检查key是否为空
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
//辅助变量
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
//比较器，声明TreeSet时，传入的比较器，在这里赋值
Comparator<? super K> cpr = comparator;
//当这个比较器不为null时，进行比较
//cpr就是一个匿名内部类
if (cpr != null) {
do {
parent = t;
//动态绑定到匿名内部类（对象）compare方法
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value); //如果相等，cmp为0，数据就加入不了，相当于替换
} while (t != null);
}
//这里是没有匿名内部类的逻辑
else {
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
//根据compareTo进行比较
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
2、TreeMap
特点：
1、传入的是k-y，比较key
默认排序：
在使用无参构造器时，这里的排序是根据ASCII码进行比较的，字母表顺序排序
import java.util.TreeMap;
public class TreeMap_ {
public static void main(String[] args) {
TreeMap treeMap = new TreeMap();
treeMap.put("java",100);
treeMap.put("mysql",200);
treeMap.put("php",300);
treeMap.put("js",400);
System.out.println("treeMap = " + treeMap);
}
}
//输出打印 treeMap = {java=100, js=400, mysql=200, php=300}
使用匿名内部类进行排序：
import java.util.Comparator;
import java.util.TreeMap;
public class TreeMap_ {
public static void main(String[] args) {
//传入匿名内部类
TreeMap treeMap = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//比较规则：按照传入的k（String）的大小进行排序
return ((String)o2).compareTo((String)o1);
}
});
treeMap.put("java",100);
treeMap.put("mysql",200);
treeMap.put("php",300);
treeMap.put("js",400);
System.out.println("treeMap = " + treeMap);
}
}
//打印输出 treeMap = {php=300, mysql=200, js=400, java=100}
源码：
第一步：接收传入的实现了匿名内部类（对象）Comparator，传给了TreeMap的comparator属性
//源码
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
第二步：调用add方法
public V put(K key, V value) {
Entry<K,V> t = root;
//第一次添加走这里
if (t == null) {
//传了两个相同的key，检查key是否为空
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
//接收传入的匿名内部类（对象）比较方法
Comparator<? super K> cpr = comparator;
//进入比较器
if (cpr != null) {
//遍历，如果遍历完后没有一个数据与传进来的数据相同，那就会挂到root上
//如果有一个数据相同，那就不会挂载
do {
parent = t;
//这里的值相等判断与HashMap有区别
//HashMap判断值是否相等是通过hash或者equals方法等进行判断的
//这里的相等是通过compare方法决定的
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value); //有相同的，替换
} while (t != null);
}
//走默认的比较规则
else {
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
//默认的比较规则
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
Entry<K,V> e = new Entry<>(key, value, parent);
//判断元素挂载在左边还是挂载在右边
if (cmp < 0)
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
八、Collections工具类
基本介绍：
1、Collections是一个操作Set、List和Map等集合的工具类
2、Collections中提供了一系列静态方法对集合元素进行排序、查询和修改等操作
排序操作：（均为static方法）
1、reverse（List）：反转 List 中元素顺序
2、shuffle（List）：对 List 集合元素进行随机排序
3、sort（List）：根据元素的自然顺序对指定List集合元素按升序排序
4、sort（List，Comparator）：根据指定的Comparator产生的顺序对List集合元素进行排序
5、swap（List，int，int）：将指定List集合中的 i 处元素和 j 处元素进行交换
测试代码：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Collections_ {
public static void main(String[] args) {
List list = new ArrayList();
list.add("java");
list.add("mysql");
list.add("css");
list.add("html");
list.add("js");
//reverse（List）：反转 List 中元素顺序
Collections.reverse(list);
System.out.println("reverse = " + list);
//shuffle（List）：对 List 集合元素进行随机排序
Collections.shuffle(list);
System.out.println("shuffle = " + list);
//sort（List）：根据元素的自然顺序对指定List集合元素按升序排序
Collections.sort(list);
System.out.println("sort = " + list);
//sort（List，Comparator）：根据指定的Comparator产生的顺序对List集合元素进行排序
Collections.sort(list, new Comparator<Object>() {
@Override
public int compare(Object o1, Object o2) {
//自定义排序规则
return ((String)o1).length() - ((String)o2).length();
}
});
System.out.println("sort自定义排序 = " + list);
//swap（List，int，int）：将指定List集合中的 i 处元素和 j 处元素进行交换
Collections.swap(list, 2, 3);
System.out.println("swap = " + list);
}
}
查找、替换：
1、Object max(Collection)：根据元素的自然顺序，返回给定集合中最大元素
2、Object max(Collection，Comparator)：根据Comparator指定的顺序，返回集合中最大的元素
3、Object mix(Collection)：根据元素的自然顺序，返回给定集合中最小元素
4、Object mix(Collection，Comparator)：根据Comparator指定的顺序，返回集合中最小的元素
5、int frequency(Collection，Object)：返回指定集合中指定元素出现次数
6、void copy(List dest,List src)：将src的内容复制到dest中
7、boolean replayceAll(List list,Object oldVal,Object newVal)：使用新的值替换List对象的所有旧值
演示代码：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Collections_ {
public static void main(String[] args) {
List list = new ArrayList();
list.add("java");
list.add("mysql");
list.add("css");
list.add("html");
list.add("js");
//Object max(Collection)：根据元素的自然顺序，返回给定集合中最大元素
System.out.println("自然排序最大值：" + Collections.max(list));
//Object max(Collection，Comparator)：根据Comparator指定的顺序，返回集合中最大的元素
System.out.println("自定义规则最大值：" + Collections.max(list, new Comparator<Object>() {
@Override
public int compare(Object o1, Object o2) {
//自定义比较规则
return ((String)o1).length() - ((String)o2).length();
}
}));
//参考max即可
//Object mix(Collection)：根据元素的自然顺序，返回给定集合中最小元素
//Object mix(Collection，Comparator)：根据Comparator指定的顺序，返回集合中最小的元素
//int frequency(Collection，Object)：返回指定集合中指定元素出现次数
System.out.println("frequency：" + Collections.frequency(list,"java"));
//void copy(List dest,List src)：将src的内容复制到dest中
ArrayList dest = new ArrayList();
//拷贝前需要给dest赋值，长度与list现在的长度一致
for (int i = 0; i < list.size(); i++) {
dest.add("");
}
//拷贝
Collections.copy(dest,list);
System.out.println("dest = " + dest);
//boolean replayceAll(List list,Object oldVal,Object newVal)：使用新的值替换List对象的所有旧值
Collections.replaceAll(list,"java","javaee");
System.out.println("replaceAll = " + list);
}
}
