集合框架

集合类

概述：面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
与数组的区别：
- 数组：可存储基本数据类型，可存储对象，但长度是固定的，只能存同一类型的对象；
- 集合：只用于存储对象，长度是可变的，可以存储不同类型的对象；
数据结构：因为每个容器对数据的存储方式不同，这种存储方式称之为数据结构；
集合体系：

Collection接口

Collection的两个子接口：

List：可存放重复元素，元素存取是有序的。
- ArrayList：底层数据结构是数组，查询快，增删慢，线程不同步；
- LinkedList：链表数据结构，增删快，查询慢；
- Vector：1.2版本功能，效率低，被ArrayList替代
Set：不可以存放重复元素，元素存取是无序的。
- HashSet：底层数据结构是哈希表，线程不同步；
- TreeSet：底层是二叉树数据结构，可以对Set集合中的元素进行排序，线程不同步；

Collection中的共性方法：

返回值类型	方法	功能描述
boolean	add(E e)	添加元素
boolean	addAll(Collection< ? extends E>c)	添加指定集合中的所有元素
void	clear()	移除集合中的所有元素
boolean	contains(Object o)	集合中是否包含指定元素
boolean	containsAll(Collection< ?> c)	是否包含指定集合所有元素
boolean	equals(Object o)	比较集合与指定对象是否相等
int	hashCode()	返回此集合的哈希码值
boolean	isEmpty()	判断集合是否为空
Iterator < E>	iterator()	返回此集合的元素上进行迭代的迭代器；
boolean	remove(Object o)	移除集中指定元素（若存在）
boolean	removeAll(Collection< ?> c)	移除集合中包含在指定集合中的所有元素；
boolean	retainAll(Collection< ?> c)	仅保留此集合中那些包含在指定集合的元素（取交集）
int	size()	返回此集合中所有元素的个数；

Iterator迭代器

迭代器是取出集合中元素的一种方式，因为Collection中有iterator方法，所以每个子类集合对象都具备迭代器；
获取迭代器的方式：
Collection对象可以通过调用自身的iterator方法，返回一个迭代器，例：
Collection< Object o> al=new ArrayList< Object o>();
Iterator it=al.iterator();

迭代器的常用方法；

返回值类型	方法	功能描述
boolean	hasNext()	如果仍有元素可以迭代返回true；
E	next()	返回迭代器的下一个元素；
void	remove()	从迭代器指向的集合中移除迭代器返回的最后一个元素；

迭代器的使用：

方式一：

for(Iterator iter = iterator();iter.hasNext();)
{
    System.out.println(iter.next());
}

方式二：

Iterator iter = l.iterator();
while(iter.hasNext())
{
    System.out.println(iter.next());
}

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

List集合中的常用类

List集合中的共性(特有)方法

返回值类型	方法	功能描述
void	add(int index,E element)	在列表的指定位置插入元素
boolean	addAll(int index,Collection< ? extends E> c)	将指定集合中所有元素都插入到列表中的指定位置
E	get(int index)	返回列表中指定位置的元素
int	lastIndexOf(Object o)	返回集合中最后出现的指定元素的索引，不存在返回-1；
ListIterator< E>	listIterator()	返回此列表元素的列表迭代器
ListIterator< E>	listIterator(int index)	返回此列表元素的列表迭代器,从列表的指定位置开始
E	remove(int index)	移除列表中指定位置的元素
E	set(int index,E element)	用指定元素替换列表中指定位置的元素
List< E>	subList(int formIndex,int toIndex)	返回列表中指定的fromIndex（包括）和toIndex（不包括）之间的部分试图

注：集合在迭代时循环中next调用一次，hasNext就要判断一次，否则将会出现异常（奇数时可能出现访问不到的情况）；

ListIterator列表迭代器

概述：ListIterator列表迭代器是List集合特有的迭代器，该迭代器是Itreator迭代器的子接口；
区别：
- Iterator迭代器在迭代时不能通过集合对象的方法操作集合中的元素；
- ListIterator可以使用该迭代器下的方法对集合中的元素进行操作，如：添加、修改等；
该迭代器的获取方式与Iterator相同：
List< Object o> al=new ArrayList< Object o>();
ListIterator it=al.iterator();
ListIterator常用方法

返回值类型	方法	功能描述
void	add(E e)	将指定元素插入列表
boolean	hasNext()	以正向遍历时，如果列表迭代器有多个元素，返回true
boolean	hasPrevious()	如果以逆向遍历列表，列表迭代器有多个元素，返回true
E	next()	返回列表中的下一个元素
int	nextIndex()	返回对next的后续调用所返回元素的索引
E	previous()	返回列表中的前一个元素
int	previousIndex()	返回对previous的后续调用所返回元素的索引
void	remove()	从列表中移除由next或previous返回的最后一个元素
void	set(E e)	用指定元素替换next或previous返回的最后一个元素

ArrayList

