Iterator 迭代器；collection功能

数组和集合的区别？

1.长度区别
数组长度固定
集合长度可变
2.内容不同
数组存储的是同一种类型的元素
而集合可以存储不同类型的元素
3.元素的数据类型问题
数组可以存储基本数据类型，也可以存储引用数据类型
集合中存储的类型最后转换成Object

Collection：是集合的一个顶级集合

collection 的功能概述：

1.添加功能：

       boolean   add(Object object)添加一个元素
       boolean   addAll(Collection c):添加一个集合

2.删除功能：

        void clear():  移除所有元素
        Boolean remove（Object o）:移除元素
        Boolean removeAll（Collection）：移除一个集合元素

3.判断功能：

		boolean contains(object o)  判断集合中是否包含着指定元素
		Boolean containsAll(collection c):判断集合中是否包含指定的集合元素（一个）
		boolean isEmpty（）：判断集合是否为空

4.获取功能

	   Iterator 对象：循环遍历

5.长度

	 int size（）：元素的个数
	 面试题：数组中有length（）**属性**，字符串有，集合中没有

6.交集功能

	 Boolean retainAll（Collection c）；两个集合都有的元素？返回的boolean值又是什么

7.把集合转换为数组

	 Object[] toArray()

实例：

package test2;

import java.util.ArrayList;
import java.util.Collection;

/**
 * @作者:Xem626
 * @date: 2022/7/19 21:38
 * @TODO
 */
public class Test1 {
    public static void main(String[] args) {


        //创建一个集合对象:利用多态
        //面向接口编程原则
        Collection c=new ArrayList();
        //面向对象
//        ArrayList arrayList=new ArrayList();
        c.add("hello");
        c.add("world");
        c.add("java");
        System.out.println(c);
        System.out.println("----------");
		//清空
        c.clear();
        System.out.println(c);
		//移除
        boolean hello=c.remove("hello");
        boolean javaee=c.remove("javaee");
        System.out.println(hello);
        System.out.println(javaee);
		//判断
        boolean hello = c.contains("hello");
        System.out.println(hello);
        System.out.println(c.contains("javaee"));
        

        boolean empty = c.isEmpty();
        System.out.println(empty);
		//长度
        int size = c.size();
        System.out.println("集合中元素的个数："+size);


    }
}

package test2;

import java.util.ArrayList;
import java.util.Collection;

/**
 * @作者:Xem626
 * @date: 2022/7/19 21:47
 * @TODO
 */
public class Test2 {
    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添加到集合c1中
//        System.out.println("addAll()"+c1.addAll(c2));



        //移除一个集合元素
        System.out.println("removeAll:"+c1.removeAll(c2));
        //Boolean containsAll(collection c):判断集合中是否包含指定的集合元素（一个）
//        System.out.println("containsAll()"+c1.containsAll(c2));
//        System.out.println(c1);

        // Boolean retainAll（Collection c）；A对B求交集，然后把交集的结果放在A中
        //**当前返回值的意思:表示A是否发生过改变**
        System.out.println("retainAll():"+c1.retainAll(c2));
        System.out.println(c1);

    }
}

交集：

// Boolean retainAll（Collection c）；A对B求交集，然后把交集的结果放在A中
//当前返回值的意思:表示A是否发生过改变
System.out.println(“retainAll():”+c1.retainAll(c2));
System.out.println(c1);

集合中的遍历：其实就是依次从集合中获取集合的元素

package test2;

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

/**
 * @作者:Xem626
 * @date: 2022/7/20 8:13
 * @TODO
 */
public class Test3 {

    public static void main(String[] args) {

        Collection c =new ArrayList();

        c.add("hello");
        c.add("world");
        c.add("java");

        System.out.println(c);
        System.out.println("---------------");


        //先把当前集合转换成数组
        //object[] toArray()

        Object[] objects=c.toArray();

        for(int x=0;x<objects.length;x++){

            String s=(String)objects[x];
            System.out.println(s);
        }

    }
}

构造学生类 并遍历

package test2;

/**
 * @作者:Xem626
 * @date: 2022/7/20 8:20
 * @TODO
 */
