黑马程序员--集合框架(Collection集合)

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
集合类
为什么会出现集合类？

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

集合类在内存当中存放的是对象的地址。

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

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

集合类的特点：

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

想了解一个体系，应该先要了解最底层，了解最底层的方法功能，整个体系的功能就了解的差不多了。

集合框架最底层 (Collection)各种集合类不断向上抽取，得共性方法 ，成为了接口
为什么会出现这么多容器呢？

因为每一个容器对数据的存储方式都不同，这个存储方式称之为数据结构

Collection //接口

|--List             //接口   List集合：元素是有序的，元素可以重复，因为该集合体系有索引。
    |--ArrayList：底层使用的数据结构是数组结构。特点：查询速度很快，增删稍慢。线程不同步。多线程使用时，自己加锁。
                  默认生成一个长度为10的数组，如果元素个数超过10，会50%延长，即生成一个长度为15的数组，将前面的元素copy到新数组中
    |--LinkedList：底层使用的数据结构是链表，特点：查询稍慢，增删速度很快，线程不同步，
    |--Vector：底层使用的是数组数据结构。 ArrayList与Victor功能一模一样，但是Victor线程同步,增删该查都很慢，因为要判断锁。被ArrayList替代
                  当超过10时，它是100%延长，比较浪费空间，现在基本已经不使用了。
|--Set              //接口   Set集合：元素是无序的，元素不可以重复，该集合没索引
    |--HashSet:底层数据结构是哈希表
    |--TreeSet

集合类是一个容器了解一个容器的功能无外乎增删改查。

Collection内的方法：

1.添加
add(Object o);向集合添加元素
addAll(Collection<? extends E> c);向集合中添加集合
2.
clear();清空集合
remove(Object o);删除指定元素
removeAll(Collection<? extends E> c);删除集合中包含指定集合中的所有元素
3.判断
contains(Object o);判断集合中是否有指定元素
containsAll(Collection<?> c);判断集合中是否包含指定集合的所有元素
isEmpty();判断集合是否有元素
3.获取
size()；获取长度
iterator();用迭代器取出元素
4.交集
retainAll(Collection<? extends E> c);取出该集合与c集合相同的元素
removeAll(Collection<? extends E> c);删除该集合与c集合相同的元素
5.转换
Object[] toArray();将集合转换为数组。

什么是迭代器呢？
其实迭代器就是集合取出元素的特有方式
以ArrayList为例示范iterator()的使用

    public static void main(String[] args){
        Collection c=new ArrayList();
        //添加
        c.add(2);
        c.add(4);
        c.add("haha");
        c.add(7);
        c.add(777);

        //方法1
        Iterator it=c.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }

        //方法2
        for(Iterator it=c.iterator();it.hasNext();)
        {
            System.out.println(it.next());
        }
    }   

    其中方法2较为节省内存,因为方法1使用后内存中还存在迭代器对象。
    注意：在迭代时循环中next调用一次就要hasNext判断一次
    while(it.hasNext()){System.out.print(it.next()+"...."+it.next())}
    上面这种写法是不安全的。

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

List集合特有的方法：
凡是有角标的方法都是该体系特有的方法。

1.添加
add(int index,E element);在指定位置添加元素
addAll(int index,Collection<? extends E> c);在指定位置添加另一个集合中的元素

2.删除
remove(int index);移除指定位置的元素
3.修改(只有List集合具有修改功能)
set(int index,E element);用指定元素替换指定位置的元素
4.获取
get(int index);通过索引获取
List <E> subList(int fromIndex,int toIndex);获取子List  含头不含尾
listIterator();
5.判断
indexOf(Object o);返回元素第一次出现的位置
lastIndexOf(Object o);返回元素最后出现的位置

由于List集合有角标，所以可以通过遍历的方式取出元素

    public static void main(){ 
        ArrayList a1=new ArrayList();
        //添加
        al.add(2);
        al.add(4);
        al.add("haha");
        al.add(7);
        al.add(777);

        //List集合独有的取出方式
        for(int i=0;i<al.size();i++)
        {
            System.out.println(al.get(i));
        }
    }   

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

在迭代时，不可以通过集合对象的方法操作集合中的元素
因为会发生ConcurrentModificationException异常

所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法时有限的
只能对元素进行判断、取出、删除的操作。
如果想要其他的操作如添加、修改等，就需要使用其子接口ListIterator
该接口只能通过List集合的listIterator()方法获取到。
listIterator()的出现，我们可以对List集合进行遍历中的增删改查。

