集合：（ArrayList）的插值和去重，包含（Iterator和listIterator）迭代器相关使用

总结：去重用for循环，插值可用for循环和迭代器（可以方便在中间插值），如果要修改集合，就用listIterator，防止父类的Iterator没有add添加功能，也避免版本号不一致报错

去重：用contains方法，确认新集合中是否存在旧值

1、基本数据类型String去重

public class ArrayListQuChong {
    public static void main(String[] args) {
        ArrayList arr=new ArrayList();//Ait+右键竖向编辑
        arr.add("java");
        arr.add("hadoop");
        arr.add("hive");
        arr.add("java");
        arr.add("hello");
        arr.add("hadoop");
        //使用for循环遍历，去重
         ArrayList arr1=new ArrayList();//创建一个新的集合
        for (int i=0;i//可以将集合当作数组处理，ArriList底层代码就是数组结构
//            arr1.get(i)=arr.get(i);//不能这样写，因为两边都是变量
           if(!arr1.contains(arr.get(i))){
               arr1.add(arr.get(i));
           }
        }System.out.println("for循环去重"+arr1);//ArrayList自带重写了toString方法，所以可以直接打印

2、引用数据类型的去重，去重之前首先要在ArrayListYingYong类修改toString方法 //便于直接比较内容,如果是插其他值，看是否有相同的,就用equals方法 //第一题、使用for循环去重

/*使用for循环*/      ArrayList arr2=new ArrayList();
        ArrayListYingYong yingYong0=new ArrayListYingYong("程啊伟",22);
        ArrayListYingYong yingYong1=new ArrayListYingYong("小强",20);
        ArrayListYingYong yingYong2=new ArrayListYingYong("韩韩",18);
        ArrayListYingYong yingYong3=new ArrayListYingYong("小强",20);
        ArrayListYingYong yingYong4=new ArrayListYingYong("程啊伟",22);
        arr2.add(yingYong0);
        arr2.add(yingYong1);
        arr2.add(yingYong2);
        arr2.add(yingYong3);
        arr2.add(yingYong4);
        ArrayList arr3=new ArrayList();//创建新集合接收
        for(int j=0;j
            if(!arr3.contains(arr2.get(j))){
                arr3.add(arr2.get(j));
            }
        }
        System.out.println("引用数据类型去重："+arr3);

插值：用equals方法，进行比较，如果是引用型数据类型，要重写其equals方法，才能直接比较内容，或者调用get方法进行比较

需求：
        使用List集合存储字符串元素，使用迭代器遍历，遍历的时候，如果遇到"java"，就向集合中添加一个元素"shujiakuaile"

常见错误示范：

public class ListDemo1 {
    public static void main(String[] args) {
        List list1 = new ArrayList();
 
        list1.add("hello");
        list1.add("java");
        list1.add("hadoop");
        list1.add("redis");
        System.out.println("list1: " + list1);
 
        Iterator iterator = list1.iterator();
       while (iterator.hasNext()){
            Object o = iterator.next();
          String s = (String) o;
           if("java".equals(s)){
                list1.add("shujiakuaile");
            }
        }

  我们按照需求编写代码，在遍历迭代器的时候，当遇到"java"，我们是使用集合中add方法进行添加元素的，运行的时候就报错了。

错误原因： //因为继承自父亲的迭代器中没有添加元素的方法，所以我们需要使用List中特有的迭代器进行遍历及添加
        //通过观察源码发现，List中特有的迭代器中的add方法，不仅可以对迭代器中元素进行添加，底层也针对原集合进行添加元素
        //将原集合以及迭代器的版本号也设置成一样的了，所以将来再检查版本号的时候，原集合和迭代器的版本号是一致的
        //这样就不会产生并发修改异常了
    ConcurrentModificationException 并发修改异常，迭代器遍历的时候，无法使用集合的方法对集合本身做改动。

正确写法如下：基本数据类型（第一种是迭代器，第二种是for循环）

ListIterator listIterator = list1.listIterator();
//        while (listIterator.hasNext()){
//            Object o = listIterator.next();
//            String s = (String) o;
//            if("java".equals(s)){
//                listIterator.add("shujiakuaile");
//            }
//        }
 
 
        Object[] array = list1.toArray();
        for (int i = 0; i < array.length; i++) {
            String s = (String) array[i];
            if("java".equals(s)){
                list1.add("shujiakuaile");
            }
        }
 
        System.out.println("list1: " + list1);
    }
}

2、引用数据类型：（迭代器插值）

直接打印集合list,是因为其本身就重写了toString方法，使用迭代器就要将其放入的内容强制转换为String类型，因为只有String类型可以用equals,迭代器自身没有这个方法，可以在引用的DieDai类中重写equals方法,或者用对象调用get方法，不然比较的是对象的地址值。

import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
 
public class DieDaiQi {
    public static void main(String[] args) {
        List li=new ArrayList();
        DieDai a=new DieDai("java");
        DieDai b=new DieDai("hello");
        DieDai c=new DieDai("java");
        DieDai d=new DieDai("vajava");
        DieDai e=new DieDai("world");
        DieDai f=new DieDai("java");
        DieDai g=new DieDai("ja");
        DieDai h=new DieDai("shujia");
        //使用迭代之前，先把内容导入到list集合中
        li.add(a);
        li.add(b);
        li.add(c);
        li.add(d);
        li.add(e);
        li.add(f);
        li.add(g);
        String str="java";
//        String b1=new String();
//        String b2="";
//        Iterator iterator=li.iterator();//使用迭代器，使用迭代器遍历的时候，不能修改list集合
        //会出现版本号不一致错误，所以要调用list独有的方法，进行添加
        ListIterator listIterator =li.listIterator();
        while (listIterator.hasNext()){
            Object o=listIterator.next();
           DieDai d1=(DieDai) o;//转型为DeiDai,因为li里面存的是DieDai对象，且DieDai有contain和equals功能
            //不能转成String类型，因为list里面传入的值是DeiDai的对象，不能将其他类的对象转成String类
            if(d1.getName().equals(str)){//调用类方法得到传入的内容，与str进行比较,或者重写equals方法
              listIterator.add(h);//往集合中添加对象,不能写成用li添加，会报错：ConcurrentModificationException
                //显示并发修改异常，原因是版本不同
                //总结：用数组遍历就数组遍历方法，用迭代器就使用迭代器，用其独有的listIterator方法，将内容添加到集合中
                //如果添加的是同样的list对象就显示的和DieDai对象一样内容，如果是字符串，就单独显示，
                // 如：[DieDai{name='java'}, shujia, DieDai{name='hello'}。
                //正常是：[DieDai{name='java'}, DieDai{name='shujia'}, DieDai{name='hello'}.
            }
        } System.out.println(li);//此时打印集合li,其实是所指的ArrayList，因为其重写了toString方法，
        // 所以显示的是内容，不能打印迭代器，迭代器还是默认的引用数据类型，打印的是地址值
 
//        while (iterator.hasNext()){
//            Object o=iterator.next();
//            DieDai d1=(DieDai)o;
//            System.out.print(d1.getName()+"\t");
//            b2+=d1.getName();//用字符串接收，防止转型错误
//            if(d1.getName().equals(str)){
//                b1+=str;
//            }else {
//                continue;
//            }
//        }
//        System.out.println(b2+"\t"+b1+"\t");
        //此方法不如数组，也不如迭代器，还是老一套的拼接只能在后面添加，过于麻烦
 
 
 
        }
 
 
    }