集合

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
数组虽然也可以存储对象，但长度是固定的，集合的长度是可变的；而且数组只能存储基本类型的数据，集合只能存储对象。
集合框架图：

问：集合中为什么会有那么多的容器呢？
因为每一个容器对数据的存储方式都有不同，这个存储方式称之为：数据结构
Collection
Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。
|——-List:元素有序，可以重复，因为有索引
|——-|—–ArrayList：底层使用数组存储结构，查：快，增删：稍慢，线程不同步
|——-|—–LinkedList：底层使用链表存储结构，查：慢，增删：快
|——-|—–Vector：与ArrayList一样，在Collection出现前就有，线程同步，被ArrayList替代了
|——-Set:元素无序(存储和取出顺序不一定一致)，不能重复
|——-|—–HashSet:底层数据结构是Hash表，
|——-|—–TreeSet:
Set集合的功能和Collection是一致的

集合Collection的共性方法，以ArrayList为例：

package second;

import java.util.ArrayList;
/*
 * 1.add方法的参数类型是Object，以便于接受任意类型对象
 * 2.集合中存储的都是对象的引用（地址）
 */

public class CollectionDemo {
    public static void main(String[] args) {
        //创建一个集合容器，使用Collection接口的子类：ArrayList
        ArrayList al=new ArrayList();
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        //打印集合长度
        System.out.println("size="+al.size());//size=4
        //打印集合
        System.out.println(al);//[java01, java02, java03, java04]
        //删除元素
        al.remove("java02");
        //al.clear();//清空集合
        System.out.println("size="+al.size());//size=3
        System.out.println("java03是否存在："+al.contains("java03"));//java03是否存在：true
        //al.isEmpty()//是否为空
        method();
        method_get();
    }
    /*
     * 迭代器（Iterator），就是集合的取出元素的方式
     * 迭代器就是把取出方式定义在集合的内部
     * 这样取出方式就可以直接访问集合内容的元素
     * 取出方式被定义为内部类
     * 每一个集合的数据结构不同，所以取出的动作也不一样
     * 但是都有共性内容，判断和取出，可以将这些共性抽取即Iterator
     * 通过对外提供的iterator()获取
     */
    public static void method_get() {
        ArrayList al1=new ArrayList();
        al1.add("java01");
        al1.add("java02");
        al1.add("java03");
        al1.add("java04");
        for(Iterator it=al1.iterator();it.hasNext();){
            System.out.println(it.next());
        }
    }
    public static void method() {
        ArrayList al1=new ArrayList();
        al1.add("java01");
        al1.add("java02");
        al1.add("java03");
        al1.add("java04");
        ArrayList al2=new ArrayList();
        al2.add("java05");
        al2.add("java06");
        al2.add("java03");
        al2.add("java04");
        //al1.retainAll(al2);//al1=[java03, java04],取交集
        al1.removeAll(al2);//al1=[java01, java02]，去掉al2中包含的
        System.out.println(al1);
    }
}

List集合的共性方法

package second;
/*
 * List 集合的特有方法，（所有带角标的都是其特有方法）
 * 增add(index,element);         addAll(index,Collection)
 * 删remove(index)
 * 改set(index,element)
 * 查get(index)                  subList(from,to)        ListIterator()
 * 
 * List集合的特有迭代器ListIterator是Iterator的子接口
 * 在迭代时，不可以通过集合对象的方法操作集合中的元素，会发生异常
 * 所以在迭代时，Iterator方法是有限的，只能有判断，取出，删除操作
 * 如果想要增加修改等操作，就需要其子接口，ListIterator
 * 该借款通过List的ListIterator方法获取
 */

import java.util.ArrayList;
import java.util.ListIterator;

public class ListDemo {
    public static void main(String[] args) {
        //以ArrayL为例
        ArrayList al=new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        System.out.println("原来的集合"+al);
        al.add(1, "java05");
        System.out.println("add以后"+al);
        al.remove(2);
        System.out.println("remove以后"+al);
        al.set(1, "java07");
        System.out.println("set以后"+al);
        //获取元素
        System.out.println("get获取元素"+al.get(1));
        //获取所有元素
        for(int i=0;i<al.size();i++){
            System.out.println("al-->"+i+":"+al.get(i));
        }
        //获取对象的位置
        System.out.println(al.indexOf("java03"));
        System.out.println(al.subList(0, 2));//包头不包尾
        //在迭代过程中准备添加或删除元素，但不能对数据进行并发操作，要用到列表迭代器
        ListIterator li=al.listIterator();
        while(li.hasNext()){
            Object obj=li.next();
            if (obj.equals("java03")){
                li.add("java10");
            }
        }
        //li.hasPrevious();//可以逆向遍历
        System.out.println(al);
    }
}

