黑马程序员—集合

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

1.集合类的关系图：
这张图简单扼要地介绍了集合框架各种类之间的关系：

1.1集合类是什么？
集合就是存储对象最常用的一种方式，为了方便对多个对象的操作，和对象进行存储。

1.2数组和集合类的异同？
两者都是容器。
不同之处在于数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

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

常见操作：
1、添加元素
add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。
2、删除元素
remove(Objectobj);
removeAll(另一集合);//调用者只保留另一集合中没有的元素。
clear();//清空集合
3、判断元素
contains(Objectobj);//判断是否存在obj这个元素
isEmpty();//是否为空
4、获取个数，集合长度
size();
5、取交集
retainAll(另一集合);//调用者只保留两集合的共性元素。

import java.util.*;//导入包

class CollectionDemo 
{
    public static void main(String[] args) 
    {
        ArrayList al = new ArrayList();
        ArrayList all = new ArrayList();

        //添加元素
        //add方法的参数类型是Object，以便于接收任意类型对象。
        al.add("java 01");
        al.add("java 02");
        al.add("java 03");
        al.add("java 04");
        al.add("java 05");
        al.add("java 06");
        al.add(0,"java 00");

        all.add("java 01");
        all.add("java 02");
        all.add("java 03");

        //打印集合
        sop("al原集合："+al);
        sop("all原集合："+all);
        //删除第二个角标的元素
        al.remove(2);
        //删除al和all集合的交集元素
        al.removeAll(all);
        //保留al和all集合的交集元素
        al.retainAll(all);
        //获取个数，集合长度
        sop(al.size());
        //判断集合是否为空，长度为0
        sop(al.isEmpty());
        //移除集合里的所有元素
        al.clear();
        sop(al);

        //判断al集合是否包含此元素
        sop(al.contains("java 01"));
        //判断al集合是否包含all集合的所有元素
        sop(al.containsAll(all));

        //获取集合al的哈希码值
        sop(al.hashCode());

        //获取集合al的迭代器,用于取出集合中的元素。
        sop(al.iterator());
        Iterator it = al.iterator();
        //如果仍有元素可以迭代，则返回true。
        while(it.hasNext())
        {
            sop("下一个元素="+it.next());
        }
        //返回包含al集合所有元素的数组
        sop(al.toArray());
    }

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

2.2 迭代：
什么是迭代器呢？
其实就是集合取出元素的方式。

把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。
那么取出方式就被定义成了内部类。
而每一个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性内容，
判断和取出。那么可以将共性内容抽取，

那么这些内部类都符合一个规则，该规则是Iterator。如何获取集合的取出对象呢？
通过一个对外提供的方法，iterator():

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

3.2 List的特有方法
凡是可以操作角标的方法都是该体系特有的方法。
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 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();

代码：

import java.util.*;
class LinkedListDemo
{
    public static void main(String[] args) 
    {
        LinkedList link = new LinkedList();

        link.addLast("java00");
        link.addLast("java01");
        link.addLast("java02");
        link.addLast("java03");
        link.addLast("java04");
        link.addLast("java05");

        sop("原来集合="+link);

        //返回此列表的第一个元素。
        sop(link.getFirst());
        sop(link.getLast());
        //获取但不移除此列表的头（第一个元素）。
        sop(link.element());
        sop(link.get(2));

        //移除并返回此列表的第一个元素。
        sop(link.removeFirst());
        //移除并返回此列表的最后一个元素。
        sop(link.removeLast());
        //返回此列表的元素数。
        sop(link.size());

        //用这种循环遍历的方法也可以将元素全部提取出来。
        while (!link.isEmpty())//只要link集合有元素，就一直循环。
        {
        //移除并返回此列表的第一个元素。如果列表为空，返回NoSuchElementException。
            sop(link.removeFirst());
        //获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
            sop(link.pollFirst());
        }

    }

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

4. Set：
|–Set:元素是无序的(存入和取出顺序不一定一致），元素不可以重复，集合体系没有索引。
|–HashSet:底层数据结构是哈希表。
Hash是如何保证元素唯一性的呢？
是通过元素的两个办法，hashCode和equals来完成。
如果元素的hashCode值相同，才会判断equals是否为true。
如果元素的hashCode值不同，不会调用equals。
注意：对于判断元素是否存在，以及删除等操作，依赖的方法
是元素的hashCode和equals方法。
|–TreeSet
可以对Set集合中的元素进行排序。
排序时，当主要条件相同时，一定要判断一下次要条件。
可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据：
compareTo方法return 0。

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

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;
    }


