黑马程序员——Java基础---Java集合

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

Java集合

要想学好Java集合这一部分其实很简单，每一种集合的特点、方法以及使用特点必须牢记，张嘴就能说出来，这些都是记忆性的东西，没什么难度。清楚了各种集合的特点用的时候才会信手拈来。

一.Java集合概述

在编程时，常常需要集中存放多个数据，当然我们可以使用数组来保存多个数据，但是数组长度不可变化，一旦在初始化数组时指定了数组长度，这个数组长度就是不可变的，如果需要保存数量变化的数据，数组就有点无能为力了；而且数组无法保存具有映射关系的数据。如成绩表：语文—79，数学—80，这种数据看上去像两个数组，但是这两个数组的元素之间有一定的关联关系。

为了保存数量不确定的数据，以及保存具有映射关系的数据（也被称为关联数组），Java提供了集合类。集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类。所有的集合类都位于java.util包下。
集合类和数组不一样，数组元素既可以是基本数据类型的值，也可以是对象（实际上保存的是对象的引用变量）；而集合类里只能保存对象（实际上只是保存对象的引用变量，但通常习惯上认为集合里保存的是对象）。

Java的集合类主要有两个接口派生而出：Collection和Map，Collection和Map是Java集合框架的根接口，这两个接口又包含了一些子接口或实现类。
下图是Collection和Map的集合体系，其中标黑框的是我们常用的集合

二.Collection

Collection是集合框架中的常用接口。其下有两个子接口：List，Set。
所属关系：
Collection
|——–List//元素是有序的，元素可以重复。因为该集合体系有索引。
|——–Set//元素是无序的，元素不可以重复。

2.1.Collection接口中的常见操作

1.添加元素
add(Object obj); //add方法的参数类型是Object。以便于接收任意类型对象。
addAll(Collection c)
2.删除元素
clear()//清空集合
remove(Object obj)//删除某一个元素
removeAll()//参数是集合
3.判断元素
contains()//判断是否包含obj这个元素
containsAll()//判断是否包含才这个集合
isEmpty()//判断集合是否为空
4.获取
size();//获取集合长度
5.取交集
retainAll(另一集合);//调用者只保留两集合的共性元素。
注：集合中存储的都是对象的引用（地址）。

2.2.Iterator接口

Iterator是一个迭代器，迭代是取出集合中元素的一种方式。
对于集合的元素取出这个动作：
当不足以用一个函数来描述，需要用多个功能来体现，所以就将取出这个动作封装成一个对象来描述。就把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。
而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都具有共性内容： 判断和取出。那么就可以将这些共性抽取。
那么这些内部类都符合一个规则（或者说都抽取出来一个规则）。该规则就是Iterator。通过一个对外提供的方法：iterator();，来获取集合的取出对象。
因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

2迭代的常见操作
hasNext();//有下一个元素，返回真
next();//取出下一个元素
remove();//移除
注：在迭代时循环中next调用一次，就要hasNext判断一次。
使用：
ArrayList a=newArrayList();//创建一个集合
Iteratorit=a.iterator();//获取一个迭代器，用于取出集合中的元素。
第一种打印方式：
for(Iterator iter = a.iterator();iter.hasNext(); )
{
System.out.println(iter.next());
}

第二种打印方式：

Iteratoriter = a.iterator();
                while(iter.hasNext())
               {
                           System.out.println(iter.next());
               }

3.迭代注意事项
(1)迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。
(2)迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。
(3)迭代器的next方法返回值类型是Object，所以要记得类型转换。

三.List

3.1.List体系

List：元素是有序的，元素可以重复。因为该集合体系有索引。
|——ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|——LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
|——Vector：底层是数组数据结构。线程同步。被ArrayList替代了。

3.2.List的特有方法

凡是可以操作角标的方法都是该体系特有的方法。
3.2.1.增
booleanadd(index,element);//指定位置添加元素
BooleanaddAll(index,Collection);//在指定位置增加给定集合中的所有元素，若省略位置参数，则在当前集合的后面依次添加元素
2.删
Booleanremove(index);//删除指定位置的元素
3.改
set(index,element);//修改指定位置的元素。
4.查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5.其他
listIterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置，如果没有则返回-1
注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。

3.3.ListIterator

1、概述

ListIterator是List集合特有的迭代器，是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以在迭代器时，只能用迭代器的方法操作元素。可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作。如果想要其他的操作，如添加、修改等，就需要使用其子接口：ListIterrator。该接口只能通过List集合的ListIterator方法获取。
2、ListIterator特有的方法
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素

3.4.Vector

