JavaSE 集合框架（1）- 集合框架基础以及List集合

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

集合类和数组同时容器，有何不同呢？
数组虽然也可以存储对象，但是长度固定；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

JAVA集合大致可以分成Set ,List,Queue, Map四个体系。Set代表无序、不可重复的集合；List代表有序、重复的集合；而Map则代表有映射关系的集合。以下是体系的框架图。

---

集合与数组的联系与区别

A:集合的由来
　数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少

B:数组和集合的区别
　区别1 :
　　数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
　　集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
　区别2:
　　数组长度是固定的,不能自动增长
　　集合的长度的是可变的,可以根据元素的增加而增长

C:数组和集合什么时候用
　　1,如果元素个数是固定的推荐用数组
　　2,如果元素个数不是固定的推荐用集合

D：数组和集合存储引用数据类型,存的都是地址值

---

（1）共性方法

例子。 增删改查

class CollectionDemo{
    public static void main(String[] args)　{
        ArrayList a1 = new ArrayList();  //创建一个集合容器。使用Collection接口的子类。ArrayList     
        a1.add("java01")； //添加元素
        a1.add("java02")；
        a1.add("java03")；
        a1.add("java04")；

        ArrayList a2 = new ArrayList();
        a2.add("java01")； //添加元素
        a2.add("java02")；
        a2.add("java05")；
        a2.add("java06")；

        System.out.println("size:"+a1.size());  // 获取个数。集合长度

        System.out.println(a1);  //打印集合

        a1.remove("java02");  //删除元素

        a1.clear();           // 清空集合

        System.out.println("java03是否存在："+a1.contains("java03"));  //判断元素
        System.out.println("集合是否为空？"+a1.isEmpty());

        a1.retainAll(a2);  //取交集，a1中只会保留和a2中相同的元素
        a1.removeAll(a2);  //去交集，a1中只会保留和a2中不同的元素

        Iterator it = a1.iterator();  //获取只迭代器，用于取出集合中的元素。
        while(it.hasNext()) { //如果仍有元素可以迭代，则返回true
            System.out.println(it.next());  //返回迭代下一个元素
        }   
    }
}

PS：Iterator仅用于遍历集合，Iterator本身并不提供盛装对象的能力，如果需要创建Iterator对象，则必须有一个被迭代的集合。Iterator必须依附于Collection对象，若有一个Iterator对象，则必然有一个与之对应的Collection对象。

迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可

---

（2）List集合

List:元素是有序的，元素可以重复，因为该集合体系有索引。
Set：元素是无序，元素不可以重复。该集合中没有索引。

List集合：特有方法，凡是可以操作角标的方法都是该体系特有的方法。

增：add(index,element); addAll(index,Collection);
删：remove(index);
改：set(index,element);
查：get(index); subList(from,to) listIterator();

ListIterator
List集合特有的迭代器。ListIterator的Iterator的子接口。在迭代时，不可以通过集合对象方法操作集合中的元素，因为会发生并发修改异常（ConcurrentModificationException）

    List list = new ArrayList();
            list.add("a");
            list.add("b");
            list.add("world");
            list.add("d");
            list.add("e");

            /*Iterator it = list.iterator();
            while(it.hasNext()) {
                String str = (String)it.next();
                if(str.equals("world")) {
                    list.add("javaee");         //这里会抛出ConcurrentModificationException并发修改异常
                }
            }*/

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

ListIterator li = a1.ListIterator();
while(li.hasNext()){
    Object obj = li.next();

    if(obj.equals("java02"))
        li.set("java06")              //将java02换成java06
}

ArrayList:底层的数据结构使用的是数组结构。 特点：查询速度很快。但是增删稍慢。线程不同步。
LinkedList:底层使用的链表数据结构。 特点：增删速度很快，查询稍慢
Vector：底层是数组数据结构。 线程同步。 被ArrayList替代了。

ArrayList存储自定义对象

import java.util.*;
/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存入对象。同姓名同年龄，视为同一个人，位重复元素

思路；1，对人描述，将数据封装进人对象
      2，定义容器，将人存入。
      3，取出。

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)   {      //ArrayList中判断相同用的是equals()方法，如果不重写equals方法，会导致容器里所有对象都判断为不同
        if(!(obj instanceof Person))
            return false;
        Person p = (Person)obj;
        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 a1 = new ArrayList();
        a1.add(new Person("java01",30));        //a1.add(Object obj);  Object obj = new Person("java01",30);  提升成了Objcet类
        a1.add(new Person("java02",31));
        a1.add(new Person("java03",32));
        a1.add(new Person("java03",32));
        a1.add(new Person("java04",33));

        a1 = singleElement(a1);

        sop("remove 04:"+a1.remove(new Person("java04",33)));   //删除元素，也要调用equals方法

        Iterator it = a1.iterator();

        while(it.hasNext()) {
            Object obj = it.next();
            Person p =(Person)obj;      //这两句也可以简写为 Person p = (Person)it.next(); 必须将其向下转型为Person类  才能调用Person类的方法
            sop(p.getName()+"::"+p.getAge());
        }
    }
    public static ArrayList singleElement(ArrayList a1){
        ArrayList newA1 = new ArrayList();

        Iterator it = a1.iterator();

        while(it.hasNext()) {
            Object obj = it.next();
            if(!newA1.contains(obj))
                newA1.add(obj);
        }
        return newA1;
    }
}