集合框架

集合框架

1. 集合框架是什么
2. 集合框架结构
3. List
4. Set

---

集合框架是什么

集合框架是由底层容器不断向上抽取共性获得的接口，在集合中存放的是对象的存储地址。多个数据抽取出对象，多个对象抽取出集合。

集合框架结构

Collection是一个接口，List是实现Collection的类，而Set与Collection一样是一个接口。
List:ArrayList(数组集合)，LinkedList(链表集合),Vector
Set:HashSet(哈希表)，TreeSet

---

Collection

基本的方法：
add() :添加方法，向list集合内添加元素
clear() :清空容器
remove() :移除某个元素
size() :集合容量
itrator() :取出元素

ArrayList array = new ArrayList();
A a = new A();

---

Iterator类
用于操作Collection集合的元素

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

    public static void main(String[] args)
    {
        ArrayList a = new ArrayList();
        a.add("java1");
        a.add("java2");
        a.add("java3");

        a.add(1,"java9");
        print(a);

        a.remove(1);
        print(a);

        a.set(1, "java二");
        print(a);

        for(int i = 0;i<a.size();i++)
        {
            print(a.get(i));
        }

        for(Iterator it = a.iterator(); it.hasNext();)
        {
            print(it.next());
        }

        //同样可以使用while循环
        Iterator it = a.iterator();
        while(it.hasNext())
        {
            print(it.next());
        }
    }

效果相同但使用for()循环更有利于变量回收

List

与List区别：
封装的方法能够操作角标,add()、remove()、set()等方法都能够直接操作角标。
add(int,Element)
remove(int)
set(int,Element)

ListIterator类
能够配合List使用，在Iterator的基础上添加了nextIndex(),perviousIndex()，能够操作元素的角标

• ArrayList：有序的、元素可重复（不同步）
• LinkedList：底层使用链表数据结构（不同步）
• Vector：底层是数组数据结构（与ArrayList重复）（同步）

---

Set

set元素是无序的，元素不可重复（以hashcode判定）

HashSet（线程不同步）
int HashCode()：返回set的哈希值

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

        newPerson p1 = new newPerson("aa1",11);
        newPerson p2 = new newPerson("aa2",12);
        newPerson p3 = new newPerson("aa3",13);
        newPerson p4 = new newPerson("aa4",14);
        newPerson p5 = new newPerson("aa5",15);
        newPerson p6 = new newPerson("aa6",16);

        hs.add(p1);
        hs.add(p2);
        hs.add(p3);
        hs.add(p4);
        hs.add(p5);
        hs.add(p6);

        Iterator it = hs.iterator();
        while(it.hasNext())
        {
            newPerson p = (newPerson)it.next();
            print(p.getName()+p.getAge());
        }

    }

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

class newPerson{
    private String name;
    private int age;

    public newPerson(String name,int age)
    {
        this.name = name;
        this.age = age;
    }

    public boolean equals(Object obj)
    {
        if(obj instanceof newPerson)
        {
            return false;
        }
        newPerson p = (newPerson) obj;
        return p.getName().equals(this.name) && p.getAge() == this.age;
    }

    public String getName()
    {
        return this.name;
    }
    public int getAge()
    {
        return this.age;
    }

TreeSet（线程不同步）
二叉树存储结构，可以对set集合排序
TreeSet排序方法：
第一种排序方法：
在元素对象中复写compareTo()方法，或使用自然排序
第二种排序方法：
让集合自身具备比较性
在集合初始化时就拥有比较部分

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

        ts.add(new Student("lisi",12));
        ts.add(new Student("wangwu",13));
        ts.add(new Student("zhouqi",14));
        ts.add(new Student("liuba",15));


        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            Object obj = new Object();
            obj = it.next();
            Student stu = (Student) obj;
            print(stu.getName() +"+++++"+ stu.getAge());

        }
    }

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

class Student implements Comparable{

    private String name;
    private int age;
    public Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public int compareTo(Object obj)
    {
        if(!(obj instanceof Student))
        {
            return 0;
        }
        Student stu = (Student) obj;
        if(stu.getAge()>this.age)
        {
            return -1;
        }
        if(stu.getAge() == this.age)
        {
            return stu.getName().compareTo(this.name);
        }

        return 1;
    }
    public String getName()
    {
        return name;        
    }
    public int getAge()
    {
        return age;
    }
}

class myCompare implements Comparator{
    public int compare(Object obj1,Object obj2)
    {
        Student stu1 = (Student) obj1;
        Student stu2 = (Student) obj2;
        int num = stu1.getName().compareTo(stu2.getName());
        if(num == 0)
        {
            return new Integer(stu1.getAge()).compareTo(new Integer(stu2.getAge()));
        }
        return num;
    }
}