collection泛型，collections工具类，list接口

1、Collection集合

1.1 集合概述
①在前面基础课我们已经学习过并使用过集合ArrayList<E> ,那么集合到底是什么呢?
集合：集合是java中提供的一种容器，可以用来存储多个数据。

②集合和数组既然都是容器，它们有啥区别呢？
1)数组的长度是固定的。集合的长度是可变的。
2)数组中存储的是同一类型的元素，可以存储基本数据类型值，也可以存储引用数据类型。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。

1.2  集合框架
集合按照其存储结构可以分为两大类，分别是单列集合`java.util.Collection`和双列集合`java.util.Map`:(java.util.Map后面学习)
①Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是`java.util.List`和`java.util.Set`。其中，`List`的特点是元素有序、元素可重复。`Set`的特点是元素无序，而且不可重复。`List`接口的主要实现类有`java.util.ArrayList`和`java.util.LinkedList`，`Set`接口的主要实现类有`java.util.HashSet`和`java.util.TreeSet`。

注意：
①在学习使用集合的时候，学习顶层接口/抽象类中的共性方法，因为所有子类都可以用。
②在学习使用集合的时候，使用底层，因为顶层不是接口就是抽象类，不可以创建对象使用，需要使用底层的子类创建对象使用。

1.3 Collection 常用功能
java.util.Collection接口
所有单列集合的最顶层的接口,里边定义了所有单列集合共性的方法，任意的单列集合都可以使用Collection接口中的方法
共性的方法:
public boolean add(E e)：把给定的对象添加到当前集合中。
public void clear() :清空集合中所有的元素。
public boolean remove(E e): 把给定的对象在当前集合中删除。
public boolean contains(E e): 判断当前集合中是否包含给定的对象。
public boolean isEmpty(): 判断当前集合是否为空。
public int size(): 返回集合中元素的个数。
public Object[] toArray(): 把集合中的元素，存储到数组中。

代码演示：
// 首先创建集合对象(用ArrayList举例)，使用多态形式

Collection<String> coll = new ArrayList<String>();

/*
    public boolean add(E e)：  把给定的对象添加到当前集合中 。
    返回值是一个boolean值,一般都返回true,所以可以不用接收
 */
boolean b1 = coll.add("张三");
System.out.println("b1:"+b1);//b1:true
System.out.println(coll);//[张三]

/*
    public boolean remove(E e): 把给定的对象在当前集合中删除。
    返回值是一个boolean值,集合中存在元素,删除元素,返回true
    集合中不存在元素,删除失败,返回false
 */
boolean b2 = coll.remove("张三");
System.out.println("b2:"+b2);//b2:true

boolean b3 = coll.remove("李四");
System.out.println("b3:"+b3);//b3:false

/*
    public boolean contains(E e): 判断当前集合中是否包含给定的对象。
    包含返回true
    不包含返回false
 */
boolean b4 = coll.contains("张三");
System.out.println("b4:"+b4);//b4:true
boolean b5 = coll.contains("李四");
System.out.println("b5:"+b5);//b5:false

//public boolean isEmpty(): 判断当前集合是否为空。集合为空返回true,集合不为空返回false
boolean b6 = coll.isEmpty();
System.out.println("b6:"+b6);//b6:false

//public int size(): 返回集合中元素的个数。
int size = coll.size();
System.out.println("size:"+size);//size:1

//public Object[] toArray(): 把集合中的元素，存储到数组中。
Object[] arr = coll.toArray();
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

//public void clear() :清空集合中所有的元素。但是不删除集合,集合还存在
coll.clear();
System.out.println(coll);//[]
System.out.println(coll.isEmpty());//true

2、Iterator迭代器
1、概述
在程序开发中，经常需要遍历集合中的所有元素。因为有的集合没有索引，不能使用普通的for循环遍历。针对这种需求，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。

1.1迭代的概念：
迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

1.2 获取迭代器的方法：
`public Iterator iterator()`: 获取集合对应的迭代器，用来遍历集合中的元素的。	

1.3 Iterator接口的常用方法：	
① `public E next()`:判断集合中还有没有下一个元素,有就返回改元素,没有就报异常
② `public boolean hasNext()`:如果仍有元素可以迭代，则返回 true。

代码演示：
//创建一个集合对象
Collection<String> coll = new ArrayList<>();
//往集合中添加元素
coll.add("科比");
coll.add("麦迪");
coll.add("卡特");
coll.add("艾弗森");
//多态方式创建Iterator对象
Iterator<String> it = coll.iterator();
//取出一个数据
String s = it.next();
//循环取出剩下所有数据
while(it.hasNext()){
    String e = it.next();
    System.out.println(e);
}
System.out.println("----------------------");
for(Iterator<String> it2 = coll.iterator();it2.hasNext();){
    String e = it2.next();
    System.out.println(e);
}

注意：①Iterator<E>接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型。
	     ②发现使用迭代器取出集合中元素的代码,是一个重复的过程，所以我们可以使用循环优化
	不知道集合中有多少元素,使用while循环，循环结束的条件,hasNext方法返回false。
	     ③在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发生java.util.NoSuchElementException没有集合元素的错误。
	
	//创建一个Student类，属性姓名，年龄，班级。使用迭代方法遍历出一个学生集合。

3、泛型
3.1 泛型概述
在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

3.1.1 使用泛型主要是在我们不清楚需要什么数据类型是时候。
注意：①泛型可以在类或方法中预支地使用未知的类型。
      ②一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

