关于集合的概述以及迭代/遍历【重点】

**集合的概述**

1、集合的概述

   1.1、什么是集合？有什么用？
        数组其实就是一个集合。集合实际上就是一个容器。可以来容纳其它类型的数据。

        集合为什么说在开发中使用较多？
            集合是一个容器，是一个载体，可以一次性容纳多个对象。
            在实际开发中，假设连接数据库，数据库当中有10条记录，
            那么假设把这10条记录查询出来，在java程序中会将10条
            数据封装成10个java对象，然后将10个java对象放到某个
            集合当中，将集合传到前段，然后遍历集合，将数据一个一
            个展现出来。

   1.2、集合不能直接存储基本数据类型，另外集合也不能直接存储java对象，
    集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用。）
        List.add(100);  //自动装箱成Integer
        注意：集合在java中本身是一个容器，是一个对象。
        集合中任何时候存储的都是"引用"。

   1.3、在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中
     存储存储元素，等于将数据放到不同的数据结构当中去。什么是数据结构？数据
     存储的结构就是数据结构，不同的数据结构，数据存储的方式不同。例如：
        数组、二叉树、链表、哈希表...
        以上这些都是常见的数据结构。

        你往集合c1中放数据，可能是放到数组上了。
        你往集合c2中放数据，可能是放到二叉树上了。
        ......
        你是用不同的集合等同于使用了不同的数结构。

        在这一章，不需要掌握数据结构，java中已经将数据结构实现了，已经写好了
        这些常用的集合类，只要掌握怎么用？在什么情况下选择哪一种合适的集合去
        使用即可。

            new ArrayList();  创建一个集合，底层是数组。
            new LinkedList();  创建一个集合对象，底层是链表。
            new TreeSet();    创建一个集合对象，底层是二叉树。
            .......

   1.4、集合在java  JDK那个包下？
        java.util.*;
            所有的集合类和集合接口都在java.util.*；包下。

  1.5、集合的结构继承图。


  1.6、在java中集合分为两大类：

        一类是单个方式存储元素：
            单个方式存储元素，这一类集合中超级父类接口：java.util.Collection;

        一类是以键值对的方式存储元素【 K , V】
            以键值对的方式存储元素，这一类集合中的超级父类接口是：java.util.Map;



总结（所有的实现类）：
    ArrayList：底层是数组。
    LinkedList：底层是双向链表。
    Vector：底层是数组，线程安全的，效率较低，使用较少。
    HashSet：底层是HashMap，放到HashSet集合中的元素等同于放到HashMap集合key部分了。
    TreeSet：底层是TreeMap，放到TreeSet集合中的元素等同于放到TreeMap集合key部分了。
    HashMap：底层是哈希表。【以键值对方式存储引用K，V】
    Hashtable底层也是哈希表，只不过线程安全的，效率较低，使用较少。
    Properties：是线程安全的，并且key和value只能存储字符串String。
    TreeMap：底层是二叉树。TreeMap集合的key可以自动按照大小顺序排序。

List集合存储元素的特点：
    有序可重复
    有序：存进去的顺序和取出来的顺序一样，每个元素都有下标。
    可重复：存进去1，可以在存储一个1.

Set集合存储元素的特点：
    无序不可重复
    无序：指的是存进去的顺序和取出来的顺序不一定相同。另外Set集合中的元素没有下标。

SortSet集合存储元素特点：
    首先是无序不可重复的，但是SortedSet集合中的元素是可排序的。
    无序：存进去的顺序和取出来的顺序不一定相同。另外Set集合中的元素没有下标。
    不可重复：存进去1，不能在存进去1了。
    可排序：可以按照大小顺序排列。

    Map集合的key，就是一个Set集合。
    在Set集合中放数据，实际上放到Map集合的key部分。

集合的常用方法

package edu.tjdz.javaSE.collection;
/*
关于java.util.Collection接口中的方法。
    1、Collection中能存放什么元素？
        没有使用“泛型”之前，Collection中可以存放Object的所有子类型。
        使用了“泛型”之后，Collection中只能存储某个具体类型。
        集合后期会讲到“泛型”语法。目前先不用管。Collection中什么都
        能存，只要是Object的子类就行。（集合中不能直接存储基本数据类型，
        也不能存java对象，只能存储java对象的内存地址）

    2、Collection中的常用方法
        boolean add(Object e)   往集合中添加元素
        int size()    获取集合中元素的个数
        void clear()  清空集合
        boolean contains(Object o)   判断集合中是否包含这个o元素,包含返回true，不包含返回false
        boolean remove(Object o)  删除集合中的某个元素
        boolean isEmpty()    判断集合是否为空
        Object[] toArray()   调用这个方法可以将集合转换成数组【作为了解，使用不多】
 */

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

