黑马程序员_Java_Collection

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
一、集合概述
集合是存储对象最常用的一种方式，方便操作对象，集合就是存储多个对象的一个容器。
集合的特点：
(1)只能存储对象；
(2)长度可以发生改变；
(3)可以存储多种类型对象。
集合和数组的区别：
(1)集合的长度是可变的；数组的长度是固定的。
(2)集合只能存储对象；数组可以存储对象，也可以存储基本数据类型。
(3)集合存储的数据类型是不固定的；数组存储的数据类型是固定的。
集合的框架：不断向上抽取来的，是一个体系。

二、Collection
Collection是层次结构中的根接口（顶层接口）。
Collection的常用子类：
|–List:元素是有序的，元素可以重复。因为该集合体系有索引
|–ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快，但增删速度稍慢
|–LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢，线程不同步
|–Vector：底层是数组数据结构。线程同步。被ArrayList替代了。
1.方法
添加元素：
boolean add(E e)：此处的E可以当成Object去理解，将指定的元素添加到此列表的尾部。
boolean addAll(Collection c)：将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
删除元素：
boolean remove(Object obj)：移除一个指定元素。
boolean removeAll(Collection c)：只在调用者中移除两集合中的共同元素。
void clear()：清空集合
判断元素：
boolean contains(Objectobj)：如果此 collection 包含指定的元素，则返回true。
booleancontainsAll(Collection)：判断师傅含有指定集合中的元素，只有所有元素都包含才返回ture。
booleanisEmpty()：判断是否为空。
获取：
int size()：获取集合长度，若为0，则为空。
int hasCode()：返回此Collection的哈希码值。
Iterator iterator()：返回次元素上的迭代器，用于遍历集合中的元素。
取交集：
boolean retainAll()：只在调用者中爆裂共同的交集元素。
程序示例：

private static void base_method() {
        ArrayList al=new ArrayList();

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

        //2，获取个数
        sop(al.size());

        //3，删除元素
        al.remove("java03");

        //4，判断元素
        sop(al.contains("java02"));
        sop(al.isEmpty());
        sop(al);
    }

2.Iterator
Iterator（迭代器），对 collection 进行迭代的迭代器，其实就是集合取出元素的方式，会直接访问集合中的元素。所以将迭代器通过内部类的形式来进行描述，通过容器的iterator()方法获得内部类的对象。迭代器取代了Enumeration。
迭代器的方法：
boolean hasNext()：用于判断集合中是否还存在元素，如果仍有元素可以迭代，则返回true。
E next()：返回迭代的下一个元素。
void remove()：移除迭代器中返回的元素。
迭代器使用程序示例：

private 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循环回收迭代器内存
        for(Iterator it=al.iterator();it.hasNext();){
            sop(it.next());
        }
    }

3、迭代注意事项
迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。
迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。
迭代器的next方法返回值类型是Object，所以要记得类型转换。

三、List
1.List概述
List组成：
List:元素是有序的，元素可以重复。因为该集合体系有索引
|–ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快，但增删速度稍慢
|–LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢，线程不同步
|–Vector：底层是数组数据结构。线程同步。被ArrayList替代了。
2.ArrayList
特有方法：凡是可操作角标的方法都是该体系特有的方法。
1.增
add(index,element)：在指定位置加入元素。
addAll(index,Conllection)：在指定位置添加指定集合中的所有元素；若省略位置参数，则默认在当前集合后面添加元素。
2.删
remove(index)：移除指定位置的元素。
3.改
set(index)：修改指定位置的元素。
4.查
get(index)：获取指定位置的元素。
subList(from,to)：截取部分元素。
ListIterator()：获取List特有的迭代器。
ListIteratro迭代器的特有方法：
add(obj)：增加
set(obj)：修改为obj
hasPrevious()：判断前面有没有元素
previous()：取前一个元素
程序示例：

public class ListDemo {

    public static void main(String[] args) {
//      method();

        ArrayList al=new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        sop(al);

        ListIterator lt=al.listIterator();
        while(lt.hasNext()){
            Object obj=lt.next();
            if(obj.equals("java02"))
                lt.add("java009");
        }
        sop(al);

        //在迭代过程中，添加或删除元素
        /*
        Iterator it=al.iterator();
        while(it.hasNext()){
            Object obj=it.next();
            if(obj.equals("java02"))
                it.remove();
            sop(obj);
        }
        sop(al);
        */
    }

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

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

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

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

