Java基础-集合Collection&List接口

集合的由来和特点
由来：由于我们使用的是面向对象语言，所以，我们要经常使用对象。而很多时候，我们可能需要使用很的对象，
这个时候，我们就只能使用以前讲过的数组进行存储了，而数组的特点是长度固定。
这样的话就不适合变化的数据。所以，java重新提供了一种容器，用于存储对象，这种容器叫集合。
特点：
A：集合的长度可变
B：集合只可以存储引用类型（对象）

集合和数组的区别
数组：
A：数组的长度固定
B：数组可以存储基本数据类型，也可以存储引用数据类型
C：同一个数组里面，只能存储同一种数据类型的元素
集合：
A：集合的长度可变
B：集合只可以存储引用数据类型
C：同一个集合里面，可以存储多种不同数据类型的元素

数组的代码

        /*         * 数组:         *  在定义数组的时候,需要指定一种数据类型,如int[] 代表装int类型数据的数组         *  并且,要在定义数组的时候,指定数组的长度         */        int[] arr = new int[5];        String[] str = new String[5];

集合的代码：

        /*         * 集合:           *  在定义集合的时候,需要指定一种集合的实现子类,如ArrayList/LinkedList等         */        Collection c = new ArrayList();

集合体系的结构图：

结合体系的学习方法：    学顶层，用底层    顶层：Collection            |--List                |--ArrayList                |--Vector                |--LinkedList            |--Set                |--HashSet                |--TreeSetList和Set的区别：    List：元素有序（指的是元素的存入顺序与取出顺序是一致的），元素可以重复    Set：元素无序（指的是每次取出元素的顺序有可能不一样），元素不可以重复，是唯一的ArrayList、Vector和LinkedList的区别：    ArrayList：底层是数组结构，线程不同步（线程不安全），查询快，增删速度慢。现在代替了Vector    Vector：底层是数组结构，线程同步（线程安全），增删查速度都很慢。被ArrayList替代了。    LinkedList：底层是链表结构，线程不同步（线程不安全），查询慢，增删速度快。HashSet和TreeSet的区别：    HashSet：底层数据结构是哈希表，线程不同步（线程不安全）。特点：无序，高效    TreeSet：底层数据结构是二叉树，线程不同步（线程不安全）。特点：对集合Set中的元素进行指定顺序的排序。

Collection接口中的功能：
Ps.由于Collection是一个接口，其中的方法都是抽象的，所以Collection接口中的功能，都必须要被其实现子类重写后才有意义，所以，在定义Collection集合时，一般都是直接用其实现子类ArrayList或者LinkedList来定义，也可以使用多态来定义，如：Collection c = new ArrayList（） ； 父类引用指向子类对象。

A：添加元素功能    boolean add（Object obj）：向集合中添加元素，添加成功返回true，否则返回false    boolean addAll（Collection c）：向集合中添加一个集合的元素，成功返回trueB：删除元素功能    void clear（）：清空集合    boolean remove（Object obj）：删除集合中指定的元素    boolean removeAll（Collection c）：从一个集合中删除一个指定集合的元素C：判断功能：    boolean isEmpty（）：判断集合是否为空    boolean contains（Object obj）：判断集合中是否包含指定的元素    boolean containsAll（Collection c)：判断集合中是否包含一个指定的集合D：遍历功能    Iterator iterator（）：获取集合中的每个元素（别名迭代器)        获取某一个集合的迭代器：            Collection c = new ArrayList（）；            Iterator it = c.iterator();//相当于获取到了结合c的迭代器，用于迭代集合c中的每一个元素E：长度功能    int size（）；获取集合的长度F：交集功能    boolean retainAll（Collection c）：判断该集合与指定集合中元素的交集。两个集合共有的元素，会被赋值到该集合中，                                      致使原集合发生改变，如果原集合发生改变，则会返回true    基本功能代码：

