ACAC Collection的一些方法，和迭代器

/*
*
* 1、Collection中放什么元素？
*       没有使用“泛型”之前，Collection中可以存储Object的所有子类型
*       使用“泛型”之后，Collection中只能存储某个具体的类型，集合后，学习泛型，
*   注意：集合中不能直接存储基本数据类型，也不能存java对象，只是存储java对象的内存地址
*
* 2、Collection中的常用方法：
*       boolean add(E e) 向集合中添加元素
*       void clear() 从这个集合中移除所有的元素（可选操作）。
*       boolean contains(Object o) 返回 true如果集合包含指定元素。
*       boolean isEmpty() 返回 true如果集合不包含任何元素。
*       boolean remove(Object o) 从这个集合中移除指定元素的一个实例，如果它是存在的（可选操作）。
*       int size() 返回此集合中的元素的数目。
*       Object[] toArray() 返回包含此集合中所有元素的数组。
*
 * */

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

public class CollectionTest01 {
    public static void main(String[] args) {

        //创建一个集合对象
        //Collection c = new Collection();//接口是无法实例化的，抽象的

        //多态，ArrayList实现Collection
        Collection c = new ArrayList();

        c.add(123);//注意：这里采用自动装箱机制，Integer i = new Integer(111); add(i),传进去的是内存地址
        c.add("hello master!!");
        c.add(new Object());
        c.add(new Student());
        c.add(12.23);

        System.out.println(c.contains(123));
        System.out.println(c.contains(111));
        System.out.println(c.contains(new Student()));
        //这个我认为应该是false的，因为你又new的一个新对象，果然如此
        Student st = new Student();
        c.add(st);
        System.out.println(c.contains(st));
        //这个就是true了，就是这样


        System.out.println("---------------");
        System.out.println(c.isEmpty());//false
        //c.clear();
        System.out.println(c.isEmpty());//true

        c.remove(123);
        c.remove(111);//这个会不会报错呢？方法说明是可选操作，应该是没有问题的,没有报错

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

        System.out.println("-------------");
        Object[] obj = c.toArray();
        for (int i = 0; i < obj.length; i++) {
            System.out.print(obj[i] + " ");
        }

//        boolean addAll(Collection<? extends E> c)
//        将指定集合中的所有元素添加到这个集合（可选操作）。
        Collection d = new ArrayList();
        d.addAll(c);
        Object a = d.toArray();

        //暂时没搞定
        /*for (int i = 0; i < a.; i++) {

        }*/



       /* for (int i = 0; i < c.size(); i++) {
            //无法直接对c集合进行输出，还得用toArray（）方法转一下，之前好像有个get[i]的方法
             List myList = new ArrayList();是这种类型的，List接口中有这个方法get[i]
             但collection接口没有这个方法

            System.out.println(c.get);
        }*/

    }
}
class Student{

}

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

/*
* 关于集合遍历，迭代专题（重点）
* */
public class CollectionTest02 {
    
    
    public static void main(String[] args) {
    
    
        //注意：以下的遍历，迭代方式，是所有Collection通用的一种方式
        //在Map集合中不能用，在所有Collection以及子类中使用

        //创建集合对象
        Collection a = new HashSet();

        a.add("qwqe");
        a.add(1234);
        a.add("miao");
        a.add(24.23);
        a.add(new Object());

        //对集合Collection进行遍历/迭代
        //1、获取集合对象的迭代器对象Iterator
        Iterator it = a.iterator();

        //2、通过以上获取的迭代器对象开始迭代/遍历集合
        /*
        * 通过以下两个方法：
        *   boolean hasNext() 返回 true,如果迭代具有更多的元素。
        *   next() 返回迭代中的下一个元素。
        *
        * */

        while(it.hasNext()){
    
    
            //不管当初存进去的是什么类型，取出一律是Object
            Object ob = it.next();
            if(ob instanceof Integer){
    
    
                System.out.print("Integer 类型 ：");
            }else if(ob instanceof String){
    
    
                System.out.print("String 类型 ：");
            }else if(ob instanceof Double){
    
    
                System.out.print("Double 类型 ：");
            }else if(ob instanceof Object){
    
    
                System.out.print("Object 类型 ：");
            }
            System.out.println(ob);

        }
        /*
        * 复习下八种包装类：
        *    Byte，Short，Integer，Long，Float，Double，Boolean，Character*/
    }
}

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

public class CollectionTest03 {
    
    
    public static void main(String[] args) {
    
    

        Collection c = new ArrayList();

        //有序可重复的
        c.add(1234);
        c.add("saf");
        c.add(1234);
        c.add(new Object());
        Iterator aa = c.iterator();
        while(aa.hasNext()){
    
    
            System.out.println(aa.next());
        }

//        1234
//        saf
//        1234
//        java.lang.Object@16b98e56

        //无序，不可重复的
        //注意：这个无序是指添进去，和取出来的顺序不一样
        //不可重复，但是代码可以写重复的，底层的数据结构自动将重复的数据拦截了
        Collection d = new HashSet();
        d.add(1);
        d.add(2);
        d.add("miao");
        d.add(3);
        d.add(4);
        d.add("sdfs");
        d.add(1);
        d.add(new Object());
        d.add(new Object());

        Iterator dd = d.iterator();
        while(dd.hasNext()){
    
    
            System.out.println(dd.next());
        }
       /*
        1
        2
        3
        4
        java.lang.Object@27d6c5e0
        java.lang.Object@7ef20235
        miao
        sdfs
        */



    }
}