集合框架

因为每一个容器对于数据的存储方式都有不同，这个存储方式称之为:数据结构
Collection有两个常见的接口
List和Set
List分为ArrayList LinkedList Vector
Set分为HashSet和TreeSet

List中的元素是有序的，可以重复，因为该集合体系有索引
ArrayList：底层的数据结构使用的是数组结构，查询速度快，增删速度慢。
LinkedList：底层的数据结构使用的是链表结构，增删速度快，查询速度慢。
Vector：底层的数据结构使用的是数组结构，Vector和ArrayList比较相似，但Vector是线程同步的，ArrayList是不同步的。Vector是可变长度数组，ArrayList默认情况下长度为10，超过10时会新建一个长度15的数组，将旧数组copy到新数组中。Vector默认长度也为10，超过10时自身会延长到20。相对而言Vector相对浪费空间。由于Vector速度比较慢，被ArrayList替换了。

1,add方法的参数类型是Object,以便于接收任意类型对象

2.集合中存储的都是对象的引用（地址）

这是输出函数sop()

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

几个简单操作

ArrayList a1=new ArrayList();
        //1,添加元素
        a1.add("java1");
        a1.add("java2");
        a1.add("java3");
        a1.add("java4");

        ArrayList a2=new ArrayList();
        a2.add("java1");
        a2.add("java3");
        a2.add("java5");
        a2.add("java7");

        //2,打印集合
        sop(a1);//会直接封装成列表

        //3,删除元素
        //a1.remove("java2");
        //打印删除后的集合
        //sop(a1);
        //清空集合
        // a1.clear();

        //4,判断元素
        sop("java3是否存在 "+a1.contains("java3"));

        //5,获取个数。集合长度
        sop("size="+a1.size());

        //6,取交集
        a1.retainAll(a2);//取交集并且保存在a1中
        sop("a1 "+a1);
        sop("a2 "+a2);

迭代器：
迭代器是集合取出元素的方式

public static void method_get()//取出元素，用sop直接输出只能打印，不能取出进行其他操作
    {
        ArrayList a1=new ArrayList();
        a1.add("java1");
        a1.add("java2");
        a1.add("java3");
        a1.add("java4");
        Iterator it=a1.iterator();//返回一个接口的子对象,获取迭代器，用于取出集合中的元素
        //sop(it.next());//取出一个元素
        //sop(it.next());//再取出一个元素
        //对于取出的动作，不足以用一个方法描述，需要多个方法配合。
        //把取出动作封装成对象放在集合内部。
        while (it.hasNext())循环输出对象
        {
            sop(it.next());
        }
        
    }

//for循环对内存的使用优于while循环，用完会自动释放
        for (Iterator it=a1.iterator();it.hasNext();)
        {
            sop(it.next());
        }

把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内容的元素。那么取出方式就被定义成了内部类。而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都有共性内容：判断和取出。那么可以将这些共性抽取。那么这些内部类都符合一个规则。该规则是Iterator。
ArrayList 特有方法。凡是可以操作角标的方法都是该体系特有的方法。
增
add(index, element) ;
addAll (index, Collection) ;
删
remove (index) ;
改
set (index, element) ;
查
get (index) ;
subList (from, to) ;
ListIterator () ;

//增加
    // a1.add(1,"java09");
    //sop("新集合 "+a1);
    //删除
    // a1.remove(2);
    //sop("新集合 "+a1);
    //修改
    //a1.set(2,"java05");
    //sop("新集合 "+a1);
    //查找 通过角标获取元素
    //a1.get(2);
    //sop("新集合 "+a1);

    //获取所有元素
    for (int i=0;i<a1.size();i++)
    {
        sop("ArrayList["+i+"]= "+a1.get(i));
    }

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

Iterator it=a1.iterator();
        ListIterator li=a1.listIterator();
        while (li.hasNext())
        {
            Object obj=li.next();
            if (obj.equals("java2"))
            {
                li.set("java6");//循环到java2时将其修改为java6
            }
        }

链表LinkedList:特有方法:
addFirst() ;
addLast() ;
getFirst () ;
getLast () ;
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst() ;
removeLast () ;
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchEl ementException
在JDK1.6出现了替代方法。
offerFirst() ;
offerLast () ;
:I
peekFitst () ;
peekLast () ;
获取元素，但不删除元素。如果集合中没有元素，会返回null。
pollFirst() ;
pollLast () ;
获取元素，但是元素被删除。如果集合中没有元素，会返回null。

几个LinkerList的小练习：

1 使用LinkedList模拟一个堆栈或者队列数据结构。
这两个是数据结构里面的经典概念，并不陌生。
堆栈:先进后出如同一个杯子。
队列:先进先出如同一个水管。