public class CollectionDemo {    public static void main(String[] args) {        // 创建对象        // Collection c = new Collection();//接口不能被实例化        Collection c = new ArrayList();        // 添加元素        // boolean add(Object obj):一个是添加，一个是返回添加是否成功。        // System.out.println(c.add("hello"));        // c.add("world");        c.add("hello");        c.add("world");        c.add("java");        // 删除功能        // void clear()：删除集合中的所有元素。        // c.clear();        // boolean remove(Object obj)        // System.out.println("remove:"+c.remove("world"));        // System.out.println("remove:"+c.remove("wor"));        // 判断功能        // boolean isEmpty()        // System.out.println("isEmpty:"+c.isEmpty());        // boolean contains(Object obj)        System.out.println("contains:" + c.contains(c));//      System.out.println("contains:" + c.contains("wor"));        // 长度功能        // int size()        System.out.println("size:" + c.size());        System.out.println("c:" + c);    }}

所有带all的功能的代码如下：

import java.util.ArrayList;import java.util.Collection;/* * 所有带All的方法：(听完就忘) * boolean addAll(Collection c)：向集合中添加一个集合的元素。 * boolean removeAll(Collection c):从集合中删除一个指定的集合元素。  * boolean containsAll(Collection c)：判断集合中是否存在指定的一个集合中的元素。 * boolean retainAll(Collection c):判断两个集合中是否有相同的元素。??? */public class CollectionDemo3 {    public static void main(String[] args) {        // 创建一个集合        Collection c1 = new ArrayList();        c1.add("abc1");        c1.add("abc2");        c1.add("abc3");        c1.add("abc4");        // 再创建一个集合        Collection c2 = new ArrayList();        c2.add("abc1");        c2.add("abc2");        c2.add("abc3");        c2.add("abc4");        c2.add("abc5");        c2.add("abc6");        c2.add("abc7");        // boolean addAll(Collection c)：向集合中添加一个集合的元素。        // System.out.println("addAll:" + c1.addAll(c2));        // boolean removeAll(Collection c):从集合中删除一个指定的集合元素。        // 只要有数据被删除，则返回true。        // System.out.println("removeAll:" + c1.removeAll(c2));        // boolean containsAll(Collection c)：判断集合中是否存在指定的一个集合中的元素。        // 只有所有数据包含了，才返回true        // System.out.println("containsAll:" + c1.containsAll(c2));        // boolean retainAll(Collection c)        /*         * 如果有两个集合A和B。         * A对B做交集。         * A集合保存的是交集元素。B集合不发生改变。         * 返回值表示的是A集合是否发生过改变。         */        System.out.println("retainAll:" + c1.retainAll(c2));        System.out.println("c1:" + c1);        System.out.println("c2:" + c2);    }}

练习题：
遍历一个集合，判断集合中是否包含一个指定的元素。如“hello”

import java.util.ArrayList;import java.util.Collection;/* * 请遍历集合。也就是说要获取到集合中的每一个元素。 * 判断集合中是否存在"hello"这个元素. *  * 注意： *      在往集合中添加元素的时候，集合默认接收的是Object类型。 *      也就是说你开始存储字符串的时候，其实做了一个向上转型的操作。 *  *      在获取元素的时候，默认还是以Object类型的返回。 *      但是，你明明知道这应该是String类型。 *      所以，如果你想使用String类型的特殊功能，就必须做向下转型。 *      如果仅仅是为了看结果，就不用。因为通过多态的形式，最终输出语句调用的是String类的toString() */public class CollectionDemo2 {    public static void main(String[] args) {        Collection c = new ArrayList();        c.add("hello"); // String -- Object        c.add("world");        c.add("java");        // c.add(new Student())        // 直接使用判断功能        // System.out.println("contains:"+c.contains("hello"));        // System.out.println("c:" + c);        // 遍历集合，获取到每一个元素，然后判断这个元素是否是hello        // Object[] toArray():把集合变成数组。        Object[] objs = c.toArray();        for (int x = 0; x < objs.length; x++) {            // System.out.println(objs[x]);            // Object obj = objs[x];            // System.out.println(obj);            String s = (String) objs[x];            System.out.println(s + "***" + s.length());        }    }}

集合的遍历：
代码

import java.util.ArrayList;import java.util.Iterator;/* * ArrayList类型集合的两种遍历方式 */public class Test2 {    public static void main(String[] args) {        // 创建对象        ArrayList aList = new ArrayList();        // 想对象中添加元素        aList.add("hello");        aList.add("world");        aList.add("java");        // 迭代集合        // 方式一:        // 获取集合的迭代器        Iterator it = aList.iterator();        // 遍历集合        while (it.hasNext()) {            System.out.println(it.next());        }        // 方式二:        // 由于ArrayList中有一个特有的功能,get(int index),可以获取指定索引位置上的值        // 那么可以用for循环,size()方法和get(int index)方法来遍历        for (int x = 0; x < aList.size(); x++) {            System.out.println("get:" + aList.get(x));        }    }}

Iterator迭代器的使用
注意:在使用Iterator过程可能出现如下异常: NoSuchElementException(没有这个元素异常)
当已经获取到最后一个元素时,还继续往后获取,就出现了NoSuchElementException.
在迭代器中,通过方法 boolean hasNext(),可以判断集合中还有没有下一个元素,可以避免出现NoSuchElementException
一般情况下,hasNext()方法用在if或者while的判断语句位置处.

集合的使用步骤
A:创建集合对象
B:创建元素对象
C:向对象中添加元素
D:遍历集合
a:通过集合对象获得迭代器对象iterator();
b:通过hasNext()方法,判断指针是否还有下一个元素
c:通过next()方法,获取指针后的一个元素

List接口的概述和特有功能
概述:List接口是实现了Collection接口的一个接口.
特有功能:
A:添加功能:void add(int index,Object obj): 在集合的指定位置添加一个指定的元素
B:删除功能:Object remove(int index): 删除集合中指定索引位置上的元素,并且返回被删除的元素
C:修改功能:Object set(int index, Object obj):用指定的元素替换指定索引位置上的元素,并且返回被替换的元素
D:获取功能:Object get(int index):获取集合中指定索引位置上的元素
int indexOf(Object obj):获取指定元素在集合中第一次出现的索引

ListIterator<E> listIterator(): 列表迭代器E:截取功能:List subList(int frmoIndex,int toIndex):从指定位置到指定结束位置截取集合,返回截取出来的一个新的集合

代码:

import java.util.ArrayList;import java.util.List;/* * List的特有功能： * A:添加功能 *      void add(int index, Object obj):在指定位置添加元素 * B:删除功能 *      Object remove(int index):根据指定索引删除元素，并把删除的元素返回。 * C:修改功能 *      Object set(int index, Object obj):把指定索引位置的元素修改为指定的值，返回修改前的值。 * D:获取功能 *      int indexOf(Object o):返回指定元素在集合中第一次出现的索引 *      Object get(int index):获取指定位置的元素 *      ListIterator listIterator()：列表迭代器 * E:截取功能 *      List subList(int fromIndex, int toIndex)：截取集合。 */public class ListDemo2 {    public static void main(String[] args) {        // 创建集合对象        List list = new ArrayList();        // 添加元素        list.add("hello");        list.add("world");        list.add("java");        // void add(int index, Object obj):在指定位置添加元素        // list.add(1,"javaEE");        // IndexOutOfBoundsException        // list.add(14,"javaSE");        // Object remove(int index):根据指定索引删除元素，并把删除的元素返回。        // System.out.println("remove:"+list.remove(1));        // System.out.println("remove:"+list.remove(12));        // Object set(int index, Object obj):把指定索引位置的元素修改为指定的值，返回修改前的值。        // System.out.println("set:" + list.set(1, "javaee"));        //List subList(int fromIndex, int toIndex)：截取集合。        // List list2 = list.subList(1, 2);        // System.out.println("list2:"+list2);        //int indexOf(Object o):返回指定元素在集合中第一次出现的索引        System.out.println("indexOf:"+list.indexOf("world"));        System.out.println("indexOf:"+list.indexOf("world2"));        System.out.println("list:" + list);    }}集合中的并发修改异常的产生原因及解决方案    产生原因:就是在使用迭代器对集合进行遍历的过程中,使用集合操作了集合.    解决方案:        A:全部通过迭代器操作：元素是添加到刚遍历的那个元素后面。          通过迭代器迭代的时候，可以通过迭代器对集合进行操作。        B:全部通过集合操作：元素是添加到最后的。          通过集合普通for遍历的时候，可以通过集合去操作。代码如下:

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

/*
* ListIterator listIterator()：列表迭代器
*
* public interface ListIterator extends Iterator
*
* 面试题：ConcurrentModificationException:并发修改异常。
* 这是个什么异常，怎么产生的，怎么解决的?
*
* 怎么产生：
* 当我们通过迭代器迭代元素的过程中，又通过集合去添加了元素。这种情况是不允许的。
* 因为迭代器是依赖于集合存在的，如果集合发生改变，迭代器也应该相应的发生改变。
* 而我们目前看到的确实，迭代器没变，集合变了。所以，报出了一个并发修改异常。
*
* 注意问题：通过迭代器遍历集合的时候，是不能通过集合去操作(添加，删除)。
* 那么，我们可不可以这样解决呢？
* A:全部通过迭代器操作：元素是添加到刚遍历的那个元素后面。
* 通过迭代器迭代的时候，可以通过迭代器对集合进行操作。
* B:全部通过集合操作：元素是添加到最后的。
* 通过集合普通for遍历的时候，可以通过集合去操作。
*/
public class ListDemo4 {
public static void main(String[] args) {
// 创建集合对象
List list = new ArrayList();

    // 添加元素    list.add("hello");    list.add("world");    list.add("java");    // 迭代器    // Iterator it = list.iterator();    // while (it.hasNext()) {    // String s = (String) it.next();    // System.out.println(s);    // }    // System.out.println("-----------");    // 需求：请遍历集合，判断其中是否有"hello"这个元素，如果有，就再添加一个元素:"IOS"    // Iterator it = list.iterator();    // while (it.hasNext()) {    // String s = (String) it.next();    // if ("hello".equals(s)) {    // list.add("IOS");    // // it = list.iterator();//这样从原理是可以解决的，但是它会引起另外一个问题。    // }    // }    // System.out.println("list:" + list);    // System.out.println("-----------");    // 完全通过集合实现    // for (int x = 0; x < list.size(); x++) {    // String s = (String) list.get(x);    // if ("hello".equals(s)) {    // list.add("IOS");    // }    // }    // System.out.println("list:"+list);    // System.out.println("-----------");    // 遍历    ListIterator lit = list.listIterator();    while (lit.hasNext()) {        String s = (String) lit.next();        if ("hello".equals(s)) {            lit.add("IOS");        }    }    System.out.println("list:" + list);}

}