黑马程序员 集合框架

——- android培训、java培训、期待与您交流！ ———-

1，为什么会出现集合类

面向对象语言对实物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。对象多的时候有集合可以存储。

然而集合和数组区别在哪里？

数组也可以存储对象，但是数组长度固定，集合长度可变；而且集合只能存储对象，数组可以存储基本数据类型。

根据数据存储的方式不同功能不同，出现了许多类型的容器，就是数据结构不同。

集合关系图

2，Collection
(a)List：元素是有序的，可以重复，因为List体系内有索引
(b)Set：元素是无序的，不可以重复

Collection的共性方法

(a)添加：
boolean add(Object obj)
add方法的参数类型是Object，以便于接收任意类型对象

(b)删除：
boolean remove(Object obj)
从集合中移除指定元素的单个实例，如果删除成功返回true
void clear()
移除这个集合中所有的元素

(c)判断：
boolean contains(Object obj)
如果此集合中包含obj元素，返回true
boolean isEmpty()
判断这个集合是否为空

(d)获取
int size()
获取集合内元素的个数

3，迭代器

迭代器简单来讲就是取出集合中元素的方式。

每个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性内容，判断和取出，那么可以将这些共性抽取一个规则（这些内部类中抽取一个规则），这个规则就是Iterator。

迭代的常用方法：

(a)boolean hasNext()
如果还有下一个元素，返回true，可以作为循环条件

(b)E next()
返回迭代的下一个元素

(c)void remove()
移除迭代器返回的最后一个元素

ArrayList a1= new ArrayList();//创建一个集合

Iterator it=a1.iterator();//获取一个迭代器，用于取出集合中的元素。

while(it.hasNext())

{

system.out.println(it.next());

}

4，List集合

List：元素是有序的，元素可以重复，因为该集合体系有索引。

(a)ArrayList 底层的数据结构是数组结构。
查询速度快，增删速度慢，线程不同步。ArrayList的长度是可变化的

(b)LinkedList 底层的数据结构是表链数据结构。
增删速度快，查询速度慢

(c)Vector 底层的数据结构是数组数据结构。
增删，查询都很慢，线程同步，被ArrayList替代

凡是可以操作角标的方法都是该体系特有的方法

增

void add(int index , E element) 在列表指定位置插入指定元素

删

E remove(int index) 移除列表中指定位置的元素

改

E set(int index , E element) 用指定元素替换列表中指定位置的元素

查

E get(int index) 返回列表中指定位置的元素

ListIterator listIterator() 返回此列表元素的列表迭代器

注意：如果想要其他的操作如：添加，修改等，就需要使用其子接口，ListIterator。该接口只能通过List集合的listIterator()方法获取。

//去除ArrayList集合的重复元素。  
import java.util.*;  
class ArrayListTest  
{  
    public static ArrayList singleElement(ArrayList a1)  
    {  
        ArrayList a2=new ArrayList();//创建集合a2  
        Iterator it=a1.iterator();//获取a1迭待器  
        while(it.hasNext())  
        {  
            /*判断a2集合里是否已存在该元素， 
            不存在则将元素存在a2集合里*/  
            Object obj=it.next();  
            if(!a2.contains(obj))  
                a2.add(obj);  
        }  
        return a2;  
    }  
    public static void main(String[] args)   
    {  
        ArrayList a1=new ArrayList();//创建集合a1  
        //添加元素  
        a1.add("java01");  
        a1.add("java02");  
        a1.add("java01");  
        a1.add("java02");  
        a1.add("java03");  
        System.out.println(a1);  
        a1=singleElement(a1);//调用函数  
        System.out.println(a1);  
    }  
}  

LinkedList

addFirst()：将元素添加在最前面

addLast()：将元素添加在最后面

getFirst()：获取第一个元素

getLast()：获取最后一个元素

removeFirst()：获取第一个元素并从集合中删除该元素

removeLast()：获取最后一个元素并从集合中删除该元素

注意：get方法和remove方法中，如果集合没有元素，则会出现NoSuchElementException

//使用LinkedList模拟一个堆栈或者队列数据结构队  
import java.util.*;  
class DuiLie   
{  
    private LinkedList link;  
    DuiLie()  
    {  
        link=new LinkedList();  
    }  
    public void myAdd(Object obj)  
    {  
        link.addFirst(obj);//先进,在首位添加元素  
    }  
    public Object myRemove()  
    {  
        return link.removeLast();//先出，删除末尾的元素  
    }  
    public boolean isNull()  
    {  
        return link.isEmpty();//判断集合是否为空  
    }     
}  
class LinkedListTest  
{  
    public static void main(String[] args)   
    {  
        DuiLie d=new DuiLie();  
        d.myAdd("java01");  
        d.myAdd("java02");  
        d.myAdd("java03");  
        d.myAdd("java04");  
        while(!d.isNull())  
        {  
            System.out.println(d.myRemove());  
        }  
    }  
}

5，set集合

元素是无序的（存入和取出的顺序不一定一致）元素不可重复

(a)HashSet：底层数据结构是哈希表，线程是非同步的

HashSet特点保证元素唯一性：

通过hashCode()和equals()方法来完成。如果元素的HashCode值相等，才会判断equals是否为true，如果元素的HashCode值不相同，不会调用equals。以上就是HashSet保证元素唯一性的依据。

(b)TreeSet：底层数据结构是二叉树，可以对Set集合中的元素进行排序

