java集合操作
1、java集合概述
Java 集合可分为Collection 和Map 两种体系
-
Collection接口:单列数据,定义了存取一组对象的方法的集合
List:元素有序、可重复的集合
Set:元素无序、不可重复的集合
-
Map接口:双列数据,保存具有映射关系“key-value对”的集合
1.1、Collection接口继承树
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eD0BRy3r-1593572915697)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508142343433.png)]
1.2、Map接口继承树
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9voieAI1-1593572915700)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508142523629.png)]
2、 Collection 接口方法
Collection 接口
- Collection 接口是List、Set 和Queue 接口的父接口,该接口里定义的方法既可用于操作Set 集合,也可用于操作List 和Queue 集合。
- JDK不提供此接口的任何直接实现,而是提供更具体的子接口(如:Set和List)实现。
- 在Java5 之前,Java 集合会丢失容器中所有对象的数据类型,把所有对象都当成Object 类型处理;从JDK 5.0 增加了泛型以后,Java 集合可以记住容器中对象的数据类型。
1、添加
add(Objectobj)
addAll(Collectioncoll)
2、获取有效元素的个数
int size()
3、清空集合
void clear()
4、是否是空集合
boolean isEmpty()
5、是否包含某个元素
boolean contains(Objectobj):是通过元素的equals方法来判断是否是同一个对象
boolean containsAll(Collectionc):也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。
6、删除
boolean remove(Object obj) :通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素
boolean removeAll(Collection coll):取当前集合的差集
7、取两个集合的交集
boolean retainAll(Collection c):把交集的结果存在当前集合中,不影响c
8、集合是否相等
boolean equals(Object obj)
9、转成对象数组
Object[] toArray()
10、获取集合对象的哈希值
hashCode()
11、遍历
iterator():返回迭代器对象,用于集合遍历
3、Iterator迭代器接口
3.1、使用Iterator接口遍历集合元素
- Iterator对象称为迭代器(设计模式的一种),主要用于遍历Collection 集合中的元素。
- GOF给迭代器模式的定义为:提供一种方法访问一个容器(container)对象中各个元素,而又不需暴露该对象的内部细节。迭代器模式,就是为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。
- Collection接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,那么所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象。
- Iterator 仅用于遍历集合,Iterator本身并不提供承装对象的能力。如果需要创建Iterator 对象,则必须有一个被迭代的集合。
- 集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。
3.2、Iterator接口的方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7QewEBYn-1593572915702)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508144214109.png)]
在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用,且下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常。
3.3、迭代器的执行原理
Iterator iterator = coll.iterator();
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
//next():①指针下移②将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}
3.4、Iterator接口remove()方法
Iterator iter= coll.iterator();
//回到起点
while(iter.hasNext()){
Object obj= iter.next();
if(obj.equals("Tom")){
iter.remove();
}
}
注意:
- Iterator可以删除集合的元素,但是是遍历过程中通过迭代器对象的remove方法,不是集合对象的remove方法。
- 如果还未调用next()或在上一次调用next方法之后已经调用了remove方法,再调用remove都会报IllegalStateException。
3.5、使用foreach循环遍历集合元素
- Java 5.0 提供了foreach循环迭代访问Collection和数组。
- 遍历操作不需获取Collection或数组的长度,无需使用索引访问元素。
- 遍历集合的底层调用Iterator完成操作。
- foreach还可以用来遍历数组。
public class ForTest {
public static void main(String[] args) {
String[] str= newString[5];
for(String myStr: str) {
myStr= "atguigu";
System.out.println(myStr);
}
for(inti= 0; i< str.length; i++) {
System.out.println(str[i]);
}
}
}
4、Collection子接口之一:List接口
4.1、List接口概述
- 鉴于Java中数组用来存储数据的局限性,我们通常使用List替代数组
- List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
- JDK API中List接口的实现类常用的有:ArrayList、LinkedList和Vector。
List接口方法
- 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(intindex):移除指定index位置的元素,并返回此元素
- Object set(intindex, Object ele):设置指定index位置的元素为ele
- List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
4.2、List实现类之一:ArrayList
ArrayList是List 接口的典型实现类、主要实现类
- 本质上,ArrayList是对象引用的一个”变长”数组ArrayList的JDK1.8之前与之后的实现区别?
- JDK1.7:ArrayList像饿汉式,直接创建一个初始容量为10的数组
- JDK1.8:ArrayList像懒汉式,一开始创建一个长度为0的数组,当添加第一个元素时再创建一个始容量为10的数组
- Arrays.asList(…) 方法返回的List 集合,既不是ArrayList实例,也不是Vector 实例。Arrays.asList(…) 返回值是一个固定长度的List 集合
4.3、List实现类之二:LinkedList
对于频繁的插入或删除元素的操作,建议使用LinkedList类,效率较高
- 新增方法:
- void addFirst(Object obj)
- void addLast(Object obj)
- Object getFirst()
- Object getLast()
- Object removeFirst()
- Object removeLast()
LinkedList:双向链表,内部没有声明数组,而是定义了Node类型的first和last,用于记录首末元素。同时,定义内部类Node,作为LinkedList中保存数据的基本结构。
Node除了保存数据,还定义了两个变量:
- prev变量记录前一个元素的位置
- next变量记录下一个元素的位置
4.4、List 实现类之三:Vector
- Vector 是一个古老的集合,JDK1.0就有了。大多数操作与ArrayList相同,区别之处在于Vector是线程安全的。
- 在各种list中,最好把ArrayList作为缺省选择。当插入、删除频繁时,使用LinkedList;Vector总是比ArrayList慢,所以尽量避免使用。
- 新增方法:
- void addElement(Object obj)
- void insertElementAt(Object obj,int index)
- void setElementAt(Object obj,int index)
- void removeElement(Object obj)
- void removeAllElements()
4.5、面试题
1、ArrayList和LinkedList的异同
二者都线程不安全,相对线程安全的Vector,执行效率高。此外,ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove,LinkedList比较占优势,因为ArrayList要移动数据。
2、ArrayList和Vector的区别
Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized),属于强同步类。因此开销就比ArrayList要大,访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间,而ArrayList是1.5倍。Vector还有一个子类Stack。
5、Collection子接口之二:Set接口
5.1、Set 接口概述
- Set接口是Collection的子接口,set接口没有提供额外的方法
- Set 集合不允许包含相同的元素,如果试把两个相同的元素加入同一个Set 集合中,则添加操作失败。
- Set 判断两个对象是否相同不是使用== 运算符,而是根据equals() 方法
5.2、Set实现类之一:HashSet
- HashSet是Set 接口的典型实现,大多数时候使用Set 集合时都使用这个实现类。
- HashSet按Hash 算法来存储集合中的元素,因此具有很好的存取、查找、删除性能。
- HashSet具有以下特点:
- 不能保证元素的排列顺序
- 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将会把它们存储在不同的位置,但依然可以添加成功
5.2.1、重写hashCode() 方法的基本原则
- 在程序运行时,同一个对象多次调用hashCode() 方法应该返回相同的值。
- 当两个对象的equals() 方法比较返回true 时,这两个对象的hashCode() 方法的返回值也应相等。
- 对象中用作equals() 方法比较的Field,都应该用来计算hashCode 值。
5.2.2、重写equals() 方法的基本原则
以自定义的Customer类为例,何时需要重写equals()?
- 当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候,总是要改写hashCode(),根据一个类的equals方法(改写后),两个截然不同的实例有可能在逻辑上是相等的,但是,根据Object.hashCode()方法,它们仅仅是两个对象。
- 因此,违反了“相等的对象必须具有相等的散列码”。
- 结论:复写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。
5.3、Set实现类之二:LinkedHashSet
LinkedHashSet是HashSet的子类
- LinkedHashSet根据元素的hashCode值来决定元素的存储位置,但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入顺序保存的。
- LinkedHashSet插入性能略低于HashSet,但在迭代访问Set 里的全部元素时有很好的性能。
- LinkedHashSet不允许集合元素重复。
5.4、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和后面要讲的TreeMap采用红黑树的存储结构
特点:有序,查询速度比List快
5.4.1、排序—自然排序
- 自然排序:TreeSet会调用集合元素的compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按升序(默认情况)排列
- 如果试图把一个对象添加到TreeSet时,则该对象的类必须实现Comparable 接口。
- 实现Comparable 的类必须实现compareTo(Object obj) 方法,两个对象即通过compareTo(Object obj) 方法的返回值来比较大小。
- Comparable 的典型实现:
- BigDecimal、BigInteger 以及所有的数值型对应的包装类:按它们对应的数值大小进行比较
- Character:按字符的unicode值来进行比较
- Boolean:true 对应的包装类实例大于false 对应的包装类实例
- String:按字符串中字符的unicode 值进行比较
- Date、Time:后边的时间、日期比前面的时间、日期大
-
向TreeSet中添加元素时,只有第一个元素无须比较compareTo()方法,后面添加的所有元素都会调用compareTo()方法进行比较。
-
因为只有相同类的两个实例才会比较大小,所以向TreeSet中添加的应该是同一个类的对象。
-
对于TreeSet集合而言,它判断两个对象是否相等的唯一标准是:两个对象通过compareTo(Object obj) 方法比较返回值。
-
当需要把一个对象放入TreeSet中,重写该对象对应的equals() 方法时,应保证该方法与compareTo(Object obj) 方法有一致的结果:如果两个对象通过equals() 方法比较返回true,则通过compareTo(Object obj) 方法比较应返回0。否则,让人难以理解
-
TreeSet的自然排序要求元素所属的类实现Comparable接口,如果元素所属的类没有实现Comparable接口,或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序,则考虑使用定制排序。定制排序,通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。
-
利用int compare(T o1,T o2)方法,比较o1和o2的大小:如果方法返回正整数,则表示o1大于o2;如果返回0,表示相等;返回负整数,表示o1小于o2。
-
要实现定制排序,需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
-
此时,仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常。
-
使用定制排序判断两个元素相等的标准是:通过Comparator比较两个元素返回了0
5.4.2、使用Set集合去除List集合中的重复值
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(2));
list.add(new Integer(4));
list.add(new Integer(4));
List list2 = duplicateList(list);
for (Object integer : list2) {
System.out.println(integer);
}
}
public static List duplicateList(List list){
HashSet set = new HashSet();
set.addAll(list);
return new ArrayList(set);
}
6.Map接口
6.1、Map接口概述
- 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接口:常用方法
添加、删除、修改操作:
- 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中的所有数据
元素查询的操作:
- 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是否相等
元视图操作的方法:
- Set keySet():返回所有key构成的Set集合
- Collection values():返回所有value构成的Collection集合
- Set entrySet():返回所有key-value对构成的Set集合
public static void main(String[] args) {
Map map = new HashMap();
//map.put(..,..)省略
map.put(1,"a");
map.put(2,"b");
map.put(3,"c");
System.out.println("map的所有key:");
Set keys = map.keySet();
// HashSet
for(Object key: keys) {
System.out.println(key+ "->"+ map.get(key));
}
System.out.println("map的所有的value:");
Collection values= map.values();
Iterator iter= values.iterator();
while(iter.hasNext()) {
System.out.println(iter.next());
}
System.out.println("map所有的映射关系:");
// 映射关系的类型是Map.Entry类型,它是Map接口的内部接口
Set mappings= map.entrySet();
for(Object mapping: mappings) {
Map.Entry entry= (Map.Entry) mapping;
System.out.println("key是:"+ entry.getKey() + ",value是:"+ entry.getValue());
}
}
6.3、Map实现类之一:HashMap
- HashMap是Map 接口使用频率最高的实现类。
- 允许使用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。
6.3.1、HashMap的存储结构
JDK 7及以前版本:HashMap是数组+链表结构(即为链地址法)
JDK 8版本发布以后:HashMap是数组+链表+红黑树实现。
总结:JDK1.8相较于之前的变化:
1.HashMap map = new HashMap();//默认情况下,先不创建长度为16的数组
2.当首次调用map.put()时,再创建长度为16的数组
3.数组为Node类型,在jdk7中称为Entry类型
4.形成链表结构时,新添加的key-value对在链表的尾部(七上八下)
5.当数组指定索引位置的链表长度>8时,且map中的数组的长度> 64时,此索引位置上的所有key-value对使用红黑树进行存储。
6.4、Map实现类之二:LinkedHashMap
LinkedHashMap是HashMap的子类
- 在HashMap存储结构的基础上,使用了一对双向链表来记录添加元素的顺序
- 与LinkedHashSet类似,LinkedHashMap可以维护Map 的迭代顺序:迭代顺序与Key-Value 对的插入顺序一致
6.5、Map实现类之三:TreeMap
- TreeMap存储Key-Value 对时,需要根据key-value 对进行排序。TreeMap可以保证所有的Key-Value 对处于有序状态。
- TreeSet底层使用红黑树结构存储数据
- TreeMap的Key 的排序:
- 自然排序:TreeMap的所有的Key 必须实现Comparable 接口,而且所有的Key 应该是同一个类的对象,否则将会抛出ClasssCastException
- 定制排序:创建TreeMap时,传入一个Comparator 对象,该对象负责对TreeMap中的所有key 进行排序。此时不需要Map 的Key 实现Comparable 接口
- TreeMap判断两个key相等的标准:两个key通过compareTo()方法或者compare()方法返回0。
6.6、Map实现类之四:Hashtable
- Hashtable是个古老的Map 实现类,JDK1.0就提供了。不同于HashMap,Hashtable是线程安全的。
- Hashtable实现原理和HashMap相同,功能相同。底层都使用哈希表结构,查询速度快,很多情况下可以互用。
- 与HashMap不同,Hashtable不允许使用null 作为key 和value
- 与HashMap一样,Hashtable也不能保证其中Key-Value 对的顺序
- Hashtable判断两个key相等、两个value相等的标准,与HashMap一致
6.7、Map实现类之五:Properties
- Properties 类是Hashtable的子类,该对象用于处理属性文件
- 由于属性文件里的key、value 都是字符串类型,所以Properties 里的key 和value 都是字符串类型
- 存取数据时,建议使用setProperty(String key,Stringvalue)方法和getProperty(String key)方法
public static void main(String[] args) throws IOException {
Properties pros = new Properties();
pros.load(new FileInputStream("E:\\烽火数据服务组项目\\SpringBoot项目\\springcloud_springboot_demo\\springboot_jpa\\src\\main\\resources\\jdbc.properties"));
String user = pros.getProperty("user");
System.out.println(user);
}
7、 Collections工具类
- 操作数组的工具类:Arrays
- Collections 是一个操作Set、List和Map 等集合的工具类
- Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
- 排序操作:(均为static方法)
- reverse(List):反转List 中元素的顺序
- shuffle(List):对List集合元素进行随机排序
- sort(List):根据元素的自然顺序对指定List 集合元素按升序排序
- sort(List,Comparator):根据指定的Comparator 产生的顺序对List 集合元素进行排序
- swap(List,int,int):将指定list 集合中的i处元素和j 处元素进行交换
7.1、Collections常用方法
查找、替换
- 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 对象的所有旧值
7.2、Collections常用方法:同步控制
Collections 类中提供了多个synchronizedXxx() 方法,该方法可使将指定集合包装成线程同步的集合,从而可以解决多线程并发访问集合时的线程安全问题
8、Map接口踩坑
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YZ5ui4vd-1593572915705)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508170703444.png)]
8.1、不是所有的 Map 都能包含 null
常用 Map 子类集合对于 null 存储情况:
上面的实现类约束,都太不一样,有点不好记忆。其实只要我们在加入元素之前,主动去做空指针判断,不要在 Map 中存入 null,就可以从容避免上面问题。
8.2、自定义对象为key
尽量避免使用自定义对象作为 Map 集合 key,如果一定要使用,记得重写 hashCode
与 equals
方法。另外还要保证这是一个不可变对象,即对象创建之后,无法再修改里面字段值。
8.3、错用 ConcurrentHashMap 导致线程不安全
错误使用场景案例
public static void main(String[] args) throws IOException, InterruptedException {
ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();
concurrentHashMap.put("a",1);
ExecutorService executorService = Executors.newFixedThreadPool(100);
for (int i = 0; i < 1000; i++) {
executorService.execute(()->{
//第一步:值加1
int value = concurrentHashMap.get("a") + 1;
//第二步:重新设值
concurrentHashMap.put("a",value);
});
}
TimeUnit.SECONDS.sleep(5l);
System.out.println("---------"+concurrentHashMap.get("a"));
executorService.shutdown();
}
上面示例代码,我们原本期望输出 1001,但是运行几次,得到结果都是小于 1001。
深入分析这个问题原因,实际上是因为第一步与第二步是一个组合逻辑,不是一个原子操作。
ConcurrentHashMap
只能保证这两步单的操作是个原子操作,线程安全。但是并不能保证两个组合逻辑线程安全,很有可能 A 线程刚通过 get 方法取到值,还未来得及加 1,线程发生了切换,B 线程也进来取到同样的值。
这个问题同样也发生在其他线程安全的容器,比如 Vector
等。
上面的问题解决办法也很简单,加锁就可以解决,不过这样就会使性能大打折扣,所以不太推荐。
我们可以使用 AtomicInteger
解决以上的问题。
public static void main(String[] args) throws IOException, InterruptedException {
ConcurrentHashMap<String, AtomicInteger> concurrentHashMap = new ConcurrentHashMap<>();
ExecutorService executorService = Executors.newFixedThreadPool(100);
for (int i = 0; i < 1000; i++) {
executorService.execute(()->{
//如果key不存在,新建AtomicInteger对象,否则内部AtomicInteger递增
concurrentHashMap.computeIfAbsent("a",s ->new AtomicInteger(1)).incrementAndGet();
});
}
TimeUnit.SECONDS.sleep(5l);
System.out.println("---------"+concurrentHashMap.get("a"));
executorService.shutdown();
}
Map 接口除了支持增删改查功能以外,还有三个特有的方法,能返回所有 key,返回所有的 value,返回所有 kv 键值对。
// 返回 key 的 set 视图
Set<K> keySet();
// 返回所有 value Collection 视图
Collection<V> values();
// 返回 key-value 的 set 视图
Set<Map.Entry<K, V>> entrySet();
这三个方法创建返回新集合,底层其实都依赖的原有 Map 中数据,所以一旦 Map 中元素变动,就会同步影响返回的集合。
另外这三个方法返回新集合,是不支持的新增以及修改操作的,但是却支持 clear、remove
等操作。
public static void main(String[] args) throws IOException, InterruptedException {
Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("a",1);
hashMap.put("b",2);
hashMap.put("c",3);
Collection<Integer> values = hashMap.values();
hashMap.put("d",4);
Set<Map.Entry<String, Integer>> entrySet = hashMap.entrySet();
Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator();
while (iterator.hasNext()){
Map.Entry<String, Integer> entry = iterator.next();
System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
}
Iterator<Integer> iterator1 = values.iterator();
while (iterator1.hasNext()){
Integer next = iterator1.next();
System.out.println("value:"+next);
}
}
9、List接口踩坑
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QfRNXUMT-1593572915707)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508203306744.png)]
9.1、Array数组转成List集合注意点
数组转List集合,Arrays.asList,不支持增删元素,共享原始数组,修改原始数据,影响新集合,修改新集合,又会影响数组元素
public static void main(String[] args) throws IOException, InterruptedException {
String[] array={"a","b","c"};
List<String> list = Arrays.asList(array);
// list.add("d");//数组转成List不支持新增,java.lang.UnsupportedOperationException
array[0]="aaa";
list.set(1,"bbb");
System.out.println(Arrays.toString(array));
for (String s : list) {
System.out.println(s);
}
}
//运行结果
[aaa, bbb, c]
aaa
bbb
c
知道了实际原因,修复的办法也很简单,套娃一层 ArrayList
呗!
List<String> list = new ArrayList<>(Arrays.asList(arrays));
不过这么写感觉十分繁琐,推荐使用 Guava Lists 提供的方法。
List<String> list = Lists.newArrayList(arrays);
通过上面两种方式,我们将新的 List 集合与原始数组解耦,不再互相影响,同时由于此时还是真正的 ArrayList
,不用担心 add/remove
报错了。
除了 Arrays#asList
产生新集合与原始数组互相影响之外,JDK 另一个方法List#subList
生成新集合也会与原始 List
互相影响。
我们来看一个例子:
public static void main(String[] args) throws IOException, InterruptedException {
ArrayList<Integer> integers = new ArrayList<>();
integers.add(1);
integers.add(2);
integers.add(3);
List<Integer> subList = integers.subList(0, 2);
integers.set(0,100);
subList.set(1,200);
System.out.println("list:"+integers);
System.out.println("subList:"+subList);
}
//运行结果
list:[100, 200, 3]
subList:[100, 200]
这里修复的办法也很简单,跟上面一样,也来个套娃呗,加一层 ArrayList
。
为了防止 List 集合被误操作,我们可以使用 Collections#unmodifiableList
生成一个不可变(immutable)集合,进行防御性编程。
这个不可变集合只能被读取,不能做任何修改,包括增加,删除,修改,从而保护不可变集合的安全。
public static void main(String[] args) throws IOException, InterruptedException {
ArrayList<String> arrayList = Lists.newArrayList(Arrays.asList("a", "b", "c"));
List<String> list = Collections.unmodifiableList(arrayList);
// list.add("d");//抛异常java.lang.UnsupportedOperationException
arrayList.add("d");//修改原集合,从原集合生成的不可变集合也跟着改动
System.out.println(list);
}
可以看到这跟上面 SubList
其实是同一个问题,新集合底层实际使用了原始 List。
由于不可变集合所有修改操作都会报错,所以不可变集合不会产生任何改动,所以并不影响的原始集合。但是防过来,却不行,原始 List 随时都有可能被改动,从而影响不可变集合。
可以使用如下两种方式防止上卖弄的情况。
使用 JDK9 List#of 方法。
List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
List<String> unmodifiableList = List.of(list.toArray(new String[]{}));
使用 Guava immutable list
List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
List<String> unmodifiableList = ImmutableList.copyOf(list);
相比而言 Guava 方式比较清爽,使用也比较简单,推荐使用 Guava 这种方式生成不可变集合。
9.2、foreach 增加/删除元素大坑
先来看一段代码:
String[] arrays = {"1", "2", "3"};
List<String> list = new ArrayList<>(Arrays.asList(arrays));
for (String str : list) {
if (str.equals("1")) {
list.remove(str);
}
}
上面的代码我们使用 foreach
方式遍历 List 集合,如果符合条件,将会从集合中删除改元素。
这个程序编译正常,但是运行时,程序将会发生异常,日志如下:
java.util.ConcurrentModificationException
at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:939)
at java.base/java.util.ArrayList$Itr.next(ArrayList.java:893)
可以看到程序最终错误是由 ArrayList$Itr.next
处的代码抛出,但是代码中我们并没有调用该方法,为什么会这样?
实际是因为 foreach
这种方式实际上 Java 给我们提供的一种语法糖,编译之后将会变为另一种方式。
我们将上面的代码产生 class 文件反编来看下最后代码长的啥样。
可以看到 foreach
这种方式实际就是 Iterator
迭代器实现方式,这就是为什么foreach
被遍历的类需要实现 Iterator
接口的原因。
修复的办法有两种:
使用 Iterator#remove 删除元素
public static void main(String[] args) throws IOException, InterruptedException {
String[] arrays = {"1", "2", "3"};
List<String> list = new ArrayList<>(Arrays.asList(arrays));
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
String next = iterator.next();
if(next.equals("1")){
iterator.remove();
}
}
System.out.println(list);
}
JDK1.8 List#removeIf
public static void main(String[] args) throws IOException, InterruptedException {
String[] arrays = {"1", "2", "3"};
List<String> list = new ArrayList<>(Arrays.asList(arrays));
list.removeIf(s -> s.equals("1"));
System.out.println(list);
}
9.3、总结
第一,我们不要先入为主,想当然就认为 Arrays.asList
和 List.subList
就是一个普通,独立的 ArrayList
。
如果没办法,使用了 Arrays.asList
和 List.subList
,返回给其他方法的时候,一定要记得再套娃一层真正的 java.util.ArrayList
。
第二 JDK 的提供的不可变集合实际非常笨重,并且低效,还不安全,所以推荐使用 Guava 不可变集合代替。
最后,切记,不要随便在 foreach
增加/删除元素。