第九天-Java集合之一

1 对象数组

(1)数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。

2 集合(Collection)

(1)集合
    数组的长度固定，所以不适合做变化的需求 
(2)集合和数组的区别
    A:长度区别
        数组固定
        集合可变
    B:内容区别
        数组可以是基本类型，也可以是引用类型 
        集合只能是引用类型
    C:元素内容
        数组只能存储同一种类型
        集合可以存储不同类型(其实集合一般存储的也是同一种类型)
(3)集合的继承体系结构

    Collection
        |--List
            |--ArrayList
            |--Vector
            |--LinkedList
        |--Set
            |--HashSet
            |--TreeSet
(4)Collection的方法
    A:添加: boolean add(E e)
            boolean addAll(Collection<? extends E> c) 
    B:删除:  boolean remove(Object o) 移除一个元素
            boolean removeAll(Collection<?> c) 移除集合中相同的元素
            void clear() 移除所有的元素
    C:判断: boolean isEmpty() 判断集合是否为空
            boolean contains(Object o)  判断集合中是否包含指定的元素
            boolean containsAll(Collection<?> c) 判断集合中是否包含指定的集合元素
    D:获取: Iterator<E> iterator()  
    E:长度: int size() 返回此 collection 中的元素数。
    F:交集: boolean retainAll(Collection<?> c)  两个集合都有的元素
        注意：如果此 collection 由于调用而发生更改，则返回 true
    G:把集合转数组:Object[] toArray()  

(5)Collection集合的遍历
    A:把集合转数组 
        import java.util.ArrayList;
        import java.util.Collection;
        import java.util.List;
        public class TestCollection {
            public static void main(String[] args) {
                Collection collection1 = new ArrayList<String>();
                collection1.add("s1");
                collection1.add("s2");
                collection1.add("s3");
                collection1.add("s4");

                Object[] objs = collection1.toArray();
                for(int index = 0;index<objs.length;index++){
                    System.out.println(objs[index]);
                }
            }
        }
    B:迭代器 
        import java.util.ArrayList;
        import java.util.Collection;
        import java.util.Iterator;
        import java.util.List;
        import java.util.TreeSet;
        public class TestCollection {
            public static void main(String[] args) {

                Collection collection1 = new ArrayList<String>();
                collection1.add("s1");
                collection1.add("s2");
                collection1.add("s3");
                collection1.add("s4");

                Iterator iterator = collection1.iterator();
                while(iterator.hasNext()){
                    Object obj = iterator.next();
                    System.out.println(obj);
                }

            }
        }

(6)迭代器
    A:是集合的获取元素的方式。
    B:是依赖于集合而存在的。
    C:迭代器的原理和源码。
        a:为什么定义为了一个接口而不是实现类?
            Java中提供了很多集合类，而这些集合类的数据结构是不同的，所以，存储的方式和遍历的方式应该是不同的，进而它们的遍历方式也应该不是一样的。 

问题：迭代器并发修改异常
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * 解决：
 * 1： 迭代器遍历元素并且修改元素
 * 2： 集合遍历元素，集合修改元素（普通for）
 * @author Administrator
 *
 */
public class TestList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Hello");
        list.add("world");
        list.add("moto");

        /*Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            String str = iterator.next();
            if("Hello".equals(str)){
                list.add("haha");//抛出ConcurrentModificationException
            }
        }*/
        // 方式一解决 通过迭代器来进行添加：
        ListIterator<String> listIterator = list.listIterator();
        while(listIterator.hasNext()){
            String str = listIterator.next();
            if("Hello".equals(str)){
                listIterator.add("haha"); 
            }
        }
        System.out.println(list);//[Hello, haha, world, moto]
        // 方式二解决：
         for (int i = 0; i < list.size(); i++) {
             if("Hello".equals(list.get(i))){
                 list.add("mola");
             }
        }

        System.out.println(list);//[Hello, haha, world, moto, mola]
    }
}

注意：
1 数组的长度方法是length属性，String的长度方法是length()方法，集合的长度方法是size()方法
2 交集中的返回值是什么？返回值代表调用该方法的集合是否发生改变，true为改变，false为未改变

3 集合(List)

(1)List是Collection的子接口
    特点：有序(存储顺序和取出顺序一致)，可重复。
(2)List方法： 
    A:添加：  boolean add(E e) 
             void add(int index, E element) 
    B:删除：  E remove(int index) 根据索引删除元素，返回被删除的元素
    C:获取：  E get(int index)  
    D:迭代器： Iterator<E> iterator()  
              ListIterator<E> listIterator()  
    E:修改：  E set(int index, E element)  

(4)列表迭代器的特有功能 
    可以逆向遍历，但是要先正向遍历 
(5)并发修改异常
    A:出现的现象
        迭代器遍历集合，集合修改集合元素
    B:原因
        迭代器是依赖于集合的，而集合的改变迭代器并不知道。
    C:解决方案
        a:迭代器遍历，迭代器修改(ListIterator)
            元素添加在刚才迭代的位置
        b:集合遍历，集合修改(size()和get())
            元素添加在集合的末尾

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

4 List的子类

(1)Vector
    A:方法
        a:添加
            public void addElement(E obj)       --  add()
        b:获取
            public E elementAt(int index)       --  get()
            public Enumeration<E> elements()    --  iterator()

(2)LinkedList
    A:方法
        a:添加
            void addFirst(E e)  将指定元素插入此列表的开头
            void addLast(E e)   将指定元素添加到此列表的结尾。
        b:删除
            E removeFirst()    移除并返回此列表的第一个元素。
            E removeLast()     移除并返回此列表的最后一个元素。
        c:获取
            E getFirst()  返回此列表的第一个元素。
            E getLast()   返回此列表的最后一个元素。

5 泛型

(1)泛型概述
    是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
(2)格式：
    <数据类型>
    注意：该数据类型只能是引用类型。
(3)好处：
    A:把运行时期的问题提前到了编译期间
    B:避免了强制类型转换
    C:优化了程序设计，解决了黄色警告线问题，让程序更安全
(4)泛型的
    A:泛型的由来
        Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题
    B:泛型类
    C:泛型方法
    D:泛型接口
    E:泛型高级通配符
        ?
        ? extends E
        ? super E

6 增强for循环

(1)是for循环的一种
(2)格式：
    for(元素的数据类型 变量名 : 数组或者Collection集合的对象) {
        使用该变量即可，该变量其实就是数组或者集合中的元素。
    }
(3)好处：
    简化了数组和集合的遍历
(4)弊端
    增强for循环的目标不能为null。建议在使用前，先判断是否为null。

7 可变参数

(1)写方法的时候，参数个数不明确，可以定义为可变参数。
(2)格式：
    修饰符 返回值类型 方法名(数据类型... 变量) {}
    注意：
        A:该变量其实是一个数组名
        B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后

(3)Arrays工具类的一个方法
    asList()把数组转成集合。
    注意：这个集合的长度不能改变。