        //通过角标获取元素
//      sop(al.get(3));

        for(int i=0;i<al.size();i++){
            sop(al.get(i));
        }
        Iterator it=al.iterator();
        while(it.hasNext())
            sop(it.next());

        sop(al.indexOf("java007"));

        List sub=al.subList(1, 3);
        sop(sub);
    }

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

3.LinkedList
LinkedList是List接口的链接列表实现，此实现不同步。
LinkedList特有方法:
addFirst()
addLast()
getFirst()：获取元素，但不删除元素
getLast()
removeFirst()：获取元素，但元素被删除。如果集合中没有元素，会出现NoSuchElementException
removeLast()
在JDK1.6后出现了替代方法
offerFirst()
offerLast()
peekFirst()：获取元素，但不删除元素
peekLast()
pollFirst()：获取元素，但元素被删除。如果集合中没有元素，会返回null。
pollLast()
程序示例：

public class LinkedListDemo {

    public static void main(String[] args) {
        LinkedList  link=new LinkedList();
        link.addFirst("java01");
        link.addFirst("java02");
        link.addFirst("java03");
        link.addFirst("java04");
//      sop(link);
//      sop(link.getFirst());
//      sop(link.getLast());
//      sop(link.removeFirst());//取并删
        while(!link.isEmpty()){
            sop(link.removeLast());
        }
    }

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

四、Set
1.Set概述
Set组成：
Set:元素是无序（存入和取出的顺序不一定一致，元素不可重复。
|–HashSet:底层数据结构是哈希表
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成
如果元素的hashCode值相同，才会判断equals是否为true。
如果元素的hashCode值不同，不会调用equals。
注意，对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
|–TreeSet:可以对Set集合中的元素进行排序
底层数据结构是二叉树
保证元素唯一性的依据：
compareTo方法return 0
TreeSet排序的第一种方式：让元素自身具备比较性。
元素需要实现Comparable接口，覆盖compareTo方法
这种方式也成为元素的自然顺序，或者叫默认顺序。
TreeSet的第二种排序方式：
当元素自身不具备比较性时，或者具备的比较性不是所需要的。
这时就要让集合自身具备比较方式。
Set集合的功能和Collection是一致的
2.HashSet
HashSet：线程不安全，存取速度快。
可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不
会调用equals。注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
程序示例：

class Demo{

}
public class HashSetDemo {

    public static void main(String[] args) {
//      Demo d1=new Demo();
//      Demo d2=new Demo();
//      sop(d1);
//      sop(d2);

        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());
        }
    }
    public static  void sop(Object obj){
        System.out.println(obj);
    }
}

3.TreeSet
TreeSet：底层的数据结构是二叉树，可对Set集合中的元素进行排序。TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写com
pareTo方法，才能让对象按指定需求进行排序，并加入集合。通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。
TreeSet排序的第一种方式：
让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也叫元素的自然排序，或者叫做默认排序。
程序示例：

class Student implements Comparable{

    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public int compareTo(Object obj) {

//      return 1;

        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象");
        Student s=(Student) obj;
        sop(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;

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

TreeSet排序的第二种方式：
当元素自身不具备比较性时，或者具备的比较性不是所需要的，
这时就需要让集合自身具备比较性。定义比较器，将比较器对象作为参数传递给TreeSet构造函数。
比较器Comparator是一个接口，需定义一个类，实现Comparator接口，覆盖compare方法。
程序示例：

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

            ts.add(new Student("lisi01",22));
            ts.add(new Student("lisi02",20));
            ts.add(new Student("lisi03",19));
            ts.add(new Student("lisi04",23));

            Iterator it =ts.iterator();
            while(it.hasNext()){
                Student stu=(Student) it.next();
                sop(stu.getName()+"..."+stu.getAge());
            }
        }

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

class MyCompare implements Comparator{

    public int compare(Object o1, Object o2) {
        Student s1=(Student)o1;
        Student s2=(Student)o2;
        int num=s1.getName().compareTo(s2.getName());
        if(num==0)
            return s1.getAge()-s2.getAge();
        return num;
    }

}