集合笔记

一、集合基础（ArrayList）：

1.集合概述：

集合类的特点：提供一种存储空间可变的储存模式，存储的数据容量可以发生改变
ArrayList<E>:
可调整大小的数组实现
<E>:是一种特殊的数据类型，泛型
用法：
在出现E的地方使用引用数据结构类型替换即可，则集合中的元素类型就是该引用类型
例：ArrayList<String>,ArrayList<Student>

2.ArrayList构造方法和添加方法：

public ArrayList()：创建一个空的集合对象
例：
	ArrayList<String> list = new ArrayList<>();
public boolean add(E e):将制定的元素追加到此集合的末尾
public void add(int index,E element):在此集合中的指定位置插入指定的元素
	指定的位置不能超过集合的当前长度

3.ArrayList集合常用方法：

public boolean remove(Object o)：删除指定的元素，返回删除是否成功
	public E remove(int index)：删除指定索引处的元素，返回被删除的元素
	public E set(int index,E element)：修改指定索引处的元素，返回被修改的元素
	public E get(int index)：返回指定索引处的元素
	public int size()：返回集合中的元素的个数

4.存储字符串并遍历：

思路：
	1）创建集合对象
	2）往集合对象中添加字符串对象
	3）遍历集合，首先要能获取集合中的每一个元素，通过get()方法实现
	4）获取集合长度，通过size()方法实现
	5）遍历集合通用格式：
		for(int i = 0; i < 集合对象.size(); i++){
			E e = 集合对象.get(i);
			System.out.println(e);
		}

5.储存学生对象并遍历：

思路：
	1）定义学生类
	2）创建集合对象
	3）创建学生对象
	4）添加学生对象到集合中
	5）遍历集合，采用通用遍历格式实现

6.储存学生对象并遍历：（学生的姓名和年龄由键盘录入）

思路：
	1)定义学生类，为了键盘录入方便，其成员变量都定义为String类型
	2）创建集合对象
	3）键盘录入学生对象所需要的数据
	4）创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
	5）往集合中添加学生对象
	6）遍历集合，采用通用遍历格式实现

二、集合进阶：

1.Collection：

1.1.集合类体系结构：

Collection（单列）：
	List（可重复）：
		ArrayList
		LinkedList
	Set（不可重复）：
		HashSet
		TreeSet
Map（双列）：
		HashMap

1.2.Collection集合概述和使用

Collection集合概述：
	是单例集合的顶层接口，它表示一组对象，这些对象也被称为Collection的元素
	此接口没有任何直接实现，提供更具体的子接口（如Set和List）实现
创建Collection集合的对象：
	多态的方式
	具体的实现类ArrayList

1.3.Collection集合常用方法：

boolean add(E e)：添加元素（永远返回true）
boolean remove(Object o)：从集合中移除指定的元素
void clear()：清空集合中的元素
boolean contains(Object o)：判断集合中是否存在指定的元素
boolean isEmpty()：判断集合是否为空
int size()：集合的长度，即集合中元素的个数

1.4.Collection集合遍历：

Iterator：迭代器，集合的专业遍历方式
	Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
	迭代器是通过集合的iterator()方法得到的，它依赖于集合而存在
Iterator中的常用方法：
	E next()：返回迭代中的下一个元素
	boolean hasNext()：如果迭代具有更多元素，则返回true
例：
	Iterator<String> it = c.iterator();
	while(it.hasNext()){
		System.out.println(it.next());
	}
	其中c为集合引用变量

1.5.集合的使用步骤：

1）创建集合对象
2）添加元素
	创建元素
	添加元素到集合
3）遍历集合
	通过集合对象获取迭代器对象
	通过迭代器对象的hasNext()方法判断是否还有元素
	通过迭代器对象的next()方法获取下一个元素

2.List：

2.1.List集合概述和特点：

List集合概述：
	有序集合（也被称为序列），可以精确控制列表中每个元素的插入位置，可以通过整数索引访问元素，并搜索列表中的元素
	与Set集合不同，列表通常允许重复的元素
List集合特点：
	有序：存储和取出的元素顺序一致
	可重复：存储的元素可以重复

2.2.List集合特有方法：

void add(int index,E element)：在此集合中的指定位置插入指定的元素
E remove(int index):删除指定索引处的元素，返回被删除的元素
E set(int index,E element)：修改知道个索引处的元素，返回被修改的元素
E get(int index)：返回指定索引处的元素
既可以通过迭代器遍历List集合也可以通过遍历集合的通用格式遍历集合

