Collection
数组一旦初始化后，长度就确定了，存储数据对象不能达到动态扩展，其次数组存储元素不便于对数组进行添加、修改、删除操作，而且数组可以存储重复元素。面对这些问题，集合的作用显现出来了。集合分为Collection和Map两种体系。。其中collection中的元素是一个value值，map中的元素是key:value形式的。collection来源于Java.util包，字面意思就是容器。
Collection的继承体系：
List:
1. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
常用方法：
public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
public E get(int index) :返回集合中指定位置的元素。
public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素
例子：
public class ListDemo {
public static void main(String[] args) {
// 创建List集合对象
List<String> list = new ArrayList<String>();
// 往 尾部添加 指定元素
list.add("图图");
list.add("小美");
list.add("不高兴");
System.out.println(list);
// add(int index,String s) 往指定位置添加
list.add(1,"没头脑");
System.out.println(list);
// String remove(int index) 删除指定位置元素 返回被删除元素
// 删除索引位置为2的元素
System.out.println("删除索引位置为2的元素");
System.out.println(list.remove(2));
System.out.println(list);
// String set(int index,String s)
// 在指定位置 进行 元素替代（改）
// 修改指定位置元素
list.set(0, "三毛");
System.out.println(list);
// String get(int index) 获取指定位置元素
// 跟size() 方法一起用 来 遍历的
for(int i = 0;i<list.size();i++){
System.out.println(list.get(i));
}
//还可以使用增强for
for (String string : list) {
System.out.println(string);
}
}
}
List的常用子类：
ArrayList
java.util.ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以 ArrayList 是最常用的集合。
LinkedList
java.util.LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。
Vector（实际开发不常用，面试时会和ArrayList做对比）
Vector是【同步】操作
ArrayList是【异步】操作
Set：
java.util.Set 接口和 java.util.List 接口一样，同样继承自 Collection 接口，它与 Collection 接口中的方法基本一致，并没有对 Collection 接口进行功能上的扩充，只是比 Collection 接口更加严格了。与 List 接口不
同的是， Set 接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。
Set 的常用子类：
HashSet
java.util.HashSet 是 Set 接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。 HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于： hashCode 与 equals 方法。
LinkedHashSet（有序）
java.util.LinkedHashSet ，它是链表和哈希表组合的一个数据存储结构，元素是有序的。
TreeSet：不可重复，没有索引
底层就是红黑树，可以对集合中的元素按照元素的内容实现排序
去重原理：基于compareTo的返回值来实现去重，与hashCode和equals方法无关，返回值为0，就认为是重复元素，不再添加
举例：
public class Person implements Comparable<Person>{
private String name;
private int age;
......
@Override
public int compareTo(Person o) {
int i = o.age - this.age;
if (i == 0){
return this.name.hashCode() - o.name.hashCode();
}
return i;
}
}
=====================
TreeSet<Person> set = new TreeSet<>();
Person p1 = new Person("小美女1",18);
Person p4 = new Person("小美女4",18);
Person p3 = new Person("小美女3",24);
Person p2 = new Person("小美女2",74);
Person p5 = new Person("小美女5",60);
set.add(p1);
set.add(p2);
set.add(p3);
set.add(p4);
set.add(p5);
System.out.println(set);
Collection的常用方法：
public boolean add(E e)： 把给定的对象添加到当前集合中，添加成功返回true，否则返回false 。
public void clear() :清空集合中所有的元素。
public boolean remove(E e): 把给定的对象在当前集合中删除，有并删除成功返回true，没有或者删除失败返回false。
public boolean contains(E e): 判断当前集合中是否包含给定的对象，包含返回true，否则返回false。
public boolean isEmpty(): 判断当前集合是否为空，为空返回true，否则返回false。
public int size(): 返回集合中元素的个数。
public Object[] toArray(): 把集合中的元素，存储到数组中。
public T[] toArray(T[] arr) :把集合转成指定类型的数组
如：
Collection<String> coll = new ArrayList<>();
String[] arr = coll.toArray(new String[0]); -- 转成String类型数组
Object[] arr2 = coll.toArray(); -- 转成Object类型数组
Collection的遍历方式:
方式一：转成数组后，通过角标方式遍历
方式二：通过集合的特有方式--迭代器（Iterator）
Iterator常用方法：
boolean hasNext(); -- 判断集合中是否有下一个元素
E next(); -- 如果有下一个元素，该方法取出该元素
remove(); -- 如果有下一个元素，该方法删除该元素
举例：
Collection coll = new ArrayList();
Iterator it = coll.iterator();
while(it.hasNext()){
it.next();
}
方式三：增强for循环（内部用的就是Iterator）
举例：
for(int i=0;i<xx;i++){ -- 当需要修改原本容器中的值时，使用普通for循环
}
for(数据类型 变量名 ：集合){ -- 当仅仅只是遍历容器取值时，使用增强for循环最方便
}
List<String> list;
for(String s : list){
}
注意：在迭代过程中，是不允许使用【原来集合】对集合中的元素做删除操作的，否则会出现【并发修改异常-ConcurrentModificationException】
假如有删除的需求，怎么做？
① 使用迭代器对象的remove方法实现删除操作 -- 要求必须有迭代器对象
② 将需要删除的元素，保存在另一个集合中， 等遍历结束后，调用【原来集合】的removeAll方法删除
Collections
java.utils.Collections 是集合工具类，用来对集合进行操作。部分方法如下：
public static <T> boolean addAll(Collection<T> c, T... elements) :往集合中添加一些元素。
public static void shuffle(List<?> list) 打乱顺序 :打乱集合顺序。
public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。
public static <T> void sort(List<T> list，Comparator<? super T> ) :将集合中元素按照指定规则排序。
举例：
public class CollectionsDemo {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
//原来写法
//list.add(12);
//list.add(14);
//list.add(15);
//list.add(1000);
//采用工具类 完成 往集合中添加元素
Collections.addAll(list, 5, 222, 1，2);
System.out.println(list);
//排序方法
Collections.sort(list);
System.out.println(list);
}
}
结果：
[5, 222, 1, 2]
[1, 2, 5, 222]
public static <T> void sort(List<T> list，Comparator<? super T> ) 里面涉及到了Comparator这个接口，位于java.util包下，排序是comparator能实现的功能之一,该接口代表一个比较器，比较器具有可比性！顾名思义就是做排序的，通俗地讲需要比较两个对象谁排在前谁排在后，比较的方法是：
public int compare(String o1, String o2) ：比较其两个参数的顺序。
两个对象比较的结果有三种：大于，等于，小于。
如果要按照升序排序， 则o1 小于o2，返回（负数），相等返回0，01大于02返回（正数） 如果要按照
降序排序 则o1 小于o2，返回（正数），相等返回0，01大于02返回（负数）
举例：
public class CollectionsDemo3 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("cba");
list.add("aba");
list.add("sba");
list.add("nba");
//排序方法 按照第一个单词的降序
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.charAt(0) ‐ o1.charAt(0);
}
});
System.out.println(list);
}
}
简述Comparable和Comparator两个接口的区别。
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
泛型:引用数据类型的占位符，仅限于定义类或者功能时使用
注意：在使用类或者功能时，要确定具体的数据类型，这个时候就不能在使用泛型了
举例：
class PageBean<T>{
List<T> list;
}
泛型可以定义在类上，也可以定义在方法上，那么这两者的区别是什么呢？
区别①：
定义在类上的泛型，作用范围为整个类有效，包括变量包括方法
定义在方法上的泛型，只对当前方法有效，对其他方法和变量无效
区别②：
对于静态方法中的泛型声明，只能定义在方法上
如：
/**
* 定义一个方法，将某个数据类型的集合转成对应数据类型的数组
*/
public class CollectionUtils {
public static <T> T[] toArray(List<T> list,T[] arr){
for (int i = 0; i < list.size(); i++) {
arr[i] = list.get(i);
}
return arr;
}
}
通配符？：泛型的占位符，在使用泛型类时，如果不能确定具体的数据类型，使用?占位
? extends T: 只能是T类型或者T的子类型，上限已经被限制
? super T:只能是T类型或者T类型的父类型，下限已经被限制