实现TreeSet排序有两种方式：

(1)让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法。这种方式也成为元素的自然顺序，或者叫做默认顺序。

(2)当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性。出现比较器。

TreeSet保证元素唯一性的依据：

compareTo方法return 0

import java.util.*;  
class GenericDemo   
{  
    public static void main(String[] args)   
    {  
        //添加了比较器，按照比较器的要求排序  
        //a1集合的元素为Student类型  
        TreeSet<Student> a1=new TreeSet<Student>(new Comp());  
        a1.add(new Student("stu01"));  
        a1.add(new Student("stu03"));  
        a1.add(new Student("stu02"));  
        Iterator<Student> it=a1.iterator();  
        while(it.hasNext())  
        {  
            System.out.println(it.next().getName());  
        }  
        //a2集合的元素为Worker类型  
        TreeSet<Worker> a2=new TreeSet<Worker>(new Comp());  
        a2.add(new Worker("work01"));  
        a2.add(new Worker("work03"));  
        a2.add(new Worker("work02"));  
        Iterator<Worker> it2=a2.iterator();  
        while(it2.hasNext())  
        {  
            System.out.println(it2.next().getName());  
        }  
    }  
}  
class Person  
{  
    private String name;  
    Person(String name)  
    {  
        this.name=name;  
    }  
    public String getName()  
    {  
        return name;  
    }  
}  
class Student extends Person//继承关系  
{   Student(String name)  
    {  
        super(name);//调用父类的构造方法  
    }  
}  
class Worker extends Person//继承关系  
{  
    Worker(String name)  
    {  
        super(name);  
    }     
}  
class Comp implements Comparator<Person>//比较器  
{  
    public int compare(Person p1,Person p2)  
    {  
        return p1.getName().compareTo(p2.getName());  
    }  
}  

6，Map集合

常见方法：

添加

V put( K key , V value) 将指定的值与此映射中的指定键关联。

当存储了相同的键时，新的值会替换老的值，put方法还会把这个键原来的值返回来。当在存第一个键时，没有对应的值，返回的是null。put方法会返回这个键原来的值。

删除

void clear() 从此映射中移除所有映射关系

V remove(Object key) 移除指定键对应的值，并返回这个值，如果此键没有映射关系，返回null

判断

boolean containsKey(Object key) 如果此映射包含指定键的映射关系，则返回true

boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回true

boolean isEmpty() 如果此映射未包含键-值映射关系，则返回 true

获取

get(Object key)
返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回null
可以通过get方法的返回值来判断一个键是否存在，通过返回null来判断

int size() 返回此映射中的键-值映射关系数，也就是集合大小

Set < Map.Entry< K,V > > entrySet() 将此Map集合的映射关系返回到一个Set集合中

Set< K > keySet() 将此映射中所有的键返回到一个Set集合中

Map的子类

Hashtable：底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的，效率低

HashMap：底层是哈希表数据结构，允许使用null键，该集合是不同步的，效率高

TreeMap：底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序

Map集合有两种取出方式

(a)Set< K > keyset()：将Map中所有的键存入到Set集合中

因为Set具备迭代器，所以Set< K > keySer()方法可以通过迭代方式取出所有的键，再根据get方法获取每一个键对应的值。

/* 
keySet：将Map中所有的键存入到Set集合，因为Set具备迭代器。 
所以可以通过迭代方式取出所有的键，在根据get方法，获取每一个键对应的值。 
*/  
import java.util.*;  
class KeySetDemo   
{  
    public static void main(String[] args)   
    {  
        //创建Map集合并定义泛型  
        Map<String,String> map=new HashMap<String,String>();  
        map.put("04","lisi04");  
        map.put("02","lisi02");  
        map.put("01","lisi01");  
        map.put("03","lisi03");  
        //将Map集合中的键存放在Set集合中  
        Set<String> keySet=map.keySet();  
        //获取Set集合的迭待器  
        Iterator<String> it=keySet.iterator();  
        while(it.hasNext())  
        {  
            String key=it.next();  
            String value=map.get(key);//通过键获取该键对应的值  
            System.out.println("key:"+key+";value:"+value);  
        }  
    }  
} 

(b)Set< Map.Entry< K,Y > > entrySet()：将Map集合中的映射关系存入到了Set集合中，而这个关系的数据类型就是Map.Entry

注意：在Map中键值是映射关系，在Set中键值的关系的数据类型就是Map.Entry。键值合起来就是一个Map.Entry的实例对象

/* 
Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了Set集合中， 
而这个关系的数据类型是：Map.Entry。 
*/  
import java.util.*;  
class EntrySetDemo   
{  
    public static void main(String[] args)   
    {  
        //创建Map集合  
        Map<String,String> map=new HashMap<String,String>();  
        map.put("04","lisi04");  
        map.put("02","lisi02");  
        map.put("01","lisi01");  
        map.put("03","lisi03");  
        //将映射关系存放在Set集合里面  
        Set<Map.Entry<String,String>> entrySet=map.entrySet();  
        //获取Set集合的迭待器  
        Iterator<Map.Entry<String,String>> it=entrySet.iterator();  
        while(it.hasNext())  
        {   //提取映射关系，直接获取键值和键值对应的值  
            Map.Entry<String,String> me=it.next();  
            String key=me.getKey();  
            String value=me.getValue();  
            System.out.println("key:"+key+";value:"+value);  
        }  
    }  
}