java 集合框架--14

集合框架（体系概述）

为什么会出现这么多的容器呢？

因为每一个容器对数据的存储方式都有不同。

这个存储方式称之为数据结构。

Collection

[code]import java.util.*;

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

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

把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内容的元素。
那么取出方式就被定义成了内部类。

而每一个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性的内容（判断和取出）。那么可以对共性进行抽取。

那么这些内部类都符合一个规则，该规则是Iterator。
如何获取集合的去除对象呢？

通过一个对外提供的方法。
iterator();

*/

class CollectionDemo
{
    public static void main(String[] args)
    {
        base_method();
        sop("---------------------");
        method_2();
        sop("---------------------");
        method_get();
    }

    public static void method_get()
    {
        ArrayList al = new ArrayList();

        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");

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

        while(it.hasNext())
        {
            sop(it.next());
        }
        */

        for(Iterator it = al.iterator();it.hasNext();)
        {
            sop(it.next());
        }
    }

    public static void method_2()
    {
        ArrayList al1 = new ArrayList();

        al1.add("java01");
        al1.add("java02");
        al1.add("java03");
        al1.add("java04");

        ArrayList al2 = new ArrayList();

        al2.add("java01");
        al2.add("java02");
        al2.add("java05");
        al2.add("java06");

        //al1.retainAll(al2);//取交集，al1中只会保留和al2中相同的元素
        al1.removeAll(al2);//去交集，al1中只会保留和al2中不相同的元素

        sop("al1:"+al1);
        sop("al2:"+al2);
    }

    public  static void base_method()
    {
        //创建一个集合容器。使用Collection接口的子类。ArrayList
        ArrayList al = new ArrayList();

        //1,添加元素
        al.add("java01");//add(Object obj);
        al.add("java02");
        al.add("java03");
        al.add("java04");

        //打印原集合
        sop(al);

        //2,获取个数，集合长度
        sop("size:"+al.size());

        //3,删除元素
        al.remove("java02");

        //清空集合
        //al.clear();

        //打印改变后的集合
        sop(al);

        //4，判断元素
        sop("java03是否存在"+al.contains("java03"));
        sop("集合是否为空"+al.isEmpty());
    }

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

List集合

collection

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

|–ArrayList：底层的数据结构使用的是数组结构。线程不同步。

特点：查询速度很快，但是增删稍慢。

|–LinkedList：底层使用的是链表数据结构。

特点：增删速度很快，查询速度稍慢。

|–Vector：底层是数组数据结构。线程同步。增删查询都稍慢，被ArrayList替代了。

|–set:元素是无序的，元素不可以重复。没有索引。

list:

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

增

add(index,element);

addAll(index,Collection);

删

remove(index);

改

set(index,element);

查

get(index);

subList(from,to);

listIterator();

List集合特有的迭代器。ListIterator是Iterator的子接口

在迭代时，不可以通过集合对象的方法操作集合中的元素

因为会发生ConcurrentModificationException异常

所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有限的

只能对元素进行判断，取出，删除的操作

如果想要其他的操作如添加，修改等，就需要使用其子接口ListIterator

该接口只能通过list集合的ListIterator方法获取

[code]import java.util.*;
class ListDemo
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

    public static void method()
    {
        ArrayList al = new ArrayList();

        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");

        sop("原集合是："+al);
        //在指定位置添加元素
        al.add(1,"java09");

        //删除指定位置的元素
        //al.remove(2);

        //修改元素。
        //al.set(2,"java007");

        //通过角标获取元素
        sop("get(1):"+al.get(1));

        sop(al);

        //获取所有元素  遍历
        for(int x=0;x<al.size();x++)
        {
            sop("al("+x+")="+al.get(x));
        }

        //迭代器
        Iterator it = al.iterator();

        while(it.hasNext())
        {
            sop("next:"+it.next());
        }

        //通过indexOf获取对象的位置
        sop("index="+al.indexOf("java02"));

        //获取子集合
        List sub = al.subList(1,3);

        sop("sub="+sub);
    }

    public static void main(String[] args)
    {
        //演示列表迭代器
        ArrayList al = new ArrayList();

        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");

        sop(al);

        ListIterator li = al.listIterator();

        sop("hasPrevious():"+li.hasPrevious());//没有前一个元素，false

        while(li.hasNext())        //是否有后一个元素
        {
            Object obj = li.next();

            if(obj.equals("java02"))
                li.add("java009");
                //li.set("java006");
        }

        while(li.hasPrevious())     //是否有前一个元素
        {
            sop("pre:"+li.previous());
        }

        sop("hasNext():"+li.hasNext());//取了一遍又回来了，有下一个元素，true
        sop("hasPrevious():"+li.hasPrevious());//没有前一个，false

        sop(al);

        /*
        //在迭代过程中，准备添加或者删除元素
        Iterator it = al.iterator();

        while(it.hasNext())
        {
            Object obj = it.next();

            if(obj.equals("java02"))
                //al.add("java008");
                it.remove();//将java02的引用从集合中删除，原数据还在内存中

            sop("obj="+obj);
        }
        */

    }
}

方法method打印结果：



主函数里的打印结果：

Vector（枚举）

[code]import java.util.*;
/*
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的，因为枚举的名称以及方法的名称都过长，
所以被迭代器取代了。
*/

class VectorDemo
{
    public static void main(String[] args)
    {
        Vector v = new Vector();

        v.add("java01");
        v.add("java02");
        v.add("java03");
        v.add("java04");

        Enumeration en = v.elements();

        while(en.hasMoreElements())
        {
            System.out.println(en.nextElement());
        }
    }
}

