1 引言
集合是java中提供的大小可变的容器。
集合分为单列结合Collection
和双列集合Map
。
集合和数组的区别:
- 数组的长度是固定的。集合的长度是可变的。
- 数组中存储的是同一类型的元素,可以存储任意类型数据。集合存储的都是引用数据类型,如果想存储基本类型数据需要存储对应的包装类型。
2 Collection
2.1 继承体系
Collection:单列集合类的根接口,Collection接口又派生出三个子接口,分别是java.util.List
、java.util.Set
和java.util.Queue
。
注:紫色框体代表接口,其中加粗的是代表四类集合的接口。蓝色框体代表实现类,其中有阴影的是常用实现类。
List
的特点是元素有序、元素可重复、有索引(可通过索引遍历集合)。
- ArrayList:集合数据存储的结构是数组结构。元素增删慢,查找快,由于日常开发中使用最多的功能为查询数据、遍历数据,所以ArrayList是最常用的集合。
- LinekdList:集合数据存储的结构是双向链表结构。方便元素添加、删除的集合(增删首尾元素尤其快)。在开发时,LinkedList集合也可以作为堆栈,队列的结构使用。
- Vector:大多数操作与ArrayList相同,区别之处在于Vector是线程安全的,但性能略差。
Set
的特点是元素不可重复、无索引(不可通过索引遍历集合)、底层均为值为空的Map。
- HashSet:添加的元素是无序,不重复,无索引的。增删改查的性能都很好。根据对象的哈希值来确定元素在集合中的存储位置,具有良好的存储和查找性能。依赖
hashCode
与equals
方法保证元素唯一性。在JDK1.8
之前,哈希表底层采用数组+链表实现。这存在一个问题,就是当hash值相等的元素较多时,通过key值依次查找链表元素的效率较低。而JDK1.8
中,哈希表存储采用数组+链表+红黑树实现,当链表长度超过阈值 8 时,将链表转换为红黑树,这样大大减少了查找时间。tips:数组初始容量为16,当如果使用率超过0.75(16*0.75=12)就会扩大容量为原来的2倍。(16扩容为32,依次为64,128…等) - LinkedHashSet:添加的元素是有序,不重复,无索引的。
LinkedHashSet
是HashSet
的子类,依然是使用哈希表存储元素,区别是LinkedHashSet
使用了一个双向链表来维护元素的次序,这使得元素看起来是以插入顺序保存的。LinkedHashSet
插入性能略低于HashSet
且多了一个存储顺序的链会占内存空间,但在迭代访问Set
里的全部元素时有很好的性能。 - TreeSet:添加的元素是按照大小默认升序排序、不重复、无索引的。底层依赖于
TreeMap
,是一种基于红黑树的实现。需要使用自然排序(元素实现Comparable接口)或者定制排序(创建TreeSet
时提供Comparator
比较器)来实现对元素进行排序。如果同时使用了自然排序和定制排序,生效的是定制排序。
Queue
:先进先出(FIFO)的队列;
2.2 Collection 常用API
Collection是所有单列集合的父接口,因此在Collection中定义了单列集合(List和Set)通用的一些方法。如下所示:
public boolean add(E e)
: 把给定的对象添加到当前集合中 。public void clear()
:清空集合中所有的元素。public boolean remove(E e)
: 把给定的对象在当前集合中删除。public boolean contains(Object obj)
: 判断当前集合中是否包含给定的对象。public boolean isEmpty()
: 判断当前集合是否为空。public int size()
: 返回集合中元素的个数。public Object[] toArray()
: 把集合中的元素,存储到数组中(可以通过String[]::new
指定返回数组的类型为String)
2.3 Collection 的三种遍历方式
Collection集合的遍历方式是全部集合都可以直接使用的。
Collection集合的遍历方式有三种:
- 迭代器Iterator
- foreach(增强for循环)
- JDK 1.8开始之后的新技术Lambda表达式
2.3.1 Iterator迭代器
JDK专门提供了一个接口java.util.Iterator
用于遍历集合中的所有元素。
public Iterator iterator()
: 获取集合对应的迭代器,用来遍历集合中的元素的。
Iterator接口的常用方法如下:
public E next()
:返回迭代的下一个元素。public boolean hasNext()
:如果仍有元素可以迭代,则返回 true。
代码示例:
public static void main(String[] args) {
Collection<String> coll = new ArrayList<String>();
coll.add("张三");
coll.add("李四");
coll.add("王五");
//使用迭代器遍历。每个集合对象都有自己的迭代器。
//泛型指的是迭代出元素的数据类型
Iterator<String> it = coll.iterator();
while(it.hasNext()){ //判断是否有迭代元素
String s = it.next();//获取迭代出的元素
System.out.println(s);
}
}
tips:
- 在进行集合元素获取时,如果集合中已经没有元素了,还继续使用迭代器的next方法,将会抛出
java.util.NoSuchElementException
没有集合元素异常。- 在进行集合元素获取时,如果添加或移除集合中的元素 , 将无法继续迭代 , 将会抛出
ConcurrentModificationException
并发修改异常.
2.3.2 增强for循环
foreach是一种遍历形式,可以遍历集合或者数组。
优点:foreach遍历集合实际上是迭代器遍历的简化写法。
缺点:foreach遍历无法知道遍历到了哪个元素了,因为没有索引。
代码示例:
public static void main(String[] args) {
Collection<String> lists = new ArrayList<>();
coll.add("张三");
coll.add("李四");
coll.add("王五");
for (String ele : lists) {
System.out.println(ele);
}
int[] ages = new int[]{17 , 18 , 38 , 21};
for (int age : ages) {
System.out.println(age);
}
}
2.3.3 Lambda表达式
public static void main(String[] args) {
Collection<String> lists = new ArrayList<>();
coll.add("张三");
coll.add("李四");
coll.add("王五");
System.out.println(lists);
lists.forEach(s -> {
System.out.println(s);
});
// 简化版本(1)
lists.forEach(s -> System.out.println(s));
// 简化版本(2)
lists.forEach(System.out::println);
}
2.4 Collections类
java.utils.Collections
是集合工具类,用来对集合进行操作。
常用方法如下:
public static <T> boolean addAll(Collection<? super T> c, T... elements)
:往集合中添加一些元素。public static void shuffle(List<?> list)
:打乱集合顺序。(注意:只能打乱有序的List集合)public static <T> void sort(List<T> list)
:将集合中元素按照默认规则排序。public static <T> void sort(List<T> list,Comparator<? super T> )
:将集合中元素按照指定规则排序。
这里涉及的知识点:泛型通配符、可变参数、自然排序、定制排序。
3 Map
3.1 继承体系
java.util.Map
接口是Java
提供的专门用来存放映射关系的对象的集合类。
注:紫色框体代表接口,其中加粗的是代表四类集合的接口。蓝色框体代表实现类,其中有阴影的是常用实现类。
- HashMap<K,V>:键是无序、不重复、无索引的,值不做要求。
HashMap
是最经典的、用的最多的键值对集合。存储数据采用的哈希表结构,元素的存取顺序不能保证一致。由于要保证键的唯一、不重复,自定义对象作为键时要重写hashCode()
方法、equals()
方法。在JDK1.8
之前,哈希表底层采用数组+链表实现。这存在一个问题,就是当hash值相等的元素较多时,通过key值依次查找链表元素的效率较低。而JDK1.8
中,哈希表存储采用数组+链表+红黑树实现,当链表长度超过阈值 8 时,将链表转换为红黑树,这样大大减少了查找时间。tips:数组初始容量为 16,当如果使用率超过 0.75(16*0.75=12)就会扩大容量为原来的 2 倍。(16扩容为32,依次为64,128…等) - LinkedHashMap<K,V>:键是有序、不重复、无索引的,值不做要求。
LinkedHashMap
是HashMap
的子类,依然是使用哈希表存储元素,区别是LinkedHashMap
使用了一个双向链表来维护元素的次序,这使得元素看起来是以插入顺序保存的。 - TreeMap<K,V>:添加的元素是按照大小默认升序排序、不重复、无索引的。底层基于红黑树的实现。需要使用自然排序(元素实现
Comparable
接口)或者定制排序(创建TreeSet
时提供Comparator
比较器)来实现对元素进行排序。如果同时使用了自然排序和定制排序,生效的是定制排序。 - Hashtable<K,V>:大多数操作与
HashMap
相同,区别之处在于Hashtable
是线程安全的,但性能略差。 - Properties:
Hashtable
的子类,该对象用于处理属性文件。由于属性文件里的key
和value
都是字符串类型,所以Properties
里的key
和value
都是字符串类型。存取数据时,建议使用setProperty(String key,String value)
方法和getProperty(String key)
方法。
3.2 Map 常用API
public V put(K key, V value)
: 把指定的键与指定的值添加到Map集合中。public V remove(Object key)
: 把指定的键 所对应的键值对元素 在Map集合中删除,返回被删除元素的值。public V get(Object key)
根据指定的键,在Map集合中获取对应的值。public Set<K> keySet()
: 获取Map集合中所有的键,存储到Set集合中。public Set<Map.Entry<K,V>> entrySet()
: 获取到Map集合中所有的键值对对象的集合(Set集合)。public boolean containKey(Object key)
:判断该集合中是否有此键。
tips:
- 使用put方法时,若指定的键(key)在集合中没有,则没有这个键对应的值,返回null,并把指定的键值添加到集合中;
- 若指定的键(key)在集合中存在,则返回值为集合中键对应的值(该值为替换前的值),并把指定键所对应的值,替换成指定的新值。
3.3 Map 的三种遍历方式
Map集合的遍历方式有三种:
- “键找值”的方式遍历(先获取Map集合全部的键,再根据遍历键找值。)
- “键值对”的方式遍历。
- JDK 1.8开始之后的新技术:Lambda表达式。
3.3.1 键找值
通过元素中的键,获取键所对应的值
操作步骤:
- 获取Map中所有的键,由于键是唯一的,所以返回一个
Set
集合存储所有的键。方法提示:keyset()
- 遍历键的
Set
集合,得到每一个键。 - 根据键,获取键所对应的值。方法提示:
get(K key)
public static void main(String[] args) {
Map<String , Integer> maps = new HashMap<>();
maps.put("可口可乐",3);
maps.put("雪碧",3);
maps.put("脉动",5);
maps.put("果粒橙",4);
maps.put("魔爪",6);
System.out.println(maps);
// a.获取当前Map集合的全部键的集合 。
Set<String> keys = maps.keySet();
// b.通过遍历键然后通过键取对应的值
for (String key : keys) {
// 通过键取对应的值
Integer value = maps.get(key);
System.out.println(key + "=" + value);
}
}
3.3.2 键值对方式
通过集合中每个键值对Entry
对象,获取键值对Entry
对象中的键与值。
Entry键值对对象:
我们已经知道,Map
中存放的是两种对象,一种称为key
(键),一种称为value
(值),它们在在Map
中是一一对应关系,这一对对象又称做Map
中的一个Entry(项)
。Entry
将键值对的对应关系封装成了对象。即键值对对象,这样我们在遍历Map
集合时,就可以从每一个键值对(Entry
)对象中获取对应的键与对应的值。
tips:Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。
操作步骤:
- 获取
Map
集合中,所有的键值对对象(Map.Entry
内部类),以Set
集合形式返回。方法提示:entrySet()
。 - 遍历包含键值对
Entry
对象的Set
集合,得到每一个键值对Entry
对象。 - 通过键值对
Entry
对象,获取Entry
对象中的键与值。 方法提示:getkey() getValue()
public static void main(String[] args) {
Map<String , Integer> maps = new HashMap<>();
maps.put("可口可乐",3);
maps.put("雪碧",3);
maps.put("脉动",5);
maps.put("果粒橙",4);
maps.put("魔爪",6);
System.out.println(maps);
// 获取Map集合中,所有的键值对对象
Set<Map.Entry<String,Integer>> entries = maps.entrySet();
// 遍历包含键值对(Entry)对象的Set集合,得到每一个键值对(Entry)对象。
for (Map.Entry<String, Integer> entry : entries) {
// 通过键值对(Entry)对象,获取Entry对象中的键与值
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + "=" + value);
}
}
3.3.3 Lambda表达式
public static void main(String[] args) {
Map<String , Integer> maps = new HashMap<>();
maps.put("可口可乐",3);
maps.put("雪碧",3);
maps.put("脉动",5);
maps.put("果粒橙",4);
maps.put("魔爪",6);
maps.forEach((k , v) -> {
System.out.println(k+"="+v);
});
// 简化版本
maps.forEach((k , v) -> System.out.println(k+"="+v));
}
4 集合类常考面试题
Collection的remove方法和List的remove方法的区分
public static void main(String[] args) throws ParseException {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
//删除的是索引为2的元素
list.remove(2);
//删除的是值为2的元素
list.remove(Integer.valueOf(2));
System.out.println(list);
}
请问ArrayList/LinkedList/Vector的异同?谈谈你的理解?ArrayList底层是什么?扩容机制?Vector和ArrayList的最大区别?
- ArrayList和LinkedList的异同
二者都线程不安全,相对线程安全的Vector,执行效率高。
此外,ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove,LinkedList比较占优势,因为ArrayList要移动数据。 - ArrayList和Vector的区别
Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized),属于强同步类。因此开销就比ArrayList要大,访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间,而ArrayList是1.5倍。Vector还有一个子类Stack。
Set集合添加的元素是不重复的,它是如何去重复的?
HashSet去重的原理:
向HashSet中添加元素的过程:
- 当向 HashSet 集合中存入一个元素时,HashSet 会调用该对象的hashCode() 方法来得到该对象的 hashCode 值,然后根据 hashCode 值,通过某种散列函数决定该对象在 HashSet 底层数组中的存储位置。(这个散列函数会与底层数组的长度相计算得到在数组中的下标,并且这种散列函数计算还尽可能保证能均匀存储元素,越是散列分布,该散列函数设计的越好)
- 如果两个元素的hashCode()值相等,会再继续调用equals方法,如果equals方法结果为true,添加失败;如果为false,那么会保存该元素,但是该数组的位置已经有元素了,那么会通过链表的方式继续链接。
- 如果两个元素的 equals() 方法返回 true,但它们的 hashCode() 返回值不相等,hashSet 将会把它们存储在不同的位置,但依然可以添加成功
如果希望HashSet集合认为两个对象只要内容一样就重复了,对应的类一定要重写equals()和hashCode()方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码”。
TreeSet去重的原理:
通过compareTo()方法或者compare()方法的返回值判断,如果返回0,说明两个对象是重复的。
HashSet 添加删除元素的细节
public static void main(String[] args) {
HashSet<Person> set = new HashSet<>();
Person p1 = new Person(1001,"AA");
Person p2 = new Person(1002,"BB");
set.add(p1);
set.add(p2);
// 修改了数组中person对象的属性值,但是其在底层数组中位置没变(依旧是由{id=1002, name='AA'}计算出的hashCode决定的)
p1.name = "CC";
// 删除的是由{id=1002, name='CC'}计算出的hashCode决定的位置上的对象,而此时该位置为空,因此没有元素被删除
set.remove(p1);
System.out.println(set);
// 由{id=1002, name='CC'}计算出的hashCode决定的位置为空,成功添加
set.add(new Person(1001,"CC"));
System.out.println(set);
// 由{id=1002, name='AA'}计算出的hashCode决定的位置上存在一个{id=1002, name='CC'},此时会调用和equals方法,返回false,成功添加
set.add(new Person(1001,"AA"));
System.out.println(set);
}
输出:
[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}]
[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}, Person{id=1001, name='AA'}]
利用 HashSet 去重
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(2);
list.add(4);
list.add(4);
HashSet<Integer> set = new HashSet<>(list);
List<Integer> list2 = new ArrayList<>(set);
list2.forEach(System.out::println);
}
谈谈你对HashMap的存储结构?对put/get方法的认识?
HashMap的内部存储结构其实是数组+链表+树的结合。
在put第一对映射关系时,系统会创建一个长度为initialCapacity的Node数组,这个长度在哈希表中被称为容量(Capacity),在这个数组中可以存放元素的位置我们称之为“桶”(bucket),每个bucket都有自己的索引,系统可以根据索引快速的查找bucket中的元素。每个bucket中存储一个元素,即一个Node对象,但每一个Node对象可以带一个引用变量next,用于指向下一个元素,因此,在一个桶中,就有可能生成一个Node链。也可能是一个一个TreeNode对象,每一个TreeNode对象可以有两个叶子结点left和right,因此,在一个桶中,就有可能生成一个TreeNode树。
HashMap的扩容机制?底层链表转变为树的条件?
当HashMap中的元素个数超过吞吐临界值 时,就会进行数组扩容。也就是说,默认情况下,数组大小(DEFAULT_INITIAL_CAPACITY)为16,那么当HashMap中元素个数超过16*0.75=12(这个值就是代码中的threshold值,也叫做临界值)的时候,就把数组的大小扩展为 2*16=32,即扩大一倍,然后重新计算每个元素在数组中的位置,而这是一个非常消耗性能的操作,所以如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。
吞吐临界值 = 容量(Capacity) * 负载因子(loadFactor)
当HashMap中的其中一个链的对象个数如果达到了8个,此时如果capacity没有达到64,那么HashMap会先扩容,如果已经达到了64,那么这个链会变成树,结点类型由Node变成TreeNode类型。
当然,如果当映射关系被移除后,下次resize方法时判断树的结点个数低于6个,也会把树再转为链表。
负载因子值的大小,对HashMap有什么影响?
负载因子的大小决定了HashMap的数据密度。
- 负载因子越大密度越大,发生碰撞的几率越高,数组中的链表越容易长,
造成查询或插入时的比较次数增多,性能会下降。 - 负载因子越小,就越容易触发扩容,数据密度也越小,意味着发生碰撞的几率越小,数组中的链表也就越短,查询和插入时比较的次数也越小,性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能,建议初始化预设大一点的空间。
- 按照其他语言的参考及研究经验,会考虑将负载因子设置为0.7~0.75,此时平均检索长度接近于常数
HashMap的key能否修改?
可以改,但不建议修改。
映射关系存储到HashMap中会存储key的hash值,这样就不用在每次查找时重新计算每一个Entry或Node(TreeNode)的hash值了,因此如果已经put到Map中的映射关系,再修改key的属性,而这个属性又参与hashcode值的计算,那么会导致匹配不上,这样可能导致HashMap中出现相同的key。
Java中的容器,线程安全和线程不安全的分别有哪些?
java.util包下的集合类大部分都是线程不安全的,例如我们常用的HashSet、TreeSet、ArrayList、LinkedList、ArrayDeque、HashMap、TreeMap,这些都是线程不安全的集合类,但是它们的优点是性能好。如果需要使用线程安全的集合类,则可以使用Collections工具类提供的synchronizedXxx()方法,将这些集合类包装成线程安全的集合类。
**java.util包下也有线程安全的集合类,例如Vector、Hashtable。**这些集合类都是比较古老的API,虽然实现了线程安全,但是性能很差。所以即便是需要使用线程安全的集合类,也建议将线程不安全的集合类包装成线程安全集合类的方式,而不是直接使用这些古老的API。
从Java5开始,Java在java.util.concurrent包下提供了大量支持高效并发访问的集合类,它们既能包装良好的访问性能,有能包装线程安全。这些集合类可以分为两部分,它们的特征如下:
-
以Concurrent开头的集合类代表了支持并发访问的集合,它们可以支持多个线程并发写入访问,这些写入线程的所有操作都是线程安全的,但读取操作不必锁定。以Concurrent开头的集合类采用了更复杂的算法来保证永远不会锁住整个集合,因此在并发写入时有较好的性能。
-
以CopyOnWrite开头的集合类采用复制底层数组的方式来实现写操作。当线程对此类集合执行读取操作时,线程将会直接读取集合本身,无须加锁与阻塞。当线程对此类集合执行写入操作时,集合会在底层复制一份新的数组,接下来对新的数组执行写入操作。由于对集合的写入操作都是对数组的副本执行操作,因此它是线程安全的。