Vector有三种取出方式。
其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。
特有方法：
addElement(obj);//添加元素，相当于add(obj);
Enumerationelements();//Vector特有取出方式(枚举)
hasMoreElements();//相当于Iterator的hasNext()方法
nextElements();//相当于Iterator的next()方法

3.5.LinkedList

LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
特有方法：
1、增
addFirst();
addLast();
2、获取
//获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
getFirst();
getLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
在JDK1.6以后，出现了替代方法。
1、增
offFirst();
offLast();
2、获取
//获取元素，但是不删除。如果集合中没有元素，会返回null。
peekFirst();
peekLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
练习一：

/* 
使用LinkedList模拟一个堆栈或者队列数据结构。 

堆栈：先进后出  如同一个杯子。 
队列：先进先出 First in First out  FIFO 如同一个水管。 

*/  
import java.util.*;  

class LinkedListTest  
{  
    public static void main(String[] args)   
    {  
        LinkedList l=new LinkedList();  
        l.addFirst("java01");  
        l.addFirst("java02");  
        l.addFirst("java03");  
        l.addFirst("java04");  
        l.addFirst("java05");  

        //堆栈输出  
    //  stack(l);  

        //队列输出  
        queue(l);  

    }  

    //堆栈  
    public static void stack(LinkedList l)  
    {  
        while (!l.isEmpty())  
        {  
            sop(l.removeFirst());  
        }  
    }  

    //队列  
    public static void queue(LinkedList l)  
    {  
        while(!l.isEmpty())  
        {  
            sop(l.removeLast());  
        }  
    }  

    //输出  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
} 

四.Set

1.概述

Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
|–HashSet：底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。
|–TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0。
Set集合的功能和Collection是一致的。

2.HasSet

HashSet：线程不安全，存取速度快。
可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。
注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
练习二：

/* 
往hashSet集合中存入自定对象 
姓名和年龄相同为同一个人，重复元素。去除重复元素 
思路：1、对人描述，将人的一些属性等封装进对象 
      2、定义一个HashSet容器，存储人对象 
      3、取出 

*/  
import java.util.*;  

//人描述  
class Person  
{  
    private String name;  
    private int age;  

    Person(String name,int age)  
    {  
        this.name=name;  
        this.age=age;  
    }  

    public String getName()  
    {  
        return name;  
    }  

    public int getAge()  
    {  
        return age;  
    }  

    public boolean equals(Object obj)  
    {  
        if(!(obj instanceof Person))  
            return false;  
        Person p=(Person)obj;  
        return this.name.equals(p.name)&&this.age==p.age;  
    }  

    public int hashCode()  
    {  
        return this.name.hashCode()+this.age;  
    }  
}  
class  HashSetTest  
{  
    public static void main(String[] args)   
    {  
        HashSet h=new HashSet();  
        h.add(new Person("shenm",10));  
        h.add(new Person("shenm2",6));  
        h.add(new Person("shenm1",30));  
        h.add(new Person("shenm0",10));  
        h.add(new Person("shenm0",10));  

        getOut(h);  

    }  

    //取出元素  
    public static void getOut(HashSet h)  
    {  
        for (Iterator it=h.iterator(); it.hasNext(); )  
        {  
            Person p=(Person)it.next();  
            sop(p.getName()+"..."+p.getAge());  
        }  
    }  

    //打印  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
}  

3.TreeSet

1.特点

1）底层的数据结构为二叉树结构（红黑树结构）
2）可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。
java中的很多类都具备比较性，其实就是实现了Comparable接口。
3） 保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。
注意：排序时，当主要条件相同时，按次要条件排序。
2.Tree排序的两种方式

1）第一种排序方式：自然排序
让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。
例：

import java.util.*;  
//学生类  
class Student implements Comparable  
{  
    private String name;  
    private int age;  
    Student(String name,int age)  
    {  
        this.name=name;  
        this.age=age;  
    }  
    public String getName()  
    {  
        return name;  
    }  

    public int getAge()  
    {  
        return age;  
    }  
    //复写hashCode以便HashSet集合调用  
    public int hashCode()  
    {  
        return name.hashCode()+age;  
    }  
    //复写equals以便HashSet集合和集合中一些比较方法调用  
    public boolean equals(Object obj)  
    {  
        if(!(obj instanceof Student))  
            throw new RuntimeException();  
        Student s = (Student)obj;  
        return this.name.equals(s.name)&&this.age==s.age;  
    }  
    //复写compareTo以便TreeSet集合调用  
    public int compareTo(Object obj)  
    {  
        Student s=(Student)obj;  
        if(this.age==s.age)  
            return this.name.compareTo(s.name);  
        return this.age-s.age;  
        //return new Integer(this.age).compareTo(new Integer(s.age));   
    }  
}  

