java集合框架---List/Set

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

|–ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快，但是增删较慢。线程不同步。

|–linkedList:底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。

|–Vector:底层是数组数据结构。特点：线程同步，被ArrayList替代。

|–Set:元素是无序的，元素不可重复。

|–HashSet: 底层数据结构是哈希表。线程是非同步的。

保证元素唯一性原理：判断hashcode值是否相等，再判断equals方法。

|–TreeSet: 可以对Set集合中的元素进行排序

底层结构是二叉树

保证元素唯一性的依据：compareTo方法return 0

排序方法1：实现Comparable接口,并重写compareTo方法

排序方法2：实现comparator接口，并重写compare方法

package pack;

import java.util.*;

public class Demo {

    public static void sys(Object obj) {

        System.out.println(obj);
    }

    public static void main(String[] args) {

        method8();

    }
    public static void method1() {

        ArrayList al = new ArrayList();   //创建集合，collection的子类，ArrayList
        al.add("java1");
        al.add("java2");
        al.add(1,"java9");  //增
        al.remove(1);    //删
        al.set(1, "hello");  //改
        al.get(1);  //查
        al.add(23);
        //al.remove("java1");
        //al.clear();
        sys(al.indexOf("hello"));
        sys(al.isEmpty());
        sys(al.contains("java"));
        sys(al);     //输出列表
        sys("size="+al.size());

        for(int i = 0;i<al.size();i++) {
            al.get(i);
        }
        /*
        Iterator it=al.iterator();  //获取迭代器，取出元素
        while(it.hasNext()) {
            sys(it.next()); */
        for(Iterator it = al.iterator();it.hasNext();) {
            sys(it.next());
        }   

    }

    public static void method2() {

        ArrayList al1 = new ArrayList();
        al1.add("java1");
        al1.add("java2");
        al1.add("java3");
        ArrayList al2 = new ArrayList();
        al2.add("java2");
        al2.add("java3");
        al2.add("java4");

        al1.retainAll(al2);  //取交集
        al1.removeAll(al2);  //去除交集

        /*for(Iterator it = al2.iterator();it.hasNext();) {
            if(it.next().equals("java3"))
                it.remove();    //此迭代器只能删除，其它做不了，会出现并发修改异常。
                                //所以出现了ListIterator
        }*/

        /*for(ListIterator li = al2.listIterator();li.hasNext();) {
            if(li.next().equals("java2"))
                al2.add("java");
        }*/
        sys(al2);
    }
    public static void method3() {

        Vector v = new Vector();
        v.add("java1");
        v.add("java2");
        v.add("java3");
        //sys(v);
        for(Enumeration en = v.elements();en.hasMoreElements();) //枚举是Vector的特有取出方式
            sys(en.nextElement());
    }

    public static void method4() {

        LinkedList link = new LinkedList();
        link.addFirst("java1");
        link.addLast("java2");
        link.addFirst("java3");
        sys(link.getFirst());  //取
        sys(link.removeFirst()); //取、删
        /*
        while(!link.isEmpty()) {
            sys(link.removeFirst());
        }*/
    }

    public static void method5() {

        HashSet hs = new HashSet();
        hs.add("java1");
        sys(hs.add("java1"));  //false,set里无重复，添加失败
        hs.add("java2");
        hs.add("java3");
        hs.add("java4");
        for(Iterator it = hs.iterator();it.hasNext();) {   //set只能迭代输出
            sys(it.next());
        }
    }

    public static void method6() {

        HashSet hs = new HashSet();
        hs.add(new Person("aa",1));
        hs.add(new Person("bb",6));
        hs.add(new Person("cc",3));
        hs.add(new Person("dd",4));
        for(Iterator it = hs.iterator();it.hasNext();) {
            sys(((Person)it.next()).getName());
            sys(((Person)it.next()).getAge());
        }

    }

    public static void method7() {      //TreeSet特点：比较性
        TreeSet ts = new TreeSet();
        ts.add(new Person("aa",1));
        ts.add(new Person("bb",6));
        ts.add(new Person("cc",3));
        ts.add(new Person("dd",4));
        /*for(Iterator it = ts.iterator();it.hasNext();) {  //4个元素排序了
            sys(((Person)it.next()).getName()+((Person)it.next()).getAge());
        }*/

        Iterator it = ts.iterator();
        while(it.hasNext()) {
            Person p = (Person)(it.next());
            sys(p.getName()+"----"+p.getAge());
        }
    }

    public static void method8() {
        TreeSet ts = new TreeSet(new Mycompare());  //往构造函数传入比较器对象
        ts.add(new Person("aa",1));
        ts.add(new Person("bb",6));
        ts.add(new Person("cc",3));
        ts.add(new Person("dd",4));
        Iterator it = ts.iterator();
        while(it.hasNext()) {
            Person p = (Person)(it.next());
            sys(p.getName()+"----"+p.getAge());
        }
    }
}

/*该接口强制让人对象具备比较性。因为TreeSet输出要排序的，而人对象不具备比较性，输出出错，
  因此要实现Comparable,并重写compareTo方法*/
class Person implements Comparable {    //实现接口是为了method7()

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

    public int compareTo(Object obj) {   //重写compareTo方法，指定以年龄为排序方式

        if(!(obj instanceof Person)) {
            throw new RuntimeException("not Person object");
        }
        Person p = (Person)obj;
        if(this.age>p.age)
            return 1;
        /*if(this.age==p.age)   //这是不对的，如果两个人年龄相同救返回0，被认为是同一对象，
         *                        按照Set的规则将不保存后面这个元素
            return 0;*/
        if(this.age==p.age) {
            return this.name.compareTo(p.name); //年龄相同时按照姓名排序
        }
        else
            return -1;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

class Mycompare implements Comparator {    //实现个比较器，实现接口是为了method8()
    public int compare(Object o1,Object o2) {    //重写compare方法
        Person p1 = (Person)o1;
        Person p2 = (Person)o2;
        int a = p1.getName().compareTo(p2.getName());  //按姓名比较
        if(a==0) {
            if(p1.getAge()>p2.getAge())
                return 1;
            if(p1.getAge()==p2.getAge())
                return 0;
            else
                return -1;
        }
        return a;

    }
}