java集合一：Collection

package com.company.collection;
/*
    最主要的几个方法：
    boolean add(Object element);   向集合中添加元素
    void clear();  清空集合
    int size();  获取集合中元素的个数
    boolean isEmpty();  判断集合中是否有元素
    Object[] toArray();  将集合转化为数组

    Iterator<E> iterator();  获取集合所依赖的迭代器对象

    boolean remove(Object o);  删除集合中某个元素
    boolean contanis(Object o);  判断集合中是否包含某个元素

    bolean addAll​(Collection<? extends E> c);  将指定collection中的所有元素都添加到此collection中
    bolean removeAll​(Collection<?> c);  移除此collection中那些也包含在指定collection中的所有元素

*/
import java.util.*;
public class CollectionTest01 {
    public static void main(String[] args) {

        // 1、创建集合 Collection是接口
        Collection c = new ArrayList();  //多态

        // 2、添加元素
        c.add(1);   // 自动装箱
        c.add(new Integer(100));

        Object o = new Object();
        c.add(o);  // Collection集合只能单个存储元素，并且只能存储引用类型

        Customer cu = new Customer("zhangsan", 24);
        c.add(cu);  // int size();  获取集合中元素的个数

        // 3、获取元素的个数
        System.out.println(c.size());  // 4

        // 4、将集合转化为Object类型数组
        Object[] objs = c.toArray();
        for(int i =0; i<objs.length; i++){
            System.out.println(objs[i]);
            /*
            1
            100
            [e-mail]
            Customer[name:zhangsan, age:24]
            */
        }

        // 5、查看集合是否为空
        System.out.println(c.isEmpty());  // flase

        // 6、清空
        c.clear();
        System.out.println(c.size()); // 0
        System.out.println(c.isEmpty());  // true
    }
}

class Customer{
    String name;
    int age;

    Customer(){}

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

    // 重写toString方法
    public String toString(){
        return "Customer[name:"+name+", age:"+ age +"]";
    }
}

迭代器

package com.company.collection;
/*
    Iterator iterator();  获取集合中所依赖的迭代器对象
    通过迭代器中方法完成集合的迭代（遍历）

    注意：这种方式是所有集合通用的遍历方式
*/
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
public class CollectionTest02 {
    public static void main(String[] args) {

        // 创建集合对象
        Collection c = new LinkedList();

        // 添加元素
        c.add(100);  // 自动装箱
        c.add(3.14);  // 自动装箱
        c.add(false);  // 自动装箱

        // 迭代、遍历
        // 1、获取迭代器对象
        // 不需要关心底层集合的具体类型，所有的集合依赖的迭代器都实现了java.util.Iterator;接口
        // 分析：c可能是LinkedList，也可能是ArrayList，他们这些类型的引用对象都可以调用iterator()方法
        // 而Iterator又是一个接口类型，it是引用，保存内存地址，指向堆中“迭代器对象”
        // 迭代器是面向接口编程
        Iterator it = c.iterator();
        // 输出结果：$表示内部类
        System.out.println(it);

        // java.util.LinkedList$ListItr 类是LinkedList集合所依赖的迭代器
        // java.util.ArrayList$Itr  类是ArrayList集合所依赖的迭代器

        // 2、调用方法，完成遍历，迭代。

        while(it.hasNext()){
            Object element = it.next();
            System.out.println(element);
            /*
                100
                3.14
                false
            */
        }
        /*
            boolean hasNext()  如果仍有元素可以迭代，则返回true。
            E  next()  返回迭代器的下一个元素，将迭代器向下移动一位。
            void remove() 从迭代器指向的collection中移除迭代器返回的最后一个元素（可选操作）

            原则：调用it.next()方法之前必须调用it.hasNext();
        */

        // for循环
        for(Iterator its= c.iterator(); it.hasNext(); ){   // for循环要求：for(执行一次；boolean类型；)
            Object o = its.next();
            System.out.println(o);
        }
        
    }
}

contains()

package com.company.collection;
/*
    boolean contains(Object o); 判断集合中是否包含某个元素
    boolean remove(Object o); 删除集合中某个元素
*/
import java.util.*;
public class CollectionTest03 {
    public static void main(String[] args) {

        // 创建集合
        Collection c = new ArrayList();

        // 创建Integer类型的对象
        Integer i1 = new Integer(10);

        // 添加元素
        c.add(i1);

        // 判断集合中是否包含i1
        System.out.println(c.contains(i1));  // true

        // 创建Integer类型对象
        Integer i2 = 10;

        // contains方法底层调用的是equals方法。如果equals放回true，就是包含
        System.out.println(c.contains(i2));  // true


        Manager m1 = new Manager(110, "jack");
        c.add(m1);
        System.out.println(c.contains(m1));  // true

        Manager m2 = new Manager(110, "jack");
        System.out.println(c.contains(m2));  // 重写之前false  Manager继承Object中的equals方法，比较的是内存地址
        // 但是显然，m1和m2编号一样，姓名也一样，从业务逻辑上来讲是相等的，所以需要从写Manager中的equals()方法
    }

}

class Manager{
    int no;
    String name;

    Manager(int no, String name){
        this.no = no;
        this.name = name;
    }


    // 重写equals方法
    // 需求规定：如果编号和姓名都相同则表示同一个Manager
    public boolean equals(Object o){

        if(this == o) return true;
        if(o instanceof Manager){
            Manager m = (Manager)o;
            if(m.no==this.no && m.name.equals(this.name)){
                return true;
            }
        }

        return false;
    }
}

remove()

package com.company.collection;
/*
    boolean remove(Object o);

    remove和contains方法都需要集合中的元素重写equals方法
    因为Object中的equals方法比较的是内存地址，在现实的业务逻辑当中，
    不能比较内存地址，应该比较内容。
*/
import java.util.*;
public class CollectionTest04 {
    public static void main(String[] args) {

        // 创建集合对象
        Collection c = new ArrayList();

        Integer i1 = new Integer(10);

        // 添加元素
        c.add(i1);

        // 删除
        Integer i2 = new Integer(10);
        c.remove(i2);

        System.out.println(c.size());  // 0

        Manager m1 = new Manager(100, "smith");
        c.add(m1);
        System.out.println(c.size());  // 1

        Manager m2 = new Manager(100, "smith");
        c.remove(m2);

        System.out.println(c.size());  // equals()方法重写后为0，与contains()方法一致


    }
}

深入remove()

package com.company.collection;
/*
    深入remove()方法：
        1.迭代器的remove()方法
        2.集合自身带的remove()方法
*/
import java.util.*;
public class CollectionTest05 {
    public static void main(String[] args){
        Collection c = new ArrayList();

        c.add(1);
        c.add(2);
        c.add(5);

        // 遍历
        Iterator it = c.iterator();

        while(it.hasNext()){
            // 尽量使用迭代器自身去删除某个元素
            // 1.使用迭代器的remove()方法删除
            it.next();
            // 删除
            it.remove();   // 通过迭代器删除

            /*
            // 2.使用集合自身所带的remove方法
            // 【注】如果使用下面这种方法it.next()就会异常：集合自身删除元素后，集合所依赖的迭代器也会发生变化，需要从新获取一个迭代器
            Object element = it.next();

            // 删除
            c.remove(element);

            */
        }

        System.out.println(c.size());  // 0
    }
}