class  TreeSetTest  
{  
    public static void main(String[] args)   
    {  
        TreeSet<Student> t=new TreeSet<Student>();  
        t.add(new Student("wo1",12));  
        t.add(new Student("wosj",2));  
        t.add(new Student("wo1sdj",12));  
        t.add(new Student("wo6sd",12));  
        t.add(new Student("wo",22));  


        for (Iterator<Student> it=t.iterator(); it.hasNext(); )  
        {  
            Student s=it.next();  
            System.out.println(s.getName()+"....."+s.getAge());  
        }  
    }  
}  

2）第二种方式：比较器
当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。
当两种排序都存在时，以比较器为主。
示例：

/* 
需求： 
往TreeSet集合中存储自定义对象学生。 
想按照学生的年龄进行排序。 

*/  

import java.util.*;  
//学生类  
class Student implements Comparable  
{  
    private String name;  
    private int age;  
    Student(String name,int age)  
    {  
        this.name=name;  
        this.age=age;  
    }  
    public String getName()  
    {  
        return name;  
    }  

    public int getAge()  
    {  
        return age;  
    }  
    //复写hashCode以便HashSet集合调用  
    public int hashCode()  
    {  
        return name.hashCode()+age;  
    }  
    //复写equals以便HashSet集合和集合中一些比较方法调用  
    public boolean equals(Object obj)  
    {  
        if(!(obj instanceof Student))  
            throw new RuntimeException();  
        Student s = (Student)obj;  
        return this.name.equals(s.name)&&this.age==s.age;  
    }  
    //复写compareTo以便TreeSet集合调用  
    public int compareTo(Object obj)  
    {  
        Student s=(Student)obj;  
        if(this.age==s.age)  
            return this.name.compareTo(s.name);  
        return this.age-s.age;  
        //return new Integer(this.age).compareTo(new Integer(s.age));   
    }  

}  

class  TreeSetTest  
{  
    public static void main(String[] args)   
    {  
        TreeSet<Student> t=new TreeSet<Student>(new LenCompare());  
        t.add(new Student("wo1",12));  
        t.add(new Student("wosj",2));  
        t.add(new Student("wo1sdj",12));  
        t.add(new Student("wo6sd",12));  
        t.add(new Student("wo",22));  


        for (Iterator<Student> it=t.iterator(); it.hasNext(); )  
        {  
            Student s=it.next();  
            System.out.println(s.getName()+"....."+s.getAge());  
        }  
    }  

}  
//定义一个比较器，以姓名长度为主要比较  
class LenCompare implements Comparator<Student>  
{  
    public int compare(Student s1,Student s2)  
    {  
        int num=new Integer(s1.getName().length()).compareTo(new Integer(s2.getName().length()));  
        if (num==0)  
        {  
            return new Integer(s1.getAge()).compareTo(s2.getAge());  
        }  
        return num;  
    }  
}  

五. Map集合

1.概述：

Map< K,V >集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，即键（Key）

2.特点：

1）该集合存储键值对，一对一对往里存
2）要保证键的唯一性。

3.Map集合的子类

Map
|–Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低。
|–HashMap：底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。
|–TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
Map和Set很像。其实Set底层就是使用了Map集合。

4.Map集合的常用方法

1、添加
put(K key,V value);//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。
voidputAll();//添加一个集合
2、删除
clear();//清空
Vremove(Object key);//删除指定键值对
3、判断
containsKey(Objectkey);//判断键是否存在
containsValue(Objectvalue)//判断值是否存在
isEmpty();//判断是否为空
4、获取
Vget(Object key);//通过键获取对应的值
size();//获取集合的长度
Collectionvalue();//获取Map集合中所以得值，返回一个Collection集合

5.Map集合的两种取出方式

Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。
1、Set keySet()：将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值，再通过get方法。获取每一个键对应的值。
例：

/*
每一个学生都有对应的归属地。
学生Student，地址String。
学生属性：姓名，年龄。
注意：姓名和年龄相同的视为同一个学生。
保证学生的唯一性。

思路：1、描述学生类
      2、定义一个Map集合，存储学生对象和地址值
      3、获取Map中的元素
*/

import java.util.*;

//描述学生类
class Student implements Comparable<Student>
{
    private String name;
    private int age;
    Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public String getName()
    {
        return name;
    }

    public int getAge()
    {
        return age;
    }

