/----Collection 接口：单列汇合，用来存储一个一个的对象
/----List 接口：存储有序的、可反复的数据。--->"动静" 数组
/----ArrayList、LinkedList、Vector
/----Set 接口：存储无序的、不可反复的数据
/---- HashSet、LinkedHashSet、TreeSet
package com.study.java;
/**
* /----Collection 接口：单列汇合，用来存储一个一个的对象
* /----List 接口：存储有序的、可反复的数据。--->"动静" 数组
* /----ArrayList：作為 List 接口的次要實現，線程不平安，效率高，底层用 Object[] elementData 存储
* /----LinkedList 对于频繁的插入、删除操作，效率比 ArrayList 高，底层用双向链表存储
* /----Vector：List 的古老實現類，線程平安，效率低, 底层用 Object[] elementData 存储
*
* 1. ArrayList 源码剖析 jdk 7 状况下
* ArrayList list = new ArrayList();// 底层创立了长度是 10 的 object[] 数组 elementData
* list.add(123);//elementData[0] = new Integer(123);
* ...
* list.add(11); // 如果此次增加导致底层 elementData 数组容量不够、则扩容;
* 默认状况下，扩容原来容量的 1.5 倍，同时须要将原有数组中的数据复制到新的数组中
*
*
* 论断：倡议开发中应用带参结构器，ArrayList list = new ArrayList(int capacity);
* jdk8 中：* ArrayList list = new ArrayList(); // 底层 object[] elementData 初始化为 {}, 并没有创立长度为 10 的数组
* list.add(11); // 第一次调用 add 底层才创立了长度为 10 的数组，并将数据 123 增加到 elementData[0]
* 后续增加和扩容操作与 jdk7 无异
* 结存：提早数组创立，更节俭内存
*
* 2. LinkedList 源码剖析：* LinkedList list = new LinkedList(); 外部申明了 Node 类型的 first 和 last 属性，默认值为 null
* list.add(123); 将 123 封装到 Node 中，创立了 Node 对象
* 其中，Node 定义为：* private static class Node<E> {
* E item;
* Node<E> next;
* Node<E> prev;
*
* Node(Node<E> prev, E element, Node<E> next) {
* this.item = element;
* this.next = next;
* this.prev = prev;
* }
* }
* 3.Vector 源码剖析：* 通过 Vector 窗常见底层为 10 的数组，默认扩容为原来的，两倍
*
* ArrayList、LinkedList、Vector 三者异同？* 同：三个类都实现了 List 接口，存储数据的特点雷同：存储有序的、可反复数据
*/
public class ListTest {
}
package com.study.java;
import org.junit.jupiter.api.Test;
import java.util.*;
/**
* /----Collection 接口：单列汇合，用来存储一个一个的对象
* /----Set 接口：存储无序的、不可反复的数据
* /---- HashSet: 作为 Set 接口的次要实现类：线程不平安：能够存储 null 值
* /----LinkedHashSet: 作为 HashSet 的子类，遍历其外部数据时，可依照增加的程序遍历
* /----TreeSet：可依照增加对象的指定属性，进行排序
* 没有定义新的办法，用的都是 Collection 定义好的办法
* 要求：向 Set 中增加数据，其所在类肯定要重写 hashCode() 和 equals()
* 重写的 hashCode() 和 equals() 尽可能放弃一致性，相等的对象必须具备相等的散列码
* 重写的两个办法的技巧：对象中用作 equals 办法比拟的 Field，都应该用来计算 hashCode
*/
public class SetTest {
/*
set : 存储无序的、不可反复的数据
无序性：不等于随机性，存储的数据在底层数组中并非依照数组索引程序排序，而是依据数据的哈希值决定的
不可重复性：保障增加的元素依照 equals() 判断时，不能返回 true
增加数据的过程：以 HashSet 为例：增加元素 a，首先调用元素 a 所在类的 hashCode() 办法，计算元素 a 的哈希值
此 hash 值通过某中算法算出在 hashSet 底层数组中的寄存地位（即索引地位），判断
数组此地位是否已有元素，无则增加胜利，有其余元素 b（或以链表模式存在的多个元素），则比拟 a 与 b 的 hash 值
如果 hash 值不雷同，则 a 增加胜利，如果 hash 值雷同，进而须要调用元素 a 所在类的 equals() 办法
equals() 返回 true，元素 a 增加失败
equals() 返回 false，元素 a 增加胜利
对于后两种状况，元素 a 与曾经存在指定索引地位上的数据以链表的形式存储
jdk7 元素 a 放到数组指向原来的元素
jdk8 原来的元素在数组中，指向元素 a
HashSet 底层：数组加链表
LinkedHashSet: 作为 HashSet 的子类，增加数据时，还保护了两个援用，记录前一个和后一个数据
TreeSet :
天然排序：比拟两个对象是否雷同的规范为：compareTo() 返回 0, 不再是 equals();
订制排序：比拟两个对象是否雷同的规范为：compare() 返回 0, 不再是 equals();
*/
@Test
public void test1() {Set set = new HashSet();
set.add(456);
set.add("ddd0");
set.add(new Person("Tom", 12));
set.add(new Person("Tom", 12));
set.add(129);
set.add(129);
Iterator iterator = set.iterator();
while(iterator.hasNext()) {System.out.println(iterator.next());
}
}
/**
* 增加数据，要求同类的对象
*/
@Test
public void test2() {TreeSet treeSet = new TreeSet();
treeSet.add(new Person("jj", 44));
treeSet.add(new Person("ja", 55));
for (Object aa : treeSet) {System.out.println(aa);
}
}
@Test
public void test3() {Comparator com = new Comparator() {
@Override
public int compare(Object o1, Object o2) {if (o1 instanceof Person && o2 instanceof Person) {Person p1 = (Person) o1;
Person p2 = (Person) o2;
return Integer.compare(p1.getAge(), p2.getAge());
} else {throw new RuntimeException("输出数据类型不匹配");
}
}
};
TreeSet treeSet = new TreeSet(com);
treeSet.add(new Person("jj", 44));
treeSet.add(new Person("ja", 55));
treeSet.add(new Person("ja", 11));
for (Object aa : treeSet) {System.out.println(aa);
}
}
}