    public int compareTo(Object obj)
    {
        //return 1;//会以存入的顺序取出，先进先出
        //return -1;//会以存入的反顺序取出，先进后出
        //TreeSet底层数据结构是二叉树，只看返回的结果，如果是正数，放到右下，如果是负数，放到左下，如果是零，后面传入的对象都相等，保留第一个对象。

        if(!(obj instanceof Student))
        throw new RuntimeException("这不是学生对象");

        Student s = (Student)obj;
        //System.out.println(this.name+"..compareTo."+s.name);
        if(this.age > s.age)
            return 1;
        if(this.age==s.age)
            return this.name.compareTo(s.name);
        else
            return -1;


    }
}

class TreeSetDemo
{
    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet();

        ts.add(new Student("zhangsan",10));

        /*
        ts.add(new Person("zhangsan",10));
        提示异常：ClassCastException 
        zhangsan..compareTo.zhangsan
        Exception in thread "main" java.lang.
        ClassCastException: Person cannot be cast to java.lang.Comparable
        at java.util.TreeMap.put(Unknown Source)
        at java.util.TreeSet.add(Unknown Source)
        at TreeSetDemo.main(TreeSetDemo.java:121)
        */

        ts.add(new Student("lisi",20));
        ts.add(new Student("wangwu",30));
        ts.add(new Student("zhangsan",20));
        ts.add(new Student("zhangsan",10));

        Iterator it = ts.iterator();
        while (it.hasNext())
        {
            Student stu = (Student)it.next();
            sop(stu.getName()+","+stu.getAge());
        }
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

运行结果：

5. Map：
1.获取
get(Object key) :返回指定键所映射的值；
如果此映射不包含该键的映射关系，则返回 null。
size()
返回此映射中的键-值映射关系数。
values()
返回此映射中包含的值的 Collection 视图。

2.增加
put(K key, V value)
将指定的值与此映射中的指定键关联（可选操作）。
如果出现添加相同的键，后添加的值会覆盖原有键的值，并且put方法会返回被覆盖的值。
从指定映射中将所有映射关系复制到此映射中（可选操作）。
3.判断
containsKey(Object key):如果此映射包含指定键的映射关系，则返回 true。
containsValue(Object value) :如果此映射将一个或多个键映射到指定值，则返回 true。
isEmpty()
如果此映射未包含键-值映射关系，则返回 true
4.删除
clear()
从此映射中移除所有映射关系（可选操作）。
remove(Object key)
如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
演示代码：

interface Map
{
    public static interface Entry
    {
        public abstract Object getKey();
        public abstract Object getValue();
    }
}
class HashMap implements Map
{
    class Hahs implements Map.Entry
    {
        public Object getKey();
        public Object getValue();
    }
}

et(k) keySet()
返回此映射中包含的键的 Set 视图。
将Map中所有的键存入到Set集合中，因为Set具备迭代器。
所以可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。

Map集合取出原理：将map集合转成set集合，再通过迭代器取出。

Map
|–Hashable:底层是哈希表数据结构，不可以存入null键null值。
该集合是线程同步的，jdk1.0效率低。
|–HashMap：底层是哈希表数据结构，允许使用 null键和 null值，非同步，此实现提供所有可选的映射操作。
（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
jdk1.2效率高。
|–TreeMap：底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序。
和Set很像，其实Set底层就是使用了Map集合。

演示代码：

import java.util.*;
class MapDemo
{
    public static void main(String[] args)
    {
        Map<String,String> map = new HashMap<String,String>();
        map.put("01","zhangsan");
        map.put("02","lisi");
        map.put("03","wangwu");

        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        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);
        }
    }

}

运行结果：

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