2.3.并发修改异常：

ConcurrentModificationException：当不允许这样的修改时，可以通过检测到对象的并发修改的方法来抛出此异常
产生原因：
	迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致
解决方案：
	用for循环遍历，然后用集合对象做对应的操作即可

2.4.ListIerator：

列表迭代器
通过List集合的listIterator()方法得到，它是List集合特有的迭代器
用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置
ListIterator中的常用方法：
	E next()：返回迭代中的下一个元素
	boolean hasNext()：如果迭代具有更多元素，则返回true
	E previous()：返回列表中的上一个元素
	boolean hasPrevious()：如果此列表迭代器在相反反向遍历列表时具有更多元素，则返回true
	void add( E e)：将指定的元素插入列表

2.5.增强for循环：

简化数组和Collection集合的遍历
实现Iterator接口的类允许其对象成为增强for语句的目标
内部原理是一个Iterator迭代器
格式：
	for(元素数据类型 变量名 : 数组或者Collection集合){
		//在此处使用变量即可，该变量就是元素
	}

2.6.List集合子类特点：

常用子类：ArrayList，LinkedList
ArrayList：底层数据结构是数组，查询快，增删慢
LinkedList：底层数据结构是链表，查询慢，增删快

2.7.LinkedList集合的特有功能：

public void addFirst(E e)：在该列表开头插入指定的元素
public void addLast(E e)：将指定的元素追加到此列表的末尾
public E getFirst()：返回此列表中的第一个元素
public E getLast()：返回此列表中的最后一个元素
public E removeFirst()：从此列表中删除并返回第一个元素
public E removeLast()：从此列表中删除并返回最后一个元素

3.Set:

3.1.Set集合概述和特点：

Set集合特点：
	不包含重复元素的集合
	没有带索引的方法，所以不能使用普通for循环遍历

3.2.哈希值：

根据对象的地址或者字符串或者数字算出来的int类型的数值
public int hashCode()：返回对象的哈希码值
同一个对象多次调用hashCode()方法返回的哈希值是相同的
默认情况下，不同对象的哈希值是不相同的
通过方法重写，可以实现不同对象的哈希值是相同的

3.3.HashSet集合概述和特点：

1）底层数据结构是哈希表
2）对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
3）没有带索引的方法，所以不能使用普通for循环遍历
4）不包含重复元素
要保证元素唯一性需要重写hashCode()和equals()方法

3.4.LinkedHashSet集合概述和特点：

哈希表和链表实现的Set接口，具有可预测的迭代次序
由链表保证元素有序，元素的存储和取出顺序一致
由哈希表保证元素唯一，没有重复元素

3.5.TreeSet集合概述和特点：

元素按照一定的规则进行排序，具体排序方式取决于构造方法：
	TreeSet()：根据其元素的自然排序进行排序
	TreeSet(Comparator comparator)：根据指定的比较器进行排序
没有带索引的方法，不能使用普通for循环遍历
不包含重复元素

3.6.自然排序Comparable的使用：

用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
重写方法时，一定要注意排序规则必须按要求的主要条件和次要条件来写

3.7.比较器排序Comparator的使用：

用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
比较器排序就是让集合构造方法接收Comparator的实现类对象，重写Compare（To1，To2）方法
重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

4.泛型：

4.1.泛型概述：

泛型本质：参数化类型，即所操作的数据类型被指定为一个参数
参数化类型：将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型
这种参数类型可以用在类、方法、和接口中，分别被称为范类型、泛型方法、泛型接口

4.2.泛型定义格式：

<类型>：指定一种类型的格式，这里的类型可以看成参数
<类型1，类型2...>：指定多种类型的格式，多种类型之间用逗号隔开，这里的类型可以看成是参数
将来具体调用时给定的类型可以看成实参，并且实参的类型只能时引用数据类型
泛型好处：把运行时期的问题提前到了编译时期，避免了强制类型转换

4.3.泛型类：

定义格式：
	修饰符 class 类名<类型>{}
范例：
	public class Generic<T>{}
	此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
在实例化类的时候指定泛型的具体类型，例如：Generic<String> g1 = new Generic<String>();

4.4.泛型方法：

格式：修饰符<类型> 返回值类型 方法名(类型 变量名){}
范例：public<T> void show(T t){}
这样使用方法时传入什么类型的变量参数就是什么类型

4.5.泛型接口：