public class CollectionTest01 {
    public static void main(String[] args) {
        //创建一个集合对象
        //Collection c = new Collection(); //接口是抽象的，无法实例化
        //多态
        Collection c = new ArrayList();
        //测试Collection接口中的方法
        c.add(1200); //自动装箱，实际上是放进去一个对象的内存地址。Integer i = new Integer();
        c.add(3.14); //自动装箱，实际上放进去的是一个对象的内存地址，Double d = new Double();
        c.add(new Students());
        c.add(new Object()); //实际上底层存储的是这个对象的内存地址，Object o = new Object();
        c.add(true); //自动装箱，Boolean b = new  Boolean();

        //获取集合元素个数
        System.out.println("集合中元素个数为:"+c.size());  //5

        //清空集合
        c.clear();
        System.out.println("集合中元素个数为："+c.size());  //0

        //在向集合中添加元素
        c.add("hello"); // hello对象的内存地址放到了集合当中
        c.add("word");
        c.add("浩克");
        c.add("绿巨人");
        c.add(1);

        //判断集合中是否包含"绿巨人"
        boolean flag = c.contains("绿巨人");
        System.out.println(flag); //true
        boolean flag2 = c.contains("绿巨人2");
        System.out.println(flag2);// false
        System.out.println(c.contains(1)); // true

        System.out.println("集合中元素的个数："+c.size()); //5

        //删除集合中某个元素
        c.remove(1);
        System.out.println("集合中元素个数是："+c.size()); //4

        //判断集合是否为空(集合中的元素是否为空)
        System.out.println(c.isEmpty());  //false
        //清空
        c.clear();
        System.out.println(c.isEmpty());  //true

        c.add("abc");
        c.add("def");
        c.add(100);
        c.add("hello word");
        c.add(new Students());

        //转换成数组【了解】
        Object [] objs = c.toArray();
        for(int i=0; i<objs.length;i++){
            //遍历
            System.out.println(objs[i]);
        }

    }
}

class Students{

}

关于集合的迭代/遍历【重点，所有集合通用的】

package edu.tjdz.javaSE.collection;

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

/**
 * 关于集合遍历/迭代专题。（重点：五颗星）
 *
 *      通过调用集合的iterator获取迭代器对象
 *          迭代器对象[Iterator]里面有两个方法
 *              hasNext()
 *              next()
 *
 */
public class CollectionTest02 {
    public static void main(String[] args) {
        //注意：以下讲解的遍历方式/迭代方式，是所有的Collection通用的一种方式。
        //在Map集合下不能用，在所有的Collection以及子类中使用。
        Collection c = new ArrayList(); // 后面的集合无所谓，主要是看前面的Collection接口，怎么遍历/迭代。
        //添加元素
        c.add("abc");
        c.add("def");
        c.add(100);
        c.add(new Object());
        //对集合Collection进行遍历/迭代
        //第一步：获取对象的迭代器对象Iterator
        Iterator it = c.iterator();
        //第二步：通过以上获取的迭代器对象开始迭代/遍历集合。
        /*
        以下两个方法是迭代器对象Iterator中的方法：
            boolean hasNext()  如果仍有元素迭代，则返回true
            Object next()  返回迭代的下一个元素
         */
        /*
        while(it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }
        */
        //一直取，不判断，会出现异常java.util.NoSuchElementException
        while(true){
            Object obj = it.next();
            System.out.println(obj);
        }


        /*
        boolean hasNext = it.hasNext();
        System.out.println(hasNext);
        if(hasNext){
            Object obj = it.next();
            System.out.println(obj);
        }
        */
     }
}


package com.tjdz.javaSE.collection;

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) {
        //创建集合对象
        // ArrayList集合：有序可重复
        Collection c1 = new ArrayList();
        //添加元素
        c1.add(1);
        c1.add(2);
        c1.add(3);
        c1.add(4);
        c1.add(1);

        //迭代元素
        Iterator it = c1.iterator();
        while(it.hasNext()){
            //存进去是什么类型，取出来还是什么类型
            Object obj = it.next();
            if(obj instanceof Integer){
                System.out.println("Integer类型");
            }
            //只不过在输出的时候会转成字符串。因为这里的println会调用toString()方法
            System.out.println(obj);
        }

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

        //HashSet集合：无序不可重复
        Collection c2 = new HashSet();
        //无序：存进去的顺序和取出来的顺序不一定相同
        //不可重复：存进去100，不能在存100.
        c2.add(100);
        c2.add(68);
        c2.add(30);
        c2.add(100);
        c2.add(200);
        c2.add(100);
        Iterator it2 = c2.iterator();
        while(it2.hasNext()){
            System.out.println(it2.next());
        }
    }
}

---