JavaSE之集合知识点总结

最新推荐文章于 2022-07-28 19:58:31 发布

敐

最新推荐文章于 2022-07-28 19:58:31 发布

阅读量304

点赞数 1

分类专栏：学习总结文章标签： java

本文链接：https://blog.csdn.net/weixin_44528963/article/details/109260023

版权

学习总结专栏收录该内容

13 篇文章 1 订阅

订阅专栏

JavaSE之集合知识点总结

一、单列集合——Collection

1.Collection

(1)注意事项:
1)某些集合可以存储重复元素,某些集合不能重复元素。
2)有些集合有序,有些集合无序。
3)有序/无序:存储元素和取出元素顺序是否一致。
4)此接口没有任何直接子实现类。
5)它提供更具体的子接口（如 Set 和 List）实现。
6)单列集合的根接口。
(2)单列集合结构体系：
Collection接口的子接口：List接口和Set接口
List接口的子实现类：ArrayLis、LinkedList、Vector 。
Set接口子实现类：HashSet、TreeSet。
(3)基本功能:
1)添加功能:
boolean add(Object e)
作用：将任何数据类型添加到集合中,只要添加元素,最终的结果是true。
2)删除功能:
void clear()
作用：从此集合中删除所有元素。
boolean remove(Object o)
作用：移出指定的元素。
3)判断功能
boolean contains(Object o)
作用：判断是否包含指定的元素。
boolean isEmpty()
作用：判断集合是否为空,如果为空,则返回 true。

2.Collection中的高级功能

(1)boolean addAll(Collection c)
作用：添加一个集合中的所有元素。
(2)boolean removeAll(Collection c)
作用：只要集合c中有一个元素被包含,将这个元素从c1中删除掉,就返回true。
(3)boolean containsAll(Collection c)
作用：包含所有元素才算包含,返回true。
(4)public boolean retainAll(Collection c)
作用：取交集

	举例：c1.retainlAll(c)
		boolean的含义是:c1集合对c集合取交集,将交集的元素保存到c1集合,boolean表达的是c1集合是否发生变化。
							如果c1集合没有变	化,返回结果false;如果c1集合有变化,则返回true。

(5)Object[] toArray()
作用：以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
(6)Iterator<E> iterator()
作用：以正确的顺序返回该列表中的元素的迭代器。Collection集合的专有遍历方式。
iterator()的返回值是接口，需要返回的是该接口的子实现类对象。
(7)Iterator中的方法
1)Object next()
作用：获取下一个元素。
2)boolean hasNext()
作用：判断当前迭代器中是否有下一个可以遍历的元素,如果存在,则返回true。
(8)迭代器的注意事项
1)Object next()获取集合的下一个元素,每轮不能使用多次,使用一次即可获取所有元素信息。
2)能使用for循环,不推荐，因为可能不知道集合中元素个数,推荐使用while循环。

3.List

(1)描述：List集合接口继承(extends)Collection接口，是有序的集合,允许元素重复。
(2)有序性:存储和取出的顺序一致。
(3)List集合的特有功能:
1)添加功能
void add(int index,Object element)
作用：在指定位置处添加一个新的元素。
2)删除功能
Object remove(int index)
作用：删除角标对应的元素。
3)获取功能
Object get(int index)
作用：获取指定位置处的元素。
int size()
作用：获取集合的元素数。
Object set(int index,Object element)
作用：在指定位置处使用当前元素element元素替换。
ListIterator<E> listIterator()
作用：List集合的专有遍历方式 :列表迭代器。
(4)ListIterator:列表迭代器
1)ListIterator<E> listIterator()底层实现:
是通过ArrayList里面的成员内部类ListIterator extends Iterator实现的。
2)添加方法：
void add(E e)
作用：将指定的元素插入列表。
3)正向遍历
boolean hasNext()
作用：判断是否有下一个元素。
Object next()
作用：获取下一个元素。
3)逆向遍历（前提：先正向遍历）
boolean hasPrevious()
作用：判断是否有上一个元素。
Object previous()
作用：获取前一个元素。
(5)List集合的遍历方式:
1)Collection集合的方法 Object[] toArray。
2)Collection集合的迭代器Iterator iterator()。
3)size()+Object get(int index)+普通for循环。
4)列表迭代器:ListIteraotr listiterator()。
5)增强for循环。

4.ArrayList

(1)ArrayList集合实现了List接口。可以存储重复元素,存储和取出一致。
(2)创建：
ArrayList(int initialCapacity)
通过初始化容量构造ArrayList集合默认容量大小:capacity(10个)。
ArrayList()
通过初试容量大小判断是否构造一个新Object[] 数组对象
(3)特点：
1)底层数据结构: 是可变数组结构,查询快,增删慢。
2)线程角度:线程不安全的类,不同步的,执行效率高。
(4)注意：ArrayList:单线程程序中考虑执行效率,优先采用。