IistIterator使用示例：

    public static void main(String[] args){
        ArrayList al=new ArrayList();
        //添加
        al.add(78);
        al.add(33);
        al.add(2);
        al.add(4);
        al.add("haha");
        al.add(7);
        al.add(777);
        System.out.println(al);

        ListIterator li=al.listIterator();
        while(li.hasNext())
        {
            Object obj=li.next();
            if(obj.equals(2))
                li.add(30);//遍历中的增
                //al.set(80);//遍历中的该
        }
        System.out.println(al);
        //此时li角标指向最后，可以使用hasPrevious()方法对元素进行逆向遍历
        while(li.hasPrevious())
        {
            System.out.print("["+li.previous()+"]");
        }

        //如果想直接对集合进行逆向遍历
        则可以
        ListIterator li=al.listIterator();
        while(li.hasNext()){li.next()}//将角标指向最后
        while(li.hasPrevious())
        {
            System.out.print("["+li.previous()+"]");
        }
    }

作为了解的部分:
Vector集合里面带Element的方法都是特有的，枚举还拥有自己特有的取出方式。
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像
其实枚举和迭代是一样的
迭代多了一个可选的移除操作，
枚举名称和方法名都太长，被迭代器取代了。
枚举取出Vetor中元素示例：

    public static void main(){  
        Vector v=new Vector();
        v.add(4);
        v.add(44);
        v.add(556);
        v.add(23);
        v.add(55);
        v.addElement(34);
        Enumeration en=v.elements();
        while(en.hasMoreElements())
        {
            System.out.println(en.nextElement());
        }
    }

LinkedList特有方法

1.添加
addFirst();
addLast();

JDK1.6版本出现的替代方法：
offerFirst()
offerLast();

2.获取但不删除：
getFirst();
getLast();
获取并移除,如果元素不存在，抛出NoSuchElementExection

JDK1.6版本出现的替代方法
peek();获取但不移除该列表的头
peekFirst();
peekLast();
获取第一个元素并不删除,如果元素不存在，则返回null

3.也可以获取元素，但是元素被删除
removeFirst();
removeLast();如果元素不存在，抛出NoSuchElementExection

JDK1.6版本出现的替代方法
poll();获取并移除该列表的头
pollFirst();
pollLast();如果元素不存在则返回null   

list 集合判断元素是否相同调用的是元素的equals方法。contains()方法，remove()方法底层调用的也都是equals方法。

Set集合：元素是无序的，元素不可以重复，该集合没索引
发现：set集合和collection的功能时一致的

HashSet 是如何保证元素唯一性的呢？

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

对于判断元素是否存在，以及删除等操作，依赖的是hashCode方法和equals方法。
先判断hashCode是否相同，在判断equals是否为true
所以开发过程中，自定义对象一般都要复写hashCode方法和equals方法。
TreeSet:可以对Set集合中的元素进行排序

    底层数据结构是二叉树
    保证元素唯一性的依据是compareTo方法 return0

    TreeSet排序的第一种方式：让元素具备比较性
    元素需要实现Comparable接口，覆盖compareTo方法
    这种方式也称为元素的自然顺序或者叫做默认顺序。
    contains remove方法底层都调用compareTo方法

    TreeSet的第二种排序方式
    当元素自身不具备比较性时，或者具备的比较性不是所需要的
    这时就需要让集合自身具备比较性

    如何让容器自身具备比较性呢？
    定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
    即定义一个类，实现Comparator接口，覆盖compare方法。


    使用时，注意compareTo，与Comparator是不同的，覆盖的方法也不同。
    当两种比较方法都存在时，以比较器为主。

    在集合初始化时，就有了比较方式
    构造函数中传入Comparator的子类对象

Comparator方法示例

/*
需求：往TreeSet集合内存字符串，要求按照字符串长度进行排序

思路：String自身是具备比较性的，但是这个比较性不是我们所需要的，
因此，我们需要样集合自身具备比较性，即定义一个类实现Comparetor接口，覆盖compare方法，并把这个类作为参数传入Set集合的构造方法
*/

import java.util.*;
class TreeSetTest
{
    public static void main(String[] args) 
    {
        TreeSet ts=new TreeSet(new Comparator()
        {
            public int compare(Object o1,Object o2)
            {
                String s1=(String)o1;
                String s2=(String)o2;
                if(s1.length()==s2.length())
                    return s1.compareTo(s2);
                return new Integer(s1.length()).compareTo(new Integer(s2.length()));
            }
        });

        ts.add("hehe");
        ts.add("woqu");
        ts.add("aa");
        ts.add("dfsjhsdfgh");
        ts.add("aas");

        Iterator it=ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }

    }
}

记住：排序时，当主要条件相同时，一定要判断次要条件