15.集合Collection,List,ArrayList,LinkedList

ONE.集合

1.集合的由来
当需要操作很多对象的时候，就需要使用容器，我们学过的容器有数组和StringBuffer，但是数组的长度固定，而StringBuffer只能容纳字符串，所以为了适应变化的需求，java中提供了集合供我们使用。

2.集合和数组的区别
1)长度：集合可以变化，而数组的长度是固定的
2)内容：集合只能是引用类型，而数组即可以是引用类型也可以是基本类型，但是集合中可以存储不同的类型（其实一般使用集合多数也储存一种类型），而同一个数组中只能存储一种类型

3.集合的继承体系
java中提供多种集合类（即不同的数据结构），但是他们肯定有共性的内容（储存，获取和判断），通过不断的向上提取，我们就能够得到一个集合的继承（实现）体系机构图

4.Collection的功能概述
1）添加功能
boolean add(E e) 添加一个元素，（查看源码得知总是返回true）
boolean addAll(Collection c) 将一个集合中的所有元素都添加到此集合中

2）删除功能
void clear() 移除此集合中所有元素
boolean remove(Object o) 移除此集合中的一个指定元素
boolean remove(Collection c) 移除此集合中哪些包含在指定集合中的元素

3）判断功能
boolean contains(Object o) 如果此集合中包含指定元素，返回true
boolean containsAll(Collection c) 如果此集合中包含指定集合中所有元素，返回true
boolean isEmpty() 如果此集合不包含元素，返回true
4）获取功能
Iterator iterator() 返回在此集合的元素上进行迭代的迭代器（重要，下面单独讲）
5）长度功能
int size() 返回此集合中元素的个数（类是于length()）
6）交集功能
boolean retainAll(Collection c) 仅保留此集合中也包含在指定集合中的元素，注意返回值不是根据有没有交集来判断的，而是根据集合中元素是不是改变来判断的
7）把集合转成数组
Object[] toArray() 把集合转成数组

5迭代器的原理（重要）
1）迭代器是集合中获取元素的方式，迭代器依赖于集合而存在

2）迭代器为什么不定义成一个类，而是一个接口呢？
如果迭代器定义成一个类，我们在使用的时候就要创建这个类的对象，调用该类的方法来实现集合的遍历，但是集合只是一个接口，真正遍历的是实现了集合接口的具体集合实现类，而这些具体的集合实现类的数据结构是不同的，所以储存方式和遍历方式应该是不同的，所以无法设计一个适用于所有集合实现类的遍历方法，所以最终就没有定义迭代类
3）为了解决这一问题，我们自然而然想到可以使用接口将遍历这一功能给提取出来，然后由具体的实现类去实现，那么谁是具体的实现类呢？
我们来看源码

pubic interface Interator{
    boolean hasNext();
    boolean next();
}
public interface Interable{
    Interator iterator();
}
public interface Collection extends Iterable{
    //通过继承得到，未重写,其实很容易理解，接口都是抽象方法，不能重写
    Interator iterator();
}
public interface List extends Collection{
    //通过继承得到，未重写，其实很容易理解，接口都是抽象方法，不能重写
    Interator iterator();
}
public class ArrayList  implements List{
    //在这个具体类中重写了interator()方法
    public Interator interator(){
        //返回一个Itr类的对象
        return new Itr();
    }
    //Itr类是ArrayList的内部类
    private class Itr implements Iterator{
        //这个内部类实现了了Iterator，并重写了hasNext()和next()方法
        public boolean hasNext(){};
        public Object next(){};
    }
}

6.迭代器遍历集合(重要)
1).迭代器：是遍历集合的一种工具，方式，迭代器是依赖于集合而存在的
2).集合迭代的步骤
A.创建集合对象
Collection c = new ArrayList;
B.给集合中添加元素
c.add(“hello”);c.add(“world”);
C.通过集合获取迭代器对象
Iterator it = c.iterator();
D.遍历集合
for(lterator it = c.iterator(); it.hasNext();){
String s = (String)it.next();
System.out.println(s);
}//使用for循环的好处在于，it在循环结束后会变成垃圾
3）代码1：迭代器遍历字符串

import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;

public class CollectionDemo{
    public static void main(String[] args){
        Collection c = new ArrayList();
        c.add("Hello");
        c.add("world");
        c.add("java");
        //使用while循环，结构清晰
        Iterator it = c.iterator();
        while(it.hasNext()){
            String s = (String)it.next();
            System.out.println(s);
        }
    }
}

4）代码二：遍历自定义对象

import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;

public Class CollectionDemo2{
    public static void main(String[] args){
        Collection c = new ArrayList();
        c.add(new Student("罗海威",22));
        c.add(new Student("刘意",30));
        c.add(new Student("林青霞",27));
        //使用for循环，it在循环结束后就消失在内存中
        for(Iterator it = c.iterator(); it.hasNext();){
            Student s = (Student)it.next();
            System.out.println(s.getName() + s.getAge());
            System.out.println(s);
        }
    }
}

