Collection
0.1.List集合
- "动态"数组，替换原有的数组
- List接口：存储
有序的、可重复的数据，各元素数据就是对象插入的顺序。允许放入null元素。
实现类
- ArrayList：作为List接口的主要实现类；线程不安全，效率高；底层使用数组结构（Object[] elementData）存储。查找和添加(尾部添加)操作效率高，时间复杂度为
O（1）；删除和插入效率低，时间复杂度O（n） - LinkList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用
双向链表存储;删除和插入效率高，时间复杂度O（1）；查找时间复杂度O（n） - Vector：作为List接口的古老实现类；线程安全，效率低；底层使用Object[] elementData存储。
ArrayList源码分析
- JDK1.7
ArrayList<Object> objects = new ArrayList<>();//底层创建了长度为10的Object[]数组elementData
objects.add(123);//elementData[0]=new Integer(123);
.
.
.
objects.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。
默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
结论：建议开发中使用带参的构造器：
ArrayList<Object> objects = new ArrayList<>(int capacity)
- JDK1.8中ArrayList的变化
ArrayList<Object> objects = new ArrayList<>();
//底层Object[] elementData;初始化为{}.并没有创建长度为10的数组
objects.add(123);
//第一次调用add（)时，才创建了长度为10的数组，并将数据123添加到elementData[0]
...
//后续添加与扩容操作与JDK7 无异
- 小结：
JDK 7中的ArrayList的对象的创建类似于单例 的饿汉式，而JDK8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
LinkedList的源码分析
LinkedList<Object> objects = new LinkedList<>();
//内部声明了Node类型的first和last属性，默认值为null
objects.add(123);//将123封装到Node中，创建了Node对象。
//其中Node定义为：体现了LinkedList的双向链表的说法
/*
private static class Node<E> {
E item;
LinkedList.Node<E> next;
LinkedList.Node<E> prev;
Node(LinkedList.Node<E> prev, E element, LinkedList.Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
*/
Vector源码分析
通过Vector()构造器创建对象时，底层创建了长度为10的数组，在扩容方面，默认扩容为原来的数组的2倍。
List接口方法
List集合常用方法
- 增：add（Object obj）
- 删：remove（int index）/ remove（Object obj）
- 改：set（int index，Object obj）
- 查：get（int index）
- 插：add（int index，Object obj）
- 长度：size（）
- 遍历：
①Interator迭代器方法
② 增强for循环
③ 普通的循环
0.2.Set集合
- Set接口：存储无序的、不可放入重复的对象元素，可以放入
null元素
实现类
-
HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值
-
LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历
- 优点：对于频繁的遍历操作，LinkedHashSet 效率高于HashSet。
-
TreeSet：可以按照添加对象的指定属性，进行排序。底层采用二叉树中的红黑树存储，
- 要求是相同的对象
- 排序方式：自然排序（实现Comparable接口）和定制排序（Comparator）
- 自然排序中，比较两个对象是否相同的标准为：Comparable compareTo（Object obj）返回0.不再是equals（）.
- 定制排序中，比较两个对象是否相同的标准为：Comparator compare（Object obj1,Object obj2）返回0.不再是equals（）.
-
Set接口中没有额外定义新的方法，使用的都是Colletion中声明过的方法。
-
要求：向Set中添加的数据，其所在类一定要重写hashCode（）和equals（）
-
要求：重写hashCode（）和equals（）尽可能保持一致性：相等的对象必须具有相等的散列码
-
重写两个方法的小技巧：对象中用作equals（）方法比较的Field，都应该用来计算hashCode值。
Set：存储无序的、不可重复的数据
以HashSet为例说明
- 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引顺序添加，而是根据数据的哈希值决定的。
- 不可重复性：保证添加的元素按照equals（）判断时，不能返回true。即：相同的元素只能添加一个。
HashSet底层是用的HashMap
public HashSet() {
map = new HashMap<>();
}
添加元素过程：以HashSet为例
添加一个元素的时候底层使用的map的put方法
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
我们向HashSet中添加元素a，首先 调用元素a所在类的hashCode（）方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中存放的位置（即为：索引位置），判断数组此位置上是否已经有元素：
-
如果此位置上没有其他元素，则元素a添加成功。–>情况1
-
如果此位置上有其他元素b（或以链表形式存在多个元素），则比较元素a与元素b的哈希值：
-
如果hash值不相同，则元素a添加成功。—>情况2
-
如果hash值相同，进而需要调用元素a所在类的equlas（）方法：
- equals（）返回true，元素a添加失败
- equals（）返回false，则元素a添加成功。–>情况3
-
对于添加成功的情况2和情况3而言：元素a与已经存在指定位置索引位置上数据以链表的方式存储。
JDK7:元素a放在数组中，指向原来的元素
JDK8:原来的元素在数组中，指向元素a
总结：七上八下
HashSet底层：数组+链表的结构
LinkedHashSet的使用
LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录次数据前一个数据和后一个数据
优点：对于频繁的遍历操作，LinkedHashSet 效率高于HashSet。
在List内去除重复数字值，要求尽量简单
public class Test {
//在List内去除重复数字值，要求尽量简单
public static List duplicateList(List list){
HashSet<Object> set=new HashSet();
set.addAll(list);
return new ArrayList(set);
}
public static void main(String[] args) {
List list = new ArrayList<>();
list.add(new Integer(123));
list.add(new Integer(123));
list.add(new Integer(456));
list.add(new Integer(789));
list.add(new Integer(456));
List newList = duplicateList(list);
Iterator iterator=newList.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
//789 456 123
}
}
Map接口
双列数据，存储key-value对的数据
HashMap：作为Map的主要实现类；线程不安全的，效率高；可以存储null的key和value
LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序实现遍历。
原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。
对于频繁的遍历操作，此类执行效率高于HashMap。TreeMap：保证按照添加的key-value对进行排序，实现遍历。 此时考虑key的自然排序或定制排序。（底层使用红黑树）
Hashtable：作为古老的实现类；线程安全的，效率低；不能存储null的key和value
Map结构的理解
- Map中的key：无序的、不可重复的，使用Set存储所有的key–>key所在的类要重写equals（）和hashCode（）（以hashMap为例）
- Map中的value：无序的、可重复的，使用Collection存储所有的value–>value所在的类要重写equals（）
- 一个键值对：key-value构成了一个Entry对象。
- Map中的entry：无序的、不可重复的，使用Set存储所有的entry
实现类
- HashMap：作为Map的主要实现类；线程不安全，效率高；可以存储null的key和value
-
HashMap的底层：数组+链表（JDK7及之前）
-
数组+链表+红黑树（JDK8及之前）
-
LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序实现遍历。
- 原因：在原有的HashMap底层结构上，添加了一对指针，指向前一个和后一个元素。
- 对于频繁的遍历操作，此类指向效率高于HashMap。
-
- TreeMap：保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序。
- Hashtable：作为古老的实现类；线程安全，效率低；不可以存储null的key和value；底层使用红黑树
- Properties：常用来处理配置文件。key和value都是String类型
HashMap的底层实现原理？
JDK7：
HashMap hashMap=new HashMap();
在实例化以后，底层创建了长度为16的一维数组Entry[] table。
. . .可能已经执行过多次put（） . . .
map.put（key1,value1）：
-
首先，调用key1所在的类的hashCode（）计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。
-
如果此位置上的数据为空，此时的key1-value1添加成功。-----情况1
-
如果此位置上的数据不为空，（意味着此位置上存在一个或者多个数据（以链表形式存在）），比较key1和已经存在的一个或多个数据的哈希值：
-
如果key1的哈希值与已经存在的数据的哈希值都不同，此时key1-value1添加成功。------情况二
-
如果key1的哈希值和已经存在的某一个数据（key2,value2）的哈希值相同，继续比较：调用key1所在类的equals（key2）方法，比较：
- 如果equals（）返回false：此时key1-value1添加成功。
- 如果equals（）返回true：使用value1替换相同key的value值。
-
补充：
①关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。
在不断的添加过程中，会涉及到扩容问题，当超出临界值（且要存放的位置非空）时，扩容。默认的扩容方式：扩容到原来容量的2倍，并将原来的数据复制过来。
JDK8相较JDK7在底层实现方面的不同：
- new HashMap()：底层没有创建一个长度为16的数组，在首次调用put（）方法时，底层创建长度为16的数组
- JDK8底层的数组是：Node[]，而非是Entry[]
- JDK7中底层结构只有：数组+单向链表
- JDK8中底层结构：数组+链表+红黑树
当数组的某一个索引位置上的元素以链表形式存在的数据个数>8 且当前数组的长度>64时，此时此索引位置上的所有数据改为使用红黑树存储。（核心）
HashMap的源码分析
DEFAULT_INITIAL_CAPACITY：HashMap的默认容量，16
MIN_TREEIFY_CAPACITY=64：桶中的Node被树化时最小的hash表容量：64
TREEIFY_THRESHOLD= 8：Bucket中链表长度大于该默认值，转化为红黑树
threshold：扩容的临界值，=容量*填充因子：16 * 0.75=>12
DEFAULT_LOAD_FACTOR= 0.75f：HashMap的默认加载因子：0.75
LinkedHashMap的底层实现原理
Map接口中的常用方法
总结：常用方法：
- 添加：put（Object key，Object value）
- 删除：remove（Object key）
- 修改：put（Object key，Object value）
- 查询：get（Object key）
- 长度：size（）
- 遍历：keySet（） / values（） / entrySet（）
TreeMap两种添加方式
- 向TreeMap中添加key-value，要求key必须是由同一个类创建的对象。
- 因为要按照key进行排序：自然排序，定制排序。
Collections工具类
Cellectcion和Colletions的区别
Colletions：是一个操作Colletion和Map等集合的工具类
Colletion：是一个存储单例数据的集合接口
Colletions的方法
public class MapTest {
public static void main(String[] args) {
ArrayList<Integer> list=new ArrayList<>();
list.add(125);
list.add(100);
list.add(50);
list.add(1000);
//返回的newList即为线程安全的List
List<Integer> newList = Collections.synchronizedList(list);
}
}
1361
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
