javaSE（12）（集合大总结）

1.数据结构：
数据结构是底层的东西，可以让人对知识理解的更透彻，实际开发中也可能用到。常见的数据结构有线性表，链表，栈，队列，树。线性表（顺序存储和链式存储），栈（后进先出），队列（先进先出）。数据结构有时间一定要再看看。
2.在以后的实际开发中，经常会遇到一个问题：需要存储N个自定义类型的对象，即：（1）数量不确定。（2）存储的是对象。数组可以存储对象但是数量必须实现确定。
3.为了弥补数组的局限性，java引入了集合的概念，集合是java提供的超级数组，他是一个容器，他的特点：（1）长度可变，动态增长。（2）可以存储任意类型的数据。（3）底层采用了较好的数据结构存储数据，提高效率。集合接口或者类都在java.util包中。
4.Collection接口是List和Set的父接口：（1）List接口存储一组允许重复，有序（插入顺序）的对象。（2）Set接口存储一组唯一，无序的对象。
5.List存储一组允许重复，有序的对象，通过索引（下标）来进行访问。常用的方法：（1）存储：boolean add(Object o) 继承自Collection、boolean addAll(Collection c) 继承自Collection、void add (int index，Object o)、boolean addAll (int index，Collection c).
（2）替换：set(int index,Object O)（3）删除：boolean remove(Object o) 继承自Collection、boolean removeAll(Collection c) 继承自Collection、boolean retainAll(Collection c) 继承自Collection、void clear() 继承自Collection、remove(int index).（4）判断（5）获取，具体方法见博客代码。
6.List接口常用的实现类：（1）Vector（向量列表）：底层数据结构是动态数组，线程安全，无论增删还是查询都非常慢，初始容量为10，增量10
（2）ArrayList（现行列表）：底层数据结构是动态数组，线程不安全，增删的效率很慢（因为要移动数据），但是随即查询的效率很高，默认初始容量为10，增量未指定（经测试发现未原来的50%）
（3）LinkedList（链式列表）底层数据结构是链表，线程不安全，对元素的增删效率很高，随即查询的效率低（因为要移动指针寻址），默认初始容量为0，没有增量。（PS：线程和安全不可兼得，没有十全十美）
7.Vector：构造方法：public Vector()；public Vector(int initialCapacity),public Vector(int initialCapacity,int capacityIncrement),其他常用方法来自List接口
8.ArrayList:构造方法：public ArrayList(),public ArrayList(int initialCapacity).其他常用方法来自于List接口。
9.LinkedList构造方法：底层数据结构是链表，构造方法：public LinkedList().自有方法：见博客代码。
10.泛型(Generic type):集合可以存储任意类型的对象，因此从集合总取出这些对象时需要强转，但如果存储的不是同一种类型，取出对象时怎么强转？泛型只能用于引用数据类型，泛型的本质是类型的参数化，即让类型“任意化”，就是在定义（类型，参数，方法，成员变量的定义）的时候，设置他的类型可变，也就是数据类型可以是任意的类型，java5之前是将其设置为object 类型，必须事先知道各个Object具体类型是什么。往往有时候JVM无法事先知道对象的具体类型。
11.泛型不一定非要出现在泛型类或者泛型接口中，也可以出现在普通类或者普通接口中，实现泛型方法如下（1）：泛型类（2），泛型接口（3）

12.泛型方法（定义时需要声明泛型，然后就可以用于参数和返回值了）泛型类（定义时需要声明泛型，创建对象时需要指定泛型的具体类型）
泛型接口（定义时需要声明泛型，实现类在实现接口时需要制定具体类型）。
13.有界泛型：泛型支持extends关键字，来向下限制一个范围：public void calc(N n1,N n2);声明泛型只能是Number和他的子类，public void calc(N n):声明泛型只能是GenericInter接口的实现类。泛型支持super关键字，来向上限制一个范围。
14.集合与泛型：java中的集合类都已经实现了泛型，java7提供了更简单的菱形写法：List bList = new ArrayList<>();
15.java 泛型的技术细节：JVM没有泛型，只有普通类和普通方法。因此Java实现的是伪泛型，即泛型只存在于源代码中，编译后的字节码中已经进行了“类型擦除”并自动实现了“强转”代码。编译时会对泛型类型进行语法检查，然后“类型擦除”进行编译，运行时已经没有泛型了。

