1、集合与数组存储数据的概述
- 集合、数组都是对多个数据进行存储操作的结构，简称Java容器。说明:此时的存储，主要指内存层面的存储，不涉及到持久化的存储(.txt,jpg,avi,数据库中)
- 数组在存储多个数据方面的特点:
- 一旦初始化以后，其长度就确定了。
- 数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。比如:String[] arr; int [] arr1; Object[] arr;
- 数组在存储多个数据方面的缺点:
- 一旦初始化以后，其长度就不可修改。
- 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
- 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
- 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
- 集和存储的优点：解决存储数据方面的弊端
- 集合的分类
- Java集合可分为Collection和Map两种体系
- Collection接口：单列数据，定义了存取一组对象的方法的集合
- List：元素有序、可重复的集合
- Set：元素无序、不可重复的集
- Map接口：双列数据，保存具有映射关系“key-value对”的集合
- Collection接口：单列数据，定义了存取一组对象的方法的集合
- Java集合可分为Collection和Map两种体系
2、集合的框架结构
|----Collection接口：单列集合，用来存储一个一个的对象
|----List接口：存储有序的、可重复的数据。 -->“动态”数组
|----ArrayList：作为List接口的主要实现类，线程不安全的，效率高;底层采用Object[] elementData数组存储
|----LinkedList：对于频繁的插入删除操作，使用此类效率比ArrayList效率高底层采用双向链表存储
|----Vector：作为List的古老实现类，线程安全的，效率低;底层采用Object[]数组存储
|----Set接口：存储无序的、不可重复的数据 -->数学概念上的“集合”
|----HashSet：作为Set接口主要实现类;线程不安全;可以存null值
|----LinkedHashSet：作为HashSet的子类;遍历其内部数据时，可以按照添加顺序遍历;对于频繁的遍历操作，LinkedHashSet效率高于HashSet.
|----TreeSet：可以按照添加对象的指定属性，进行排序。
|----Map:双列数据，存储key-value对的数据 ---类似于高中的函数：y = f(x)
|----HashMap:作为Map的主要实现类；线程不安全的，效率高；存储null的key和value
|----LinkedHashMap:保证在遍历map元素时，可以照添加的顺序实现遍历。
原因：在原的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。
对于频繁的遍历操作，此类执行效率高于HashMap。
|----TreeMap:保证照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序
底层使用红黑树
|----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value
|----Properties:常用来处理配置文件。key和value都是String类型
3、Collection接口
- Collection接口是List、Set和Queue接口的父接口，该接口里定义的方法既可用于操作Set集合，也可用于操作List和 Queue集合。
- JDK不提供此接口的任何直接实现，而是提供更具体的子接口（如：Set和List）实现。
- 在JDK 5.0之前，Java集合会丢失容器中所有对象的数据类型，把所有对象都当成 Object类型处理；从JDK 5.0增加了泛型以后，Java集合可以记住容器中对象的数据类型。
3.1、单列集合框架接口
|----Collection接口：单列集合，用来存储一个一个的对象
|----List接口：存储有序的、可重复的数据。 -->“动态”数组
|----ArrayList：作为List接口的主要实现类，线程不安全的，效率高;底层采用Object[] elementData数组存储
|----LinkedList：对于频繁的插入删除操作，使用此类效率比ArrayList效率高底层采用双向链表存储
|----Vector：作为List的古老实现类，线程安全的，效率低;底层采用Object[]数组存储
|----Set接口：存储无序的、不可重复的数据 -->数学概念上的“集合”
|----HashSet：作为Set接口主要实现类;线程不安全;可以存null值
|----LinkedHashSet：作为HashSet的子类;遍历其内部数据时，可以按照添加顺序遍历;对于频繁的遍历操作，LinkedHashSet效率高于HashSet.
|----TreeSet：可以按照添加对象的指定属性，进行排序。
图示:
3.2、Collection接口常用方法:
add(object e):将元素添加到集合中
addAll(Collection coll1): 将cool1集合中的元素添加到当前的集合中
size():获取添加的元素的个数
clear(): 清空集合元素
isEmpty(): 判断当前集合是否为空
contains(Object obj): 判断当前集合中是否包含obj，判断时会调用obj对象所在类的equals();
containsAll(Collection c):判断形参c中的所有元素是否都存在当前集合中，也会调用equals();
remove(Object obj):从当前集合中移除obj元素，判断时会调用obj对象所在类的equals();
removeAll(Collection coll1): 从当前集合中移除coll1中所有的元素，只留下coll1中没有的元素。
retainAll(Collection coll1): 交集：获取当前集合和coll1集合的交集，其他元素则删除。
equals(Object obj): 要想返回true，需要当前集合和形参集合的元素都相同。顺序则根据使用的什么集合来定，例如有序集合ArrayList，无序集合HashSet。
hashCode(): 返回当前对象的哈希值
toArray(): 集合转换为数组
iterator(): 返回迭代器对象，用于集合遍历
//代码示例
@Test
public void test1(){
Collection coll = new ArrayList();
//`add(object e)`:将元素e添加到集合coll中
coll.add("张三");
coll.add("李四");
coll.add(50);
coll.add(new Date());
//`size()`:获取添加的元素的个数
System.out.println(coll.size());//4
//`addAll(Collection coll1)`: 将cool1集合中的元素添加到当前的集合中
Collection coll1 = new ArrayList<>();
coll1.add("王五");
coll1.add("AA");
coll1.addAll(coll);
System.out.println(coll1.size());//6
//`clear()`: 清空集合元素
coll.clear();
//`isEmpty()`: 判断当前集合是否为空
System.out.println(coll.isEmpty());//true
}
@Test
public void test2(){
//`contains(Object obj)`: 判断当前集合中是否包含obj，判断时会调用obj对象所在类的equals();
Collection coll = new ArrayList();
coll.add("AA");
coll.add(15);
coll.add("王五");
boolean contains = coll.contains(15);
System.out.println(contains);
//`containsAll(Collection c)`:判断形参c中的所有元素是否都存在当前集合中，也会调用equals();
Collection coll1 = new ArrayList();
coll1.add("AA");
boolean b = coll.containsAll(coll);
System.out.println(b);
//`remove(Object obj)`:从当前集合中移除obj元素，判断时会调用obj对象所在类的equals();
boolean aa = coll.remove("王五");
System.out.println(aa);
//`removeAll(Collection coll1)`: 从当前集合中移除coll1中所有的元素
boolean b1 = coll.removeAll(coll1);
System.out.println(b1);
}
@Test
public void test3(){
//`retainAll(Collection coll1)`: 交集：获取当前集合和coll1集合的交集，并返回当前的集合
Collection coll = new ArrayList();
coll.add(15);
coll.add("as");
Collection coll1 = new ArrayList<>();
coll1.add("as");
System.out.println(coll.retainAll(coll1));
System.out.println(coll);//[as]
//`equals(Object obj)`: 要想返回true，需要当前集合和形参集合的元素都相同。顺序则根据使用的什么集合来定，例如有序集合ArrayList，无序集合HashSet。
System.out.println(coll.equals(coll1));
//`hashCode()`: 返回当前对象的哈希值
System.out.println(coll.hashCode());
//`toArray()`: 集合转换为数组
Object[] objects = coll.toArray();
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
}
3.3、Iterator接口
3.3.1、Iterator迭代器说明
迭代器（Iterator）
迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。
Java中的Iterator功能比较简单，并且只能单向移动：
(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。
(2) 使用next()获得序列中的下一个元素。
(3) 使用hasNext()检查序列中是否还有元素。
(4) 使用remove()将迭代器新返回的元素删除。
Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。
作用
遍历集合Collection的元素
//代码示例
@Test
public void test5(){
Collection coll = new ArrayList();
coll.add("AAA");
coll.add("123");
coll.add(789);
Iterator iterator = coll.iterator();
while (iterator.hasNext()){//判断集合中是否有元素
System.out.println(iterator.next());
}
}
3.3.2、Iterator的执行原理
集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
3.3.3、iterator中remove()方法的使用：
- 测试Iterator中的remove()
- 如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，再调用remove都会报IllegalStateException。
- 内部定义了remove(),可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()
//代码示例
@Test
public void test5(){
Collection coll = new ArrayList();
coll.add("AAA");
coll.add("123");
coll.add(789);
Iterator iterator = coll.iterator();
while (iterator.hasNext()){
Object next = iterator.next();
if (next.equals("AAA")){
iterator.remove();
}
}
//上面已经调用迭代完没有了，要想从新遍历就需要从新迭代。
iterator = coll.iterator();//对象每次调用iterator()方法都得到一个全新的迭代器对象
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
3.3.4、新特性使用foreach遍历集合元素
- Java5.0提供了foreach循环迭代访问Collection和数组。
- 遍历操作不需要获取Collection或数组的长度，无需使用索引访问元素。
- 遍历集合的底层调用Iterator完成操作。
- foreach还可用来遍历数组。
//代码示例
@Test
public void test6() {
Collection coll = new ArrayList();
coll.add("AAA");
coll.add("123");
coll.add(789);
for (Object o: coll){
System.out.println(o);
}
}
4、Collection子接口: List接口
4.1、概述
- 鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组
- List集合类中 元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存储容器中的元素。
- JDK API中List接口的实现类常用的有: ArrayList、LinkedList和Vector。
- ArrayList、LinkedList和Vector三者存储数据的特点相同: 存储有序的、可重复的数据。
4.2、常用实现类
|----Collection接口：单列集合，用来存储一个一个的对象
|----List接口：存储序的、可重复的数据。 -->“动态”数组,替换原的数组
|----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
|----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
|----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储
4.3、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)
- JDK 8中ArrayList的变化:
- ArrayList list = new ArrayList();//底层Object[] elementData初始化为{},并没有创建长度为10的数组
- list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
- …
- 后续的添加和扩容操作与jdk7 一样。
- 小结: jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
4.4、LinkedList源码分析
-
LinkedList list = new LinkedList();//内部声明了Node类型的first和last属性，默认值为null、
-
list.add(123);//将123封装到Node中，创建Node对象。
-
其中，Node定义为: 体现了LinkedList的双向链表的说法
-
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; } }
-
4.5、Vector源码分析
- jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组
- 在扩容方面，默认扩容为原来的数组长度的2倍。
4.6、常用方法
List除了从 Collection集合继承的方法外，List集合里添加了一些根据索引来操作集合元素的方法。
void add(int index, Object ele):在index位置插入ele元素boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来Object get(int index):获取指定index位置的元素int indexOf(Object obj):返回obj在集合中首次出现的位置int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置Object remove(int index):移除指定index位置的元素，并返回此元素Object set(int index, Object ele):设置指定index位置的元素为eleList subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合,末尾不取。
//代码示例
@Test
public void test8(){
ArrayList list = new ArrayList();
list.add("张三");
list.add("王五");
list.add(123);
//`void add(int index, Object ele)`:在index位置插入ele元素
list.add(1,"李四");
System.out.println(list);//[张三, 李四, 王五, 123]
//`boolean addAll(int index, Collection eles)`:从index位置开始将eles中的所有元素添加进来
ArrayList list2 = new ArrayList();
list2.add("中国");
list2.add(123);
list.addAll(3,list2);
System.out.println(list);//[张三, 李四, 王五, 中国, 123, 123]
//`Object get(int index)`:获取指定index位置的元素
System.out.println(list.get(0));//张三
//`int indexOf(Object obj)`:返回obj在集合中首次出现的位置
System.out.println(list.indexOf("李四"));//1
//`int lastIndexOf(Object obj)`:返回obj在当前集合中末次出现的位置
System.out.println(list.lastIndexOf(123));//5
//`Object remove(int index)`:移除指定index位置的元素，并返回此元素
list.remove(0);
System.out.println(list);//[李四, 王五, 中国, 123, 123]
//Object set(int index, Object ele)`:设置指定index位置的元素为ele,类似于修改
list.set(0,"法国");
System.out.println(list);//[法国, 王五, 中国, 123, 123]
//List subList(int fromIndex, int toIndex)`:返回从fromIndex到toIndex位置的子集合,末尾不取
System.out.println(list.subList(0,2));//[法国, 王五]
}
总结: 经常使用的方法
- 增：add(Object obj)
- 删：remove(int index) / remove(Object obj)
- 改：set(int index, Object ele)
- 查：get(int index)
- 插：add(int index, Object ele)
- 长度：size()
- 遍历： ① Iterator迭代器方式② foreach（增强for循环） ③ 普通的循环
5、Collection子接口:Set接口
5.1、概述
- Set接口是Collection的子接口，set接口没有提供额外的方法
- Set集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set集合中，则添加操作失败。（多用于过滤操作，去掉重复数据）
- Set判断两个对象是否相同不是使用==运算符，而是根据equals()方法
- Set里面添加自定义类是通过先判断hashCode()在判断equals(),来确定值是否重复。
5.2、常用实现类
|----Collection接口：单列集合，用来存储一个一个的对象
|----Set接口：存储无序的、不可重复的数据 -->高中讲的“集合”
|----HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值
|----LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历，对于频繁的遍历操作，LinkedHashSet效率高于HashSet.
|----TreeSet：可以按照添加对象的指定属性，进行排序。
5.3、Set: 存储无序的、不可重复的数据
Set: 存储无序的、不可重复的数据
- 无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。
- 不可重复性:保证添加的元素按照equals()判断时，不能返回true，即: 相同的元素只能添加一个。
5.4、常用方法
Set接口中没额外定义新的方法，使用的都是Collection中声明过的方法。
5.5、添加元素的过程: 以HashSet为例：
- 我们想HashSet中添加元素a，首先调用元素a所在类的hashCode(),计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为：索引位置)，判断数组此位置上是否已经有元素:
- 如果此位置上没有其他元素，则元素a添加成功。 ----情况1
- 如果此位置上有其他元素b(或以链表形式存在的多个元素)，则比较元素a和 元素b的hash值:
- 如果hash值不相同，则元素a添加成功 —情况2
- 如果hash值相同，进而需要调用元素a所在类的equals()方法:
- equals()返回true，元素a添加失败
- equals()返回false，则元素a添加成功 —情况3
对于添加成功的情况2和情况3而言: 元素a 与已经存在指定索引位置上数据以链表的方式存储。
jdk 7：元素a放到数组中，指向原来的元素
jdk 8：原来的元素在数组中，指向元素a
总结：七上八下
HashSet底层：数组+链表的机构。
jdk7.0以前图示:
5.6、重写hashCode()方法
- 在程序运行时，同一个对象多次调用hashCode()方法应该返回相同的值。
- 当两个对象的equals()方法比较返回true时，这两个对象的 hashCode()方法的返回值也应相等。
- 对象中用作equals()方法比较的Field，都应该用来计算hashCode值
5.7、重写equals()方法基本原则
- 以自定义的 Customer类为例，何时需要重写equals()？
- 当一个类有自己特有的“逻辑相等”概念，当改写equals()的时候，总是要改写 hash Code（），根据一个类的 equals方法(改写后)，两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，它们仅仅是两个对象。
- 因此，违反了“相等的对象必须具有相等的散列码”.
- 结论：复写equals方法的时候一般都需要同时复写 hashCode方法。通常参与计算 hashCode的对象的属性也应该参与到equals()中进行计算。
5.8、Eclipse/IDEA工具里hashCode()重写
以Eclipse/DEA为例，在自定义类中可以调用工具自动重写equals()和hashCode() 问题：为什么用 Eclipse/IDEA复写 hash Code方法，有31这个数字？
- 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）
- 并且31只占用5bits，相乘造成数据溢出的概率较小。
- 31可以由i*31==(<<5)-1来表示，现在很多虚拟机里面都有做相关优化。（提高算法效率）
- 31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有1来整除！（减少冲突）
5.9、HashSet
- Hashset是Set接口的典型实现，大多数时候使用Set集合时都使用这个实现类。
- HashSet按Hash算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。
- HashSet具有以下特点：
- 不能保证元素的排列顺序
- HashSet不是线程安全的
- 集合元素可以是nul
- HashSet集合判断两个元素相等的标准：两个对象通过hashCode()方法比较相等，并且两个对象的equals()方法返回值也相等。
- 对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”
//代码示例
@Test
//HashSet使用
public void test1(){
Set set = new HashSet();
set.add(454);
set.add(213);
set.add(111);
set.add(123);
set.add(23);
set.add("AAA");
set.add("EEE");
set.add(new User("Tom",34));
set.add(new User("Jarry",74));
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
5.10、LinkedHashSet
- LinkedhashSet是HashSet的子类
- LinkedhashSet根据元素的hashCode值来决定元素的存储位置但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
- LinkedhashSet插入性能略低于HashSet， 但在迭代访问Set里的全部元素时有很好的性能。
- LinkedhashSet不允许集合元素重复。
图示:
@Test
//LinkedHashSet使用
//LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。
//优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet
public void test2(){
Set set = new LinkedHashSet();
set.add(454);
set.add(213);
set.add(111);
set.add(123);
set.add(23);
set.add("AAA");
set.add("EEE");
set.add(new User("Tom",34));
set.add(new User("Jarry",74));
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
5.11、TreeSet(了解)
- 向TreeSet中添加的数据，要求是相同类的对象。
- 两种排序方式：自然排序 和定制排序
- 自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals().
- 定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals().
//自然排序
TreeSet set = new TreeSet();
set.add(new Persion("Jack",21));
set.add(new Persion("Ami",15));
set.add(new Persion("Fack",34));
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
//定制排序
@Test
public void test2(){
Comparator comparator = new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Persion && o2 instanceof Persion){
Persion persion = (Persion)o1;
Persion persion2 = (Persion)o2;
return Integer.compare(persion.getAge(),persion2.getAge());
}
throw new RuntimeException("输入的数据类型不匹配");
}
};
TreeSet set = new TreeSet(comparator);
set.add(new Persion("Jack",21)) ;
set.add(new Persion("Ami",15));
set.add(new Persion("Fack",34));
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
6、Map接口
Map接口继承树
虚线----->实现
实现----->继承
6.1、概述
- Map与Collection并列存在。用于保存具有映射关系的数据:key-value
- Map中的key和value都可以是任何引用类型的数据
- Map中的 key用set来存放，不允许重复， 即同一个Map对象所对应的类，须重写 hashCode()和 equals()方法
- 常用 String类作为Map的“键”
- key和value之间存在单向一对一关系，即通过指定的key总能找到唯一的、确定的value
- Map接口的常用实现类:HashMap、TreeMap、LinkedHashMap和Properties。其中，HashMap是Map接口使用频率最高的实现类。
6.2、常用实现类
|----Map:双列数据，存储key-value对的数据
|----HashMap:作为Map的主要实现类；线程不安全的，效率高；存储null的key和value
|----LinkedHashMap:保证在遍历map元素时，可以照添加的顺序实现遍历。
原因：在原的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。
对于频繁的遍历操作，此类执行效率高于HashMap。
|----TreeMap:保证照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序
底层使用红黑树
|----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value
|----Properties:常用来处理配置文件。key和value都是String类型
HashMap的底层： 数组+链表 （JDK 7.0及之前)
数组+链表+红黑树 （JDK 8.0以后)
6.3、Map结构的理解
- Map中的key: 无序的、不可重复的，使用Set存储所有的key—>key所在的类要重写equals()和hashCode(),以HashMap为例
- Map中的value: 无序的、可重复的，使用Collection存储所有的value---->value所在的类要重写equals()
- 一个键值对: key-value构成了一个Entry对象。
- Map中的entry: 无序的、不可重复的，使用Set存储所有的entry
6.4、HashMap的底层实现原理？
jdk7
- HashMap map = new HashMap(): 在实例化以后，底层创建了长度是16的一位数组Entry[] table。
- …可能已经执行过多次put…
- map.put(key1,value1): 首先,调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。如果此位置上的数据为空，此时的key1-value1添加成功 ---->情况1。如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(一链表形式存在))，比较key1和已经存在的一个或多个数据的哈希值:
- 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功 —>情况2
- 如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较: 调用key1所在类的equals(key2)
- 如果equals()返回false: 此时key1-value添加成功。 ----情况3
- 如果equals()返回true: 使用value1替换value2。
补充: 关于情况2和情况3: 此时key1-value1和原来的数据以链表的方式存储。
在不断的添加过程中，会涉及到扩容问题，当超过临界值(且要存放的位置非空)时，扩容，默认的扩容方式: 扩容为原来容量的2倍，并将原有的数据复制过来。
jdk8 相较于jdk7在底层实现方面的不同:
- new HashMap(): 底层没有创建一个长度为16的数组
- jdk 8底层的数组是: Node[],而非Entry[]
- 首次调用put()方法时，底层创建长度为16的数组
- jdk7底层结构只有: 数组+链表。jdk8中底层结构: 数组+链表+红黑树。
- 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度>64时，此时此索引位置上的索引所有数据改为使用红黑树存储。
HashMap底层典型属性的说明
- DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
- DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
- threshold：扩容的临界值，= 容量*填充因子：16 * 0.75 => 12
- TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:JDK 8.0引入
- MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64
6.5、LinkedHashMap的底层实现原理(了解)
- LinkedHashMap底层使用的结构与HashMap相同，因为LinkedHashMap继承于HashMap.
- 区别就在于：LinkedHashMap内部提供了Entry，替换HashMap中的Node.
- 与Linkedhash Set类似，LinkedHashMap可以维护Map的迭代顺序：迭代顺序与Key-value对的插入顺序一致
HashMap中内部类Node源码：
static class Node<K,V> implements Map.Entry<K,V>{
final int hash;
final K key;
V value;
Node<K,V> next;
}
LinkedHashM中内部类Entry源码：
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;//能够记录添加的元素的先后顺序
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
6.6、常用方法
添加、删除、修改操作：
- Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
- void putAll(Map m):将m中的所有key-value对存放到当前map中
- Object remove(Object key)：移除指定key的key-value对，并返回value
- void clear()：清空当前map中的所有数据
//代码示例
@Test
public void test7(){
HashMap hashMap = new HashMap();
//Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
hashMap.put(1,"AA");
hashMap.put(2,"BB");
hashMap.put(3,"CC");
//void putAll(Map m):将m中的所有key-value对存放到当前map中
HashMap hashMap1 = new HashMap();
hashMap1.put(4,"DD");
hashMap.putAll(hashMap1);
System.out.println(hashMap);//{1=AA, 2=BB, 3=CC, 4=DD}
//Object remove(Object key)：移除指定key的key-value对，并返回value
hashMap.remove(1);
System.out.println(hashMap);//{2=BB, 3=CC, 4=DD}
//void clear()：清空当前map中的所有数据
hashMap.clear();
System.out.println(hashMap);//{}
}
元素查询的操作
- Object get(Object key)：获取指定key对应的value
- boolean containsKey(Object key)：是否包含指定的key
- boolean containsValue(Object value)：是否包含指定的value
- int size()：返回map中key-value对的个数
- boolean isEmpty()：判断当前map是否为空
- boolean equals(Object obj)：判断当前map和参数对象obj是否相等
//代码示例
@Test
public void test8(){
HashMap hashMap = new HashMap();
hashMap.put("A","中国");
hashMap.put("B","美国");
hashMap.put("C","法国");
//Object get(Object key)：获取指定key对应的value
System.out.println(hashMap.get("A"));//中国
//boolean containsKey(Object key)：是否包含指定的key
System.out.println(hashMap.containsKey("A"));//true
//boolean containsValue(Object value)：是否包含指定的value
System.out.println(hashMap.containsValue("美国"));//true
//int size()：返回map中key-value对的个数
System.out.println(hashMap.size());//3
//boolean isEmpty()：判断当前map是否为空
System.out.println(hashMap.isEmpty());//false
//boolean equals(Object obj)：判断当前map和参数对象obj是否相等
HashMap hashMap1 = new HashMap();
hashMap1.put("A","中国");
hashMap1.put("B","美国");
hashMap1.put("C","法国");
System.out.println(hashMap.equals(hashMap1));//true
}
元视图操作的方法：
- Set keySet()：返回所有key构成的Set集合
- Collection values()：返回所有value构成的Collection集合
- Set entrySet()：返回所有key-value对构成的Set集合
//代码示例
@Test
public void test9(){
HashMap hashMap = new HashMap();
hashMap.put("A","中国");
hashMap.put("B","美国");
hashMap.put("C","法国");
//Set keySet()：返回所有key构成的Set集合
Set set = hashMap.keySet();
System.out.println(set);//[A, B, C]
//Collection values()：返回所有value构成的Collection集合
Collection values = hashMap.values();
System.out.println(values);//[中国, 美国, 法国]
//Set entrySet()：返回所有key-value对构成的Set集合
Set set1 = hashMap.entrySet();
System.out.println(set1);//[A=中国, B=美国, C=法国]
}
总结：常用方法：
- 添加：put(Object key,Object value)
- 删除：remove(Object key)
- 修改：put(Object key,Object value)
- 查询：get(Object key)
- 长度：size()
- 遍历：keySet() / values() / entrySet()
6.7、TreeMap的使用
- 向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
- 因为要按照key进行排序: 自然排序、定制排序
//代码示例
@Test
public void test10(){
TreeMap treeMap = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Persion && o2 instanceof Persion){
Persion P = (Persion)o1;
Persion P2 = (Persion)o2;
return P.getName().compareTo(P2.getName());
}
throw new RuntimeException("数据类型不匹配");
}
});
Persion persion = new Persion("C", 10);
Persion persion2 = new Persion("A", 20);
Persion persion3 = new Persion("B", 8);
treeMap.put(persion,52);
treeMap.put(persion2,81);
treeMap.put(persion3,79);
System.out.println(treeMap);
}
6.8、Properties
- Properties类是Hashtable的子类，该对象用于处理属性文件
- 由于属性文件里的key、value都是字符串类型，所以Properties里的key和value都是字符串类型
- 存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法
//代码示例
@Test
public void test11() throws IOException {
Properties properties = new Properties();
FileInputStream fileInputStream = new FileInputStream("jdbc.properties");
properties.load(fileInputStream);//加载流对应的文件
String name = properties.getProperty("name");
String password = properties.getProperty("password");
System.out.println("name =" + name +","+ "password=" + password);
}
7、Collection工具类
7.1、作用
Collections是一个操作Set、Lit和Map等集合的工具类
Collections中提供了一系列静态的方法对集合元素进行排序、査询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
7.2、常用方法
排序操作
- reverse(List)：反转 List 中元素的顺序
- shuffle(List)：对 List 集合元素进行随机排序
- sort(List)：根据元素的自然顺序对指定 List 集合元素升序排序
- sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
- swap(List，int startindex， int endindex)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
//代码示例
@Test
public void test(){
List list = new ArrayList();
list.add(45);
list.add(123);
list.add(10);
list.add(8);
//reverse(List)：反转 List 中元素的顺序
Collections.reverse(list);
System.out.println(list);//[8, 10, 123, 45]
//shuffle(List)：对 List 集合元素进行随机排序
Collections.shuffle(list);
System.out.println(list);//[123, 45, 8, 10]
//sort(List)：根据元素的自然顺序对指定 List 集合元素升序排序
Collections.sort(list);
System.out.println(list);//[8, 10, 45, 123]
//swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
Collections.swap(list,2,3);
System.out.println(list);//[8, 10, 123, 45]
}
查找、替换
- Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
- Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
- Object min(Collection)
- Object min(Collection，Comparator)
- int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
- void copy(List dest,List src)：将src中的内容复制到dest中
- boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所旧值
//代码示例
@Test
public void test2(){
List list = new ArrayList();
list.add(123);
list.add(123);
list.add(123);
list.add(43);
list.add(765);
list.add(-97);
list.add(0);
System.out.println(list);//[123, 43, 765, -97, 0]
//Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Comparable max = Collections.max(list);
System.out.println(max);//765
//Object min(Collection)
Comparable min = Collections.min(list);
System.out.println(min);//-97
//int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
int frequency = Collections.frequency(list,123);
System.out.println(frequency);//3
//void copy(List dest,List src)：将src中的内容复制到dest中
List dest = Arrays.asList(new Object[list.size()]);
System.out.println(dest.size());//7
Collections.copy(dest,list);
System.out.println(dest);//[123, 123, 123, 43, 765, -97, 0]
//boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
}
同步控制
Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题
//代码示例
@Test
public void test3() {
List list = new ArrayList();
list.add(123);
list.add(123);
list.add(123);
list.add(43);
list.add(765);
list.add(-97);
list.add(0);
System.out.println(list);//[123, 43, 765, -97, 0]
//返回的list1即为线程安全的List
List list1 = Collections.synchronizedList(list);
System.out.println(list1);//[123, 123, 123, 43, 765, -97, 0]
}
45万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
