概述
1.Collection是java集合框架中的顶层接口，用于表示一些相同类型的数据集合，内部提供了一系列用于对集合中元素进行存储的方法。
2.List是从Collection继承过来，也是一个接口；List是一个有序集合：内部的元素存储可以按照规定的顺序存储（默认顺序从头到尾依次存储，存储顺序跟添加顺序一致），可以通过索引获取指定位置的元素。
由于List是一个接口，所以没法直接实例化，因此JDK中提供了一些对于List接口实现的实现类：
- ArrayList
- LinkedList
3.Set集合也是从Collection扩展而来的子集合，相比List集合来说，Set集合内部存储的数据不是按照添加顺序存储，内部不允许出现重复的元素(不允许出现e1.equals(e2))，对null也只允许出现一个，对于set集合常用的实现主要有以下:
- HashSet（哈希表-散列表）
- TreeSet（二叉树-红黑树）
- LinkedHashSet
4.Map也称之为映射，内部的元素是以键值对为结构存储，可以通过key获取map中的value;Key不允许重复；但是值是可以重复的，Map集合有一些常见的实现：
- HashMap
- TreeMap
- ConcurrentHashMap
ArrayList
ArrayList是基于对象数组的实现，初始容量为10（不是new出来就是10，在第一次执行add方法时初始），当容量超出时，会扩容为原来的1.5倍。
List<String> list1 = new ArrayList<>();
list1.add("Jack");
list1.add("肉丝");
List<String> list2 = new ArrayList<>();
list2.add("Tom");
//将一个集合作为参数添加到另一个集合中
list2.addAll(list1);
System.out.println(list2);
System.out.println(list2.contains("Jack"));
Dog d1 = new Dog(1,"大黄");
Dog d2 = new Dog(2,"来福");
Dog d3 = new Dog(3,"旺财");
List<Dog> dogs = new ArrayList<>();
dogs.add(d1);
dogs.add(d2);
dogs.add(d3);
Dog d4 = new Dog(2,"来福");
//判断指定对象是否存在容器中（依据类中的equals和hashcode）
System.out.println(dogs.contains(d4));
dogs.forEach(d->System.out.println(d.getNum()+"--"+d.getName()));
//返回指定元素在容器中第一次出现的位置
System.out.println(list2.indexOf("Jack"));
LinkedList
LinkedList是基于链表的List实现，元素之间通过首尾指针连接，在进行修改(增加，删除)时只需要修改元素的首尾指针即可，修改效率要比ArrayList高，但是在查询时，由于LinkedList没有像ArrayList的索引，在查询时需要从链表的第一个元素开始依次向搜索，所以查询效率较低。
//创建基于链表的List实现
List<String> list = new LinkedList<>();
list.add("10");
list.add("20");
list.add("30");
list.add("40");
list.add("50");
System.out.println(list.get(4));
list.forEach(s->System.out.println(s));
Vector
Vector可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。不过，Vector的大小是可以增加或者减小的，以便适应创建Vector后进行添加或者删除操作。
关于迭代器
//获取集合的列表迭代器
ListIterator<String> li = list.listIterator();
//从上往下迭代
while(li.hasNext()){
String i = li.next();
System.out.println(i);
}
System.out.println("-----------------");
//从下往上迭代
while(li.hasPrevious()){
String i = li.previous();
if("20".equals(i)){
//添加元素到当前迭代器的后一位
// li.add("30");
//替换当前迭代的元素
li.set("30");
}
}
System.out.println(list);
//集合截取（前包后不包）
List<String> sub = list.subList(0,5);
System.out.println(sub);
ArrayList，LinkedList，Vector区别
ArrayList和LinkedList区别 （ArrayList查快改慢；LinkedList改快查慢）：
- ArrayList是基于对象数组的实现，内部通过数组拷贝实现扩容；LinkedList是基于链表的实现，同时实现的队列(双端队列)
- ArrayList由于基于数组实现，因此在搜索元素时可直接通过索引快速定位到元素位置，查询效率较高；LinkedList由于基于链表实现，在查询时需要从链表头开始依次查找，查询效率较低。
- 由于数组的长度一旦定义则无法修改，因此在进行非末端更新(插入和删除)时，由于可能涉及到数组拷贝问题，因此修改效率较低；LinkedList在进行元素更新操作时，只需要修改元素首尾指针的指向即可，更新效率较高。
- 两者都是线程不同步的实现
ArrayList和Vector的区别：
- Vector是老式的集合实现，内部基于对象数组实现；ArrayList是jdk1.2新增的集合实现
- Vector容量扩充时，扩充原来容量2倍；ArrayList扩充为原来的1.5倍
- Vector是基于线程安全的实现(方法都使用synchronized修饰)；ArrayList是非线程安全的实现。
HashSet
HashSet是针对于Set集合的实现，内部基于HashMap的实现，在进行元素存储时，会对每一个存储的元素进行hash()，获取一个哈希地址，通过该hash地址可以找到对象在内存的位置，因此存储方式跟具体得出的hash值有关系，因此存储顺序可能会跟添加顺序不一致。
List<String> list = new ArrayList<>();
list.add("HelloWorld");
list.add("HelloWorld");
System.out.println(list);
Set<String> set = new HashSet<>();
set.add("Table");
set.add("Desk");
set.add("Table");
set.add("Hello");
System.out.println(set);
//获取set集合的迭代器
Iterator<String> it = set.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
if("Desk".equals(s)){
it.remove();
}
}
System.out.println(set);
//将提供的Collection对象构建成一个HashSet
//去重
Set<String> set2 = new HashSet<>(list);
System.out.println(set2);
TreeSet
TreeSet集合是基于TreeMap的Set集合实现，内部元素的存储根据元素的自然顺序(存储的元素需要实现Comparable接口)排序；由于元素是自然顺序排序的实现，因此需要保证集合内部存储的元素必须都是相同的数据类型。
/*
TreeSet使用的注意事项：
1.内部存储的元素必须是相同的数据类型
2.元素对应的数据类型应该实现过Comparable接口（使用TreeSet默认构造器时)
*/
Set<User> set = new TreeSet<>();
set.add(new User(3,"randy"));
set.add(new User(1,"admin"));
set.add(new User(2,"softeem"));
System.out.println(set);
HashMap
HashMap是Map集合一个实现，内部是基于哈希表的排序实现元素存储的，实现原理是链表+数组（JDK8之后引入红黑树）
Map<String, String> map = new HashMap<>();
map.put("a", "allen");
map.put("e", "even");
map.put("d", "device");
map.put("c", "clean");
map.put("b", "bab");
System.out.println(map);
Map<String, Object> user = new HashMap<>();
user.put("id", 1001);
user.put("name", "小明");
user.put("birth", LocalDate.of(1998, 12, 22));
System.out.println(user);
//根据键获得值
Object name = user.get("name");
System.out.println(name);
//遍历Map集合
// 获取Map集合键值对的Set集合（Map转成Set）
// Set<Map.Entry<String, Object>> set = user.entrySet();
// for(Map.Entry<String,Object> e:set){
// System.out.println(e.getKey()+"------------"+e.getValue());
// }
//获取map集合的键集
Set<String> keys = user.keySet();
for (String k : keys) {
//根据键获取值
System.out.println(k + "/" + user.get(k));
}
//移除指定键对应的元素
user.remove("id");
//修改指定键对应的值
user.replace("name","小熊");
System.out.println(user);
//获取集合中元素的个数
System.out.println(user.size());
TreeMap
Treemap的实现是基于二叉排序树中的红黑树实现，所存储的元素要求键必须是同一种数据类型，并且有实现过Comparable接口(或者创建TreeMap时指定排序比较器)
Map<String,Object> map = new TreeMap<>();
map.put("v","vaen");
map.put("k",3.1415);
map.put("a","false");
map.put("s",'x');
System.out.println(map);
Map<User,Object> map2 = new TreeMap<>();
map2.put(new User(1001,"小李"),37);
map2.put(new User(1007,"小王"),100);
map2.put(new User(1003,"小赵"),true);
System.out.println(map2);
Hashtable
和HashMap一样，Hashtable 也是一个散列表，它存储的内容是键值对(key-value)映射。
Hashtable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口。
Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。此外，Hashtable中的映射不是有序的。
Map<String,Object> map = new Hashtable<>();
map.put("a","xjdkjd");
map.put("d","oljn");
System.out.println(map);
HashMap、Hashtable、TreeMap的区别
- TreeMap是有序的，HashMap和HashTable是无序的;
- HashMap是基于hash算法的实现，内不通过数组结合链表实现，允许空键值存在，是线程不同步的实现;
- TreeMap是基于红黑树的实现，内部元素的存储顺序是由自然顺序对键进行排序之后存储，是线程不同步的实现;
- Hashtable是从老式的Dictionary类继承而来，内部的实现原理跟HashMap一样，不允许空键值存在，实现线程同步的实现，运行效率较低；
- Hashtable的父类是Dictionary，TreeMap、HashMap的父类是AbstractMap。
273
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
