Collection接口

Collection
　　!--List:元素是有序的，元素可以重复，因为该集合体系有索引。
　　　　!--ArrayList：底层的数据结构使用的是数组结构。 特点：查询速度很快，但是增删很慢。
　　　　线程不同步，效率高
　　　　!--LinkList：底层使用的是链表数据结构。 特点：增删速度很快，查询速度很慢。
　　　　!--Vector:底层是数组数据结构,线程同步,被ArrayList替代，多线程加锁不用Vector

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

　　　　！--HashSet:底层数据结构是哈希表
　　　　　　HashSet是如何保证元素唯一性的呢？
　　　　　　是通过元素的两个方法，hashCode和equals来完成。
　　　　　　如果元素的HashCode值相同，才会判断equals是否为true。
　　　　　　如果元素的HashCode值不同，不会调用equals.
　　　　　　保证唯一性，要复写HashCode值，设置相同HashSet值

　　　　　　注意：对于判断元素是否存在，以及删除等操作，以来的方法是元素的hashCode和equals方法。
　　　　!--TreeSet:可以对Set集合中的元素进行排序。

　　　　　　（详情见下）

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

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方法获取。

public 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,"java07");
        
        //通过获取元素
        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) {
        // TODO Auto-generated method stub
        //演示列表迭代器
        ArrayList al = new ArrayList();
        
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");
        
        sop(al);
        
        ListIterator li = al.listIterator();
        sop("hasPreviouse()"+li.hasPrevious());
        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());
        sop("hasPreviouse()"+li.hasPrevious());
        sop(al); 
        /*
        //在迭代过程中，准备添加或者删除元素。
        Iterator it = al.iterator(); 
        while(it.hasNext())
        {
            Object obj = it.next();
            
            if(obj.equals("java02"))
                //al.add("java08");   //并发访问，不可以用
                it.remove();  //将java02的引用从集合中删除
            sop("obj="+obj); //元素还被引用，所以被打印了
        }
        */
    }

}

class Demo
{
    public int hashCode()
    {
        return 60;
    }
}
public class HashSetDemo {
    
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        HashSet hs = new HashSet();
        
        sop(hs.add("java01"));
        sop(hs.add("java02"));
        sop(hs.add("java02")); //唯一性，添加失败
        hs.add("java03");
        hs.add("java04");
        
        Iterator it = hs.iterator();
        while(it.hasNext())
        {
            sop(it.next());   //无序
        }
    }

}

LinkedList:特有方法
　　addFirst(); offerFirst()
　　addLast();

　　getFirst(); peekFirst()
　　getLast();
获取元素，但不删除元素,如果集合中没有元素，会出现NoSuchElementException

　　removeFirst(); pollFirst()
　　removeLast();
获取元素，但是元素被删除,如果集合中没有元素，会出现NoSuchElementException

在JDK1.6出现了替代方法

offerFirst();
offerLast();

peekFirst();
peekLast();
获取元素，但不删除元素,如果集合中没有元素，会返回null.

pollFirst();
pollLast();
获取元素，但是元素被删除,如果集合中没有元素，会返回null.

public class LinkedListDemo {
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LinkedList link = new LinkedList();
         
        link.addLast("java01");
        link.addLast("java02");
        link.addLast("java03");
        link.addLast("java04");
        
//        sop(link);
//        sop(link.getFirst());
//        sop(link.getFirst());
//        sop(link.getLast());
//        sop(link.removeFirst());
//        sop(link.removeFirst());
//        sop("size="+link.size());
        
        //获取元素，不用迭代器
        while(!link.isEmpty())
        {
            sop(link.removeLast());
        }
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

}

!--TreeSet:可以对Set集合中的元素进行排序。

　　　　　　底层数据结构是二叉树，
　　　　　　保证元素唯一性的依据，
　　　　　　compareTo方法return 0（1/-1）.

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

　　　　TreeSet的第二种排序方式。
　　　　当元素自身不具备比较性时，或者具备的比较性不是所需要的，
　　　　这时就需要让集合自身具备比较性。
　　　　在集合初始化时，就有了比较方式。

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

记住：排序时，当主要条件相同时，一定要判断一下次要条件。
 */
public class TreeSetDemo {

    public static void main(String[] args) {
        TreeSet ts = new TreeSet();
        //必须具备可比较性，才能有序输出
        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        ts.add(new Student("lisi08",19));
        //ts.add(new Student("lisi007",20));
//        ts.add(new Student("lisi01",40));
        
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            Student stu = (Student)it.next();
            System.out.println(stu.getName()+"..."+stu.getAge());
        }

    }

}
class Student implements Comparable //该接口强制让学生具备比较性。
{
    private String name;
    private int age;
    Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public int compareTo(Object obj)
    {
        return 1;  //如何存入就如何取出
        //return -1;  //存入倒序输出
        //return 0;  //只有第一个元素
        
        /*//按年龄排序输出
        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);
        }
        return -1;//return 1;降序
        */
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }

}

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/*
当元素自身不具备比较性，或者具备的比较性不是所需要的，
这时需要让容器自身具备比较性。
定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

当两种排序都存在时，以比较器为主。

定义一个类实现Compatator接口，覆盖compare方法。


 */


/*
不改代码的前提下，按姓名顺序输出
*/
class Student1 implements Comparable //该接口强制让学生具备比较性。
{
    private String name;
    private int age;
    Student1(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public int compareTo(Object obj)
    {
        //按年龄排序输出
        if(!(obj instanceof Student1))
            throw new RuntimeException("不是学生对象");
        Student1 s = (Student1)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);
        }
        return -1;//return 1;降序
        
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }

}
public class TreeSetDemo2 {

    public static void main(String[] args) {
        TreeSet ts = new TreeSet(new MyCompare());
        
        ts.add(new Student1("lisi02",22));
        ts.add(new Student1("lisi007",20));
        ts.add(new Student1("lisi09",19));
        ts.add(new Student1("lisi06",18));
        ts.add(new Student1("lisi007",29));
        //ts.add(new Student1("lisi007",20));
//        ts.add(new Student1("lisi01",40));
        
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            Student1 stu = (Student1)it.next();
            System.out.println(stu.getName()+"..."+stu.getAge());
        }

    }

}
class MyCompare implements Comparator
{
    public int compare(Object o1,Object o2)
    {
        Student1 s1 = (Student1)o1;
        Student1 s2 = (Student1)o2;
        
        int num = s1.getName().compareTo(s2.getName());
        if(num==0)
        {
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
            /*
            if(s1.getAge()>s2.getAge())
                return 1;
            if(s1.getAge()==s2.getAge())
                return 0;
            return -1;
            */
            
        }
        
        return num;
        
    }


}

import java.util.Enumeration;
import java.util.Vector;
/*
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像

其实枚举和迭代是一样的。

因为枚举的名称和方法的名词都过长，
所以被迭代器取代了，
枚举郁郁而终了。
 */


public class VectorDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        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());
        }
    }

}