5.Vector集合

(1)特点：
1)底层数据数组结构(对象数组)，查询快,增删慢。
2)线程角度:线程安全的类,同步的,执行效率低。
(2)注意：多线程程序中要考虑安全问题使用Vector。
(3)常用方法：
传统添加方法：
添加方法
public boolean add(Object e)
特有功能:
1)public void add(int index, E element)
插入元素
2)public Enumeration<Object> elements()
相当于:Iterator iterator()
3)public Object elementAt(int index)
通过角标获取指定的元素
相当于:Object get(int index)
应用：elementAt()+size() :vector的普通for遍历方式。
4)Enumeration接口有两个方法
boolean hasMoreElements()
作用：判断是否有下一个元素。
相当于:boolean hasNext()
Object nextElement()
作用：获取一个元素。
相当于:next()
注意：Enumeration和Iterator功能是重复的。
(4)应用:IO流:合并流 SequenceInputStream 可以将多个文件内容读出来复制到指定文件中。

6.LinkedList

(1)特点:
底层数据结构：是链表,查询慢,增删快。
线程不安全,不同的,执行效率高。
(2)应用场景:网站中记录用户的浏览足迹,Web技术:Cookie/Session。
(3)特有功能
添加
public void addFirst(Object e)
将该元素添加到列表的开头。
public void addLast(Object e)
将该元素添加到列表的末尾。
删除
public Object removeFirst()
删除列表第一个。
public Object removeLast()
删除列表最后一个。
获取
public Object getFirst()
获取第一个。
public Object getLast()
获取最后一个。

7.Set

(1)描述：继承自 Collection 接口，它与 Collection 接口中的方法基本一致。
(2)特点:元素不重复,存储和取出顺序不一致（无序的）。
(3)子实现类HashSet、TreeSet。
(4)Set集合取出元素的方式可以采用：迭代器、增强for。

8.HashSet

(1)描述：.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的。HashSet 底层的实现由HashMap支持。
(2)HashSet底层是hash表结构，哈希表依赖于哈希值存储，存储自定义类型数据，需要重写hashCode 与 equals 方法，来保证元素的唯一性。
(3)线程角度：线程不安全，效率高。
(4)HashSet的添加方法
public boolean add(E e)
HashSet集合add方法，依赖于HashMap集合put方法,put方法依赖于 hashCode()和equals方法()。

		举例：
			HashSet<String> :String类会重写Object的equals方法。
			因此自定义类型需要重写hashCood()方法和equals()方法。

9.TreeSet集合

(1)本质：基于TreeMap的底层实现是红黑树结构，是自平衡的二叉树结构。
(2)有两种排序方式:自然排序、选择器排序。
(3)决定因素：取决于创建当前Set集合对象时所使用的构造方法。
1)使用无参构造public TreeSet()，默认的自然顺序排序。
TreeSet<Integer> tsi=new TreeSet<Integer>();
2)使用有参构造public TreeSet(Comparator<? super E> comparator)，需要使用选择器排序。

10.LinkedHashSet

(1)底层结构：底层数据结构采用链表和哈希表共同实现。
(2)线程角度：线程不安全，效率高。
(3)有序性：链表保证了元素的顺序与存储顺序一致。
(4)唯一性：哈希表保证了元素的唯一性。

11.自然排序与选择器排序

(1)自然排序：使用TreeSet集合存储自定义对象,要进行自然排序，该自定义类需要实现Comparable，重写Comparaeable接口中compareTo(T t)方法。
(2)选择器排序：使用比较器排序,需要创建一个类来实现Comparator接口, 或者直接在TreeSet的有参构造中创建Comparator的匿名内部类，并重写接口中compare方法。
public TreeSet(Comparator<? super E> comparator)
1)方式1:直接给了创建了接口子实现类
TreeSet ts = new TreeSet(new MyComparator()) ;
形式参数是一个接口类型,需要传递该接口子实现类对象。
2)方式2:形参如果是接口，传入接口的匿名内部类。
匿名内部类(推荐的方式)
TreeSet<T> tss=new TreeSet<T>(new Comparator<T>() {
重写compare()
});

12.Collections

