数组和集合的区别

	(1): 长度区别:
		数组的长度是固定的而集合的长度是可变的
	(2): 存储数据类型的区别:
		数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
	(3): 内容区别:
		数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素

在最顶层的父接口Collection中一定定义了所有子类集合的共同属性和方法,因此我们首先需要学习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
	c:判断功能
		boolean contains(Object o)：判断集合中是否包含指定的元素	
		boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
		比如：1，2，3 containsAll 12=true   1,2,3 containsAll 2,3,4=false
		boolean isEmpty()：判断集合是否为空
	d:获取功能
		Iterator<E> iterator()(重点)
	e:长度功能
		int size():元素的个数
		面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
	f:交集功能
		//例如：A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化 
		boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集合都有的元素)
	g:把集合转换为数组
		Object[] toArray()

//创建集合对象
        Collection c=new ArrayList();//父类指向子类对象
        //boolean add(E e)
        boolean b=c.add("hello");
        System.out.println(b);
        boolean b1=c.add("hello");
        System.out.println(b1);//可以添加成功，Arraylist允许重复
        System.out.println(c.add("world"));
        System.out.println(c.add("java"));
        //void clear();//清空
        System.out.println(c);
       // c.clear();
        //System.out.println(c);

        boolean b2=c.remove("java");
        System.out.println(b2);//只有有才能删除成功
        //int size():一般用于遍历，返回集合中元素的个数
        System.out.println(c.size());

        //Object[]toArray():将集合转换成一个object类型的数组
        //数组用length 集合用size（）
        Object[] obj = c.toArray();
        //遍历输出
        for (int i = 0; i < obj.length; i++) {
            System.out.println(obj[i]);
        }
        System.out.println(c);

/*boolean addAll(Collection c)
        boolean removeAll(Collection c)
        boolean containsAll(Collection c)
        boolean retainAll(Collection c)*/
        Collection c1=new ArrayList();
        Collection c2=new ArrayList();
        c1.add("aaa");
        c1.add("bbb");
        c1.add("ccc");
        c1.add("aaa1");
        c2.add("aaa1");
        c2.add("bbb1");
        c2.add("ccc1");
//添加另一个集合的所有元素
//        boolean b1=(c2.addAll(c1));
//        System.out.println(b1);
//        System.out.println(c1);
//        System.out.println(c2);
        //删除另一个集合的所有交集元素
       /* boolean b2=c2.removeAll(c1);
        System.out.println(b2);
        System.out.println(c1);
        System.out.println(c2);*/

        //看是否集合2包含了集合1
      //  boolean b3=c2.containsAll(c1);
        //System.out.println(b3);

       // 1集合对2集合取交集，获取到的交集元素在1集合中。返回的布尔值表示的是1集合是否发生变化
        boolean b4=((ArrayList) c1).retainAll(c2);
        System.out.println(b4);//发生了变化则为true
        System.out.println(c1);//放置交集元素
        System.out.println(c2);

迭代器：

Collection集合元素的通用获取方式：在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
集合中把这种取元素的方式描述在Iterator接口中。Iterator接口的常用方法如下
hasNext（）方法：判断集合中是否有元素可以迭代 next（）方法：用来返回迭代的下一个元素，并把指针向后移动一位。