概述：底层数据结构使用的是数组，查询速度快，增删慢；线程不安全
创建一个ArrayList集合对象：
ArrayList al=new ArrayList();
al.add(“java01”);//向集合中添加元素；
Iterator it=al.iterator();//返回一个迭代器；
ArrayList集合是Collection集合框架下的子类，即可使用其自身的特有方法也可使用父类接口中的共性方法；
ArrayList集合可使用特殊迭代器ListIterator，可在迭代的过程中对集合元素进行操作；

import java.util.*;
class ListDemo {
public static void sop(Object obj){
        System.out.println(obj);
    }
public static void method(){    
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");   
        sop("原集合是："+al);
//在指定位置添加元素。
        al.add(1,"java09");
//通过角标获取元素。
        sop("get(1):"+al.get(1));
        sop(al);
//获取所有元素。
for(int x=0; x<al.size(); x++){
            System.out.println("al("+x+")="+al.get(x));
        }
        Iterator it = al.iterator();
while(it.hasNext()){
            sop("next:"+it.next());
        }
//通过indexOf获取对象的位置。
        sop("index="+al.indexOf("java02"));
        List sub = al.subList(1,3);
        sop("sub="+sub);
    }
public static void main(String[] args) {
//演示列表迭代器。
        ArrayList al = new ArrayList();
//添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");
        sop(al);        
        ListIterator li = al.listIterator();        
//sop("hasPrevious():"+li.hasPrevious());
while(li.hasNext()){
            Object obj = li.next();
if(obj.equals("java02"))
//li.add("java009");
                li.set("java006");
        }
while(li.hasPrevious()){
            sop("pre::"+li.previous());
        }
//sop("hasNext():"+li.hasNext());
//sop("hasPrevious():"+li.hasPrevious());
        sop(al);
    }
}

Vector

概述：底层是数组数据结构，线程同步，被ArrayList替代了。因为效率低（JDK1.2版本）。
枚举(Enumeration)是Vector特有的取出方式，类似于Collection的迭代器，其实和迭代器是一样的，被Iterator取代；

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

概述：底层是链表数据结构，增删快，查询慢；

LinkedList类中的特有方法：
addFirst(E e);//将指定元素插入到列表开头；
addLast(E e);//将指定元素添加到列表结尾；
getFirst();//仅获取
getLast();//
removeFirst();//获取并删除
removeLast();
示例代码：

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 boolean isNull()
    {
return link.isEmpty();
    }
}
class  LinkedListTest
{
public static void main(String[] args) 
    {
        DuiLie dl = new DuiLie();
        dl.myAdd("java01");
        dl.myAdd("java02");
        dl.myAdd("java03");
        dl.myAdd("java04");
while(!dl.isNull())
        {
            System.out.println(dl.myGet());
        }
    }
}

LinkedList类中的remove()方法；
remove()；移除首位；
remove(int index);移除指定位置元素
remove(Object obj);//移除指定元素
特殊：
peekFirst();等效于getFirst()；//区别：前者JDK1.6出现的方法，集合为空会返回null，后者集合为空会提示异常；
peekLast();等效于getLast();//同上；
pollFirst();等同于removeFirst();//两者区别同上；
pollLast();等同于removeLast();//同上

附：如何选择使用ArrayList和LinkedList
当有增删较多的时候用LinkedList，当查询使用较多时用ArrayList，一般情况下使用ArrayList；

注：List集合判断元素是否相同，依据的是元素的equals方法；

class Person
{
private String name;
private int age;
    Person(String name,int age)
    {
this.name = name;
this.age = age;
    }   
public boolean equals(Object obj)
    {
if(!(obj instanceof Person))
return false;
        Person p = (Person)obj;
//System.out.println(this.name+"....."+p.name);
return this.name.equals(p.name) && this.age == p.age;
    }
/**/
public String getName()
    {
return name;
    }
public int getAge()
    {
return age;
    }
}
class ArrayListTest2 
{
public static void sop(Object obj)
    {
        System.out.println(obj);
    }
public static void main(String[] args) 
    {
        ArrayList al = new ArrayList();
        al.add(new Demo());
        al.add(new Person("lisi01",30));//al.add(Object obj);//Object obj = new Person("lisi01",30);
//al.add(new Person("lisi02",32));
        al.add(new Person("lisi02",32));
        al.add(new Person("lisi04",35));
        al.add(new Person("lisi03",33));
//al.add(new Person("lisi04",35)); 
//al = singleElement(al);
        sop("remove 03 :"+al.remove(new Person("lisi03",33)));//remove方法底层也是依赖于元素的equals方法。
        Iterator it = al.iterator();
while(it.hasNext())
        {
            Person p = (Person)it.next();
            sop(p.getName()+"::"+p.getAge());
        }
    }
public static ArrayList singleElement(ArrayList al)
    {
//定义一个临时容器。
        ArrayList newAl = new ArrayList();
        Iterator it = al.iterator();
while(it.hasNext())
        {
            Object obj = it.next();
if(!newAl.contains(obj))
                newAl.add(obj);
        }
return newAl;
    }
}

秒客网

Java基础--集合框架Conllection（LinkedList、ArrayList）