    //复写hashCode
    public int hashCode()
    {
        return name.hashCode()+age*33; 
    }
    //复写equals，比较对象内容
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Student))
            throw new ClassCastException("类型不匹配");
        Student s=(Student)obj;
        return this.name.equals(s.name)&&this.age==s.age;
    }

    //复写compareTo,以年龄为主
    public int compareTo(Student c)
    {
        int num=new Integer(this.age).compareTo(new Integer(c.age));
        if(num==0)
        {
            return this.name.compareTo(c.name);
        }
        return num;
    }

    //复写toString，自定义输出内容
    public String toString()
    {
        return name+"..."+age;
    }

}
class  HashMapTest
{
    public static void main(String[] args) 
    {
        HashMap<Student,String > hm=new HashMap<Student,String >();
        hm.put(new Student("zhangsan",12),"beijing");
        hm.put(new Student("zhangsan",32),"sahnghai");
        hm.put(new Student("zhangsan",22),"changsha");
        hm.put(new Student("zhangsan",62),"USA");
        hm.put(new Student("zhangsan",12),"tianjing");

        keyset(hm);
    }

    //keySet取出方式
    public static void keyset(HashMap<Student,String> hm)
    {
        Iterator<Student> it=hm.keySet().iterator();

        while(it.hasNext())
        {
            Student s=it.next();
            String addr=hm.get(s);
            System.out.println(s+":"+addr);
        }
    }
}

2、Set< Map.entry< K, V>> entrySet()：将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry
其实，Entry也是一个接口，它是Map接口中的一个内部接口。
例：

class  HashMapTest  
{  
    public static void main(String[] args)   
    {  
        HashMap<Student,String > hm=new HashMap<Student,String >();  
        hm.put(new Student("zhangsan",12),"beijing");  
        hm.put(new Student("zhangsan",32),"sahnghai");  
        hm.put(new Student("zhangsan",22),"changsha");  
        hm.put(new Student("zhangsan",62),"USA");  
        hm.put(new Student("zhangsan",12),"tianjing");  

        entryset(hm);  
    }  
//entrySet取出方式  
    public static void entryset(HashMap<Student,String> hm)  
    {  
        Iterator<Map.Entry<Student,String>> it=hm.entrySet().iterator();  

        while(it.hasNext())  
        {  
            Map.Entry<Student,String> me=it.next();  
            Student s=me.getKey();  
            String addr=me.getValue();  
            System.out.println(s+":::"+addr);  
        }  
    }  
}  

关于Map.Entry：
Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。为何要定义在其内部呢？
原因：a、Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。
b、并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。

六.Map扩展

在很多项目中，应用比较多的是一对多的映射关系，这就可以通过嵌套的形式将多个映射定义到一个大的集合中，并将大的集合分级处理，形成一个体系。
如：

/* 
map扩展知识。 
map集合被使用是因为具备映射关系。 
以下是班级对应学生，而学生中学号对应着姓名的映射关系： 
"yureban"   Student("01" "zhangsan"); 

"yureban" Student("02" "lisi"); 

"jiuyeban" "01" "wangwu"; 
"jiuyeban" "02" "zhaoliu"; 

就如同一个学校有多个教室。每一个教室都有名称。 
*/  
import java.util.*;  

class  MapExpandKnow  
{  
    public static void main(String[] args)   
    {  
        //预热班集合  
        HashMap<String,String> yureban=new HashMap<String,String>();  
        //就业班集合  
        HashMap<String,String> jiuyeban=new HashMap<String,String>();  
        //学校集合  
HashMap<String,HashMap<String,String>> czbk=new HashMap<String,HashMap<String,String>>();  

        //学校中班级集合和名称的映射  
        czbk.put("yureban",yureban);  
        czbk.put("jiuyueban",jiuyeban);  

//预热班级中学号与姓名的映射  
        yureban.put("01","zhangsan");  
        yureban.put("02","lisi");  

        //就业班级中学号与姓名的映射  
        jiuyeban.put("01","wangwu");  
        jiuyeban.put("02","zhouqi");  

            //直接显示全部学生信息  
        getAllStudentInfo(czbk);  

    }  
    //定义一个方法获取全部学生信息，包括在哪个班级，叫什么名字，学号多少  
    public static void getAllStudentInfo(HashMap<String ,HashMap<String,String>> hm)  
    {  
        for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )//用keySet取出方式  
        {  
            String s= it.next();//班级名称  
            System.out.println(s+":");  
            HashMap<String,String> stu=hm.get(s);//班级集合  

            getStudentInfo(stu);  
        }  
    }  

    //获取班级中学生的信息，包括姓名和学号  
    public static void getStudentInfo(HashMap<String,String> hm)  
    {  
        for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )  
        {  
            String key=it.next();//学号  
            String value=hm.get(key);//姓名  
            System.out.println(key+"..."+value);  
        }  
    }  
}