集合（一）:接口Collection(集合遍历); 接口List；ArrayList；Vector；LinkedList

集合（一）

一、集合概述

1、集合概述

A:集合的由来
    面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。
B:数组和集合的区别
	(1): 长度区别:
     数组的长度是固定的而集合的长度是可变的
	(2): 存储数据类型的区别:
     数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
	(3): 内容区别:
     数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素

2、常用集合继承体系图

二、接口Collection

1、Collection常用功能

Collection的功能概述(通过API查看即可得到)
	a:添加功能
		boolean add(Object obj):在集合末尾添加一个元素
		boolean addAll(Collection c):在集合末尾添加进另一个集合中的所有元素
	b:删除功能
		void clear():移除集合所有元素
		boolean remove(Object o):移除指定元素
		boolean removeAll(Collection c):移除该集合与指定集合的交集元素，有交集元素，返回true，如果没有交集元素，则移除失败，返回false.
		boolean retainAll(Collection c):移除该集合与指定集合的非交集元素
	c:判断功能
		boolean contains(Object o)：判断集合中是否包含指定的元素	
		boolean containsAll(Collection c)：判断该集合是否包含另一个集合(所有元素)
		boolean isEmpty()：判断集合是否为空
	d:获取功能
		Iterator<E> iterator():获取迭代器
		int size():获取集合中元素的个数
	e:把集合转换为数组
		Object[] toArray()

2、Collection常用功能测试

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

public class Blog {
    public static void main(String[] args) {
        Collection coll = new ArrayList();//Collection是接口，使用它的子类创建对象
        Collection coll1 = new ArrayList();
        /*-----添加功能-----*/
        coll.add(11);    //添加Integer类型数据
        coll.add(22);
        coll.add(11);
        coll.add(22);
        coll.add(33);
        coll.add(44);
        System.out.println(coll);//[11,22,11,22,33,44]
        coll1.addAll(coll);//将coll集合所有元素添加到coll1集合中
        System.out.println(coll1);//[11,22,11,22,33,44]

        /*-----删除功能-----*/
        coll1.clear();//移除coll1集合中所有元素
        coll.remove(11);//移除coll集合中的第一个 11
        System.out.println(coll);//[22, 11, 22, 33, 44]
        coll1.add(11);    //添加Integer类型数据
        coll1.add(22);
        coll.removeAll(coll1);
        System.out.println(coll);//[33, 44]
        /*-----判断功能-----*/
        boolean contains = coll.contains(11);
        System.out.println(contains);//false
        boolean b = coll.containsAll(coll1);
        System.out.println(b);//false
        boolean empty = coll.isEmpty();
        System.out.println(empty);//false
        /*-----获取功能-----*/
        Iterator iterator = coll.iterator();//获取迭代器
        int size = coll.size();
        System.out.println(size);//获取长度  2
        /*-----把集合转为数组-----*/
        Object[] objects = coll.toArray();//将集合转为数组
        System.out.println(Arrays.toString(objects));//打印数组
    }
}

3、Collection集合遍历

A：把集合转为数组遍历

public static void listTraversing(Collection coll) {
    	if(coll==null){
            System.out.println("null");
            return;
        }
        Object[] obj = coll.toArray();
        for (int i = 0; i < obj.length; i++) {
            System.out.println(obj[i]);
        }
    }

B:使用迭代器遍历

private static void iteratorTraversing(Collection coll) {
        if(coll==null){
            System.out.println("null");
            return;
        }
        //boolean hasNext():判断是否还有元素可以迭代
        //E next()  ：返回迭代的下一个元素
        Iterator iterator = coll.iterator();//获取迭代器
        while(iterator.hasNext()){
            Object o = iterator.next();
            System.out.println(o);
        }
    }

C：增强for循环遍历

//增强for循环格式：for(容器中的元素是什么类型 当前遍历的元素名:容器名){}
//bug:采用新式for循环遍历容器元素的过程中，若修改容器中的元素则会出现 并发修改异常(ConcurrentModificationException:)，若要在遍历过程中操作元素，则需要使用普通for循环
    private static void increaseForTraversing(Collection coll) {
        for (Object o : coll) {
            System.out.println(o);
        }
    }