(1)包：java.util.Collections;
(2)描述：可以针对Collection集合进行操作的工具类。
(3)方法：
public static <T> int binarySearch(List<?> list,T key)
作用：针对集合的二分查询方法，查询key在集合中出现的索引值。
public static <T> T max(Collection<? extends T> list)
作用：获取集合中最大值。
public static <T> T min(Collection<? extends T> list)
作用：获取集合中最小值。
public static <T> void sort(List<T> list)
作用：针对List集合进行排序:升序排序。
public static <T> void sort(List<T> list,Comparator<T> com)
作用：比较器排序。
public static void shuffle(List<?> list)
作用：针对List集合的元素进行随机置换。

二、双列集合——Map集合

1.Map集合

(1)包：java.util.Map<K,V>;
(2)Map集合的特点: 一个存储键值对元素的双列集合,一个键对应一个值, 值是可以重复,但是键必须唯一。
(3)Map集合的功能:
1)添加功能
V put(K key, V value)
作用：添加一个键值对元素
返回值含义：
如果当前键是一次存储的时候,返回的结果null；
如果键不是第一次存储,后面重复,当前对应的值把以前的值覆盖掉,返回以前的值。
2)刪除功能
V remove(Object key)
作用：刪除指定的键,返回的是跟键关联的值,如果没有映射关系,则返回null。
void clear()
作用：删除全部的键以及值。
3)判断功能
boolean containsKey(Object key)
作用：是否包含指定的键。
boolean containsValue(Object value)
作用：是否包含指定的值。
boolean isEmpty()
作用：判断Map集合是否为空。
(4)高级功能:遍历
方式1:(推荐的方式:Map常用的方式)
Set keySet()
作用：获取所有的键的集合。
V get(Object key)
作用：通过键获取对应的值。
方式2遍历
Set<Map.Entry<K,V>> entrySet()
作用：获取当前Map集合中所有的键值对对象。
K getKey()
作用：通过键值对对象获取键。
V getValue()
作用：通过键值对对象获取值。

2.HashMap

(1)描述：哈希表结构,保证键唯一,不能保证迭代顺序恒久不变，线程不安全，是Map集合的子实现类。
(2)自定义类的对象存储在值的位置,是可以重复的;如果是在键位置该自定义类对象的所在类必须重写Object的equals()和hashCode()。
添加方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
hash()依赖于hashCode():算出每一个对象哈希码值一样。
putVal()依赖于equals()方法:哈希码值一样,还有比较每一个成员信息是否相同。

3.TreeMap

(1)描述：键是红黑树结构，可以保证键的有序和唯一性，线程不安全。
(2)构造方法:
public TreeMap()
作用：默认的自然顺序排序
public TreeMap(Comparator<? super K> comparator)
作用：是比较器排序(推荐)
(3)注意：TreeMap<Student,String>/TreeSet<Studdent>，一定要有条件进行排序。

4.LinkedHashMap

(1)描述：HashMap的子类
(2)底层结构：存储数据采用的哈希表结构+链表结构。
(3)有序性：通过链表结构可以保证元素的存取顺序一致。
(4)唯一：通过哈希表结构可以保证的键的唯一，需要重写键的hashCode()方法、equals()方法。

5 Entry

(1)描述：Entry是Map接口的内置接口。
(2)作用：Entry将键值对的对应关系封装成对象，即键值对对象。
(3)方法：
public K getKey()
作用：获取Entry对象中的键。
public V getValue()
作用：获取Entry对象中的值。
Map中：public Set<Map.Entry<K,V>> entrySet()
作用：获取到Map集合中所有键值对对象的集合(Set集合)。

三、常见问题

1.集合和数组

相同点：集合和数组都是"容器",存储元素。
(1)长度的区别
数组的长度:固定的
集合的长度:可变的
(2)存储数据类型的区别
数组:可以存储基本数据类型,也可以存储引用数据类型。
集合:只能存储引用数据类型。
(3)存储元素的区别
数组:只能存储同一种类型的元素。
集合:可以存储任意引用类型的元素。

2.迭代器遍历时添加元素

需求:使用集合(List)存储字符串元素,假设如果元素的内容有"world"元素,给集合中添加一个新的元素"javaee";
(1)按照上面的思路存在问题
java.util.ConcurrentModificationException
并发修改异常
(2)原因：当迭代器遍历元素的时候,不能使用集合添加元素。当前集合中添加一个新的元素,迭代器无法预知。
(3)解决方案:
要么使用迭代器遍历元素,使用迭代器添加元素。
要么使用集合遍历元素,使用集合添加元素。
(4)名词解释：
并发:指的是在一个时间点上同时发生。
并行:指的是在一个时间段内同时发生。

3.List集合去重(两个集合)

