韩顺平-Java集合笔记从零到源码 -ArrayList HashMap HashSet List Map TreeMap TreeSet...
集合体系框架：
1.集合好处：
可以动态保存多个对象
方便的操作对象的方法（add，get，set，remove）
使用集合添加,删除新元素的示意代码-简洁了
2.collection接口体系
Collection接口继承了Iterable接口
List Set接口继承了Clllection接口
List常用的实现类有ArrayList,LinkedList,Set接口常用的实现类有HashSet,TreeSet
3.Map接口体系
如图：LinkedHashMap继承了HashMap 的同时还实现了Map
4.两组集合
单列集合：Co'l'lection->List、Set 单列集合
双列集合：Map 子接口都是双列集合
5.Collection方法：
Collection接口继承了Iterable接口
collection实现子类可以存放多个元素，每个元素可以是Object
有些Coolection的实现类可以存放重复的元素，有些不可以
有些Collectiond的实现类，存放数据是有序的，有些是无序的
Collection接口没有直接的实现子类，是通过子接口Set和List来实现的
接口是不能直接被实例化的，只有实现了接口的这个类才能被实例化
上述代码未指定集合所装数据类型，所以add（addAll）的时候能装各种类型；
集合里面的数据本质上是对象， list.add(10)相当于list.add(new Integer(10))，这里并不是基本数据类型
remove 方法：
方法重载，可以删除指定元素，也能删除对应下标元素，返回值类型不一样
addAll：
方法重载，可以从原集合最后开始添加元素，也能指定对应下标处开始添加元素，返回值类型不一样
5.遍历方式
6.1迭代器（Iterator）遍历
1）Iterator对象称为迭代器，主要用于遍历Collection集合中的元素
2）所有实现了Collection接口的集合类都有一个Iterator()方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器
3）Iterator仅用于遍历集合，Iterator本身并不存储对象
附（图）：迭代器执行原理
注意返回的是指针下移以后指向的那个元素（有点像链表）
老韩提示:在调用iterator.next()方法之前必须要调用iterator.hasNext()进行检测。若不调用，且下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常。
public static void main(String[] args) {
@SuppressWarnings({"All"})
Collection col = new ArrayList();
col.add(new Book("三国演义", "罗贯中", 10.1));
col.add(new Book("小李飞刀", "古龙", 5.1));
col.add(new Book("红楼梦", "曹雪芹", 34.6));
System.out.println("col=" + col);
//现在老师希望能够遍历 col集合
//1. 先得到 col 对应的 迭代器
Iterator iterator = col.iterator();
//2. 使用while循环遍历
// while (iterator.hasNext()) {//判断是否还有数据
// //返回下一个元素，类型是Object
// Object obj = iterator.next();
// System.out.println("obj=" + obj);
// }
//老师教大家一个快捷键，快速生成 while => itit
//显示所有的快捷键的的快捷键 ctrl + j
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj=" + obj);
}
//3. 当退出while循环后 , 这时iterator迭代器，指向最后的元素
// iterator.next();//NoSuchElementException
//4. 如果希望再次遍历，需要重置我们的迭代器
iterator = col.iterator();
System.out.println("===第二次遍历===");
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj=" + obj);
}
}
}
@Data
@AllArgsConstructor
@NoArgsConstructor
class Book {
private String name;
private String author;
private double price;
}上述代码解读：
1.当退出while循环后 , 这时iterator迭代器，指向最后的元素
2. iterator.next();//NoSuchElementException
3. 如果希望再次遍历，需要重置我们的迭代器
但是注意，迭代器对象已经遍历，不是同一个对象，因为哈希值都不一样了
Iterator iterator = list2.iterator();
System.out.println(iterator .hashCode());
iterator = list2.iterator();
System.out.println(iterator .hashCode());
6.2 增强for循环
基本语法
for(元素类型 元素名：集合或数组名){
访问元素
}
public static void main(String[] args) {
Collection col = new ArrayList();
col.add(new Book("三国演义", "罗贯中", 10.1));
col.add(new Book("小李飞刀", "古龙", 5.1));
col.add(new Book("红楼梦", "曹雪芹", 34.6));
//老韩解读
//1. 使用增强for, 在Collection集合
//2. 增强for， 底层仍然是迭代器
//3. 增强for可以理解成就是简化版本的 迭代器遍历
//4. 快捷键方式 I
// for (Object book : col) {
// System.out.println("book=" + book);
// }
for (Object o : col) {
System.out.println("book=" + o);
}
//增强for，也可以直接在数组使用
// int[] nums = {1, 8, 10, 90};
// for (int i : nums) {
// System.out.println("i=" + i);
// }
}代码解读。增强for的底层仍然是迭代器，在for循环端点debug就可以看到了，会调用Iterator,增强for可以看成简易版的迭代器
6.List接口方法
List接口是Collection接口的子接口
List的实现类中的元素是有序的，即添加顺序和取出元素的顺序是一样的，且可以重复
List集合中的每个元素都有其对应的顺序索引，即支持索引
List容器的每个元素对应一个整数型的序号记载其在容器中的位置们可以根据序号存取容器中的元素（linkedList也是支持索引的）
List list3= new LinkedList();
list3.add(1);
list3.add(12);
list3.add(3);
System.out.println(list3.get(1));List接口中常用的方法
public static void main(String[] args) {
List list = new ArrayList();
list.add("张三丰");
list.add("贾宝玉");
// void add(int index, Object ele):在index位置插入ele元素
//在index = 1的位置插入一个对象
list.add(1, "韩顺平");
System.out.println("list=" + list);
// boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
List list2 = new ArrayList();
list2.add("jack");
list2.add("tom");
list.addAll(1, list2);
System.out.println("list=" + list);
// Object get(int index):获取指定index位置的元素
//说过
// int indexOf(Object obj):返回obj在集合中首次出现的位置
System.out.println(list.indexOf("tom"));//2
// int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
list.add("韩顺平");
System.out.println("list=" + list);
System.out.println(list.lastIndexOf("韩顺平"));
// Object remove(int index):移除指定index位置的元素，并返回此元素
list.remove(0);
System.out.println("list=" + list);
// Object set(int index, Object ele):设置指定index位置的元素为ele , 相当于是替换.
list.set(1, "玛丽");
System.out.println("list=" + list);
// List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
// 注意返回的子集合 fromIndex <= subList < toIndex
List returnlist = list.subList(0, 2);
System.out.println("returnlist=" + returnlist);
}代码解读
list.subList(0, 2);注意返回的子集合 fromIndex <= subList < toIndex，就是不包含toIndex对应的元素，前闭后开，可以理解，size=toIndex- fromIndex
List接口练习：
只要是实现来了Collection接口就可以使用迭代器
List接口是Collection接口的子接口，所以也可以使用迭代器
public static void main(String[] args) {
/*
添加10个以上的元素(比如String "hello" )，在2号位插入一个元素"韩顺平教育"，
获得第5个元素，删除第6个元素，修改第7个元素，在使用迭代器遍历集合，
要求:使用List的实现类ArrayList完成。
*/
List list = new ArrayList();
for (int i = 0; i < 12; i++) {
list.add("hello" + i);
}
System.out.println("list=" + list);
//在2号位插入一个元素"韩顺平教育"
list.add(1, "韩顺平教育");
System.out.println("list=" + list);
//获得第5个元素
System.out.println("第五个元素=" + list.get(4));
//删除第6个元素
list.remove(5);
System.out.println("list=" + list);
//修改第7个元素
list.set(6, "三国演义");
System.out.println("list=" + list);
//在使用迭代器遍历集合
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj=" + obj);
}
}
7.List的三种遍历方式
迭代器 增强for 普通for
public static void main(String[] args) {
//List 接口的实现子类 Vector LinkedList
//List list = new ArrayList();
//List list = new Vector();
List list = new LinkedList();
list.add("jack");
list.add("tom");
list.add("鱼香肉丝");
list.add("北京烤鸭子");
//遍历
//1. 迭代器
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println(obj);
}
System.out.println("=====增强for=====");
//2. 增强for
for (Object o : list) {
System.out.println("o=" + o);
}
System.out.println("=====普通for====");
//3. 使用普通for
for (int i = 0; i < list.size(); i++) {
System.out.println("对象=" + list.get(i));
}
}8.List排序练习
public static void main(String[] args) {
//List list = new ArrayList();
List list = new LinkedList();
//List list = new Vector();
list.add(new Book("红楼梦", "曹雪芹", 100));
list.add(new Book("西游记", "吴承恩", 10));
list.add(new Book("水浒传", "施耐庵", 19));
list.add(new Book("三国", "罗贯中", 80));
//list.add(new Book("西游记", "吴承恩", 10));
//如何对集合进行排序
//遍历
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 listSize = list.size();
for (int i = 0; i < listSize - 1; i++) {
for (int j = 0; j < listSize - 1 - i; j++) {
//取出对象Book
Book book1 = (Book) list.get(j);
Book book2 = (Book) list.get(j + 1);
if (book1.getPrice() > book2.getPrice()) {//交换
list.set(j, book2);
list.set(j + 1, book1);
}
}
}
}排序也可以通过多BOOK类实现Comparable接口
ArrayList注意事项
ArrayList可以存放空元素 arrayList.add(null);且可以存放多个空值，底层是用数组实现的，线程不安全，效率高
多线程情况下可以使用vector,vector是线程安全的
public static void main(String[] args) {
//ArrayList 是线程不安全的, 可以看源码 没有 synchronized
/*
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
*/
ArrayList arrayList = new ArrayList();
arrayList.add(null);
arrayList.add("jack");
arrayList.add(null);
arrayList.add("hsp");
System.out.println(arrayList);
}9.ArrayList源码剖析（重点，难点）
1)ArrayList中维护了一个Object类型的数组elementData. transient Object[] elementData;(Object类型的数组说明什么类型都可以放)
对象在序列化的时候，transient修饰的属性不会被序列化
transient:表示瞬间，短暂的
2)当创建对象时，如果使用的是无参构造器(ArrayList<>()),则初始elementData容量为0 (jdk7是10)
3)当添加元素时:先判断是否需要扩容,如果需要扩容，则调用grow方法，否则直接添加元素到合适位置
4)当创建ArrayList对象时，如果使用的是无参构造器（ArrayList<>()），则初始elementData容量为0，第1次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍。
5)如果使用的是指定容量capacity（ArrayList<>（int x））的构造器，则初始elementData容量为capacity
6)如果使用的是指定容量capacity的构造器,如果需要扩容，则直接扩容elementData为1.5倍。
ArrayList是空间不够了才扩容的，假设现在插入第11个元素，但是只有10个空间，就触发grow扩容
注意扩容之后调用了CopyOf函数
vector底层结构和源码剖析
public static void main(String[] args) {
//无参构造器
//有参数的构造
Vector vector = new Vector(8);
for (int i = 0; i < 10; i++) {
vector.add(i);
}
vector.add(100);
System.out.println("vector=" + vector);
//老韩解读源码
//1. new Vector() 底层
/*
public Vector() {
this(10);
}
补充：如果是 Vector vector = new Vector(8);
走的方法:
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
2. vector.add(i)
2.1 //下面这个方法就添加数据到vector集合
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
2.2 //确定是否需要扩容 条件 ： minCapacity - elementData.length>0
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
2.3 //如果 需要的数组大小 不够用，就扩容 , 扩容的算法
//newCapacity = oldCapacity + ((capacityIncrement > 0) ?
// capacityIncrement : oldCapacity);
//就是扩容两倍.
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
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);
}
*/
}10.双向链表模拟
LinkedList的全面说明
1)LinkedList底层实现了双向链表和双端队列特点
2)可以添加任意元素(元素可以重复),包括null
3)线程不安全,没有实现同步
LinkedList的底层操作机制
LinkedList底层维护了一个双向链表.
LinkedList中维护了两个属性first和last分别指向首节点和尾节点
3)每个节点(Node对象)，里面又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个节点。最终实现双向链表.
4)所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高。
5)模拟一个简单的双向链表
11.LinkedList源码图解
linkedList 遍历
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
System.out.println("linkedList=" + linkedList);
//演示一个删除结点的
linkedList.remove(); // 这里默认删除的是第一个结点
//linkedList.remove(2);
System.out.println("linkedList=" + linkedList);
//修改某个结点对象
linkedList.set(1, 999);
System.out.println("linkedList=" + linkedList);
//得到某个结点对象
//get(1) 是得到双向链表的第二个对象
Object o = linkedList.get(1);
System.out.println(o);//999
//因为LinkedList 是 实现了List接口, 遍历方式
System.out.println("===LinkeList遍历迭代器====");
Iterator iterator = linkedList.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println("next=" + next);
}
System.out.println("===LinkeList遍历增强for====");
for (Object o1 : linkedList) {
System.out.println("o1=" + o1);
}
System.out.println("===LinkeList遍历普通for====");
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}
//老韩源码阅读.
/* 1. LinkedList linkedList = new LinkedList();
public LinkedList() {}
2. 这时 linkeList 的属性 first = null last = null
3. 执行 添加
public boolean add(E e) {
linkLast(e);
return true;
}
4.将新的结点，加入到双向链表的最后
void linkLast(E e) {
final Node l = last;
final Node newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
*/
/*
老韩读源码 linkedList.remove(); // 这里默认删除的是第一个结点
1. 执行 removeFirst
public E remove() {
return removeFirst();
}
2. 执行
public E removeFirst() {
final Node f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
3. 执行 unlinkFirst, 将 f 指向的双向链表的第一个结点拿掉
private E unlinkFirst(Node f) {
// assert f == first && f != null;
final E element = f.item;
final Node next = f.next;
f.item = null;
f.next = null; // help GC
first = next;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
*/
} 12.list集合选择
ArrayList插入数据涉及扩容操作，效率低，改和查的效率比较高，因为可以通过索引定位
13.Set接口和方法
set接口无序（添加和取出元素的顺序不一样），且没有索引，不支持随机访问
不允许有重复元素，所以最多有一个null
和List接口一样，Set接口也是Collection接口的子接口，因此，常用方法和Collection接口一样
同Collection接口遍历方式一样，因为Set接口是Collection接口的子接口，所以Set接口的遍历可以使用迭代器和增强for循环
不能使用索引来获取
14.HashSet
HashSet实现了Set接口
HashSet底层实际上是HashMap
public HashSet() {
map = new HashMap<>();
}add也用的map的方法
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}key值默认是PRESENT
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();