黑马程序员——Java基础---集合（一）---Collection、set、list

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ ------

　       　　　　　　　　　　　　　　　　　　　　集合框架

java中有许多的集合，也称为容器，下图便是集合框架的构成及分类。

一、为什么出现集合类？

        面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

二、数组和集合类同是容器，有何不同？

        数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

三、集合类的特点

        集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

　　　　　　　　　　　　　　　　　　 Collection

        Collection是集合框架中的常用接口。其下有两个子接口：List（列表），Set（集）。

       所属关系：

            Collection

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

                     |--Set//元素是无序的，元素不可以重复。

　　　以下是Collection的总述：

import java.util.*;
/*
Collection定义了集合框架的共性功能。

1    添加
        add(e)；      
        addAll(collention);
2    删除
        remove(e)
        removeAll(collection);
        clear();
3    判断
        contains(e)
        isEmpty();
4    获取
        iterator()  迭代器iterator()
        size();
5    获取交集
        retainAll()
6    集合变数组
        toArray()

1    add方法的参数类型是Object。以便于接收任意类型对象
2    集合中存储的都是对象的引用(地址)

迭代器

    什么是迭代器呢？
    其实就是集合的取出元素的方式
    如同抓娃娃游戏机中的夹子

    迭代器是去除方式，会直接访问集合中的元素
    所以将迭代器通过内部类的形式来进行描述
    通过容器的Iterator()方法获取该内部类的对象
    2、迭代注意事项

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

*/
class CollectionDemo
{
    public static void main(String[] args)
    {
        method_get();
    } 
    public static void sop(Object obj)//打印一切对象
    {
        System.out.println(obj);
    }
    
    public static void base_method()
    {
        //创建一个集合容器。使用Collection接口的子类。ArrayList
        ArrayList al = new ArrayList();

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

        //打印原集合。
        sop("原集合:"+al);


        //3，删除元素。
        //al.remove("java02");
        //al.clear();//清空集合。


        //4，判断元素。
        sop("java03是否存在:"+al.contains("java03"));
        sop("集合是否为空？"+al.isEmpty());


        //2，获取个数。集合长度。
        sop("size:"+al.size());

        //打印改变后的集合。
        sop(al);

    }

    public static void method_get()
    {
        ArrayList a1=new ArrayList();//创建一个列表集合
        a1.add("java01");//添加元素
        al.add("java02");
        al.add("java03");
        al.add("java04");
        /*
        Iterator it=a1.iterator();//获取迭代器，用于取出集合中的元素
        while(it.hasNext()) 第一种打印方式：
        {
            sop(it.next());
        }
        */
        //第二种打印方式：,相对于第一种节省了开辟it的资源。
        for(Iterator it=a1.iterator();it.hasNext();)
        {
            sop(it.next());//在迭代时循环中next调用一次，就要hasNext判断一次。
        }
    }
    public static void method_2()
    {
        ArrayList a11=new ArrayList();//创建集合对象
        a11.add("java01");
        al1.add("java02");
        al1.add("java03");
        al1.add("java04");
        ArrayList al2 = new ArrayList();//创建集合对象

        al2.add("java03");
        al2.add("java04");
        al2.add("java05");
        al2.add("java06");

        a11.retainAll(a12);//取交集，保留在a11中
        sop("a11:"+a11);
        
        
        a11.IndexOf(2,"java110");//在 a11集合中 用java110替代 位置2 上的元素
        sop("a11:"+a11);
    }
}

　　　　　　　　　　　　　　　　　　　　　　　　　　　　List

一、List

组成

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

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

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

            |--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。

二、List的特有方法

        凡是可以操作角标的方法都是该体系特有的方法。

1、增

        booleanadd(index,element);//指定位置添加元素

        BooleanaddAll(index,Collection);//在指定位置增加给定集合中的所有元素，若省略位置参数，则在当前集合的后面依次添加元素

2、删

        Booleanremove(index);//删除指定位置的元素

3、改

        set(index,element);//修改指定位置的元素。

4、查

        get(index);//通过角标获取元素

        subList(from,to);//获取部分对象元素

5、其他

        listIterator();//List特有的迭代器

        indexOf(obj);//获取元素第一次出现的位置，如果没有则返回-1

注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。

三、ListIterator

1、概述 

        ListIterator是List集合特有的迭代器，是Iterator的子接口。

       在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以在迭代器时，只能用迭代器的方法操作元素。可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作。如果想要其他的操作，如添加、修改等，就需要使用其子接口：ListIterrator。该接口只能通过List集合的ListIterator方法获取。

2、ListIterator特有的方法

        add(obj);//增加

        set(obj);//修改为obj

        hasPrevious();//判断前面有没有元素

        previous();//取前一个元素

四、枚举Enumeration

枚举：

        就是Vector特有的取出方式。Vector有三种取出方式。

        其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。

特有方法：

         addElement(obj);//添加元素，相当于add(obj);

         Enumerationelements();//Vector特有取出方式(枚举)

         hasMoreElements();//相当于Iterator的hasNext()方法

         nextElements();//相当于Iterator的next()方法

例：  

import java.util.*;
/*
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。
枚举郁郁而终了。
*/
class VectorDemo 
{
    public static void main(String[] args) 
    {
        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());
        }
    }
}

五、LinkedList