给List集合中添加重复的字符串元素,将重复元素去重,然后遍历集合。
(1)创建一个List集合。
(2)给里面添加重复的字符串元素。
(3)创建一个新的集合。
(4)遍历list集合,获取到每一个元素。
(5)使用集合中的方法判断是否存在这个元素s。
boolean contains(Object o)
(6)当前元素在第二个集合中不存在,将这个元素存储新集合中。

4.List集合去重(一个集合)

给List集合中添加重复的字符串元素,将重复元素去重,然后遍历集合。
(1)还是创建List集合,存储重复元素。
(2)可以利用选择排序思想的特点。
使用0角标对应的元素依次和后面角标对应的元素对比(equals()),如果后面元素重复了,则将该角标对应的元素从集合中删除,角标- -。
(3)遍历当前集合集合。

5.List集合存储自定义类型去重

List集合<Student> ,如何去除重复的对象呢?
Student s1 = new Student(“林彬”,41) ;
Student s2 = new Student(“林彬”,41) ;
(1)Collection集合的contains方法底层依赖于equals方法,所以默认的是地址值是否相同。
(2)对String类型去重，String类本身重写了Object的eqauls方法, 所以比较内容是否相同。
(3)在自定义的类中重写equals方法和hashCood()方法。

6.Map和Collection集合的区别

(1)Map<K key,V value>集合:双列集合,键映射到值的对象 ,键必须保证唯一, 可以看成是一个(夫妻对)。
(2)遍历方式:
方式1:(Map常用的方式)
Set<K> keySet()
V get(Object key)
方式2遍历
Set<Map.Entry<K,V>> entrySet()
K getKey()与V getValue()
(3)Collection集合:单列集合，只能存储一种引用类型,里面的set集合依赖于Map集合的实现 (理解为:光棍)。
HashSet的add方法依赖于HashMap里的put方法。
TreeSe的add方法依赖于TreeMap里的put方法。
(4)Collection集合遍历方式
增强for、toArray()、iterator()、size()+get()。

7.集合分类

(1)线程角度：
线程不安全的：LinkedList、ArrayList、HashSet、HashMap
线程安全的：Vector
(2)数据结构
ArrayXxx:底层数据结构是数组，查询快，增删慢。
LinkedXxx:底层数据结构是链表，查询慢，增删快。
HashXxx:底层数据结构是哈希表。依赖hashCode()和equals()。
TreeXxx:底层数据结构是二叉树。排序方式：自然排序和比较器排序。

四、Jdk5新特性

1.增强for

(1)格式:
for(数据类型变量名 : 数组对象/集合对象(使用最多)){
输出变量名即可
}
(2)作用:是替代迭代器使用,简化遍历集合的书写格式!
(3)注意事项:
1)增强for主要用在集合中,数组一般使用的时候普通for
2)前提条件:
要使用增强for循环,必须保证该集合不能为null,否则就会出现空指针NullPointerException。
3)解决方案:针对该对象非空判断即可。

2.泛型

(1)由来：早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题，也就存在着隐患，所以Java提供了泛型来解决这个安全问题。
(2)格式：<数据类型(引用数据类型)>
(3)泛型的特点:
将集合的类型在创建的时候就明确,保证集合操作的安全性。
(4)好处:
1)避免了强制类型转换。
2)将运行时期异常提前到了编译时期。
3)解决了黄色警告线问题。
4)提高了程序的安全性。没有加入泛型之前,程序存在安全隐患,转型可能会出现类型不匹配:ClassCastException:属于运行时期异常。
(5)泛型的应用
1)泛型类：把泛型定义在类上，然后方法形参与类上的泛型保持一致的。
格式:public class 类名<泛型类型1,…>
2)泛型方法：把泛型定义在方法上
格式:public <泛型类型> 返回类型方法名(泛型类型 .)
3)泛型接口：把泛型定义在接口上
格式:public interface 接口名<泛型类型1…>

			举例：
				第一种情况:将泛型定义在接口上,子实现类明确了类型是什么
				public class InterImpl implements Inter<String> {
					@Override
					public void inter(String t) {
						System.out.println("hello,"+t);
					}
				}
				第二种情况:接口的子实现类不明确类型
				public class InterImpl<T> implements Inter<T>{
					@Override
					public void inter(T t) {
						System.out.println("hello,"+t);
					}
				}

(6)泛型的高级通配符
1)<?> 当前Object类型/任意Java类型(自定义/jdk提供…)。
2)<? extends E>:向下限定:E类型以及它的子类。
3)<? super E>:向上限定:E类型以及它的父类。
(7)注意事项：
1)jdk7以后:泛型推断,创建对象处的泛型可以不写，默认添加，建议写上。
2)泛型类型必须是引用类型。