Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是java.util.List和java.util.Set。
List的特点是元素有序、元素可重复。Set的特点是元素无序，而且不可重复。
List接口的主要实现类有java.util.ArrayList，java.util.LinkedList以及java.util.Vector。
Set接口的主要实现类有java.util.HashSet，java.util.TreeSet以及java.util.LinkedHashSet。
Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。
@Test
public void collection_Test() {
//他的实现类ArrayList，LinkedList，Vector，HashSet，LinkedHashSet，TreeSet都可以使用
Collection<Integer> ints = new ArrayList<Integer>();
//添加元素
for (int i = 1; i < 11; i++) { ints.add(i); }
//删除指定元素
ints.remove(2);
//查看是否存在指定元素
System.out.println(ints.contains(7));//OUTPUT：true
//判断是否为空
System.out.println(ints.isEmpty());//OUTPUT：false
//返回集合中元素个数
System.out.println(ints.size());//OUTPUT：10
//将集合转换为数组并返回
Object[] objects = ints.toArray();
//清空集合
ints.clear();
}
/**
* 迭代器：JDK专门提供了一个接口java.util.Iterator用来对集合进行遍历
* 可以使用Collection.iterator()获取Iterator接口实现类
* 除了使用Iterator接口实现类还需要借助Iterator接口中的方法
* hasNext()：判断下一个元素是否存在
* next()：取出并返回下一个元素
* 迭代器的原理：在取元素之前先判断集合下一个位置中有没有元素，如果有就指针下移把元素取出来，再继续判断
* 一直将所有元素全部取出，直到判断集合中没有元素。
* 遍历结束后指针会停留在集合末尾位置，想要实现再次遍历就必须再次声明一个迭代器
*/
@Test
public void iterator_Test(){
Collection<Integer> arrayList = new ArrayList();
for (int i = 1; i < 11; i++) { arrayList.add(i); }
//获取Iterator接口实现类
Iterator iterator = arrayList.iterator();
//结合hasNext()和next()实现遍历
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println(arrayList.size());
}
/**
* 增强for循环
* 底层的实现方法还是利用了迭代器，利用for循环的格式简化了迭代器的书写，是JDK1.5之后出现的新特性
* 增强for循环可以遍历集合或者是数组
*/
@Test
public void foreach_Test(){
Collection<Integer> arrayList = new ArrayList();
for (int i = 1; i < 11; i++) { arrayList.add(i); }
//使用增强for循环遍历集合
for(int i : arrayList){
System.out.println(i);
}
}
/**
* Collection接口的子接口ArrayList接口
* 特点：
* 1、有序的集合，存储元素和取出元素的顺序是一致的
* 2、有索引，包含了一些带索引的方法
* 3、允许存储重复的元素
* List除了继承了Collection定义的方法外，还额外定义其特有的方法
* add()：将指定的元素，添加到集合中指定的位置上
* get()：返回集合中指定位置的元素
* remove():移除并返回指定位置上的元素
* set()：指定一个元素替换指定位置上的元素，并返回更新前的元素
*/
@Test
public void ArrayList_Test(){
ArrayList list = new ArrayList();
//添加元素
for (int i = 1; i < 11; i++) { list.add(i); }
//向指定位置上添加元素
list.add(10,11);
//返回指定位置上的元素
System.out.println(list.get(0));//OUTPUT:1
//删除指定位置上的元素
System.out.println(list.remove(9));//OUTPUT:10
//设置指定位置上的元素
System.out.println(list.set(9, 10));//OUTPUT:11
}
/**
* List接口实现类LinkedList
* 特点：
* 1、底层是双向链表结构，查询慢增删快
* 2、实现类额外定义了大量操作首尾元素的方法
*/
@Test
public void linkedList(){
LinkedList linkedList = new LinkedList();
for (int i = 1; i < 11; i++) { linkedList.add(i); }
//将元素插入列表开头
linkedList.addFirst(0);
//将元素插入列表末尾
linkedList.addLast(11);
//将元素添加至列表开头，实现功能和addFirst一致
linkedList.push("First");
//获取开头元素
linkedList.getFirst();
//获取末尾元素
linkedList.getLast();
//删除开头元素
linkedList.removeFirst();
//删除末尾元素
linkedList.removeLast();
//弹出末尾元素，实现功能和removeLast一致
linkedList.pop();
//判断集合是否存在元素
linkedList.isEmpty();
}
List接口的古老实现类JDK1.0，时就已经存在
源码底层方法几乎都被synchronized修饰保证线程安全但效率低下，使用场景较少
截取部分源码↓↓↓↓
在JDK1.8之前，底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。 但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。
而JDK1.8中，存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找 时间。 简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的。
/**
* Collections操作集合的工具类
*/
@Test
public void collections_Test(){
//添加多个元素
ArrayList arrayList = new ArrayList();
Collections.addAll(arrayList,1,2,3,4,5,6,7,8);
Iterator iterator = arrayList.iterator();
while (iterator.hasNext()){
System.out.print(iterator.next());
}
System.out.println("\n------------");
//打乱集合的元素顺序
Collections.shuffle(arrayList);
Iterator iterator1 = arrayList.iterator();
while (iterator1.hasNext()){
System.out.print(iterator1.next());
}
System.out.println("\n------------");
//排序
Collections.sort(arrayList);//默认是升序
Iterator iterator2 = arrayList.iterator();
while (iterator2.hasNext()){
System.out.print(iterator2.next());
}
System.out.println("\n------------");
Collections.sort(arrayList, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;//降序
// return o2-o1;//升序
}
});
Iterator iterator3 = arrayList.iterator();
while (iterator3.hasNext()){
System.out.print(iterator3.next());
}
System.out.println("\n------------");
//在对自定义类进行排序时必须保证类实现了comparable接口并重写了其中的compareTo()抽象方法,自定义比较方法
//或者直接使用匿名实现Comparator接口的compare方法
ArrayList arrayList1 = new ArrayList();
Collections.addAll(arrayList1,new Ponse("小王",12),new Ponse("小李",17),new Ponse("小刘",11));
Collections.sort(arrayList1, new Comparator<Ponse>() {
@Override
public int compare(Ponse o1, Ponse o2) {
return o2.getAge()-o1.getAge();
}
});
Iterator iterator4 = arrayList1.iterator();
while (iterator4.hasNext()){
System.out.print(iterator4.next());
}
System.out.println("\n------------");
}