---

16.Set接口存储一组唯一、无序的对象，唯一：Set集合中不允许出现重复的元素，如果想Set集合中存储重复元素是无效的，但是不会报错。
无序：Set集合不会维护集合中元素的顺序，即不存在下标或者索引，Set集合中没有自有方法，全部继 承Collection接口。
17.Set接口常用实现类：HashSet：往set集合中存储对象时java如何判断集合中是否已经存在该对象？先判断hashCode，不相等就添加，如果相等就判断equals，如果不相等就添加。HashSet采用哈希算法（散列）来存储对象，大大提高查询效率，存储结构是数组+链表。不保证线程安全。
18. Set接口常用实现类：LinkedHashSet，和hashSet一样也是无序唯一的，多了一个链表用来维护插入顺序作为遍历顺序（仍然没有下标或者索引）不保证线程安全。
19. Set接口常用实现类：TreeSet：无序、唯一，以树形结构（平衡二叉树）存储，访问或者遍历的速度快，默认按照自然顺序存储，不保证线程安全，自有方法见博客代码。所谓的自然顺序就是：字母按照a~z，数字从小到大。
20.遍历集合：（1）一般的for循环，可用于List，但是Set没下标，无法用于Set。（2）foreach：可用于数组，List和Set。一般的for循环适合访问有序结构，可以根据下标快速获取指定元素，而foreach还可以访问没有顺序（无索引或者下标）的集合。foreach循环用于集合时要求集合必须实现java.long.iterable接口，因为用于集合时foreach需要借助于迭代器实现遍历，java编译器会把foreach代码转化为迭代器代码。
21.迭代器设计模式：迭代器是一种设计模式，可以遍历容器（集合），又不暴漏容器内部细节，扩展性好，java中的迭代器设计：（1）java.long.iterable接口。Iterator iterator()返回一个迭代器（2）java.util.iterator接口，boolean hasNext():有没有下一个，E next()获取下一个。void remove() 用来解决ConcurrentModificationException并发修改异常。迭代器也支持泛型。
22.java集合迭代器：使用Iterator 的好处在于可以使用相同方式去遍历集合中元素，而不用考虑集合类的内部实现（只要它实现了 java.lang.Iterable 接口），如果使用Iterator 来遍历集合中元素，一旦不再使用 List 转而使用 Set 来组织数据，那遍历元素的代码不用做任何修改，如果使用 for 来遍历，那所有遍历此集合的算法都得做相应调整,因为List有序,Set无序,结构不同,他们的访问算法也不一样。
23. 任何集合在使用ForEach或迭代器遍历时，如果修改了集合，都可能会出现并发修改异常，在遍历Set的时候不允许修改Set，可以通过迭代器的remove方法来解决。
24.遍历方法:(1)一般for循环，(2)Foreach循环（3）迭代器
25.应用场合特别重要：（1）判断要存储的数据是否有唯一性要求（2）判断要存储的数据是否有顺序性要求（3）判断功能上是查询上多一些还是插入删除多一些。（4）判断功能上是否对线程安全有要求。

---

26.Map是比较特殊的集合，也叫映射，他一次性存储两个数据（键值对）key和value可以是任何类型，键不允许重复，一个键有且只能对应一个值。（1）存储：V put(K key,V value)重复的会覆盖。（2）删除void clear(),V remove(Object Key)（3）判断（4）获取详细见博客代码。
27.Map接口常用实现类：HashMap：基于哈希表结构的Map实现，允许使用null值和null键，不保证顺序，不保证线程安全。构造方法：public HashMap()，构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空HashMap对象。其他方法来自Map 接口。
28. Map接口常用实现类：LinkedHashMap：基于哈希表和链表结构的Map实现，允许使用null值和null键，维护插入顺序为遍历顺序，不保证线程安全。构造方法：public LinkedHashMap()，构造一个带默认初始容量 (16) 和加载因子 (0.75) 的空LinkedHashMap对象。其他方法来自于Map接口。
29. Map接口常用实现类：TreeMap：基于平衡二叉树结构的Map实现，不允许null键，允许null值。根据其键的自然顺序进行排序。不保证线程安全。构造方法：public TreeMap():使用键的自然顺序构造一个空的对象，自有方法见博客地址。
30.Map的迭代器：如果只遍历所有的键：Set keySet(),如果只遍历所有的值：Collection values().如果要成对遍历则有如下方法：（1）获得所有的key，然后根据key找到value。（2）Map.Entry接口，用于获取键值对的集合，K getKey()返回与此项对应的键，V getValue()返回与此项对应值。

