容器

集合框架：由一组（主要是Collection和Map接口）用来操作对象的接口组成

Collection的父类是Iterable

数组与集合的差异：数组一次性开辟一片空间，一旦定义，数组的大小就不可以改变，集合是数组的延伸，集合的大小可以改变，可以动态的增加大小

不同接口描述不同类型的数据

接口层次：

                   

List和Set都是继承Collection接口的接口。Map并不继承collection接口。

List接口：用于定义一个允许出现重复项的有序集合List是一个特殊的Collection，它新添的面向位置的操作，包括插入某个元素或某个集合的功能，包括获取、删除或更新元素的功能

ArrayList：随机访问的效率高

创建集合li和集合a：

        List li=new ArrayList();
        li.add(2018);
        li.add(5);
        li.add(6);
        li.add(null);
        li.add("renull");

        li.add(0,"ls");//add(索引，value值），根据索引添加元素到对应位置

        List a=new ArrayList();   //定义新集合
        a.add(11);
        a.add("点");
        a.add(20);
        a.add("分");
        //添加a集合到li集合
        li.addAll(0,a);    //li.addAll(0,a); 根据索引添加a集合到li集合，并放在第一位

用迭代器遍历集合li：

Iterator iter=li.iterator();         //迭代器 ： 遍历集合
        while(iter.hasNext()){               //hasNext判断集合a的元素是否存在
            System.out.println(iter.next());  //iter.next()内为Object类  将Object类强转为目标类，实现输出对象属性
        }
        boolean c=iter.hasNext();
        System.out.println(c);

用for循环遍历集合li：

for (Object obj:li){
         System.out.println(obj);     //遍历集合
         }

集合对应的方法：

 li.addAll(0,a);    //li.addAll(0,a); 根据索引添加a集合到li集合，并放在第一位
        li.clear();      //清空集合
        li.remove(0);        //根据索引删除元素
        li.remove("ls");     //直接删元素
        li.removeAll(a);     //从集合li中删除集合a
        li.retainAll(a);     //从集合li当中删除a集合不包含的元素   ---遍历俩个集合的公共元素
        /*
        int q=li.size();      //查看集合大小
        System.out.println(q);
        */

        li.subList(0,10);    //截取集合元素索引0-9  包前不包后

        /*
        boolean c=li.isEmpty();   //判断集合是否为空
        System.out.println(c);
        */

        /*
        Object obj=li.get(0);      //根据索引找元素
        System.out.println(obj);
        */

        /*
        int v=li.indexOf("ls");    //根据元素找索引   li.lastIndexOf根据最后出现的元素找索引
        System.out.println(v);
        */

        /*
        boolean c=li.contains(2018);    //判断当前集合中是否包含（）内元素
        System.out.println(c);
        */

        /*
        boolean c=li.containsAll(a);   //判断当前集合是否包含a集合
        System.out.println(c);
        */

集合转换为数组：

Object [] obj=li.toArray();    //将集合转换为数组
        for(Object o:obj){
            System.out.println(o);
        }

LinkedList：遍历元素，顺序访问元素

public class LinkedListApp{
    LinkedList linkedList;
    public LinkedListApp(){
        //用Collection构造一个LinkedList
        Collection c= this.getData();
        linkedList=new LinkedList(c);   //把ArrayList集合填充到LinkedList集合中
        //查看linkedList的元素
        this.outData(linkedList);       //
        //获取第一个元素
        String firstStr=(String)linkedList.getFirst();
        System.out.println("\nlinkedList中第一个元素为"+firstStr);
        //获取最后一个元素
        String lastStr=(String)linkedList.getLast();
        System.out.println("\nlinkedList中最后一个元素为"+lastStr);
        //移除首尾元素
        linkedList.removeFirst();    //移除铀元素
        linkedList.removeLast();
        this.outData(linkedList);
    }
    //给集合赋值
    public ArrayList getData(){
        ArrayList List=new ArrayList();
        for(int i=0;i<=13;i++){
            List.add("第"+i+"月");
        }
        return List;
    }
    //outData方法实现集合的迭代
    public void outData(LinkedList list){
        System.out.println("查看LinkedList中的元素");
        Iterator iter=linkedList.iterator();
        int i=0;
        while(iter.hasNext()){
            if(++i%5==0)
                System.out.println(iter.next()+"");
            else
                System.out.print(iter.next()+"");
        }
        //System.out.println("\n");
    }

    public static void main(String[] args) {
        LinkedListApp l=new LinkedListApp();

    }


}

Veotor矩阵：和数组一样，可以使用整数索引进行数据访问的类。Vector的大小可以根据需要增大或缩小，以适应创建Vector后进行添加或删除的操作

Stack：是Vector的子类，通过push（）和pop（）方法实现一个标准的堆栈