格式：修饰符 interface 接口名<类型>{}
范例：public interface Generic<T>{}

4.6.类型通配符：

类型通配符：<?>
List<?>：表示元素类型未知的List，它的元素可以匹配任意的类型
这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中
通配符上限：<?extends 类型>
List<?extends Number>：它表示的类型是Number或者其子类型
类型通配符下限：<?super 类型>
List<?super Number>：它表示的类型是Number或者其父类型

4.7.可变参数：

可变参数：参数的个数可变，用作方法的形参出现，那方法参数的个数就是可变的了
格式：修饰符 返回值类型 方法名(数据类型...变量名){}
范例：public static int sum(int...a){}
个数可变的参数被封装为数组传入方法，可以用变量名[下标]的方法访问
注意事项：
	如果一个方法有多个参数，包含可变参数，可变参数要放到最后

4.8.可变参数的使用：

Arrays工具类中有一个静态方法：
	public static<T> List<T> asList(T...a)：返回由指定数组支持的固定大小的列表
	返回的集合不能做增删操作，可以做修改操作
List接口有一个静态方法：
	public static<E> List<E> of(E...elements)：返回包含任意数量元素的不可变列表
	返回的集合不能做增删改造作
Set接口有一个静态方法：
	public static<E> Set<E> of(E...elements)：返回包含一个任意数量元素的不可变集合
	不能给重复元素
	返回的集合不能做增删造作，没有修改的方法

5.Map：

5.1.Map集合概述和使用：

Interface Map<K,V>  K：键的类型；V：值的类型
将键映射到值的对象，不能包含重复的键，每个键可以映射最多一个值
创建Map集合的对象：
	多态的方式
	具体的实现类HashMap
	Map<String, String> map = new HashMap<>();

5.2.Map集合的基本功能：

V put(K key,V value)：添加元素
V remove(Object key)：根据键删除键值对元素（返回被删除键值对元素的值，若键不存在，则返回null） 
void clear()：移除所有的键值对元素
boolean containsKey(Object key)：判断集合中是否包含指定的键
boolean containsValue(Object value)：判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空
int size()：集合的长度，集合中键值对的个数

5.3.Map集合的获取功能：

V get(Object key)：根据键获取值
Set<K> keySet()：获取所有键的集合
Collection<V> values()：获取所有值的集合
Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合

5.4.Map集合的遍历：

思路1：
	1）获取所有键的集合，用KeySet()方法实现
	2）遍历键的集合，获取到每一个键，用增强for实现
	3）根据键去找值，用get(Object key)方法实现
思路2：
	1）获取所有键值对对象的集合；
		Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
	2）遍历键值对对象的集合，得到每一个键值对对象：
		用增强for实现，得到每一个Map.Entry
	3）根据键值对对象获取键和值
		用getKey()得到键
		用getValue()得到值

5.5.集合嵌套：

ArrayList集合存储HashMap元素并遍历：
	1）创建ArrayList集合
	2）创建HashMap集合，并添加键值对元素
	3）把HashMap作为元素添加到ArrayList集合
	4）遍历ArrayList集合
	关键语句：ArrayList<HashMap<String,String>> maps = new ArrayList<>();
	遍历：
		for (HashMap<String, String> map : maps) {
			Set<Map.Entry<String, String>> entrySet = map.entrySet();
			for (Map.Entry<String, String> mp : entrySet) {
				System.out.println(mp.getKey() + "," + mp.getValue());
			}
		}
HashMap集合存储ArrayList元素并遍历：
	1）创建HashMap集合
	2）创建ArrayList集合，并添加元素
	3）把ArrayList作为元素添加到HashMap集合
	4）遍历HashMap集合
	创建：HashMap<String, ArrayList<String>> listHashMap = new HashMap<>();
	遍历：
		Set<Map.Entry<String, ArrayList<String>>> entrySet = listHashMap.entrySet();
		for(Map.Entry<String,ArrayList<String>> map : entrySet){
			System.out.println(map.getKey());
			for(String s : map.getValue()){
				System.out.println(s);
			}
		}

6.Collections：

6.1.Collections概述和使用：

Collections类是针对集合的工具类
Collections类的常用方法：
	public static <T extends Comparable <?super T>> void sort(List<T> list)：将指定的列表按升序排列（注意对类进行排序时，类要实现自然排序的接口）
	public static void reverse(List<?> list)：反转指定列表中元素的顺序
	public static void shuffle(List<?> list)：使用默认的随机源随机排列指定的列表