public class Student {
      //成员变量：属性
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package test2;

import java.util.ArrayList;
import java.util.Collection;

/**
 * @作者:Xem626
 * @date: 2022/7/20 8:22
 * @TODO
 */
public class StudentTest {
    public static void main(String[] args) {

        Collection c=new ArrayList();

        Student s1=new Student();
        s1.setName("艾琳");
        s1.setAge(18);

        Student s2=new Student("周杰伦",18);
        Student s3=new Student("路明非",19);
        Student s4=new Student("绘梨衣",32);
        Student s5=new Student("墨墨",24);

        c.add(s1);
        c.add(s2);
        c.add(s3);
        c.add(s4);
        c.add(s5);

        Object[]  objects=c.toArray();
        for(int i=0;i< objects.length;i++){
//            System.out.println(objects[i]);
           Student student=(Student) objects[i];
            System.out.println("学生的姓名："+student.getName());



        }



    }
}

Iterator iterator（）：迭代器，集合的专用遍历方式

Object next（）：获取元素，并移动到下个位置

Boolean hasNext（）：如果仍有元素，返回ture

package test2;

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

/**
 * @作者:Xem626
 * @date: 2022/7/20 8:36
 * @TODO
 */
public class Test4 {
    public static void main(String[] args) {

        Collection c=new ArrayList<>();

        c.add("hello");
        c.add("world");
        c.add("java");


        //获取迭代器，专门用于集合遍历

        Iterator it = c.iterator();//实际的返回值是子类对象

//        Object object=it.next();
//        System.out.println(object);
//
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());//这行代码不应该写了，因为没有元素

        //那么如果再执行这个代码前，有一个判断元素，如果存在，则执行it.next（）否则不执行
        while(it.hasNext()){
            String string=(String) it.next();
            System.out.println(string);

        }



    }
}

List接口的特点：有序（存储和取出元素的一致），可以重复

List集合的特有功能

• A.添加元素的功能
  void add(int index,Object object):在指定的位置添加元素

• B.获取功能
  Object get(int index):获取指定位置的元素

• C.列表迭代器
  LisIterator LisIterator():List集合中特有的迭代器

• D.删除功能

• Object remove(int index):根据索引删除元素，返回被删除的元素

• E:修改功能
  Object set(int index, Object element):根据索引修改元素，返回被修改的元素

package test2;

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

/**
 * @作者:Xem626
 * @date: 2022/7/20 9:09
 * @TODO
 */
public class Test5 {
    public static void main(String[] args) {


        //创建集合对象
        List list = new ArrayList();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");

        System.out.println(list);
            //添加
//            list.add(1,"javaEE");//无问题
//            System.out.println(list);
//            list.add(11,"android");//有问题
//            System.out.println(list);
//            list.add(4,"javaee");
//            System.out.println(list);//有问题
//
//            System.out.println(list.size());
//            list.add(3,"javaEE");
//            System.out.println(list);

            //获取
            System.out.println("get:"+list.get(0));
            System.out.println("get:"+list.get(1));
            System.out.println("get:"+list.get(2));
            System.out.println("get:"+list.get(3)); //出现异常
            //删除
            System.out.println("remove:"+list.remove(1));
            System.out.println(list);
            System.out.println("remove:"+list.remove(11));

            //修改元素
            Object javaEE = list.set(1, "javaEE");
            System.out.println(javaEE);
            System.out.println(list);
            
                 
    }
}

列表迭代器：
ListIterator listIterator()：List集合特有的迭代器
该迭代器继承了iterator，所有直接使用hashNext(),next()

特有功能:
Object previous:获取上一个元素
boolean hasPrevious：判断是否有元素

注意：ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。

问题：
我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我们就添加一个“Javaee”元素

List list =new ArrayList();

        list.add("hello");
        list.add("world");
        list.add("java");

        迭代器去遍历取出元素
        Iterator iterator = list.iterator();

        while (iterator.hasNext()){

            //取出这个元素
            String string =(String)iterator.next();

            if ("world".equals(string)) {
                list.add("javaee");
            }
        }

ConcurrentModificationException:当方法检测到并发修改时，不允许修改，抛出此异常
其实这个问题描述：迭代器在遍历元素的时候。通过集合是不能修改元素的

解决方法：

//方式1:使用ListIterator

        ListIterator listIterator = list.listIterator();

        //当前这种修改方式是在元素是跟在刚才迭代的元素后面的。
        while (listIterator.hasNext()){

            String string =(String)listIterator.next();

            if ("world".equals(string)) {
                listIterator.add("JavaEE");
            }

        }

 //方式2：集合遍历元素，集合修改元素，（普通for）
        for (int x=0;x<list.size();x++){

            String string = (String) list.get(x);

            if ("world".equals(string)) {
                list.add("javaee");
            }
        }