Set集合举例

package second;

import java.util.HashSet;
import java.util.Iterator;
public class SetDemo {
public static void main(String[] args) {
    HashSet hs=new HashSet();
    hs.add("java01");
    hs.add("java02");
    hs.add("java03");
    hs.add("java04");
    System.out.println(hs.add("java01"));
    for(Iterator it=hs.iterator();it.hasNext();){
        System.out.println(it.next());
    }
    HashSet hsP=new HashSet();
    hsP.add(new Person("zhangsan",20));
    hsP.add(new Person("zhangsan",20));
    hsP.add(new Person("zhangsi",21));
    hsP.add(new Person("zhangwu",22));
    for(Iterator it=hsP.iterator();it.hasNext();){
        System.out.println(it.next());
    }
}
}
/*
 * HashSet是如何确定元素的唯一性呢？
 * 通过元素的两个方法。hashCode()和equals()来完成
 * 如果元素的hashCode相同，元素会判断equals是否为true
 */
class Person{
    private String name;
    private int age;
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int hashCode(){
        return name.hashCode()+age;
    }
    public boolean equals(Object obj){
        if(!(obj  instanceof Person) ) {
            return false;
        }
        Person p=(Person) obj;
        return this.name.equals(p.getName())&&this.age==p.getAge();
    }
    public int getAge() {
        return age;
    }
}

Map集合
Map将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
|—HashMap：底层是hash表数据结构，可以存储null键null值，线性不同步
|—TreeMap底层是二叉树数据结构，线性不同步，可以给Map的键排序
|—HashTable:底层是hash表数据结构，不可以存储null键null值，线性同步，被HashMap取代了
其实Set的底层就使用了Map
Map的一般方法

package second;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

/*
 * 借口的共性方法
 * 添加：put()  putAll()
 * 删除：clear()  remove()
 * 判断：containsValue() containsKey() isEmpty()
 * 获取：get() size() values()
 * 
 */
public class MapDemo {
    public static void main(String[] args) {
        Map<String, String>map=new HashMap<String,String>();
        Map<String, String>map2=new HashMap<String,String>();
        map.put("01", "zhangsan");
        map.put("02", "zhangsi");
        map.put("03", "zhangwu");
        System.out.println("size:"+map.size());
        System.out.println("containsKey 02:"+map.containsKey("02"));
        System.out.println("get:"+map.get("02"));
        System.out.println("remove:"+map.remove("02"));
        System.out.println("get:"+map.get("02"));
        map2.put("03", "zhangwu");
        System.out.println(map2.put("03", "wangwu"));//当存放相同键是会把原来的替换，并且返回原来的值
        System.out.println(map2.put("04", "wanger"));
        map.putAll(map2);
        System.out.println("size:"+map.size());
        System.out.println(map.get("03"));
        //values()返回所有值
        Collection<String>c=map.values();
        System.out.println(c);
    }
}

Map的特殊取出方法

package second;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
 * 
 * entrySet():将map中所有的键存入Set集合，因为Set可以迭代
 *          所以可以迭代出所有的键，再用get取出
 * keySet():将map中的映射关系取出，放到map.entry中
 * 
 */
public class MapDemo2 {
    public static void main(String[] args) {
        keySet();
        entrySet();
    }
    public static void keySet() {
        Map<String, String>map=new HashMap<String,String>();
        map.put("01", "zhangsan");
        map.put("02", "zhangsi");
        map.put("03", "zhangwu");
        //获取键，用keySet（）
        Set<String>keySet=map.keySet();
        //获取迭代器
        for(Iterator<String>it=keySet.iterator();it.hasNext();){
            String key=it.next();
            String value=map.get(key);
            System.out.println("key:"+key+" value:"+value);
        }
    }
    public static void entrySet() {
        Map<String, String>map=new HashMap<String,String>();
        map.put("01", "zhangsan");
        map.put("02", "zhangsi");
        map.put("03", "zhangwu");
        //获取键，用keySet（）
        Set<Map.Entry<String, String>>entrySet=map.entrySet();
        //获取迭代器
        for(Iterator<Map.Entry<String, String>>it=entrySet.iterator();it.hasNext();){
            Map.Entry<String, String> me=it.next();
            String value=me.getValue();
            String key=me.getKey();
            System.out.println("key:"+key+" value:"+value);
        }
    }
}

简单的集合就到这儿
谢谢！