ACAC contains 和 remove深入

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

/*
* 1、boolean contains(Object o) 返回 true 如果集合包含指定元素，否则返回false
*
*
*
* */
public class CollectionTest04 {
    public static void main(String[] args) {

        Collection c = new ArrayList();

        String s1 = new String("abc");// s1 = 0x1111
        c.add(s1);

        String s2 = new String("def");// s2 = 0x2222
        c.add(s2);

        String s3 = new String("abc");// s3 = 0x3333
        System.out.println(c.contains(s3));


        /**
         * 判断是否包含S3，我推测是不包含的，因为保存的内存地址不一样，
         * 虽然对象里的内存地址都指向了“abc”，但s3本身保存的内存地址和s1不一样
         * ok 这样分析的没有错，的确是这样
         * 但是，contains方法比较的不是s3的内存地址是否在集合中
         * 看下面源码里的，
         *        if (o.equals(es[i])) {
         *                  return i;
         *           }
         *     这个o是S3
         *     所以这是 s3.equals(es[i])
         *            s3.equals("abc") es[i] = s1嘛
         *            String 类型的equals比较重写了，所以是比较的内容
         *            所以最终结果是true
         *
         *结论：contains方法，是采用equals比较的，String类型的就不是比较内存地址了、
         *      就是比较内容，看这个字符串是否在集合中
         *
         *  public boolean contains(Object o) {
         *         return indexOf(o) >= 0;
         *     }
         *     public int indexOf(Object o) {
         *         return indexOfRange(o, 0, size);
         *     }
         *
         *     int indexOfRange(Object o, int start, int end) {
         *         Object[] es = elementData;
         *         if (o == null) {
         *             for (int i = start; i < end; i++) {
         *                 if (es[i] == null) {
         *                     return i;
         *                 }
         *             }
         *         } else {
         *             for (int i = start; i < end; i++) {
         *                 if (o.equals(es[i])) {
         *                     return i;
         *                 }
         *             }
         *         }
         *         return -1;
         *     }
         *
         */



    }
}

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

/*
* contains测试
*   放在集合中的元素，一定要重写equals方法的，否则比较的是内存地址，默认调用Object类中的equals
* */
public class CollectionTest05 {
    public static void main(String[] args) {

        Collection c = new ArrayList();

        User u = new User("miao");
        c.add(u);

        User uu = new User("miao");
        System.out.println(c.contains(uu));

        Integer it = new Integer(100);
        c.add(it);

        Integer it2 = new Integer(100);
        System.out.println("it.equals(it2)==" + it.equals(it2));
        System.out.println(c.contains(it2));

        c.remove(uu);
        System.out.println("应该有两个，现在有：" + c.size());


        /**
         *public int intValue()
         *作为一个 int返回该 Integer的值。
         *简单点：Integer类中重写了equals方法
         */

        /**
         * 刚开始，我是这样认为的：
         *      c.contains(uu) 根据Test03的经验，我认为这个也是用equals方法比较的
         *       if (o.equals(es[i])) {
         *            return i;
         *            }
         *       而这个o,也就是uu，代表的是String类型的，所以重写了equals方法，所以是true
         *
         * 指出我的错误：
         *      首先这个o是uu没错，但他是User类型的，而User类型中没有重写equals方法
         *      而当你点这个equals方法，看他在哪里，结果跳到了Object类中，而User又是
         *      间接继承Object类的，但是Object类中并没有重写equals方法，而我User类中
         *      也没有重写equals方法，所以默认调用Object类中的equals方法
         *      public boolean equals(Object obj) {
         *         return (this == obj);
         *     }
         *     这里比较的是内存地址，所以(o.equals(es[i]))比较的是内存地址，而uu并没有添加到
         *     c集合中，所以是false的
         *
         *      public int indexOf(Object o) {
         *         return indexOfRange(o, 0, size);
         *     }
         *
         *     int indexOfRange(Object o, int start, int end) {
         *         Object[] es = elementData;
         *         if (o == null) {
         *             for (int i = start; i < end; i++) {
         *                 if (es[i] == null) {
         *                     return i;
         *                 }
         *             }
         *         } else {
         *             for (int i = start; i < end; i++) {
         *                 if (o.equals(es[i])) {
         *                     return i;
         *                 }
         *             }
         *         }
         *         return -1;
         *     }
         *
         *
         *     同理这里remove也是重写了equals方法，如果你删除uu ，Java认为uu和u是一样的
         *     因为uu就是u,因为他这里是调用的equals方法比较的，而你有重写了equals方法，User类的
         *
         *      这里你删除100（it2)，也会把it删除的
         *       public boolean remove(Object o) {
         *          final Object[] es = elementData;
         *          final int size = this.size;
         *          int i = 0;
         *          found: {
         *              if (o == null) {
         *                  for (; i < size; i++)
         *                      if (es[i] == null)
         *                          break found;
         *              } else {
         *                  for (; i < size; i++)
         *                      if (o.equals(es[i]))
         *                          break found;
         *              }
         *              return false;
         *          }
         *          fastRemove(es, i);
         *          return true;
         *      }
         *
         */




    }
}
class User{
    private String name;

    public User(String name) {
        this.name = name;
    }

    public User() {
    }

    //开始重写equals方法（其实是系统默认的），结果就是true了

    /*@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(name, user.name);
    }*/

    //自己写，复习一下
    public boolean equals(Object o){
        if(o == null || !(o instanceof User)) return false;
        if(o == this) return true;
        User u = (User)o;
        //如果名字一样表示同一个人，（不再比较内存地址了）
        //放心，这里的u肯定不是null，也肯定不是其他类型的，看第一行判断
        return u.name.equals(this.name);
    }


    /**
     * 重点：
     *  1、把集合继承结构图背会（理解不深刻，也要会说）
     *  2、把Collection接口中常用方法测试几遍
     *  3、把迭代器弄明白
     *  4、Collection接口中remove方法和contains方法底层都会调用equals方法，弄明白
     *
     */

}

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

/**
 * 集合中的迭代器
 *    结论：当集合结构放生改变时，迭代器必须重新获取
 *         异常：java.util.ConcurrentModificationException
 *
 * 关于集合元素中的remove
 *      删除元素，之后，集合结构发生了改变，但是下次循环迭代器
 *      没有重新获取，所以会发生异常，迭代中不能这么干
 *
 * 在迭代元素的过程中，一定要使用哦迭代器Iterator的remove方法，不要使用集合自带的remove方法
 */
public class CollectionTest06 {
    public static void main(String[] args) {

        Collection c = new ArrayList();

        //如果把迭代器放在还集合的前面会出什么问题
        Iterator iterator = c.iterator();
        //java.util.ConcurrentModificationException
        //注意：当集合结构放生改变时，迭代器必须重新获取


        //注意：这里的可不是123，而是Integer 对象的内存地址
        c.add(1);
        c.add(2);
        c.add(3);

        Iterator it = c.iterator();

        //重复使用迭代器，也就是更新迭代器，没有问题

       while(it.hasNext()){
           System.out.println("集合的长度：" + c.size());
           Object o = it.next();
           /**
            * 删除元素，之后，集合结构发生了改变，但是下次循环迭代器
            * 没有重新获取，所以会发生异常
            * 根本原因：集合中元素删除了，但没有更新迭代器
            * 使用迭代器删除可以吗？
            */

//           c.remove(o); 直接通过集合删除元素，没有通知迭代器（导致迭代器的快照和原始状态不同）
//           迭代器删除时，会自动更新迭代器，并且更新集合
           it.remove();//删除的一定是迭代器指向的当前元素
           System.out.println(o);
       }

    }

}