目录
概述
Java 集合可分为 Collection 和 Map 两种体系。
-
Collection 接口 :单列数据,定义了存取一组对象的方法的集合。
①List:元素有序、可重复的集合。
②Set:元素无序、不可重复的集合。 -
Map 接口:双列数据,保存具有映射关系“key-value对”的集合。
Collection 接口继承树:
Map 接口继承树:
Collection接口方法
- 添加:add(Object obj)和 addAll(Collection coll)。
- 获取有效元素的个数: int size()。
- 清空集合: void clear()。
- 是否是空集合:boolean isEmpty()。
- 是否包含某个元素:boolean contains(Object obj)是通过元素的equals方法来判断是否是同一个对象; boolean containsAll(Collection c)也是调用元素的equals方法来比较的,拿两个集合的元素挨个比较。
- 删除:boolean remove(Object obj) 通过元素的equals方法判断是否是要删除的那个元素,只会删除找到的第一个元素;boolean removeAll(Collection coll)取当前集合的差集。
- 取两个集合的交集:boolean retainAll(Collection c)把交集的结果存在当前集合中,不影响c。
- 集合是否相等:boolean equals(Object obj)。
- 转成对象数组: Object[] toArray()。
- 获取集合对象的哈希值:hashCode()。
- 遍历: iterator()返回迭代器对象,用于集合遍历。
Iterator迭代器接口
- Iterator对象称为迭代器(设计模式的一种),主要用于遍历 Collection 集合中的元素。
- Collection接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,那么所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象。
- Iterator 仅用于遍历集合,Iterator 本身并不提供承装对象的能力。如果需要创建Iterator 对象,则必须有一个被迭代的集合。
- 集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。
- 在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用,且下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常。
//错误用法一
public class CollectionLen {
/**
* 1
* 3
* 5
* 7
* 9
* Exception in thread "main" java.util.NoSuchElementException
* @param args
*/
public static void main(String[] args) {
Collection collection = new ArrayList();
for(int i = 0;i < 10;i++){
collection.add(i);
}
Iterator iterator = collection.iterator();
while (iterator.next() != null){
System.out.println(iterator.next());
}
}
}
//错误用法二
/**
* 0
* 0
* 0
* 0
* 0
* 0
* 0
* ...
* 出现死循环
* @param args
*/
public static void main(String[] args) {
Collection collection = new ArrayList();
for(int i = 0;i < 10;i++){
collection.add(i);
}
while (collection.iterator().hasNext()){
System.out.println(collection.iterator().next());
}
}
//特别注意
Iterator iter = coll.iterator();
while(iter.hasNext()){
Object obj = iter.next();
if(obj.equals("Tom")){
iter.remove();
}
}
1.Iterator可以删除集合的元素,但是遍历过程中通过迭代器对象的remove方法,不是集合对象的remove方法。
2.如果还未调用next()或在上一次调用next方法之后已经调用了remove方法,再调用remove都会报IllegalStateException。
使用 foreach 循环遍历集合元素:
- 遍历操作不需获取Collection或数组的长度,无需使用索引访问元素。
- 遍历集合的底层调用Iterator完成操作。
- foreach还可以用来遍历数组。
/**
* hello
* hello
* hello
* hello
* hello
* null
* null
* null
* null
* null
* @param args
*/
String[] str = new String[5];
for (String myStr : str) {
myStr = "hello";
System.out.println(myStr);
}
for (int i = 0; i < str.length; i++) {
System.out.println(str[i]);
}
Collection子接口之一:List接口
概述
- List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
- JDK API中List接口的实现类常用的有:ArrayList、LinkedList和Vector。
接口方法
除了从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 位置的元素为ele。
- List subList(int fromIndex, int toIndex): 返回从fromIndex 到toIndex位置的子集合。
实现类之一:ArrayList
- ArrayList 是 List 接口的典型实现类、主要实现类。
- 本质上,ArrayList是对象引用的一个”变长”数组。
- ArrayList 的JDK1.8之前与之后的实现区别?JDK1.7:ArrayList像饿汉式,直接创建一个初始容量为10的数组。 JDK1.8:ArrayList像懒汉式,一开始创建一个长度为0的数组,当添加第一个元素时再创建一个始容量为10的数组。
- Arrays.asList(…) 方法返回的 List 集合,既不是 ArrayList 实例,也不是Vector 实例。 Arrays.asList(…) 返回值是一个固定长度的 List 集合。
public static void testUpdateList(){
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
removeListEle(list);
System.out.println(list);//[1, 2]
}
private static void removeListEle(List list){
list.remove(2);
}
1.考查Collection和List中remove方法传入参数的具体含义。
实现类之二:LinkedList
- 双向链表,内部没有声明数组,而是定义了Node类型的first和last,用于记录首末元素。同时,定义内部类Node,作为LinkedList中保存数据的基本结构。Node除了保存数据,还定义了两个变量:prev变量记录前一个元素的位置和 next变量记录下一个元素的位置。
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;
}
}
- 对于频繁的插入或删除元素的操作,建议使用LinkedList类,效率较高。
- 新增方法:
①void addFirst(Object obj)
②void addLast(Object obj)
③Object getFirst()
④Object getLast()
⑤Object removeFirst()
⑥Object removeLast()
实现类之三:Vector
大多数操作与ArrayList相同,区别之处在于Vector是线程安全的。但基本不用。
面试题
Collection子接口之二:Set接口
概述
- set接口没有提供额外的方法。
- Set 集合不允许包含相同的元素。
- Set 判断两个对象是否相同不是使用 == 运算符,而是根据 equals() 方法。
【注意点】: 如何理解Set接口元素的无序和不可重复性?
实现类之一:HashSet
- HashSet 按 Hash 算法来存储集合中的元素,因此具有很好的存取、查找、删除性能。
- HashSet 不能保证元素的排列顺序,且是线程不安全的,但集合元素可以是 null。
- HashSet 集合判断两个元素相等的标准:两个对象通过 hashCode() 方法比较相等,并且两个对象的 equals() 方法返回值也相等。
- 对于存放在Set容器中的对象, 对应的类一定要重写equals() 和hashCode(Object obj) 方法,以实现对象相等规则 。即: “相等的对象必须具有相等的散列码” 。
- 向HashSet中添加元素的过程:当向 HashSet 集合中存入一个元素时,HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值,然后根据 hashCode 值,通过某种散列函数决定该对象在 HashSet 底层数组中的存储位置。如果两个元素的hashCode()值相等,会再继续调用equals方法,如果equals方法结果为true,添加失败;如果为false,那么会保存该元素,但是该数组的位置已经有元素了,那么会通过链表的方式继续链接。如果两个元素的 equals() 方法返回 true,但它们的 hashCode() 返回值不相等,hashSet 将会把它们存储在不同的位置,但依然可以添加成功。
- 重写 hashCode() 方法的基本原则:在程序运行时,同一个对象多次调用 hashCode() 方法应该返回相同的值;当两个对象的 equals() 方法比较返回 true 时,这两个对象的 hashCode()方法的返回值也应相等;对象中用作 equals() 方法比较的 Field,都应该用来计算 hashCode 值。
- 重写 equals() 方法的基本原则:重写equals方法的时候一般都需要同时重写hashCode方法,通常参与计算 hashCode 的对象的属性也应该参与到equals()中进行计算。
实现类之二:LinkedHashSet
- LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置,但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入顺序保存的。
- LinkedHashSet插入性能略低于 HashSet,但在迭代访问 Set 里的全部元素时有很好的性能。
实现类之三:TreeSet
- TreeSet 是 SortedSet 接口的实现类,TreeSet 可以确保集合元素处于排序状态。
- TreeSet 底层使用红黑树结构存储数据。
- 新增的方法:
①Comparator comparator()
②Object first()
③Object last()
④Object lower(Object e)
⑤Object higher(Object e)
⑥SortedSet subSet(fromElement, toElement)
⑦SortedSet headSet(toElement)
⑧SortedSet tailSet(fromElement) - TreeSet 两种排序方法: 自然排序和定制排序。默认情况下,TreeSet 采用自然排序。
- 自然排序:TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按升序(默认情况)排列。如果试图把一个对象添加到 TreeSet 时,则该对象的类必须实现 Comparable 接口,实现 Comparable 的类必须实现compareTo(Object obj) 方法,两个对象即通过compareTo(Object obj) 方法的返回值来比较大小。
class Student implements Comparable<Student> {
private String name;
private int score;
public Student(String name, int score) {
super();
this.name = name;
this.score = score;
}
@Override
public int compareTo(Student o) {
int num = o.score - score;
if (num != 0) {
return num;
} else {
return this.name.compareTo(o.name);
}
}
}
- 定制排序:通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。利用int compare(T o1,T o2)方法,比较o1和o2的大小:如果方法返回正整数,则表示o1大于o2;如果返回0,表示相等;返回负整数,表示o1小于o2。要实现定制排序,需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
TreeSet treeSet = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//具体实现逻辑代码
return 0;
}
});
面试题
//其中Student类中重写了hashCode()和equals()
HashSet hashSet = new HashSet();
Student student = new Student("AA",1001);
Student student1 = new Student("BB",1002);
hashSet.add(student);
hashSet.add(student1);
student.setName("CC");
hashSet.remove(student);
System.out.println(hashSet);//[Student{name='CC', age=1001}, Student{name='BB', age=1002}]
hashSet.add(new Student("CC",1001));
System.out.println(hashSet);//[Student{name='CC', age=1001}, Student{name='CC', age=1001}, Student{name='BB', age=1002}]
hashSet.add(new Student("AA",1001));
System.out.println(hashSet);//[Student{name='CC', age=1001}, Student{name='CC', age=1001}, Student{name='AA', age=1001}, Student{name='BB', age=1002}]
Map接口
概述
- Map与Collection并列存在。用于保存具有映射关系的数据:key-value。
- Map中的 key 和 value 都可以是任何引用类型的数据。
- Map中的 key 用Set来存放, 不允许重复,即同一个 Map 对象所对应的类,须重写hashCode()和equals()方法。
- 常用String类作为Map的“键”。
常用方法
实现类之一:HashMap
-
允许使用null键和null值,与HashSet一样,不保证映射的顺序。
-
所有的key构成的集合是Set:无序的、不可重复的。所以,key所在的类要重写:
equals()和hashCode()。 -
所有的value构成的集合是Collection:无序的、可以重复的。所以,value所在的类
要重写:equals()。 -
一个key-value构成一个entry。所有的entry构成的集合是Set:无序的、不可重复的。
-
HashMap 判断两个 key 相等的标准是:两个 key 通过 equals() 方法返回 true,hashCode 值也相等。
-
HashMap 判断两个 value 相等的标准是:两个 value 通过 equals() 方法返回 true。
-
HashMap 的存储结构:JDK 7及以前版本中HashMap是数组+链表结构(即为链地址法);JDK 8版本发布以后HashMap是数组+链表+红黑树实现。
-
HashMap源码中的重要常量:
-底层结构分析(JDK 7及以前版本):
1、HashMap的内部存储结构其实是数组和链表的结合。当实例化一个HashMap时,系统会创建一个长度为Capacity的Entry数组,这个长度在哈希表中被称为容量(Capacity),在这个数组中可以存放元素的位置我们称之为“桶”(bucket),每个bucket都有自己的索引,系统可以根据索引快速的查找bucket中的元素。每个bucket中存储一个元素,即一个Entry对象,但每一个Entry对象可以带一个引用变量,用于指向下一个元素,因此,在一个桶中,就有可能生成一个Entry链。而且新添加的元素作为链表head。
2、添加元素的过程:向HashMap中添加entry1(key,value),需要首先计算entry1中key的哈希值(根据key所在类的hashCode()计算得到),此哈希值经过处理以后,得到在底层Entry[]数组中要存储的位置i。如果位置i上没有元素,则entry1直接添加成功。如果位置i上已经存在entry2(或还有链表存在的entry3,entry4),则需要通过循环的方法,依次比较entry1中key和其他的entry。如果彼此hash值不同,则直接添加成功。如果hash值不同,继续比较二者是否equals。如果返回值为true,则使用entry1的value去替换equals为true的entry的value。如果遍历一遍以后,发现所有的equals返回都为false,则entry1仍可添加成功。entry1指向原有的entry元素。
3、HashMap的扩容:当HashMap中的元素越来越多的时候,hash冲突的几率也就越来越高,因为数组的长度是固定的。所以为了提高查询的效率,就要对HashMap的数组进行扩容,而在HashMap数组扩容之后,最消耗性能的点就出现了:原数组中的数据必须重新计算其在新数组中的位置,并放进去,这就是resize。
4、HashMap什么时候进行扩容:当HashMap中的元素个数超过数组大小(数组总大小length,不是数组中个数size)*loadFactor时, 就会进行数组扩容, loadFactor的默认值(DEFAULT_LOAD_FACTOR)为0.75,这是一个折中的取值。也就是说,默认情况下,数组大小(DEFAULT_INITIAL_CAPACITY)为16,那么当HashMap中元素个数超过16*0.75=12(这个值就是代码中的threshold值,也叫做临界值)的时候,就把数组的大小扩展为2*16=32,即扩大一倍,然后重新计算每个元素在数组中的位置,而这是一个非常消耗性能的操作,所以如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。
- 底层结构分析(JDK 8):
1、HashMap的内部存储结构其实是数组+ 链表+ 树的结合。当实例化一个HashMap时,会初始化initialCapacity和loadFactor,在put第一对映射关系时,系统会创建一个长度为initialCapacity的Node数组,这个长度在哈希表中被称为容量(Capacity),在这个数组中可以存放元素的位置我们称之为“桶”(bucket),每个bucket都有自己的索引,系统可以根据索引快速的查找bucket中的元素。每个bucket中存储一个元素,即一个Node对象,但每一个Node对象可以带一个引用变量next,用于指向下一个元素,因此,在一个桶中,就有可能生成一个Node链。也可能是一个一个TreeNode对象,每一个TreeNode对象可以有两个叶子结点left和right,因此,在一个桶中,就有可能生成一个TreeNode树。而新添加的元素作为链表的last,或树的叶子结点。
2、HashMap什么时候进行扩容和树形化:当HashMap中的元素个数超过数组大小(数组总大小length,不是数组中个数size)*loadFactor时, 就会进行数组扩容, loadFactor的默认值(DEFAULT_LOAD_FACTOR)为0.75,这是一个折中的取值。也就是说,默认情况下,数组大小(DEFAULT_INITIAL_CAPACITY)为16,那么当HashMap中元素个数超过16*0.75=12(这个值就是代码中的threshold值,也叫做临界值)的时候,就把数组的大小扩展为2*16=32,即扩大一倍,然后重新计算每个元素在数组中的位置,而这是一个非常消耗性能的操作,所以如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。当HashMap中的其中一个链的对象个数如果达到了8个,此时如果capacity没有达到64,那么HashMap会先扩容解决,如果已经达到了64,那么这个链会变成树,结点类型由Node变成TreeNode类型。当然,如果当映射关系被移除后,下次resize方法时判断树的结点个数低于6个,也会把树再转为链表。
3、映射关系的key是否可以修改:不能修改,映射关系存储到HashMap中会存储key的hash值,这样就不用在每次查找时重新计算每一个Entry或Node(TreeNode)的hash值了,因此如果已经put到Map中的映射关系,再修改key的属性,而这个属性又参与hashcode值的计算,那么会导致匹配不上。
- JDK 8中HashMap底层结构相较于之前JDK版本的变化:
1、HashMap map = new HashMap();//默认情况下,先不创建长度为16的数组;当首次调用map.put()时,再创建长度为16的数组。
2、数组为Node类型,在jdk7中称为Entry类型。
3、形成链表结构时,新添加的key-value对在链表的尾部;而jdk7及之前版本在链表的头部(七上八下)。
4、当数组指定索引位置的链表长度>8时,且map中的数组的长度>64时,此索引位置上的所有key-value对使用红黑树进行存储。
实现类之二:LinkedHashMap
- LinkedHashMap 是 HashMap 的子类。
- 在HashMap存储结构的基础上,使用了一对双向链表来记录添加元素的顺序。
- 与LinkedHashSet类似,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;
}
- LinkedHashMap中的内部类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);
}
}
实现类之三:TreeMap
-
TreeMap存储 Key-Value 对时,需要根据 key-value 对进行排序。TreeMap 可以保证所有的 Key-Value 对处于有序状态。
-
TreeMap底层使用红黑树结构存储数据。
-
TreeMap的 Key 的排序:
①自然排序:TreeMap 的所有的 Key 必须实现 Comparable 接口,而且所有的 Key 应该是同一个类的对象。
②定制排序:创建 TreeMap 时,传入一个 Comparator 对象,该对象负责对TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口。 -
TreeMap判断两个 key 相等的标准:两个key通过compareTo()方法或者compare()方法返回0。
实现类之四:Hashtable
- 不同于HashMap,Hashtable是线程安全的。
- Hashtable实现原理和HashMap相同,功能相同。底层都使用哈希表结构,查询速度快,很多情况下可以互用。
- 与HashMap不同,Hashtable 不允许使用 null 作为 key 和 value。
- 与HashMap一样,Hashtable 也不能保证其中 Key-Value 对的顺序。
- Hashtable判断两个key相等、两个value相等的标准,与HashMap一致。
实现类之五:Properties
- Properties 类是 Hashtable 的子类,该对象用于处理属性文件。由于属性文件里的 key、value 都是字符串类型,所以 Properties 里的 key 和 value 都是字符串类型。
- 存取数据时,建议使用setProperty(String key,String value)方法和getProperty(String key)方法:
Properties pros = new Properties();
pros.load(new FileInputStream("jdbc.properties"));
String user = pros.getProperty("user");
面试题
- 谈谈你对HashMap中put/get方法的认识?如果了解再谈谈HashMap的扩容机制?默认大小是多少?什么是负载因子(或填充比)?什么是吞吐临界值(或阈值、threshold)?
- 负载因子值的大小,对HashMap有什么影响?
Collections工具类
概述
- Collections 是一个操作 Set、List 和 Map 等集合的工具类,提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象设置不可变、对集合对象实现同步控制等方法。
常用方法
-
排序操作:
①reverse(List):反转 List 中元素的顺序。
②shuffle(List):对 List 集合元素进行随机排序。
③sort(List):根据元素的自然顺序对指定 List 集合元素按升序排序。
④sort(List,Comparator):根据指定的 Comparator 产生的顺序对 List 集合元素进行排序。
⑤swap(List,int, int):将指定 list 集合中的 i 处元素和 j 处元素进行交换。 -
查找、替换操作:
①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 对象的所有旧值。 -
同步控制:Collections 类中提供了多个 synchronizedXxx() 方法,该方法可使将指定集合包装成线程同步的集合,从而可以解决多线程并发访问集合时的线程安全问题。
面试题
Collections 类和Collection 接口的异同?