Java 集合的简单理解
集合（容器）
Java的集合类分别是Collection接口和Map接口派生而来。
Collection接口
对于实现Collection接口的子类，都会实现Collection接口中抽象方法，所以他们子类都包含一部分相同的方法（从Collection中继承过来的）。
下面是Collection接口中的方法列表：
简单的泛型
这里只是简单提一下泛型，不做深入讲解。
泛型可以理解为：指定容器存放的元素的类型，比如Collection<T>，则容器中的元素就应该是T类型。
List
List是有序、可重复的容器。
有序，表示精确地可以使用索引（下标）来访问容器中元素，使用get(int index)。
可重复，表示允许e1.equals(e2)的元素重复加入容器。
有三个实现类：ArrayList、LinkedList、Vector。
ArrayList
底层使用数组实现，特点：查询效率高，增删效率低，线程不安全。
增加元素的原理：ArrayList的size可以不断扩充，在放入新元素之前，会先检测如果放入当前元素，容器的size是否会超过容器的初始容量，如果超过了容器的初始容量，就创建一个更大的新数组，然后将原容器中的元素拷贝到新的数组中，然后改变引用。
删除元素的原理：假设删除第i个元素，则会将发生复制操作，从i+1开始的元素，拷贝到第i个位置，相当于所有元素都向前移动一个位置。
LinkedList
底层使用双向链表实现，特点：查询效率低，增删效率高，线程不安全。
Vector
底层使用数组来实现，但是相关的方法都加了同步检查（synchronized），所以线程安全，但效率低。
Vector几乎和ArrayList几乎相同，只是在某些方法前面加了synchronized关键字。
Map接口
Map使用key-value格式来存储对象，Map中通过key来标识value，所以key不能重复，但是value可以重复；如果key重复了，那么后面的value就会覆盖前面的value。
Map接口中声明的方法列表如下：
HashMap
底层采用了哈希表（取模 + 拉链法），计算key的hashCode，根据散列算法计算后，得出hash值，根据这个值去数组对影位置存取元素。
在新增（put）元素的时候，将新增元素存入数组hash值所对应的位置。数组每个元素会存放（hashCode、key、value、next），如果数组中对应的位置已经有元素存在了，则将新增的元素挂在已有元素的后面（挂在原有元素的next上）。Java 8做了修改，如果拉链的链表长度大于8的时候，会采用红黑树来存储。
在获取（get）元素的时候，首先根据hash值，根据hash值去数组中对应位置，然后和链表的每一个key值相比较（调用key的equals()方法），返回相等的那个元素。
TreeMap
底层使用红黑树实现。
会将key递增进行排序之后存储。注意，如果要自定义key的排序，需要实现Comparable接口，并且重写compareTo()方法
import java.util.Map;
import java.util.TreeMap;
public class TestCollection {
public static void main(String[] args) {
Map<Student, String> m = new TreeMap<>();
m.put(new Student(1001, "张三", 99), "学习委员");
m.put(new Student(1002, "李四", 60), "体育委员");
m.put(new Student(1003, "王五", 100), "班长");
m.put(new Student(1000, "赵六", 99), "学习委员");
for (Student key : m.keySet()) {
System.out.println(key + " position: " + m.get(key));
}
// id: 1002, name: 李四, score: 60 position: 体育委员
// id: 1000, name: 赵六, score: 99 position: 学习委员
// id: 1001, name: 张三, score: 99 position: 学习委员
// id: 1003, name: 王五, score: 100 position: 班长
}
}
class Student implements Comparable<Student>{
private int id;
private String name;
private int score;
public Student(int id, String name, int score) {
this.id = id;
this.name = name;
this.score = score;
}
public String toString() {
return "id: " + this.id + ", name: " +this.name + ", score: " + this.score;
}
@Override
public int compareTo(Student o) {
// 首先按照score升序排序，score相同，则按照id升序排序。
if (this.score < o.score) {
return -1;
} else if (this.score > o.score) {
return 1;
} else {
if (this.id > o.id) {
return 1;
} else if (this.id < o.id) {
return -1;
} else {
return 0;
}
}
}
}
Set
Set接口是实现了Collection接口的接口，所以Collection中的方法，Set接口的实现类都可以调用。
Set是无序，不可重复的容器。底层使用Map来实现。
无序，是指元素没有索引，如果要查找一个元素，就需要遍历容器。
不可重复，是指调用元素的equals()方法，如果比较结果为true，则不能重复加入。
Set接口的实现类有HastSet和TreeSet。
HashSet
HashSet的底层使用HashMap来实现，存入HashSet的元素会被作为底层HashMap的key，底层HashMap的key对应的value为一个Object对象。
TreeSet
TreeSet的底层使用TreeMap来实现。
使用迭代器来遍历容器
迭代器主要是Iterator接口。
遍历Collection（List、Set）
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Demo {
public static void main(String[] args) {
traverseCollection();
}
// 遍历Collection接口的实现类对象的元素
public static void traverseCollection() {
List<String> list = new ArrayList<>();
list.add("aaaaa");
list.add("zzzzz");
list.add("yyyyy");
System.out.println(list); // [aaaaa, zzzzz, yyyyy]
Iterator<String> iter = list.iterator();
while (iter.hasNext()) {
String s = iter.next();
System.out.println(s);
}
//aaaaa
//zzzzz
//yyyyy
}
}
遍历Map
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class Demo {
public static void main(String[] args) {
traverseMap();
}
// 遍历Map接口的实现类对象的元素
public static void traverseMap() {
Map<String, String> m = new HashMap<>();
m.put("one", "11111111");
m.put("two", "22222222");
m.put("three", "3333333");
System.out.println(m);
//{one=11111111, two=22222222, three=3333333}
//Set<K> keySet();功能是返回一个包含所有Key的Set
//System.out.println(m.keySet());
//[one, two, three]
//Set<Map.Entry<K, V>> entrySet()功能是返回一个包含所有K=V的Set
//System.out.println(m.entrySet());
//[one=11111111, two=22222222, three=3333333]
// 遍历Map的第一种方式
Set<Entry<String, String>> ss = m.entrySet();
Iterator<Entry<String, String>> iter = ss.iterator();
while (iter.hasNext()) {
Entry<String, String> item = iter.next();
System.out.println(item.getKey() + " = " + item.getValue());
}
//one = 11111111
//two = 22222222
//three = 3333333
// 遍历Map的第二种方式-> 转化为遍历List
Set<String> s = m.keySet();
Iterator<String> iter2 = s.iterator();
while (iter2.hasNext()) {
String key = iter2.next();
System.out.println(key + " = " + m.get(key));
}
//one = 11111111
//two = 22222222
//three = 3333333
}
}
使用for循环遍历List
for (int i = 0; i < list.size(); i++) {
String s = (String)list.get(i);
System.out.println(s);
}
for (String s : list) {
System.out.println(s);
}
使用for循环来遍历List的时候，比较方便，一般只是用来查看List，不对其进行操作的情况。
使用Collections工具类
使用java.util.Collections工具类，可以对实现了Collection接口的子类对象进行操作，包括List、Set，但是不能操作Map。
import java.util.ArrayList;
import java.util.List;
import java.util.Collections;
public class Demo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("xxxx");
list.add("zzzz");
list.add("yyyy");
System.out.println(list); //[xxxx, zzzz, yyyy]
Collections.shuffle(list);//打乱顺序
System.out.println(list); //[zzzz, yyyy, xxxx]
Collections.reverse(list);//翻转
System.out.println(list); //[xxxx, zzzz, yyyy]
Collections.sort(list); //递增排序，自定义类需要实现Comparable接口
System.out.println(list); //[xxxx, yyyy, zzzz]
System.out.println(Collections.binarySearch(list, "yyyy")); //1
System.out.println(Collections.binarySearch(list, "wwww")); //-1
}
}
利用List和Map保存一张二维表
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Demo {
public static void main(String[] args) {
Map<String, Object> m1 = new HashMap<>();
m1.put("id", 1001);
m1.put("name", "aaaaaa");
m1.put("salary", 10000);
Map<String, Object> m2 = new HashMap<>();
m2.put("id", 1002);
m2.put("name", "cccccc");
m2.put("salary", 199999);
Map<String, Object> m3 = new HashMap<>();
m3.put("id", 1003);
m3.put("name", "bbbbb");
m3.put("salary", 20000);
List<Map<String, Object>> list = new ArrayList<>();
list.add(m1);
list.add(m2);
list.add(m3);
for (Map<String, Object> m : list) {
Set<String> keys = m.keySet();
for (String key : keys) {
System.out.print(key + ": " + m.get(key) + "\t");
}
System.out.println();
}
}
}
输出：
name: aaaaaa id: 1001 salary: 10000
name: cccccc id: 1002 salary: 199999
name: bbbbb id: 1003 salary: 20000