```java
/*
 * 集合的遍历方式：
 * 		1.toArray(),可以把集合转换成数组，然后遍历数组即可
 * 		2.iterator(),可以返回一个迭代器对象，我们可以通过迭代器对象来迭代集合
 *
 * Iterator：可以用于遍历集合
 * 	E next()  :返回下一个元素
 *  boolean hasNext()  ：判断是否有元素可以获取*/
//集合只能存储引用类型
        Collection c=new ArrayList();
        c.add(100);//自动装箱
        c.add(200);
        c.add(300);
        c.add(400);
        //用迭代器进行遍历
        //获取迭代器对象
        Iterator iterator = c.iterator();
        //System.out.println(iterator);//是一个对象，打印的是地址值
        //Iterator 接口 迭代器
        //boolean hasNext() 判断是否有元素
        //E next()  换回迭代器的下一个对象  iterator.next();
        while(iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }

List 功能概述：

A:List集合的特有功能概述
		void add(int index,E element):	在指定索引处添加元素
		E remove(int index):移除指定索引处的元素  返回的是移除的元素
		E get(int index):获取指定索引处的元素
		E set(int index,E element):更改指定索引处的元素 返回的而是被替换的元素
		

//List 接口中特有的方法

	/*  void add ( int index, E element)
	  在列表的指定位置插入指定元素（可选操作）。*/

	/*  E get ( int index)
	  返回列表中指定位置的元素。*/

	/*  int indexOf (Object o)
	  返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 - 1。*/

	 /* ListIterator<E> listIterator ()
	  返回此列表元素的列表迭代器（按适当顺序）。*/

	 /* List<E> subList ( int fromIndex, int toIndex)
	  返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。*/
        List list = new ArrayList();
        list.add(200);
        list.add(300);
        list.add(300);
        list.add(300);
        list.add(300);
        list.add(400);
        list.add(500);
        //根据指定的索引，来添加元素
        list.add(0, 100);
        System.out.println(list);

        //根据索引获取集合中的元素
        Object o = list.get(list.size() - 1);
        System.out.println(o);

        int i = list.indexOf(300);
        System.out.println(i);
        int i1 = list.lastIndexOf(300);
        System.out.println(i1);

        //根据起始索引和终止索引，截取一段元素，放到新集合中
        List list1 = list.subList(2, 6);
        System.out.println(list1);

        System.out.println(list);
        // E set()  修改指定索引处的元素
        list.set(2,3333);
        System.out.println(list);

ListIterator的特有功能

	boolean hasPrevious():			是否存在前一个元素
	E previous():					返回列表中的前一个元素
	以上两个方法可以实现反向遍历 但是注意 要完成反向遍历之前 要先进行正向遍历  这样指针才能移到最后
	如果直接反向遍历是没有效果的  因为指针默认位置就在最前面 他前面没有元素

/*ListIterator 中的两个特有方法
 *boolean hasPrevious ()
 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
 E previous ()
 返回列表中的前一个元素。
 //要进行反向迭代之前，要先进行正向迭代

 */
        List list=new ArrayList();
        list.add(200);
        list.add(300);
        list.add(300);
        list.add(300);
        list.add(300);
        list.add(400);
        list.add(500);
        ListIterator listIterator = list.listIterator();
        //正向迭代
        while (listIterator.hasNext()) {
            Object next = listIterator.next();
            System.out.println(next);
        }
        System.out.println("-----------------");

        //反向迭代
// ListIterator listIterator2 = list.listIterator();
        while (listIterator.hasPrevious()){
            Object previous = listIterator.previous();
            System.out.println(previous);

        }
    }
}

并发修改异常

ConcurrentModificationException出现
我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合 会出现并发修改异常
原因是我们的迭代依赖与集合 当我们往集合中添加好了元素之后 获取迭代器 那么迭代器已经知道了集合的元素个数
这个时候你在遍历的时候又突然想给 集合里面加一个元素（用的是集合的add方法） 那迭代器不同意 就报错了 解决方案1
我们用ListIterator迭代器遍历 用迭代器自带的add方法添加元素 那就不会报错了
a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
b:集合遍历元素，集合修改元素
解决方案2 使用for循环遍历集合 添加元素 不会报错

// ConcurrentModificationException 并发修改异常
        //我们在使用迭代器遍历，那么当集合中元素添加完毕，通过集合对象，获取迭代，那么这个迭代器，预先就已经知道
        //你集合中的元素个数了。然后你使用迭代器，遍历，那么迭代器就会按照原先的顺序进行遍历，可是你在遍历途中，要添加一个元素
        //就会打乱迭代器，预先设定好的顺序，就会抛出这个并发修改异常

        List list=new ArrayList();
        list.add("java");
        list.add("hello");
        list.add("php");
        list.add("world");
        list.add("Linux");
        //依然使用迭代器遍历,那么就需要使用Iterator的子接口ListIterator来实现向集合中添加
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            Object obj = listIterator.next();
            String str = (String) obj;
            if (str.equals("hello")) {
                //list.add("javaEE");
               listIterator.add("javaEE"); //使用迭代器添加或删除的方法
            }
        }

        //
        System.out.println(list);
        //那么怎么来处理这个并发修改异常呢？两种处理方式，
        //处理方式1.你用迭代器 遍历，那么你就使用迭代器自带的添加或删除元素的方法,来操作集合，那么就需要使用Iterator的子接口ListIterator来实现向集合中添加

        //2.你使用for循环来做
      /*  for (int i = 0; i < list.size(); i++) {
            Object obj = list.get(i);
            String str = (String) obj;
            if (str.equals("world")) {
                list.add("javaEEEEE");
            }
        }*/