1、集合
（1）集合的作用
集合只能存放对象。比如你存一个 int 型数据 1放入集合中，其实它是自动转换成 Integer 类后存入。
集合存放的是多个对象的引用，对象本身还是放在堆内存中。
集合可以存放不同类型，不限数量的数据类型。
（2）集合类体系
图：https://img-blog.csdn.net/20160124221843905
一般知道：
|- Collection
|- List : 有序,可重复
|- ArrayList
|- Vector
|- LinkedList
|- Stack
|- Set : 无序,不重复
|- HashSet
|- TreeSet
|- Queue
|- ArrayListBlockingQueue
|- LinkedListBlockingQueue
|- Map
|- HashMap
|- TreeMap
（3）List集合
（3.1）List集合最后的两兄弟
ArrayList基于动态数组的实现，它长于随机访问元素，但是在中间插入和移除元素时较慢
LinkedList基于链表实现，在List中间进行插入和删除的代价较低，提供了优化的顺序访问。LinkedList在随机访问方面相对比较慢
但是它的特性集较ArrayList更大。即LinkedList可以作为我们最经常使用的两种数据结构来使用：栈和队列，因为LinkedList的实现
一个双向链表，所以无论是FIFO还是FILO都可以实现
（3.2）List集合的遍历（以ArrayList举例）
普通for循环，可以实现删除某个数据
List<Integer> a = new ArrayList<Integer>();
a.add(1);
a.add(2);
a.add(3);
/**
* 过程：第一步：打印1 删除索引为0的数据（a.size()就减一） 2就移到了0的位置上 3就移到了1的位置上
*/
for(int i=0;i<a.size();i++) {
System.out.println(a.get(i));
a.remove(i);
System.out.println(a.size());
}
增强型for循环：不能在遍历的时候，对集合进行删除或添加
List<Integer> list = new ArrayList<Integer>();
for(Integer ele : list){
System.out.print( ele );
list.remove( ele ); //报错ConcurrentModificationException
}
使用迭代器进行遍历，可以边遍历，边删除或添加
Iterator<String> iterator = list.iterator();
while( iterator.hasNext() ){
String data = iterator.next();
System.out.pintln( data );
iterator.remove();
}
（3.3）List集合的排序（以ArrayList类为例）
（1）Collections.sort( List<T> list )默认升序
List<Integer> list = new ArrayList<Integer>();
list.add(2);
list.add(1);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
Collections.sort(list)
System.out.println( list );//[1, 2, 3, 4, 5, 6]
（2）Collections.sort( List<T> list )自定义实现降序，一般在自己定义的元素类中要实现Comparable接口，并且要重写compareto方法
List<Student> list = new ArrayList<Student>();
Student s1 = new Student( "小明",13 );
Student s2 = new Student( "小e",14 );
Student s3 = new Student( "小r",15 );
list.add(s1);
list.add(s2);
list.add(s3);
Collections.sort(list);//按照对象的年龄去排序，降序
System.out.println( list );//[{小r15 }, {小e14 }, {小明13 }]
/**
*重写compareto方法：
* 重要的是返回值，若返回正数表示this小，返回负数表示this大
*默认情况下排的是升序，则return this.age - o.age ，this大返回值即为正数，最终排序就将this作为大的数往后排
*现在要排降序，返回值设置成return o.age - this.age; 作用是当this大，返回的是负数，最终排序this是作为小的数放到前面
*/
public int compareTo(Student o) {
return o.age - this.age;
}
（3）比较器Comparetor接口：compare方法实现降序
List<People> list = new ArrayList<People>();
People s1 = new People( "小明",13 );
People s2 = new People( "小e",14 );
People s3 = new People( "小r",15 );
list.add(s1);
list.add(s2);
list.add(s3);
Collections.sort(list, new Comparator<People>(){
//o1的age大，就返回-1,表示o1的age小
public int compare(People o1, People o2) {
return o2.age - o1.age;
}
});
System.out.println( list );//[{小r 15 }, {小e 14 }, {小明13 }]
（4）比较器和利用元素本身比较方法，同时使用时，比较器优先
（3.4）ArrayList对象的创建和常用方法
1.创建对象
ArrayList()
无参构造，创建一个初始大小为size = 10的list集合
ArrayList( int initSize )
创建一个初始化大小为initSize的list集合
ArrayList( Collection c )
将c转换成ArrayList集合
2.泛型
List< String > list = new ArrayList< String >();
注：在JDK1.7版本以上，后部分的String可以不写
一旦定义了该限制，那么该list集合只能存放String类型的数据
3.常用方法
add( E e ):追加数据e到list中
add( int index, E element ):在指定位置插入数据element
list1.addAll( list2 ):把list2中所有元素追加到list1中
clear()：清空当前list中的所有数据
contains( Object o ):判断指定的对象o是否存在于当前的list中
get( int index ):取出指定位置上的数据
isEmpty():判断list是否没有元素
remove( int index ):删除指定位置上的元素
remove( object o ):删除与指定对象第一个匹配的元素
set( int index,E element ):替换指定位置上的数据为element，并将原数据返回
size():获取当前list已经存放元素的个数
T[] toArray( T[] a ):将list转换成指定类型的数组
注意：
remove( Object o )和contains( Object o )根据对象中的equals方法来搜索并判
断list中的匹配对象，一般需要重写equals方法，否则默认根据地址值进行匹配判断
（4）HashSet类
（1）特点
无序（存放的元素放在一堆），不重复（可以用来过滤）
（2）创建HashSet对象
HashSet<Integer> h = new HashSet<Integer>();
（3）讨论元素不重复：
1.获取hash值: 先调用给出元素的hashCode方法获得hash值
2.根据hash值定位元素存放位置 : 类似于 hash % table.length
3.判断该位置上是否已经存在元素(这个位置上存放的可能是一个链表)
4.若不存在, 则直接放入次元素;若已存在, 则循环遍历此链表中的每节点,依次调用元素的equals方法进行相等判断；若出现相
等情况,则过滤掉；若未出现相等情况,则追加到此链表中
注意:
1.要想HashSet按照我们的逻辑来过滤掉重复元素,必须同时重写hashCode方法和equals方法
2.为提升HashSet的使用性能, 我们应该尽量保证:当两个对象的hashCode方法返回值相等时一定让他们的equals方法也返回
true;
结论：这样我们就保证了数组中的每个位置只放一个数据, 从而保证HashSet可以指定通过hash值直接定位到具体的某个元素
（4）常用方法
boolean add(E e) 添加元素(会进行重复过滤)
void clear() 从此 set 中移除所有元素。
boolean contains(Object o) 如果此 set 包含指定元素，则返回 true。
boolean isEmpty() 如果此 set 不包含任何元素，则返回 true。
Iterator<E> iterator() 返回对此 set 中元素进行迭代的迭代器。
boolean remove(Object o)如果指定元素存在于此 set 中，则将其移除。
int size() 返回此 set 中的元素的数量（set 的容量）。
（5）遍历Set集合:
增强型for循环
迭代器
（5）HashMap类
（1）什么是Map?
一种以键值对的方式来存放数据的容器
（2）HashMap:
创建对象:new HashMap();
特点:key不重复, value可重复
对比HashSet进行理解
HashSet就是使用的是HashMap的key这部分来存放数据的
（3）常用方法:
put(key, value) 通过hash算法来将此键值对存入对应位置
get(key): 根据key获取对应的value 通过hash算法直接定位键值对的位置取出value
clear
isEmpty
entrySet(): 获取该map中的所有键值对
keySet(): 获取该map的所有key
values(): 获取该map的所有value
（4）遍历:https://www.cnblogs.com/fqfanqi/p/6187085.html
四种方式：
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}Map<Integer, Integer> map = new HashMap<Integer, Integer>();
//遍历map中的键
for (Integer key : map.keySet()) {
System.out.println("Key = " + key);
}
//遍历map中的值
for (Integer value : map.values()) {
System.out.println("Value = " + value);
}使用Iterator遍历；可以边遍历边删除
使用泛型：
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<Integer, Integer> entry = entries.next();
System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}
不使用泛型：
Map map = new HashMap();
Iterator entries = map.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry entry = (Map.Entry) entries.next();
Integer key = (Integer)entry.getKey();
Integer value = (Integer)entry.getValue();
System.out.println("Key = " + key + ", Value = " + value);
}Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (Integer key : map.keySet()) {
Integer value = map.get(key);
System.out.println("Key = " + key + ", Value = " + value);（6）集合转化
（6.1）集合转化成数组
package list_test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Run {
public static void main(String[] args) {
/**
* 将list集合转化成数组
*/
List<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
/**
* list.toArray()方法默认返回的是一个Object类型的数组
*/
Object[] arr1 = list.toArray();
System.out.println(Arrays.toString(arr1));//将数组转化成字符串输出
System.out.println("=========分割线==========");
/**
* 如何将list集合转化成String类型的数组
*/
String[] arr2 = new String[ list.size() ];
arr2 = list.toArray(arr2);
System.out.println(Arrays.toString(arr2));
}
}
（6.2）数组转化成集合
list = Arrays.asList( arr )-------数组转化成List（6.3）Set和List的转化
Set --> 数组
set.toArray
Set --> List
步骤1: arr = set.toArray()
步骤2: list = Arrays.asList( arr )
List --> Set
set = new HashSet(list)
数组 --> set
步骤1: list = Arrays.asList( arr )
步骤2: set = new HashSet(list)2、泛型
相关链接：https://www.cnblogs.com/zhenyu-go/tag/Java/