集合框架

集合框架继承关系图：

Java集合框架提供了一套性能优良，使用方便的接口和类，位于java.util包内。集合框架包含三大内容，对外的接口，接口的实现类，和对集合运算的算法。

对外的接口：表示集合的抽象数据类型（Collection,List,Set,Map,Iterator）。
**接口的实现类：**ArrayList,LinkedList,HashSet,TreeSet,HashMap,TreeMap
算法：**Java提供了进行集合操作的工具类**Collections

Collection：无序 不唯一
Set（相当于数学中的集合）：无序 唯一
List（相当于数学中的数组）：有序 不唯一
Map(相当于键值对)：Key(键)：无序，唯一，Value(值）:无序，不唯一。
Iterator：定义访问和遍历元素的接口

---

List接口：

常用类：ArrayList和LinkedList，都不唯一，有序。

ArrayList：对数组进行封装，实现了长度可变的数组，在内存中分配连续的空间，故而查询效率高，增删慢。查询快，增删慢，线程不安全，效率高
LinkedList：采用链表存储方式，故而在插入删除元素时效率高。查询慢，增删快，线程不安全，效率高（链表形式）

ArrayList常用方法使用案例

package test;

import java.util.List;
import java.util.ArrayList;

public class Test {

    public static void main(String[] args) {
        Dog dog1=new Dog("欧欧1",3);
        Dog dog2=new Dog("美美2",2);
        Dog dog3=new Dog("菲菲3",4);
        Dog dog4=new Dog("亚亚4",5);
        List list=new ArrayList();//声明集合
        list.add(dog1);//list.add()返回值类型boolean
        list.add(dog3);
        list.add(dog4);
        //指定位置添加元素,从0开始计算
        list.add(2,dog2);
        //list.size()返回元素个数
        System.out.println("共有"+list.size()+"条狗");
        for(int i=0;i<list.size();i++){
            //list.get(int index)返回索引指定位置元素，类型Object，需要强转处理
            Dog dog=(Dog) list.get(i);
            System.out.println(dog.getName()+"\t"+dog.getAge());
        }
        //删除集合中第一个和dog3元素
        list.remove(0);//list.remove(index)，返回object类型
        list.remove(dog3);//list.remove(object)，返回boolean类型
        System.out.println("删除后共有"+list.size()+"条狗");
        for(int i=0;i<list.size();i++){
            //list.get(int index)返回索引指定位置元素，类型Object，需要强转处理
            Dog dog=(Dog) list.get(i);
            System.out.println(dog.getName()+"\t"+dog.getAge());
        }
        //判断是否包含指定狗dog3元素
        if(list.contains(dog3)){//list.contains(object)返回boolean类型
            System.out.println("包含");
        }else{
            System.out.println("不包含");
        }
    }

LinkedList常用方法使用案例
上一案例中所以方法都可以适用于LinkedList。
除此之外还有些特有的特殊方法，如下：

package test;

import java.util.List;
import java.util.LinkedList;

public class Test {

    public static void main(String[] args) {
        Dog dog1=new Dog("欧欧1",3);
        Dog dog2=new Dog("美美2",2);
        Dog dog3=new Dog("菲菲3",4);
        Dog dog4=new Dog("亚亚4",5);
        LinkedList list=new LinkedList();//声明集合，注意和ArrayList不同
        list.add(dog1);//list.add()返回值类型boolean
        list.add(dog4);
        list.addFirst(dog2);//list.addFirst()列表首部添加
        list.addLast(dog3);//列表尾部添加
        list.removeFirst();//移除并返回第一个元素
        list.removeLast();//移除并返回最后一个元素
        Dog dog=(Dog)list.getLast();//返回最后一个元素
        //Dog dog=(Dog)list.removeLast();//注意:因为removeLast也可以返回，故此处有相同效果
        System.out.println("姓名"+dog.getName());
    }

}

---

Set接口：

Set接口描述的是一种比较简单的集合，集合中的对象并不按特定顺序排列，且不能保存重复的对象，即Set接口可以存储一组唯一，无序的对象

HashSet：唯一无序，线程不安全，允许集合内元素值为null。底层数据结构是哈希表。

HashSet是如何保证元素唯一性的呢？
　　是通过元素的两个方法，hashCode和equals来完成。
　　如果元素的HashCode值相同，才会判断equals是否为true。
　　如果元素的hashcode值不同，不会调用equals。
　　注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

常用方法：
boolean add(Object o)//添加元素
void clear()//移除所有元素
int size()//元素数量
boolean is Empty()//判断是否set为空
boolean contains(Object o)//是否包含这个元素
boolean remove(Object o)//如果元素存在，则移除

package test;

import java.util.HashSet;
import java.util.Set;

public class Test {

    public static void main(String[] args) {
        Dog dog1=new Dog("欧欧1",3);
        Dog dog2=new Dog("美美2",2);
        Dog dog3=new Dog("菲菲3",4);
        Dog dog4=new Dog("亚亚4",5);
        Set set=new HashSet();//声明集合
        set.add(dog1);//添加
        set.add(dog4);
        set.add(dog2);
        set.add(dog3);
        set.remove(dog1);//移除元素
        System.out.println("共有"+set.size()+"条狗");
        for(Object obj :set){//hashset无get方法,只能用增强for循环来遍历
            Dog dog=(Dog)obj;
            System.out.println(dog.toString());
        }
    }

}

另一种遍历：

public class Test {
    public static void main(String[] args) {
        Dog dog1=new Dog("欧欧1",3);
        Dog dog2=new Dog("美美2",2);
        Dog dog3=new Dog("菲菲3",4);
        Dog dog4=new Dog("亚亚4",5);
        Set set=new HashSet();//声明集合
        set.add(dog1);//添加
        set.add(dog4);
        set.add(dog2);
        set.add(dog3);
        set.remove(dog1);//移除元素
        System.out.println("共有"+set.size()+"条狗");
        for(Iterator it=set.iterator();it.hasNext();){//hashset无get方法,只能用增强for循环来遍历
            System.out.println(it.next());
        }
    }
    }

TreeSet：
有序的存放：TreeSet　　线程不安全，可以对Set集合中的元素进行排序
通过compareTo或者compare方法来保证元素的唯一性，元素以二叉树的形式存放。

TreeSet存储对象的时候, 可以排序, 但是需要指定排序的算法

Integer能排序(有默认顺序), String能排序(有默认顺序), 自定义的类存储的时候出现异常(没有顺序)

如果想把自定义类的对象存入TreeSet进行排序, 那么必须实现Comparable接口
在类上implement Comparable
重写compareTo()方法
在方法内定义比较算法, 根据大小关系, 返回正数负数或零
在使用TreeSet存储对象的时候, add()方法内部就会自动调用compareTo()方法进行比较, 根据比较结果使用二叉树形式进行存储

package test;

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;



public class Test {

        public static void main(String[] args) {
            Set ts = new TreeSet();//定义TreeSet
            ts.add("abc");//添加数据，int和String类型支持，其他类型需要实现Comparable接口
            ts.add("xyz");
            ts.add("rst");
            Iterator it = ts.iterator();//迭代
            while (it.hasNext()) {
                System.out.println(it.next());
            }
        }
    }

---

Map接口：

Map接口存储一组成对的键值对，提供Key到Value的映射，Key无序唯一，Value无序不唯一。

Hash存储方式是哈希表，通过把关键码（key value）映射到表中一个位置来访问记录，以加快查找速度。存放记录的数组成为哈希表，这种存储方式优点是查询指定元素效率高

HashMap使用方法

package test;

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

public class Test {

        public static void main(String[] args) {
            Map map = new HashMap();//定义HashMap
            map.put("CN", "中国");//存储键值对
            map.put(2, 2);//键值对可以是任意类型
          //Object get(Object key)通过键来查找值，注意结果还是Object类型需要强转
            int i=(int) map.get(2);
            System.out.println(i);
            System.out.println("Map有几组数据:"+map.size());//返回元素个数
            System.out.println(map.keySet());//返回键的集合
            System.out.println(map.values());//返回值的集合
            map.remove(2);//删除键对应的键值对
            map.containsKey(2);//判断是否存在该键
            map.clear();//删除所有映射关系（键值对）
            if(map.isEmpty()){//判断map是否还存在映射关系（键值对）
                 System.out.println("空");   
            }
        }
    }

---

迭代器Iterator

迭代器为集合而生，专门实现集合的遍历，提供了遍历集合统一编程接口。

Collection接口的Iterator（）方法返回一个Iterator,通过Iterator接口的两个方法即可方便的遍历。

boolean hasNext( )//判断是否存在另一个可访问的元素
object next( )//返回要访问的下一个元素

package test;

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

public class Test {

        public static void main(String[] args) {
            Dog dog1=new Dog("欧欧1",3);
            Dog dog2=new Dog("美美2",2);
            Dog dog3=new Dog("菲菲3",4);
            Dog dog4=new Dog("亚亚4",5);
            //放入map对象
            Map map=new HashMap();
            map.put(dog1.getName(), dog1);
            map.put(dog2.getName(), dog2);
            map.put(dog3.getName(), dog3);
            map.put(dog4.getName(), dog4);
            //迭代
            Set keys=map.keySet();//取出key集合
            Iterator it=keys.iterator();//迭代，获取Iterator对象
            while(it.hasNext()){//遍历
                String key=(String) it.next();//取出key(强转)
                Dog dog=(Dog) map.get(key);//根据key获得对应的dog对象
                int i=dog.getAge();
                System.out.println(key+"\t"+i);
            }
        }
    }

核心代码：

Iterator it=a.iterator();//迭代，获取Iterator对象
while(it.hasNext()){//判断是否存在另一个可访问元素，配合while()即遍历作用
String key=(String) it.next();//返回要访问的下一个元素

例2：迭代ArrayList

public class Test {

        public static void main(String[] args) {
            Dog dog1=new Dog("欧欧1",3);
            Dog dog2=new Dog("美美2",2);
            Dog dog3=new Dog("菲菲3",4);
            Dog dog4=new Dog("亚亚4",5);
            //放入map对象
            List list=new ArrayList();
            list.add(dog1);
            list.add(dog2);
            list.add(dog3);
            list.add(dog4);

            //迭代
            Iterator it=list.iterator();//迭代，获取Iterator对象
            while(it.hasNext()){//遍历
            Dog dog=(Dog) it.next();
                System.out.println(dog.getName()+"\t"+dog.getAge());
            }
        }
    }

---

增强型for循环

for语句的简化版本，通常称为foreach语句。
语法：

for(元素类型t 元素变量X ：数组或者集合对象）{
    //引用了X的语句
}

其中，t类型必须是属于集合或者对象的元素类型。

public class Test {
    public static void main(String[] args) {
        Dog dog1=new Dog("欧欧1",3);
        Dog dog2=new Dog("美美2",2);
        Dog dog3=new Dog("菲菲3",4);
        Dog dog4=new Dog("亚亚4",5);
        //放入map对象
        List list=new ArrayList();
        list.add(dog1);
        list.add(dog2);
        list.add(dog3);
        list.add(dog4);
        for(Object obj:list){
            Dog dog=(Dog) obj;
            System.out.println(dog.getName()+"\t"+dog.getAge());
        }
    }
    }

---

泛型应用：

上面的代码每次都要强转类型，可以通过泛型在创建集合时就指定集合中元素的类型，从而取出集合中的元素时无需强转。

上面代码用泛型优化修改后：

public class Test {
    public static void main(String[] args) {
        Dog dog1=new Dog("欧欧1",3);
        Dog dog2=new Dog("美美2",2);
        Dog dog3=new Dog("菲菲3",4);
        Dog dog4=new Dog("亚亚4",5);
        //放入map对象
        List<Dog> list=new ArrayList<Dog>();//引入泛型
        list.add(dog1);
        list.add(dog2);
        list.add(dog3);
        list.add(dog4);
        for(Dog dog:list){
            System.out.println(dog.getName()+"\t"+dog.getAge());
        }
    }
    }

注意：泛型机制是给编译器看的，本身不参与编译，底层机制没有泛型概念。