一、定义
/----Collection接口：单列汇合，用来存储一个一个的对象
/----List接口：存储有序的、可反复的数据。--->"动静"数组
/----ArrayList、LinkedList、Vector
/----Set接口：存储无序的、不可反复的数据
/---- HashSet、LinkedHashSet、TreeSet
二、List
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);
}
}
}
发表回复