集合（容器）（1）

1.集合API

Java的集合框架是由很多接口、抽象类、具体类组成的，都位于java.util包中。

 集合体系：

     单列集合                                                  双列集合        键--值 

            Collection（接口）                                     Map（接口）

                    List（接口）    可存储重复元素                HashMap

                          ArrayList                                             Hashtable

                          LinkedList                                           TreeMap

                          Vector

                    Set（接口）   不可存储重复元素

                           HashSet

                           TreeSet

2.Collection接口

在Collection 中定义了一些集合中的共有方法：

add();

addAll();       //把一个集合添加到另一个集合

equals();         //比较两个集合里面的内容是否相等

isEmpty();      //判断集合中元素的个数是否为空

remove();       //删除指定元素

retainAll();

toArray();     //将集合转化为数组

size();      //求集合的长度

clear();    //清空一个集合里面的元素

案例：

package com.ffyc.javaCollection;

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

public class collectionDemo {
    /*
       Collection接口，作为单列集合中顶级接口，里面定义了单列集合共有的方法
       方法以增，删，改，查，判断，转换为主。
       Collection<E>，ArrayListE>后面<E>是jdk5之后的语法 --泛型
       集合是容器，可以储存不同的数据，严格上讲集合是可以储存任何类型的（只能存储引用类型）
       可以通过泛型语法，危机和设置一个类型，这样 只能存储设置的数据类型
       集合中建议存储同一类型数据
     */
    public static void main(String[] args) {

        Collection<String> c = new ArrayList<>();
                   c.add("a");
                   c.add("b");
                   c.add("c");

        Collection<Integer> c1 = new ArrayList<>();
                   c1.add(1);
                   c1.add(2);
                   c1.add(3);

        Collection<String> c2 = new ArrayList<>();
                   c2.add("a");
                   c2.add("a1");
                   c2.add("b1");
                   c2.add("c1");
                   c2.addAll(c);//把一个集合添加到另一个集合
                   c2.equals(c);//比较两个集合里面的内容是否相等
                  // c.clear();//清空一个集合里面的元素
                   c2.remove("a1");//删除指定元素，成功返回true，不成功返回false
        System.out.println(c2.remove("a1"));
        System.out.println(c.isEmpty());//判断集合中元素的个数是否为空
        System.out.println(c2.equals(c));
        System.out.println(c);
        System.out.println(c2);
        System.out.println(c.size());//数组长度length，字符串长度length(),集合长度size()
        System.out.println(c2.retainAll(c));//在c2中保留c中交集的元素，发生变化返回true，没有变化返回false

        Object[] obj = c.toArray();//将集合转为Object类型数组
        String[] sobj = c.toArray(new String[c.size()]);//将集合转为指定类型数组

    }
}

3.List(接口)  共有的特点：有序(按照添加顺序)，可以有重复元素

    ArrayList

            底层是通过数组实现的，是可以变长的

             查询快，中间增删慢

package com.ffyc.javaCollection;

import java.util.ArrayList;

public class ArrayListDemo1 {
    public static void main(String[] args) {
        /*
         ArrayList底层是数组实现
         add();像集合中添加元素时，底层会默认创建一个长度为10的Object类型数组
         当数组装满时，再次添加元素，会创建一个原来数组长度1.5倍的新数组，将原数组的内容复制过里啊、、、过来
         最后将新地址赋给底层数组

         if (minCapacity - elementData.length > 0)
            grow(minCapacity);//底层扩容的方法
         */
        ArrayList<String> list = new ArrayList<>();
                          list.add("a");
                          list.add("b");
                          list.add("c");
                          list.add("d");
                          list.add("d");
                          list.add(0,"x");//向指定下标位置插入元素
                          list.contains("x");//集合中是否包含某一元素
                          list.get(3);//取下标为3的元素
                          list.set(0,"y");//替换指定位置上的元素
        System.out.println(list.size());//返回集合中实际存储的元素个数
        System.out.println(list.remove(2));//删除索引为2上的元素
        System.out.println(list.contains("x"));
        System.out.println(list);
        System.out.println(list.get(3));
    }
}

LinkedList

            底层是链表实现

            查询慢（必须从头/尾开始查找，直到找到），中间增删快，只需改变后继结点的位置 

package com.ffyc.javaCollection;

import java.util.LinkedList;

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

        LinkedList<String> llist = new LinkedList<>();
                           llist.add("a");
                           llist.add("b");
                           llist.add("c");
                           llist.add("d");
                           llist.add("e");
                           llist.get(3);//要找的元素位置小于size/2，那就从头结点开始，否则从尾结点开始查找
                           llist.addFirst("x");//从第一个位置添加元素
                           llist.addLast("y");//从最后一个位置添加元素
                           llist.removeFirst();//删除第一个元素
                           llist.removeLast();//删除末尾元素
        System.out.println(llist.get(3));
        System.out.println(llist);

    }
}

     Vector

             底层是数组实现，线程安全的

package com.ffyc.javaCollection;

import java.util.Vector;

public class VectorDemo {
    public static void main(String[] args) {
        Vector<String> v = new Vector<>();
                       v.add("a");
                       v.add("b");
                       v.add("c");
                       v.add("d");
                       v.add("a");
                       v.add("a");


        System.out.println(v);//[a, b, c, d, a, a]
    }
}

4.集合的遍历

     for循环

     增强for循环

package com.ffyc.javaCollection;

import java.util.ArrayList;

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

        ArrayList<String> list = new ArrayList<>();
                          list.add("a");
                          list.add("b");
                          list.add("c");
                          list.add("d");
                          list.add("d");
                          list.add("a");
                          list.add("b");
                          list.add("c");
                          list.add("d");
                          list.add("d");
        /*
          for循环，集合中元素的遍历
        */
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("------------------------------");
        /*
        增强for循环，合中元素的遍历
         */
        for(String s : list){
            System.out.println(s);
        }
    }
}