Java集合--Collection、Map、List、Set、Iterator、Collections工具类
文章目录
- 一、Java集合框架概述
- 二、Collection接口方法
-
- 2.1、Collection子接口一：List
-
- 2.1.1、ArrayLIst的源码分析
- 2.1.2、LinkedList的源码分析
- 2.1.3、List接口中的常用方法
- 2.2、Collection子接口二：Set
-
- 2.2.1、Set接口的无序性
- 2.2.2、添加元素的过程：以HashSet为例
- 2.2.3、Set实现类之二：LinkedHashSet
- 2.2.4、Set实现类之三：TreeSet
- 三、Map接口
-
- 3.1、HashMap
-
- 3.1.1、HashMap的底层实现原理？
- 3.1.2、LinkedHashMap
- 3.2、TreeMap
- 3.3、Hashtable
-
- 3.3.1、Properties
- 3.4、Map中的常用方法
- 四、Iterator迭代器接口
-
- 4.1、hasNext() 和 next()
- 4.2、remove()
- 五、Collections工具类
-
- 5.1、Collections常用方法
一、Java集合框架概述
- 集合、数组都是对多个数据进行存储从左的结构，简称
Java容器
说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt, .jpg, .avi，数据库中）
2.1 数组在存储多个数据方面的特点：
一旦初始化以后，其长度就确定了。
数组一旦定义好，其元素的类型就确定了。我们也就只能操作指定类型的数据了。
比如：String[] arr; int[] arr1; Object[] arr2；
2.2 数组在存储多个数据方面的缺点：
- 一旦初始化以后，其长度就不可修改
- 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高
- 获取数组中实际元素的个数的需求，数组没有线程的属性或方法可用
- 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
二、Collection接口方法
单列数据（List、Set），定义了存取一组对象的方法的集合
结论：
* 向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()
常用的15个方法：
//1.add(Object e)：将元素 e 添加到集合 coll中
Collection coll = new ArrayList();
coll.add("AA");
coll.add(55);//自动装箱
coll.add(new Date());//添加对象
//2.size()://获取添加元素的个数
System.out.println(coll.size());
//3.addAll(Collection c)：将c集合中的元素添加到当前的集合中
Collection coll1 = new ArrayList();
coll1.add("SS");
coll1.addAll(coll);
//4.clear():清空集合元素
System.out.println(coll1.isEmpty());
coll1.add(new String("Jerry"));
//5.contains(Object obj)//判断当前集合中是否包含obj,我们在判断时会调用obj对象所在类的equals()
boolean contains = coll1.contains("abc");
// 6.containsAll(Collection coll1)//判断形参coll1中的所有元素是否都在当前集合中
boolean b = coll1.containsAll(coll);
//7.remove(Object obj):从当前集合中移除obj元素
coll.remove("BB");
coll.remove("CC");
coll.remove(5);
//8.removeAll(Collection coll1)：从当前集合中移除coll1中的所有元素
Collection coll = new ArrayList();
coll.add(123);
coll.add("AA");
coll.add(987);//自动装箱
coll.add("SS");
coll.add("CC");
Collection coll1 = Arrays.asList(123,456,987);
coll.removeAll(coll1);
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(false);
Collection coll1 = Arrays.asList(123,456,987);
//9.retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合
coll.retainAll(coll1);
System.out.println(coll);//[123, 456]
//10.equals(Object obj)：要想返回true,需要当前集合和形参集合的元素都相同
Collection coll1 = new ArrayList();//List，顺序是有序的，顺序不同就是false
coll1.add(123);
coll1.add(456);
coll1.add(false);
boolean equals = coll.equals(coll1);
System.out.println(equals);//true
//11.hashCode():返回当前对象的哈希值
System.out.println(coll1.hashCode());
//12.集合-->数组toArray()
Object[] array = coll1.toArray();
for (int i=0;i<array.length;i++){
System.out.println(array[i]);
}
//数组-->集合: 调用Arrays的静态方法asList()
List<String> list = Arrays.asList(new String[]{"AA","BB","CC"});
System.out.println(list);
List<Integer> list1 = Arrays.asList(new Integer[]{123, 456});
System.out.println(list1.size());//2
List list2 = Arrays.asList(new int[]{123, 456});
System.out.println(list2.size());//1
System.out.println(list2);//[[I@7dc36524]，识别成一个元素
//13.返回iterator接口的实例,用于遍历集合元素。放在TteratorTest.java中测试
2.1、Collection子接口一：List
List：元素有序、可重复的集合。---->
”动态数组“
经典面试题：ArrayList、LinkedList、Vector三者的异同？
同：实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
异：
ArrayList：作为List接口的主要实现类：线程不安全的，效率高；底层使用Object[] 存储LinkedList：对于频发的插入、删除操作，使用此类的效率比ArrayList高；底层使用的双向链表存储Vector：作为List接口的古老实现类：线程安全的，效率低；底层使用Object[] 存储
2.1.1、ArrayLIst的源码分析
2.1 jdk7情况下
ArrayList list = new ArrayList();//底层创建了长度是10的object[]数组eLementData
list.add(123); //eLementData[e] = new Integer(123);
...
list.add(11);//如果此次的添加导致底层eLementData数组容量不够，则扩容。
默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。结论:建议开发中使用带参的构造器: ArrayList list = new ArrayList(int capacity)
2.2 jdk 8中ArrayList的变化:
ArrayList list = new ArrayList();//底层object[] elementData初始化为{}.并没有创建长
list.add(123);//第一次调用add()时，底层才创建了长度1e的数组，并将数据123添加到eLemer
后续的添加和扩容操作与jdk 7无异。
2.3小结: jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
2.1.2、LinkedList的源码分析
LinkedList list = new LinkedList();内部声明了Node类型的first和last属性，默认值为null
List.add(123);//将123封装到Node中，创建了Node对象。
// 其中，Node定义为:体现了LinkedList的双向链表的说法
2.1.3、List接口中的常用方法
List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来
操作集合元素的方法。
总结：常用方法
增：add(Object obj)
删：remove(int index) / remove(Object obj)//一个按照索引删除；一个直接删除对象（元素）
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：① Iterator 迭代器方法；② 增强for循环；③ 普通的for循环
//迭代器方式循环
Iterator iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//增强for循环
for (Object obj:list){
System.out.println(obj);
}
//普通for循环
for (int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
ArrayList list = new ArrayList();
list.add(123);
list.add(465);
list.add("AA");
list.add(new Date());
list.add("BB");
list.add("CC");
//1.void add(int index, Object ele):在index位置插入ele元素
list.add(1,"BB");
//2.boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
List list1 = Arrays.asList(1,2,3);
list.addAll(list1);
System.out.println(list.size());
//3.Object get(int index):获取指定index位置的元素
Object o = list.get(0);//123
Object o1 = list.get(6);//2
//4.int indexOf(Object obj):返回obj在集合中首次出现的位置
int index = list.indexOf(465);//1
//5.int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
int lastIndexOf = list.lastIndexOf("AA");//2
//6.Object remove(int index):移除指定index位置的元素，并返回此元素
Object obj = list.remove(0);
System.out.println(obj);//123
//7.Object set(int index, Object ele):设置指定index位置的元素为ele
list.set(1,"XX");
//8.List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
List subList = list.subList(1, 4);//左闭右开
2.2、Collection子接口二：Set
Set接口的概述
- Set接口是Collection的子接口，set接口没有提供额外的方法
- Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法
- Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。
Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。
HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值
LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的
TreeSet：可以按照添加对象的指定属性。进行排序
Set接口：元素无序、不可重复的集合。---->高中将的”集合“
HashSet、LinkedHashSet（是HashSet的子类）、TreeSet
2.2.1、Set接口的无序性
以HashSet为例说明：
- 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值。
- 不可重复性：保证添加的元素按照equals()判断时，不能返回true。即：相同的元素只能添加一个。
2.2.2、添加元素的过程：以HashSet为例
我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断数组此位置上是否已经有元素；
如果此位置上没有其他元素，则元素a添加成功。—>情况1
如果此位置上有其他元素(或以链表形式存在的多个元素），则比较元素a与元素b的hash值；
如果hash值不相同，则元素a添加成功。—>情况2
如果hash值相同，进而需要调用元素a所在类的equals()方法；
equaLs()返回true，元素a添加失败
equals(()返回false，则元素a添加成功。—>情况2
对于添加成功的情况2和情况3而言；元素a与已经存在指定索引位置上数据以链表的方式存储。jdk 7 ：元素a放到数组中，指向原来的元素。
jdk 8 ：原来的元素在数组中，指向元素a
总结；七上八下
Hashset底层：数组+链表的结构。
2.2.3、Set实现类之二：LinkedHashSet
- LinkedHashSet 是 HashSet 的子类
- LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
- LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。
- LinkedHashSet 不允许集合元素重复。
LinkedHashSet的使用
LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。
优点：对于频繁的遍历操作，LinkedHashSet效率高于Hashset
2.2.4、Set实现类之三：TreeSet
向TreeSet中添加的数据，要求是相同类的对象。
TreeSet 是 SortedSet 接口的实现类，TreeSet 可以确保集合元素处于排序状态。
TreeSet底层使用红黑树结构存储数据
TreeSet 两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。
三、Map接口
List ：单列数据
Map：双列数据
List 和 Map都可以看作是 key-value的形式，只不过 List的key是 index，是索引，自动生成的，而Map的key可以是任意类型。
Map：双列数据，保存具有映射关系
“key-value对”键值对的集合。---->高中函数：y=f(x)。x：key ； y：value
HashMap、LinkedHashMap、TreeMap、Hashtable、Properties
Map中的key value的图示：
高频面试考点：
- HashMap的基层原理是什么？
- HashMap和Hashtable的异同？
补充：
HashMap的底层：
数组+链表 （jdk7及之前）
数组+链表+红黑树 （jdk8）
3.1、HashMap
作为Map的主要实现类；线程不安全的，效率高；可以存储null的key和value
3.1.1、HashMap的底层实现原理？
以jdk7 为例说明：
3.1.2、LinkedHashMap
LinkedHashMap是HashMap的一个子类：保证在遍历map元素时，可以按照添加的顺序实现遍历。
原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。
对于频繁的遍历操作，此类执行效率高于HashMap。
3.2、TreeMap
保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序。
底层使用红黑树。
Properties 类是 Hashtable 的子类，该对象用于处理属性文件
由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key 和 value 都是字符串类型
存取数据时，建议使用setProperty(String key,String value)方法和 getProperty(String key)方法
3.3、Hashtable
作为古老的实现类，线程安全的，效率低；不能存储null的key和value
3.3.1、Properties
Properties是Hashtable的一个子类：常用来处理配置文件。key和vaLue都是String类型
3.4、Map中的常用方法
总结：常用方法：
1.添加：put(Object key,Object value)
2.删除：remove(Object key)
3.修改：put(Object key,Object value)
4.查询：get(Object key)
5.长度：size()
6.遍历：keySet() / values() / entrySet()
添加、删除、修改操作：
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集合
//遍历所有的key-value
//方式一：entrySet()
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
//entrySet集合中的元素都是entry
Map.Entry entry = (Map.Entry) obj;//强转
System.out.println(entry.getKey()+"--->"+ entry.getValue());
}
System.out.println("**********");
//方式二:自己根据已有的方法(keySet())自己拼凑
Set keySet = map.keySet();
Iterator iterator2 = keySet.iterator();
while (iterator2.hasNext()){
Object key = iterator2.next();
Object value = map.get(key);
System.out.println(key+"===="+ value);
}
四、Iterator迭代器接口
集合元素的遍历操作，使用迭代器
Iterator接口
重点掌握：
- 内部的方法：hasNext() 和 next()
- 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合 的第一个元素之前。
- 内部定义了remove()，可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()
4.1、hasNext() 和 next()
public void test(){
Collection coll = new ArrayList();
coll.add("AA");
coll.add(55);//自动装箱
coll.add("SS");
coll.add(new Date());
Iterator iterator = coll.iterator();
//方式一：
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
//报异常：NoSuchElementException
// System.out.println(iterator.next());
//方式二：
// for (int i=0;i
// System.out.println(iterator.next());
// }
//方式三:推荐
while (iterator.hasNext()){//使用hasNext()，查看下一个是否为空
System.out.println(iterator.next());
}
}
迭代器的执行原理如下：
说明：
- 调用hasNext()的时候指针没有下移，调next()的时候指针才下移。
iterator只是迭代的，用于遍历，不是容器，当前集合coll是一个容器- next()：① 指针下移； ② 讲下移后的集合位置上的元素返回
集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合 的第一个元素之前。
4.2、remove()
如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法， 再调用remove都会报IllegalStateException。
@Test
public void test3(){
Collection coll = new ArrayList();
coll.add("AA");
coll.add(55);//自动装箱
coll.add("SS");
coll.add(new Date());
//iterator.remove(): 删除集合中的"AA"
Iterator iterator = coll.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
if ("AA".equals(obj)){
iterator.remove();
}
}
Iterator iterator1 = coll.iterator();
while (iterator1.hasNext()){
System.out.println(iterator1.next());
}
}
五、Collections工具类
作用：操作Collection和Map的工具类
Collections 是一个操作 Set、List 和 Map 等集合的工具类
Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作， 还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
面试题：Collection 和 Collections 的区别？
Collection是一个接口；Collections 是一个操作 Set、List 和 Map 等集合的工具类
5.1、Collections常用方法
排序操作：（均为static方法）
1.reverse(List)：反转 List 中元素的顺序
2.shuffle(List)：对 List 集合元素进行随机排序
3.sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
4.sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
5.swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
查找、替换
1.Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
2.Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回
给定集合中的最大元素
3.Object min(Collection)
4.Object min(Collection，Comparator)
5.int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
6.void copy(List dest,List src)：将src中的内容复制到dest中
7.boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换List 对象的所有旧值
//对6.void copy(List dest,List src)，的详细使用说明
@Test
public void test2() {
List list = new ArrayList();
list.add(123);
list.add(33);
list.add(45);
list.add(-52);
// List dest = new ArrayList();//错误的，会报异常
List dest = Arrays.asList(new Object[list.size()]);//更健壮
System.out.println(dest.size());
System.out.println(dest);
Collections.copy(dest, list);
System.out.println(dest);
}
说明：ArrayList和HashMap都是线程不安全的，如果程序要求线程安全，我们可以将ArrayList、HashMap转为线程安全的。
使用synchronizedList(List list) 和 synchronziedMap( Map map)
同步控制
Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集
合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全
问题
//返回的list1即为线程安全的list
List list1 = Collections.synchronizedList(list);