THREE.List接口

1.List是Collction的子接口
有序的Collection(也叫序列)，此接口的用户可以对列表中的每一元素插入的位置进行精确的控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的位置，与Set不同，列表通常允许重复的元素

特点：有序（储存顺序和取出顺序一致），可重复

2.List的特有功能
1）添加功能
void add(int index,Object element) 在指定位置添加元素
2）获取功能
Object get(int index) 获取指定位置的元素
3）删除功能
Object remove(int index) 根据索引删除元素，返回被删除的元素
4）修改功能
Object remove(Int index,Object element) 根据索引将元素替换成指定元素，返回被修改的元素

3.列表迭代器
1）列表迭代器的特有功能
可以逆向遍历，但是要先正向遍历，所以基本不用，具体可查API

2)List集合的遍历
A.迭代器（和Collction中类似）
B.用普通的for循环，同时使用List中的get()

3）.并发修改异常ConcurrentModificationException（重要）
A.并发修改异常发生在迭代器遍历集合的过程中，如果此时集合中的元素发生了变化，但我们的迭代器是依赖于集合存在的，是在迭代前通过调用集合的方法返回得到的迭代器，所以，如果集合改变了，而迭代器还是使用原来的，就会报错，这个错误就叫并发修改异常

package cn.itcast_06;
import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
/*
 * 要求：使用迭代器遍历集合的时候，如果发现有world，就加入一个javeee
 */
public class ListIteratorDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("Hello");
        list.add("world");
        list.add("java");

        for(ListIterator ist = list.listIterator(); ist.hasNext();) {
            String s = (String)ist.next();
            if(s.equals("world")) {
                list.add("javaee");
            }
        }
    }
}
/*Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
    at java.util.ArrayList$Itr.next(ArrayList.java:851)
    at cn.itcast_06.ListIteratorDemo.main(ListIteratorDemo.java:16)*/

FOUR.常见数据结构

1）栈：先进先出
2）队列：先进后出

3）数组：查询快，增删慢
4）链表：查询慢，增删块

FIVE.LIST子类的特点

1）ArrayList
底层数据结构是数组，查询快，增删慢
线程不安全，但效率高
没有特有功能要学习
2）Vector
底层数据结构是数组，查询快，增删慢
线程安全，效率不高
特有功能
A.添加
public void addElement(E obj) ——（ArrayList中的add()）
B.获取
public E elementAt(int index) ——（中的get()）
public Enumeration elements() – iterator() ——（iterator()）
3）LinkList
底层数据结构是链表，查询慢，增删快
线程不安全，但效率高
特有功能
a:添加
addFirst()
addLast()
b:删除
removeFirst()
removeLast()
c:获取
getFirst()
getLast()
4）如何选择使用？根据需求
A.要安全吗？
要Vector（其实即使要也不用这个，后面有其他的）
B.看是查询多，还是增删多
查询多：ArrayList
增删多：LinkList

SIX.案例

A:去除集合中的多个字符串的重复元素
如果字符串的内容相同，即为重复元素
day16_02

这种分析思路左里面有，是我学习的第一个算法，通过遍历这个集合，将遍历得到的元素(这里可以 做判断，看这个元素是否存在于新集合中，不存在就放入)放入另一个集合中
这种做法也是比较推荐的

不创建新的集合能不能去除一个集合中的重复元素呢？
可以通过选择排序的思想，把每一个元素都和后面的元素比较，如果相同，就去掉
这个方法肯定是没有前面的方法好的，之所以讲这个方法的原因是
这里关于集合非常值得要注意的一点就是，就是集合的某个索引上的
元素被删了，后面的元素会补位上来
B:去除集合中的多个自定义对象的重复元素
如果自定义对象的成员变量值都相同，即为重复元素
day16_02

需求：去除集合中自定义对象的重复值（重复的判定是指成员变量值相同）
我们按照和字符串同样的操作时（第一种），却发现出问题了，那么很显然问题出在用contains()判断上，也是很显而易见的，contains的源码实现一定是通过equals来的，而Student类中的equals没有被重写，所以很简单，我们只要重写了Student中的equals()就可以解决这个问题

C:用LinkedList模拟一个栈数据结构的集合类，并测试。
你要定义一个集合类，只不过内部可以使用LinkedList来实现。
day16_02

package cn.itcast_03;
import java.util.LinkedList;
/*
 * 自定义栈，用LinkedList实现
 */
/**
 * 
 * @author 罗海威
 * @version v1.0
 */
public class MyStack {
    LinkedList linkedlist;
    public MyStack() {
        linkedlist = new LinkedList();
    }
    public void add(Object obj) {
        linkedlist.addFirst(obj);
    }
    public Object get() {
        return linkedlist.removeFirst();
    }
    public boolean isEmpty() {
        return linkedlist.isEmpty();
    }
}