---

31.当需要排序的集合或者数组存储的不是单纯的数字型或者字符型时，通常可以使用Comparator接口或者Comparable接口实现自定义方式排序。
（1）方式一：java.long.Compatable接口，int comparaTo(T o)必须重写该方法实现自定义排序算法，（0相等，负数表示小，整数表示大）。
对于要排序的集合，要保证对象的equals方法相等时返回的是0.树集合一排序算法来保证唯一性。
（2）方式二：java.util.Comparator接口，int compare(T o1,T o2) 自定义一个类实现该接口并重写该方法实现排序算法，TreeSet类有一个public TreeSet(Comparator comp)构造方法可以指定排序器(比较器)。两种方式：方式一需要定义在类的内部，后期需要更改类的源代码，方式二定义在类的外部解耦了，更灵活，更方便，（可以很方便的在不同的排序方式中切换）
32.工具类：Collections：针对集合的工具类，详情见博客代码。

---

Collection体系结构：（别人总结）
Collection接口是顶层接口，下面有两个子接口：List和Set
一、List
1.有序、可重复
2.Vector 动态数组 线程安全 增删查的效率都不好
3.add(E o) remove(E o) remove(int index) set() get(int index) size() contains(E o)
isEmpty()
4. ArrayList 动态数组 线程不安全 查询可以 增删效率低
5. LinkedList 链表 线程不安全 查询不行 增删效率高

二、Set
1.无序 、唯一（必须重写hashCode和equals方法）
2.HashSet 字典 线程不安全 增删查的效率都不错
3.测试是不是无序的 怎么保证唯一
4.LinkedHashSet 多了一个链表用来维护插入顺序作为遍历顺序
5.TreeSet 平衡二叉树 要按某种顺序来存数据(测试) 增删查的效率都不错

三、泛型
1.ArrayList al=new ArrayList<>(); get()不用强转
2.泛型类 泛型方法 泛型接口 add(Object o) add(T o) Object get(int index) T get(int index)
3.泛型的技术实现细节 类型檫除

四、迭代器
1.一般for ForEach
2.遍历Set时候只能ForEach
3.自己实现了一个迭代器遍历数组 next() hasNext()
4.
Iterator it=al.iterator();
while(it.hasNext())
{
Book temp=it.next();
if(temp.getName.equals(“a”))
it.remove();
}
5.Java集合中迭代是怎么设计的？
java.lang.Iterable iteraotr
java.util.Iterator next hasNext remove（解决并发修改异常）
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
一、集合
1.数据结构
a.线性表list 位置不变(数组，长度固定) 可加塞(位置可变，查询可以，增删不行) 链表 (查询麻烦，增删不错)
b.栈(先进后出) 队列(先进先出) 哈希表(字典，查询和增删都不错)
c.树(平衡二叉树，查询和增删都不错)
2.Collection顶层接口
a.List 有序、可重复
ArrayList LinkedList Vector(线程安全)
b.Set 无序、唯一
HashSet LinkedHashSet TreeSet(是以排序算法保证唯一性的)
3.Map接口 双列 键值对 键不允许重复，值可以
HashMap LinkedHashMap TreeMap(是以排序算法保证唯一性的)
keySet values entrySet get
二、泛型
1.集合可以存任何类型，取的时候会遇到不知强转成什么类型的问题
2.List list=new ArrayList();
3.泛型限制了集合只能存一种类型，取的时候不用强转
三、迭代器
1.就是专门用来遍历集合的，隐藏了一些细节，更重要的是统一了遍历方式
2.Iterator it=集合对象.iterator();
while(it.hasNext())
{
it.next();
}
四、集合排序
1.树形结构的集合在存储时必须是按照某种顺序来存的 TreeSet TreeMap 自定义类型的时候
2.方式一：自定义类要你实现java.lang.Comparable接口 compareTo
3.方式二: 自定义一个比较器类实现java.util.Comparator接口 compare
TreeSet ts=new TreeSet<>(new BookComparator1());
五、工具类
1.Arrays
2.Collections