public class Sta_ck {
    int goldNum=4;
    Stack stack;
    public Sta_ck(){
        stack=new Stack();
        System.out.println("死胡同里发现了"+goldNum+"两黄金,赶快去抢......");
        this.inHole();
        this.outHole();
    }
    /*进胡同*/
    public void inHole(){
        for(int i=1;i<=goldNum+1;i++){
            stack.push("people"+i);   //入栈
            if(i==goldNum+1){
                System.out.println("people"+i+":我是最后一个进入死胡同的人, 没黄金了?那你们不给我黄金谁也别想出去!");
            }else{
                System.out.println("people"+i+":我是第"+i+"个进入的人，抢了1两黄金");
            }
        }
    }
    /*出胡同*/
    public void outHole(){
        for(int i=1;i<goldNum;i++){
            String first1=(String)stack.peek();    //出栈之前的首元素
            stack.pop();                           //出栈
            String first2=(String)stack.peek();    //出栈后的首元素
            System.out.println(first2+"给了"+first1+"一两黄金，\n对其他人说他走了你们不给我黄金谁也别想出去!\"");
            if(i==goldNum-1){
                System.out.println("People1对People2说:我就不给你,谁怕谁啊!");
            }
        }
    }

    public static void main(String[] args) {
        new Sta_ck();
    }
}

Set集合：不包含重复元素的实现Collection接口的接口，Set集合最多包含一个null元素，存储无序的对象

TreeSet：集合内的对象按特定的顺序存储

HashSet：创建使用哈希表存储的集合，操作性能和时间效率较高

LinkedHashSet：扩展HashSet，以链表的形式把数据存储在哈希集合中，LinkedHashSet的迭代器按照元素插入的顺序来访问各个元素

定义一个Set集合来存放元素：

       Set<Object> s=new HashSet<Object>();
       s.add(1);     //向集合中添加元素
       s.add(2);
       s.add(3);
       s.add(4);
       s.add(5);
       s.add(6);
       s.add("sss");
       Iterator iter=s.iterator();   //迭代器遍历集合
       while(iter.hasNext()){
           System.out.println(iter.next());
       }

TreeSet的应用：

public class TreeSetApp {
        TreeSet treeSet;
        public TreeSetApp(){
            int k=0;
            treeSet=new TreeSet();
            for(int i=1;i<13;i++){
                treeSet.add("第"+i+"月");
            }
            Iterator iter=treeSet.iterator();
            while(iter.hasNext()){
                k++;
                String s=(String)iter.next();   //将Object强转为String类型
                if(k%4==0){
                    System.out.println(s+"  ");
                }
                else
                    System.out.print(s+"   ");
            }
        }
        public static void main(String args[ ]){
            new TreeSetApp();
        }
}

运行结果：

HashSet的应用：

public class SetGather {
    public static void main(String[] args) {
      new SetGather();
    }
    HashSet hashSet;
    public SetGather(){
        hashSet=new HashSet();
        for(int i=0;i<13;i++){
            hashSet.add("第"+i+"月");
        }
        System.out.println("hashSet中共有"+hashSet.size()+"个元素");   //查看集合大小 
        boolean bool=hashSet.remove("第0月");     //删除指定元素
        System.out.println("删除第一个元素"+bool);  
        System.out.println("hashSet中是否存在第0月"+hashSet.contains("第0月"));   //判断集合是否还含有第0月
        Iterator iter=hashSet.iterator(); 
        int i=0;
        while(iter.hasNext()){
            i++;
            if(i%4==0){
                System.out.println(iter.next());
            }else{
                System.out.print(iter.next());
            }
        }


    }
}

运行结果：

Map集合：用键值对存储元素

Map集合的应用：

创建一个新的Map集合并赋值：

        Map m=new HashMap();
        m.put("a","1");
        m.put("b","2");
        m.put("c","3");
        m.put("d","4");

Map集合的方法：

        /*
        //判断是否包含键
        boolean b=m.containsKey("d");
        //判断是否包含值
        boolean b1=m.containsValue("1");
        //删除键
        m.remove("a");
        //定义新的集合
        Map m1=new HashMap();
        m1.put("e","5");
        //集合叠加
        m.putAll(m1);
        //获取m中所有的键保存在key中
        Set key=m.keySet();
        //遍历集合m的键
        Iterator iter=key.iterator();
        while(iter.hasNext()){
            //将key值强转为String类型
            String k=(String)iter.next();  //类型转换
            ///根据键得到值
            System.out.println(m.get(k));   //由键获取值
        }
        */

得到集合的键的集合和值的集合：

public static void main(String[] args) {
        //Map集合
        Map m=new HashMap();
        m.put("a","1");
        m.put("b","2");
        m.put("c","3");
        m.put("d","4");
        System.out.println(m);
        System.out.println("---------------");
        //将键值对合成为一个元素存储在s集合中
        Set<Map.Entry<String,String>> s=m.entrySet();
        System.out.println(s);
        System.out.println("---------------");
        Iterator<Map.Entry<String,String>> iter=s.iterator();    //用迭代器遍历集合s
        while(iter.hasNext()){
            //强转拆分
            Map.Entry map=(Map.Entry)iter.next();
            System.out.print(map+"\t\t");
            System.out.println("key:"+map.getKey()+"\t"+"value:"+map.getValue());
        }
 }