3.3 定义和使用具有泛型的类
3.3.1 格式：修饰符 class 类名<代表泛型的变量> { }
自定义泛型类：
public class MyGenericClass {
//没有E类型，在这里代表未知的一种数据类型 未来传递什么就是什么类型
private E e;
public void setE(E e) {
this.e = e;
}
public E geE() {
return ep;
}
}
测试类：
public class GenericClassDemo {
public static void main(String[] args) {
// 创建一个泛型为String的类
MyGenericClass my = new MyGenericClass();
// 调用setMVP
my.setE(“安东尼-戴维斯”);
// 调用getE
String e = my.getE();
System.out.println(e);
//创建一个泛型为Integer的类
MyGenericClass my2 = new MyGenericClass();
my2.setE(123);
Integer e2 = my2.getE();
}
}

3.4 定义和使用具有泛型的方法
3.4.1 格式：
修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
    	  //方法体;
      }
定义泛型方法：

public class GenericMethod {
    //定义一个含有泛型的方法
    public <M> void method01(M m){
        System.out.println(m);
    }

    //定义一个含有泛型的静态方法
    public static <S> void method02(S s){
        System.out.println(s);
    }
}

测试类：
public class Demo03GenericMethod {
    public static void main(String[] args) {
        //创建GenericMethod对象
        GenericMethod gm = new GenericMethod();
        /*
            调用含有泛型的方法method01
            传递什么类型,泛型就是什么类型
         */
        gm.method01(10);
        gm.method01("abc");
        gm.method01(8.8);
        gm.method01(true);

        gm.method02("静态方法");

        //静态方法,通过类名.方法名(参数)可以直接使用
        GenericMethod.method02("静态方法");
        GenericMethod.method02(1);
    }
}

3.5 定义和使用具有泛型的接口
3.5.1 格式：
修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
    	 //方法体;
    }

例如：
定义含有泛型的接口：

public interface GenericInterface<I> {
    public abstract void method(I i);
}

接口实现类一(定义类时确定泛型的类型)：
public class GenericInterfaceImpl1 implements GenericInterface<String>{
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

接口实现类二(不确定泛型的类型，直到创建对象时，确定泛型的类型)：
public class GenericInterfaceImpl2<I> implements GenericInterface<I> {
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}


测试类：
public class Demo04GenericInterface {
    public static void main(String[] args) {
        //创建GenericInterfaceImpl1对象
        GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
        gi1.method("字符串");

        //创建GenericInterfaceImpl2对象
        GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
        gi2.method(10);

        GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();
        gi3.method(8.8);
    }
}

3.6 泛型的通配符
当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

3.6.1 通配符基本使用
	  泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。（此时只能接受数据,不能往该集合中存储数据。

//？代表可以接收任意类型
public static void getElement(Collection<?> coll){}

注意：
①泛型不存在继承关系 Collection list = new ArrayList();这种写法是错误的。
②通配符不能创建对象使用，只能作为方法的参数使用。ArrayList<?> list03 = new ArrayList<?>();这种写法是错误的。

二，collections工具类

1、概述：
`java.utils.Collections`是集合工具类，用来对集合进行操作。
2、常用方法：
① `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 void reverse (List<?> list)`:将集合中元素反转。

public class Demo01 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        System.out.println(list);//[张三, 李四, 王五]
        //`public static <T> boolean addAll(Collection<T> c, T... elements) `:往集合中添加一些元素。
        Collections.addAll(list,"麦迪","科比","姚明");
        System.out.println(list);//[张三, 李四, 王五, 麦迪, 科比, 姚明]
        //`public static void shuffle(List<?> list) `:打乱集合顺序。
        Collections.shuffle(list);
        System.out.println(list);//[王五, 麦迪, 李四, 姚明, 张三, 科比]
        //`public static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序。
        List<Integer> list1 = new ArrayList<>();
        Collections.addAll(list1,1,2,3,7,5,6);
        System.out.println(list1);//[1, 2, 3, 7, 5, 6]
        Collections.sort(list1);
        System.out.println(list1);//[1, 2, 3, 5, 6, 7]
        //`public static void reverse (List<?> list)`:将集合中元素反转。
        Collections.reverse(list1);
        System.out.println(list1);//[7, 6, 5, 3, 2, 1]
    }
}

三，list接口

1、 List接口介绍
`java.util.List`接口继承自`Collection`接口，是单列集合的一个重要分支，习惯性地会将实现了`List`接口的对象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。

1.1 List接口特点：
① 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
② 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
③ 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

1.2 List接口中带索引的方法(特有)：
① public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
② public E get(int index):返回集合中指定位置的元素。
③ public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
④ public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值为更新前的元素。

注意：
① 操作索引的时候,一定要防止索引越界异常
② IndexOutOfBoundsException:索引越界异常,集合会报
③ ArrayIndexOutOfBoundsException:数组索引越界异常
④ StringIndexOutOfBoundsException:字符串索引越界异常

① public void addFirst(E e):将指定元素插入此列表的开头。
② public void addLast(E e):将指定元素添加到此列表的结尾。
③ public E getFirst():返回此列表的第一个元素。
④ public E getLast():返回此列表的最后一个元素。
⑤ public E removeFirst():移除并返回此列表的第一个元素。
⑥ public E removeLast():移除并返回此列表的最后一个元素。
⑦ public E pop():从此列表所表示的堆栈处弹出一个元素。
⑧ public void push(E e):将元素推入此列表所表示的堆栈。
⑨ public boolean isEmpty()：如果列表不包含元素，则返回true。