三、接口List

1、List特点

      元素有序，每个元素都有一个索引，且可有重复元素。

2、List特有功能

void add(int index,E element):	在指定索引处添加元素
E remove(int index):移除指定索引处的元素,返回的是移除的元素
E get(int index):获取指定索引处的元素
E set(int index,E element):更改指定索引处的元素 返回的而是被替换的元素

3、List特有功能测试

import java.util.ArrayList;
import java.util.List;

public class Blog2 {
    public static void main(String[] args) {
        List<String> strList = new ArrayList<>();
        strList.add("aaa");
        strList.add("bbb");
        strList.add("ccc");
        strList.add(1,"ddd");//在1索引位置插入"ddd"
        System.out.println(strList);
        strList.remove(1);//移除1索引位置元素
        System.out.println(strList);
        String str=strList.get(1);//获取1索引位置元素
        System.out.println(str);
        strList.set(1,"你好");//设置1索引位置元素
        System.out.println(strList);
    }
}
运行结果：
[aaa, ddd, bbb, ccc]
[aaa, bbb, ccc]
bbb
[aaa, 你好, ccc]

4、List新增遍历方式

A：通过get()和size()方法遍历

private static void methodTraversal(List list) {
        if(list==null){
            System.out.println("null");
            return;
        }
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            System.out.println(o);
        }
    }

B:使用List特有迭代器遍历

private static void listIteratorTraversal(List list) {
        if(list==null){
            System.out.println("null");
            return;
        }
        ListIterator listIterator = list.listIterator();//获取ListIterator迭代器
        while (listIterator.hasNext()){
            Object o = listIterator.next();
            System.out.println(o);
        }
        System.out.println("--------------------");
        //ListIterator迭代器,新增反向迭代功能(其他方法可查API获取)
        //反向迭代前必须先正向迭代，让指针先指向最后一个元素，才能迭代出前面的元素
        while (listIterator.hasPrevious()){
            Object o1 = listIterator.previous();
            System.out.println(o1);
        }
    }

5、并发修改异常产生原因及解决方案

    产生原因：在迭代器或者增强for循环遍历集合过程中，由于迭代器或者增强for循环已经提前获取集合的长度，这时再在集合遍历过程中添删元素，会改变集合的长度，导致集合实际长度与迭代器或增强for循环获取的长度不一致，所以会产生并发修改异常。
    解决方案：1、使用ListIterator迭代器自身的add()方法添加元素；
             2、使用普通for循环遍历添加元素

6、Arrays工具类的asList()方法的使用

//public static <T> List<T> asList(T... a): 将数组转为集合
int[] arr={1,2,3};
List<int[]> ints=Arrays.asList(arr);//数组转集合

//使用asList()方法往集合存参数
List<Integer> list=Arrays.asList(1，2，3，4，5);
Integer[] arr1={1,2,3};
Integer[] arr2={4,5,6};
List<Integer> integerList = Arrays.asList(arr1);
List<Integer[]> asList = Arrays.asList(arr1, arr2);
//注意：
//1、通过Arrays.asList()转换过来的的集合，不能再添加或删除元素
//2、如果传的参数基本类型的数组，那么他会把数组装到集合里，如果传的参数是一个引用类型数组，那他会把元素取出来存到集合中，如果传的参数是两个及以上的引用数据类型的数组，那么他会把数组存到集合中。

四、List的三个子类

1、List的三个子类的特点

List的三个子类的特点：
    ArrayList:
         底层数据结构是数组，查询快，增删慢。
         线程不安全，效率高。
    Vector:
         底层数据结构是数组，查询快，增删慢。
         线程安全，效率低。
    LinkedList:
         底层数据结构是链表，查询慢，增删快。
         线程不安全，效率高。

2、Vector常用特有功能

	//public void addElement(E obj)
	//public E elementAt(int index)
	//public Enumeration elements()