LinkedList

LinkList:特有方法

addFirst();

addLast();

getFirst();

getLast();

获取元素，但不删除。如果集合中没有元素，会出现NoSuchElementException

removeFirst();

removeLast();

获取元素，并删除。如果集合中没有元素，会出现NoSuchElementException

在JDK 1.6出现了替代方法，

offerFirst();

offerLast();

peekFirst();

peekLast

获取元素，不删除。如果集合中没有元素，会返回null。

pollFirst();

pollLast();

获取元素，并删除。如果集合中没有元素，会返回null。

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

        link.add("java01");
        link.add("java02");
        link.add("java03");
        link.add("java04");

        sop(link);

        while(!link.isEmpty())
        {
            sop(link.removeFirst());//打印出来，在干掉
        }

        sop("size="+link.size());

        sop(link);
    }

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

练习：

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

堆栈：先进后出，如同杯子

队列：先进先出，如同水管

[code]import java.util.*;

class DuiLie
{
    private LinkedList link;

    DuiLie()
    {
        link = new LinkedList();
    }

    public void myAdd(Object obj)
    {
        link.addFirst(obj);
    }

    public Object myGet()
    {
        return link.removeLast();
    }

    public boolean isNull()
    {
        return link.isEmpty();
    }
}
class LinkedListTest
{
    public static void main(String[] args)
    {
        DuiLie dl = new DuiLie();
        dl.myAdd("java01");
        dl.myAdd("java02");
        dl.myAdd("java03");
        dl.myAdd("java04");

        while(!dl.isNull())
        {
            sop(dl.myGet());
        }
    }

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

把removeLast改成removeFirst就是堆栈，先进后出。

ArrayList

练习：去除ArrayList集合中的重复元素

[code]import java.util.*;

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

        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java04");
        al.add("java01");
        al.add("java03");
        al.add("java02");
        al.add("java04");

        //在迭代时，循环中next调用一次就要hasNext判断一次
        sop(al);

        al = singleElements(al);

        sop(al);

    }

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

    public static ArrayList singleElement(ArrayList al)
    {
        //定义一个临时容器
        ArrayList temp = new ArrayList();

        Iterator it = al.iterator();
        while(it.hasNext())
        {
            Object obj = it.next();

            if(!temp.contains(obj))
                temp.add(obj);
        }

        return temp;
    }
}

将自定义对象作为元素存储到ArrayList集合中，并去除重复元素

比如：存入人，同姓名，同年龄，视为同一个人。为重复元素。

思路：

1，对人进行描述，将数据封装进人对象。

2，定义容器，将人存入

3，取出

[code]import java.util.*;

class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = 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 String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

class ArrayListTest2
{
    public static void sop(Object obj)
    {
        System.out.printn(obj);
    }

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

        al.add(new Person("lisi01",30));
        al.add(new Person("lisi02",32));
        al.add(new Person("lisi02",32));
        al.add(new Person("lisi03",33));
        al.add(new Person("lisi04",34));
        al.add(new Person("lisi04",34));

        al = singleElement(al);

        Iterator it = al.iterator();

        while(it.hasNext())
        {
            Person p = (Person)it.next();
            sop(p.getName()+"...."+p.getAge());
        }
    }

    public static ArrayList singleElement(ArrayList al)
    {
        //定义一个临时容器
        ArrayList temp = new ArrayList();

        Iterator it = al.iterator();

        while(it.hasNext())
        {
            Object obj = it.next();

            if(!temp.contains(obj))
                temp.add(obj);
        }

        return temp;
    }
}

HashSet

|–Set:元素是无序(存入和取出的顺序不一定一致)，元素不可以重复

——|–HashSet:底层结构是哈希表

——HashSet是如何保证元素唯一性的呢？

——是通过元素的两个方法，hashcode和equals来完成

——如果元素的HashCode值相同，才会判断equals是否为true

——如果元素的hashcode值不同，不会调用equals

注意，对于判断元素是否存在，以及删除等操作，依赖的是元素的hashCode和equals方法

Set集合的功能和Collection是一致的

[code]import java.util.*;

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

    public static void main(String[] args)
    {
        HashSet hs = new HashSet();

        sop(hs.add("java01"));
        sop(hs.add("java01"));
        hs.add("java02");
        hs.add("java03");
        hs.add("java04");

        Iterator it = hs.iterator();

        while(it.hasNext())
        {
            sop(it.next());
        }
    }
}

往hashset集合中存入自定对象

姓名和年龄相同为同一个人

[code]import java.util.*;

class HashSetTest
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        HashSet hs = new HashSet();

        hs.add(new Person("a1",11));
        hs.add(new Person("a2",12));
        hs.add(new Person("a3",13));
        hs.add(new Person("a2",12));
        //hs.add(new Person("a4",14));

        Iterator it = hs.iterator();

        while(it.hasNext())
        {
            Person p = (Person)it.next();
            sop(p.getName()+"..."+p.getAge());
        }
    }
}
class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }

    public int hashCode()
    {
        //System.out.println(this.name+"...hasCode");
        return name.hashCode()+age;
    }
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Person))
            return false;

        Person p = (Person)obj;
        //System.out.println(this.name+"...equals.."+p.name);

        return this.name.equals(p.name) && this.age == p.age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

判断元素是否存在（contains），删除元素（remove），都要先判断hashcode，然后再判断equals