public class Main {

    public static void main(String[] args) {
	// write your code here
        Queue q=new Queue();
        q.myadd("java01");
        q.myadd("java02");
        q.myadd("java03");
        q.myadd("java04");
        while (!q.isNull())
        System.out.println(q.myget());
        Stack s=new Stack();
        s.myadd("java05");
        s.myadd("java06");
        s.myadd("java07");
        s.myadd("java08");
        while (!s.isNull())
            System.out.println(s.myget());
    }
}
class Queue//数据结构队列
{
    private LinkedList link;
    Queue()
    {
        link=new LinkedList();
    }
    public void myadd(Object object)
    {
        link.addFirst(object);
    }
    public Object myget()
    {
        return link.removeLast();//出队
    }
    public boolean isNull()//是否为空
    {
        return link.isEmpty();
    }
}
class Stack //数据结构堆栈
{
    private LinkedList link;
    Stack()
    {
        link=new LinkedList();
    }
    public void myadd(Object object)
    {
        link.addFirst(object);
    }
    public Object myget()
    {
        return link.removeFirst();//出队
    }
    public boolean isNull()//是否为空
    {
        return link.isEmpty();
    }
}

2 去除ArrayList中的重复元素
可以通过新建ArrayList，遍历，查重添加来实现。

public class Main {

    public static void main(String[] args) {
	// write your code here
        ArrayList a1=new ArrayList();
        a1.add("java01");
        a1.add("java02");
        a1.add("java01");
        a1.add("java02");
        a1.add("java01");
        sop(a1);
        a1=singelElement(a1);
        sop(a1);
    }
    public static ArrayList singelElement(ArrayList a1)//定义一个新的空容器，直接加入
    {
        ArrayList newAl=new ArrayList();
        Iterator it=a1.iterator();//迭代器

        while (it.hasNext())//遍历取出
        {
            Object obj=it.next();//取下一个
            if (!newAl.contains(obj))
                newAl.add(obj);
        }
        return newAl;
    }
    public static void sop(Object object)
    {
        System.out.println(object);
    }
}

另外

Iterator it=a1.iterator();//迭代器
        while (it.hasNext())
        {
            sop(it.next()+"...."+it.next());
        }

对于这个循环，当ArrayList中含有奇数个元素时就会出现error。所以在迭代时循环中next()调用一次就要hasNext判断一次。

3 将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如:存人对象。同姓名同年龄，视为同一个人。为重复元素。

public class Main {

    public static void main(String[] args) {
	// write your code here
        ArrayList a1=new ArrayList();
        a1.add(new Person("Reveck",17));//a1.add(Object obj)=new Person("````")
        a1.add(new Person("Alice",18));
        a1.add(new Person("Orianna",19));
        a1.add(new Person("De Jong",21));
        a1.add(new Person("Frenkie",22));
        a1.add(new Person("Frenkie",22));

        Iterator it=a1.iterator();//迭代器
        while (it.hasNext())
        {
            //sop(it.next().getNmae());//直接next返回的是Object对象，Object对象中没有getNmae()方法,编译不通过
            Person p=(Person)it.next();//做强转直接把it.next()给p
            sop(p.getName()+":"+p.getAge());//编译成功
        }
        a1=singelElement(a1);
        it=a1.iterator();
        while (it.hasNext())
        {
            //sop(it.next().getNmae());
            Person p=(Person)it.next();
            sop(p.getName()+":"+p.getAge());//
        }


    }
    public static ArrayList singelElement(ArrayList a1)//定义一个新的空容器，直接加入
    {
        ArrayList newAl=new ArrayList();
        Iterator it=a1.iterator();//迭代器

        while (it.hasNext())//遍历取出
        {
            Object obj=it.next();//取下一个
            if (!newAl.contains(obj))
                newAl.add(obj);
        }
        return newAl;
    }
    public static void sop(Object object)
    {
        System.out.println(object);
    }
}
class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.age=age;
        this.name=name;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public boolean equals(Object obj)
    {
        if (!(obj instanceof Person))
            return false;
        Person p=(Person)obj;
        //System.out.println(this.name+"....."+p.name);//观察equal的过程是this和p在逐个比较
        return this.name.equals(p.name)&&this.age==p.age;
    }
}

这题的关键在于Person是一个自定义的类，要比较Person需要比较name和age，这需要通过向下转型，重写Object中的equals()来实现。由于contains()函数中会调用equals，重写equals之后就成了和上题差不多的情况。做题过程中通过在equals()中设置输出来观察比较的过程，也能成功理解原理。