黑马程序员——Java基础——集合类Collection

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

集合类 Collection：是对 对象 进行存储。
要访问集合类中的元素，可以通过迭代器 Iterator
一般的格式是： Iterator it = 对象名 . iterator ( )
元素的取出方式定义在集合的内部，定义成内部类，因为这样可以直接访问集体合内部的元素。然后通过对外提供的 iterator 方法获得迭代器对象。
集合共性抽取：Iterator 接口
对外提供方法：iterator ( )
迭代主要用到两方法：hasNext( ) 用于判断有没下一个元素
next ( ) 返回下一个元素

集合分为两种： List 和 Set 。
List：元素是有序的，元素可以重复，集合体系有索引。
List集合判断元素是否相同，依据是 equals 方法。
Set：元素是无序的，元素不能重复。

先说第一种集合 List ：
List的特有方法：操作角标的方法都是它的特有方法。
add ( index , element ) 、 addAll ( index , Collection )
remove ( index ) 、set ( index , element ) 、get ( index )
subList ( from , to ) 、listIterator( )

List 集合有特有的迭代器：ListIterator ，它是 Iterator 的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素，这样会发生异常。所以，在迭代时，只能用迭代器的方法来操作元素。Iterator 里的方法比较有限，ListIterator 就是一个很好的选择，它里面的方法比较我，增删改查都会操作，比较方便。
格式：ListIterator it = 对象名 . listIterator ( )

List集合比较常见的类有以下几个：

1、ArrayList ： 它的数据结构为数组结构，查询速度快，但是增删稍慢。

2、LinkedList ：底层使用链表数据结构，增删速度很快，但查询稍慢。
LinkedList 特有方法：
addFirst ( ) 、addLast ( ) 、 getFirst ( ) 、getLast ( ) 、
removeFirst ( ) 、 removeLast ( ) (注意，这两个是获取元素，并删除元素)
集合中如果没有元素，调用上面的方法，程序会抛出异常。

JDK1.6版本后出现了替代方法：
offerFirst( ) 、 offerLast ( ) 、peekFirst ( ) 、 peekLast ( )、
pollFirst ( ) 、 pollLast ( )
集合中如果没有元素，调用这几个方法，程序不会抛出异常，只会返回null

3、Vector ：数据结构也是数组结构，它不同的地方是线程同步，比较安全。已经被ArrayList替代了。

第二种集合：Set
常见的Set集合的类有以下几种：
1、HashSet：底层数据结构是哈希表，线程非同步。
HashSet是如何保证元素唯一性呢？
是通过元素的两个方法：hashCode 和 equals 方法。
如果元素的 hashCode 值相同，才会判断 equals 是否为true ，
但如果元素的 hashCode 值不同，那么就不会调用 equals 方法了。

所以， 一般存储自定义对象，都会复写 hashCode 和 equals 方法。
例子代码如下：

import java.util.*;
public class SetList {
    public static void main(String[] args){
        HashSet a=new HashSet();
        a.add(new Person("java02",12));
        a.add(new Person("java01",11));
        a.add(new Person("java03",12));
        a.add(new Person("java01",11));

        Person p;
        Iterator it=a.iterator();
        while(it.hasNext()){
            p=(Person)(it.next());
            System.out.println(p.name);
        }
    }
}

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

    public int hashCode(){
        System.out.println(this.name+".....判断hashCode....."+this.age);
        return name.hashCode();
    }

    public boolean equals(Object obj){
        System.out.println(this.name+"......判断equals....."+this.age);
        if(obj instanceof Person){
            Person p=(Person)obj;
            return this.age==p.age;
        }
        return super.equals(obj);
    }   
}

2、TreeSet ：可以对Set集合中的元素进行排序。
它的底层数据结构是二叉树，二叉树减少比较次数。

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

import java.util.*;
public class TreeSetTest {
    public static void main(String[] args){
        TreeSet ts=new TreeSet();
        ts.add(new man("小明",36));
        ts.add(new man("小丽",24));
        ts.add(new man("东东",36));
        ts.add(new man("王五",28));

        Iterator it=ts.iterator();
        while(it.hasNext()){
            man m=(man)it.next();
            System.out.println(m.getName()+"....."+m.getAge());
        }
    }
}

class man implements Comparable{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    man(String name, int age){
        this.name=name;
        this.age=age;
    }

    public int compareTo(Object obj){
        if(!(obj instanceof man)){
            throw new RuntimeException("不是学生对象");
        }
        man m=(man)obj;
        if(this.age>m.age){
            return 1;
        }
        if(this.age==m.age){
            return this.name.compareTo(m.name);
        }
        return -1;
    }
}

第二种方式：
当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性。
例子如下：

import java.util.*;
public class TreeSetTest2 {
    public static void main(String[] args){
        TreeSet ts=new TreeSet(new Comp());
        ts.add(new Woman("花朵",20));
        ts.add(new Woman("丽丽",22));
        ts.add(new Woman("兰儿",18));
        ts.add(new Woman("少玲",22));

        Iterator it=ts.iterator();
        while(it.hasNext()){
            Woman w=(Woman)it.next();
            System.out.println(w.getName()+"------"+w.getAge());
        }
    }
}

class Woman{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    Woman(String name,int age){
        this.name=name;
        this.age=age;
    }
}

class Comp implements Comparator{
    public int compare(Object obj,Object obj2){
        if(!(obj instanceof Woman)&&!(obj instanceof Woman)){
            throw new RuntimeException();
        }
        Woman w=(Woman)obj;
        Woman w2=(Woman)obj2;       
        int num=new Integer(w.getAge()).compareTo(new Integer(w2.getAge()));
        if(num==0){
            return w.getName().compareTo(w2.getName());
        }
        return num;
    }
}