/*-----测试-----*/
import java.util.Enumeration;
import java.util.Vector;

public class Blog4 {
    public static void main(String[] args) {
        Vector<String> vector = new Vector();
        vector.addElement("q");//在集合末尾处添加元素
        vector.addElement("w");
        System.out.println(vector);	//[q, w]
        String str=vector.elementAt(0);//返回指定索引处的元素
        System.out.println(str);	//q
        Enumeration elements = vector.elements();//返回Vector的枚举
        //boolean hasMoreElements(): 判断此枚举是否包含更多的元素
        //E nextElement():  如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素
        elementsTraversing(vector,elements);
    }

    //遍历集合
    private static void elementsTraversing(Vector vector, Enumeration elements) {
        while (elements.hasMoreElements()){
            Object o = elements.nextElement();
            System.out.println(o);
        }
    }
}

3、LinkedList常用特有功能

	public void addFirst(E e)及 addLast(E e)
	public E getFirst()及 getLast()
	public E removeFirst()及 public E removeLast()

3.1、LinkedList常用特有功能测试：

import java.util.LinkedList;

public class Blog5 {
    public static void main(String[] args) {
        LinkedList<Integer> linkedList = new LinkedList<>();
        linkedList.add(11);
        linkedList.add(22);
        linkedList.addFirst(33);//在集合开头添加元素
        System.out.println(linkedList);//[33, 11, 22]
        linkedList.addLast(44);//在集合末尾添加元素
        System.out.println(linkedList);//[33, 11, 22, 44]
        Integer first = linkedList.getFirst();//获取开头元素
        System.out.println(first);//33
        Integer last = linkedList.getLast();//获取末尾元素
        System.out.println(last);//44
        Integer removeFirst = linkedList.removeFirst();//移除并返回集合的第一个元素
        System.out.println(removeFirst);//33
        System.out.println(linkedList);//[11, 22, 44]
        Integer removeLast = linkedList.removeLast();//移除并返回集合的最后一个元素
        System.out.println(removeLast);//44
        System.out.println(linkedList);//[11, 22]
    }
}

3.2、使用LinkedList模拟栈数据结构的集合

import java.util.LinkedList;

public class Blog6 {
    public static void main(String[] args) {
        //栈的数据结构，先进后出
        MyList myList = new MyList();
        //存元素
        myList.addEle("aaa");
        myList.addEle("bbb");
        myList.addEle("ccc");
        //取元素
        for (int i = 0; i < 3; i++) {
            Object ele = myList.getEle();
            System.out.println(ele);
        }
    }
}
class MyList {
    LinkedList linkedList=null;
    public MyList() {
        linkedList = new LinkedList();
    }

    //添加元素
    public void addEle(String ele) {
        linkedList.addFirst(ele);
    }

    public Object getEle() {
        //获取第一个元素并删除，这样第二次才能取到第二个元素
        Object obj = linkedList.removeFirst();
        //取的元素再加回去
        linkedList.addLast(obj);
        return obj;
    }
}
运行结果：
ccc
bbb
aaa

3.3、集合嵌套

//集合嵌套：就是将一个或多个集合存到另一个集合中，类似于二维数组
//示例：
import java.util.ArrayList;

public class Blog7 {
    public static void main(String[] args) {
        ArrayList<String> integerType = new ArrayList<>();
        integerType.add("byte");
        integerType.add("short");
        integerType.add("int");
        integerType.add("long");
        ArrayList<String> decimalType = new ArrayList<>();
        decimalType.add("float");
        decimalType.add("double");
        ArrayList<String> characterType = new ArrayList<>();
        characterType.add("char");
        ArrayList<String> booleanType = new ArrayList<>();
        booleanType.add("boolean");
        ArrayList<ArrayList<String>> basicDataType = new ArrayList<>();
        //将4类数据类型集合添加到基本数据类型集合，即实现集合的嵌套
        basicDataType.add(integerType);
        basicDataType.add(decimalType);
        basicDataType.add(characterType);
        basicDataType.add(booleanType);
    }
}