import java.util.*;
/*
 LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
LinkedList:特有方法
addFirst();
addLast();

removeFirst();获取删除，当空时，出现异常
removeLast();

getFirst();获取不删除
getLast();

offerFirst();
offerLast();

peekFirst();
peekLast();

pollFirst();
pollLast();


*/
/*
使用LinkedList模拟一个堆栈或者队列数据结构

堆栈：先进后出  如同一个杯子
队列：先进先出First in First out FIFO  如同一个水管
*/
import java.util.*;
class DuiLie
{
    private LinkedList link;//将队列私有化
    DuiLie()               //创建新的队列
    {
        link=new LinkedList();
    }
    public void myAdd(Object obj)//增加新元素
    {
        link.addFirst(obj);
    }
    public Object myGet()   //获得元素,先进后出 堆栈
    {
        return link.removeFirst();
    }
    public Object myGet2()//获得元素  先进先出   队列
    {
        return link.removeLast();
    }
    public boolean isNull()  //判断是否为空
    {
        return link.isEmpty();
    }
}
class LinkedListTest
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        DuiLie d1=new DuiLie();
        d1.myAdd("java01");
        d1.myAdd("java02");
        d1.myAdd("java03");
        d1.myAdd("java04");
        while(!d1.isNull())
        {
            System.out.println(d1.myGet());//先进后出 堆栈
            System.out.println(d1.myGet2());//先进先出   队列
        }
        sop(d1);
    }
}

   Set

一、概述

        Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。     

           |--HashSet：底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。

           |--TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0。

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

二、HasSet

        HashSet：线程不安全，存取速度快。

       可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。

注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。

示例：

/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人，重复元素。
思路：1、对人描述，将人的一些属性等封装进对象 
      2、定义一个HashSet容器，存储人对象 
      3、取出 
*/
import java.util.*;
class HashSetTest 
{
    public static void sop(Object obj)//打印任何对象
    {
        System.out.println(obj);
    }    
    public static void main(String[] args) 
    {
        HashSet hs = new HashSet();//建立集合
        hs.add(new Person("a1",11));//存储元素
        hs.add(new Person("a2",12));
        hs.add(new Person("a3",13));
        //hs.add(new Person("a2",12));
        //hs.add(new Person("a4",14));
        //sop("a1:"+hs.contains(new Person("a2",12)));
        //hs.remove(new Person("a4",13));
        Iterator it = hs.iterator();//调用集合 共有的 迭代器

        while(it.hasNext())//遍历集合，
        {
            Person p = (Person)it.next();
            sop(p.getName()+"::"+p.getAge());
        }
    }
}
class Person//创建人对象，并对其进行描述
{
    private 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");
        return name.hashCode()+age*37;
    }

    public boolean equals(Object obj)//复写equals方法，定义自己的比较方式
    {
        if(!(obj instanceof Person))//先确定调用的obj是不是  人类
        return false;

        Person p = (Person)obj;//向下转型，使obj的身份变为person
        System.out.println(this.name+"...equals.."+p.name);
        return this.name.equals(p.name) && this.age == p.age;//先比较姓名再比较年龄
    }

    
    public String getName()//返回姓名
    {
        return name;
    }
    public int getAge()//返回年龄
    {
        return age;
    }
}

三、TreeSet

1、特点

        a、底层的数据结构为二叉树结构（红黑树结构）

        b）可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。

        java中的很多类都具备比较性，其实就是实现了Comparable接口。

注意：排序时，当主要条件相同时，按次要条件排序。

　　　1）第一种排序方式：自然排序

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

示例：

/*
TreeSet 排序的第一种方式，让元素自身具备比较性
元素需要实现Comparable接口，覆盖compareTo方法
这种方式也称为元素的自然顺序，或者叫做默认顺序
*/
import java.util.*;
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)//复写compareTo方法
    {
        if(!(obj instanceof Student))//判断obj是否为学生对象
        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;
    }
    public String getName()//获取姓名方法
    {
        return name;
    }
    public int getAge()//返回年龄
    {
        return age;
    }
}

　　2）第二种方式：比较器

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

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

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

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

        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi02",21));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        ts.add(new Student("lisi06",18));
        ts.add(new Student("lisi06",18));
        ts.add(new Student("lisi007",29));
        //ts.add(new Student("lisi007",20));
        //ts.add(new Student("lisi01",40));

        Iterator it = ts.iterator();//调用集合中的迭代器，用于遍历
        while(it.hasNext())//遍历集合，每次调用it.next，都要判断该语句
        {
            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 String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public int compareTo(Object obj)//复写compareTo方法，定义自己的比较方式
    {
        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象");
        Student s=(Student)obj;
        if(this.age>s.age)
            return 1;
        if(this.age==s.age)
        {
            return this.name.compareTo(s.name);
        }
        return -1;
    }
}

class MyCompare implements Comparator//创建比较器，实现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 new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));//后比较年龄
        }
        return num;
    }

}
class StrLenComparator implements Comparator//创建长度比较器，实现Comparator接口
{
    public int compare(Object obj1,Object obj2)
    {
        String s1=(String)obj1;
        String s2=(String)obj2;
        if(s1.length()>s2.length())//比较长度
            return 1;
        if(s1.length()>s2.length())
        {
            return s1.compareTo(s2);
        }
        return -1;
    }
}

 自我总结：

　　　　List接口有三个实现类：LinkedList，ArrayList，Vector

　　　　　　LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身内存地址的同时还存储下一个元素的地址。链表增删快，查找慢

　　　　　　ArrayList和Vector的区别：ArrayList是非线程安全的，效率高；Vector是基于线程安全的，效率低 
　　　　　   List是用来处理序列的，而set是用来处理集的。