java--集合List、ArrayList、Linkedlist的应用

Collection 迭代器的作用

迭代器的作用：就是用于抓取集合中的元素。

迭代的方法：toArray() 、iterator()

迭代器的方法（一共就这3个）：

hasNext()   问是否有元素可遍历。如果有元素可以遍历，返回true，否则返回false 。  
next()    获取元素... 每次只抓取一个元素，如果连续抓去多次，则按顺序抓取元素     
remove()  移除迭代器最后一次返回 的元素。

NoSuchElementException 没有元素的异常。
出现的原因： 没有元素可以被迭代了。。

public class Demo2 {

public static void main(String[] args) {
    Collection c = new ArrayList();
    c.add("狗娃");
    c.add("狗剩");
    c.add("铁蛋");
    c.add("美美");

    /*//遍历集合的元素------>方式一： 可以使用toArray方法。
    Object[] arr = c.toArray(); // toArray()  把集合 的元素存储到一个 Object的数组中 返回。
    for(int i = 0 ; i<arr.length ; i++){
        System.out.print(arr[i]+",");
    }

    //要求使用iterator迭代器遍历。

    Iterator it = c.iterator();  //返回一个迭代器    疑问：iterator()方法返回的是一个接口类型，为什么接口又可以调用方法可以使用呢？  iterator 实际 上返回的是iterator接口的实现类对象。

    while(it.hasNext()){ // hasNext() 问是否有元素可以遍历。
        System.out.println("元素："+ it.next()); //获取元素
    }

    it.next();
    it.next();
    it.remove();  //删除迭代器最后一次返回的元素。

    //清空集合 的元素
    while(it.hasNext()){
        it.next();
        it.remove();
    }

    System.out.println("集合的元素："+ c);    
}   
}

List

List 如果是实现了List接口的集合类，该集合类具备的特点：有序，可重复。

有序： 集合的有序不是指自然顺序，而是指添加进去的顺序与元素出来的顺序是一致的。

List接口中特有方法：

添加
    add(int index, E element) 
    addAll(int index, Collection<? extends E> c) 
获取：
    get(int index) 
    indexOf(Object o) 
    lastIndexOf(Object o) 
    subList(int fromIndex, int toIndex) 包头不包尾
修改：
    set(int index, E element) 

迭代
    listIterator() 

public static void main(String[] args) {
    List list = new ArrayList();
    list.add("张三");
    list.add("李四");
    list.add("王五");
    list.add("赵六");//把元素添加到集合的末尾处。
    list.add("赵六");
    System.out.println("集合的元素："+ list);
}

List接口中特有的方法具备的特点： 操作的方法都存在索引值。

只有List接口下面的集合类才具备索引值。其他接口下面的集合类都没有索引值。

ctrl + shift + / 添加多行注释

ctrl + shift + \ 取消多行注释.

   //添加方法
    list.add(1, "赵本山"); // 把元素添加到集合中的指定索引值位置上。
    List list2 = new ArrayList();
    list2.add("本山");
    list2.add("小沈阳");
    list.addAll(2,list2); //把list2的元素添加到list集合指定索引值的位置上。
    获取的方法 
    System.out.println("get方法获取元素："+list.get(1)); //根据索引值获取集合中的元素
    使用get方法遍历集合的元素：
    for (int i = 0; i < list.size() ; i++) {
        System.out.print(list.get(i)+",");
    }
    System.out.println("找出指定元素第一次出现在集合中 的索引值："+ list.indexOf("本山"));
    System.out.println("找指定的元素最后一次出现在集合中的索引值："+list.lastIndexOf("狗娃"));
    List subList = list.subList(1, 3); //指定开始与结束的索引值截取集合中的元素。
    System.out.println("子集合的元素是："+ subList);

List迭代 listIterator()

ListIterator特有的方法：

添加：
    hasPrevious()  判断是否存在上一个元素。
    previous()  获取上一个元素  当前指针先向上移动一个单位，然后再取出当前指针指向的元素。
    next();  先取出当前指针指向的元素，然后指针向下移动一个单位。     
    add(E e)   把当前有元素插入到当前指针指向的位置上。
    set(E e)   替换迭代器最后一次返回的元素。

---

public static void main(String[] args) {
    List list = new ArrayList();
    list.add("张三");
    list.add("李四");
    list.add("王五");

    System.out.println("======get方法遍历=======");
    for(int i = 0 ; i<list.size() ; i++){
        System.out.print(list.get(i)+",");
    }

    System.out.println("\r\n======使用迭代器正序遍历==========");
    ListIterator it = list.listIterator();  //获取到迭代器
    while(it.hasNext()){
        System.out.print(it.next()+",");
    }

    System.out.println("\r\n======使用迭代器逆序遍历==========");
    while(it.hasPrevious()){
        System.out.print(it.previous()+",");
    }
}

注意事项

迭代器在变量元素的时候要注意事项：

在迭代器迭代元素 的过程中，不允许使用集合对象改变集合中的元素 个数（只要不改变个数就可以，比如set方法），如果需要添加或者删除只能使用迭代器的方法进行操作。

如果使用过了集合对象改变集合中元素个数那么就会出现ConcurrentModificationException异常。

迭代元素 的过程中: 迭代器创建到使用结束的时间。

以下代码会报错

public static void main(String[] args) {
    List list = new ArrayList();
    list.add("张三");
    list.add("李四");
    list.add("王五");

    ListIterator it = list.listIterator();  //获取到迭代器
/*  while(it.hasNext()){
        System.out.print(it.next()+",");
        //it.add("aa"); // 把元素添加到当前指针指向位置
        list.add("aa");  // add方法是把元素添加到集合的末尾处的。
//          list.remove("张三");
    }*/

    list.add("aa");//报错原因
    it.next();
    System.out.println("\r\n集合的元素："+ list);
}

ArrayList

集合的体系：

-| Collection 单列集合的根接口

–| List 如果实现了List接口的集合类，具备的特点： 有序，可重复。

—-| ArrayList ArrayList 底层是维护了一个Object数组实现 的， 特点: 查询速度快，增删慢。
什么时候使用ArrayList: 如果目前的数据是查询比较多，增删比较少的时候，那么就使用ArrayList存储这批数据。 比如 ：高校的 图书馆

—-| LinkedList

—-| Vector(了解即可)

–| Set 如果实现了Set接口的集合类， 具备的特点： 无序，不可重复。

ArrayList 特有的方法：

ensureCapacity(int minCapaci上ty)
trimToSize()  

笔试题目： 使用ArrayList无参的构造函数创建一个 对象时， 默认的容量是多少? 如果长度不够使用时又自增增长多少？

ArrayList底层是维护了一个Object数组实现 的，使用无参构造函数时，Object数组默认的容量是10，当长度不够时，自动增长0.5倍。

Linkedlist

LinkedList底层是使用了链表数据结构实现的， 特点： 查询速度慢，增删快。

Linkedlist特有的方法：

1：方法介绍
            addFirst(E e) 
            addLast(E e) 

            getFirst() 
            getLast() 

            removeFirst() 
            removeLast() 

2：数据结构
            1：栈 （1.6）  : 主要是用于实现堆栈数据结构的存储方式。
                先进后出
                push() 将该元素插入此集合的开头处。 
                pop()移除并返回集合中的第一个元素 
            2：队列（双端队列1.5）： 主要是为了让你们可以使用LinkedList模拟队列数据结构的存储方式。
                先进先出
                offer()将元素添加到列表末尾
                poll()移除并返回集合中的第一个元素 

3：返回逆序的迭代器对象      
        descendingIterator()   返回逆序的迭代器对象

public static void main(String[] args) {
    LinkedList list= new LinkedList();
    list.add("张三");
    list.add("李四");
    list.add("王五");
    list.addFirst("狗娃"); //把元素添加到集合的首位置上。
    list.addLast("狗剩");  //把元素添加到集合的末尾处。


    System.out.println("获取集合中首位置的元素:"+list.getFirst());
    System.out.println("获取集合中末尾的元素："+ list.getLast());

    System.out.println("删除集合中的首位置元素并返回："+ list.removeFirst());
    System.out.println("删除集合中的末尾素并返回："+ list.removeLast());


    list.push("狗娃");   //将该元素插入此集合的开头处。 
    System.out.println("删除集合的首元素："+list.pop()); // 移除并返回集合中的第一个元素 


    list.offer("狗剩");
    System.out.println("删除集合的首元素: "+list.poll());

    System.out.println("集合中的元素："+ list);
    Iterator  it = list.descendingIterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
}

机试题目： 使用LinkedList实现堆栈数据结构的存储方式与队列的数据结构存储方式。

// 使用LinkedList模拟堆栈的数据结构存储方式
class StackList{

LinkedList list;

public StackList(){
    list = new LinkedList();
}

//进栈
public void add(Object o){
    list.push(o);
}

//弹栈 : 把元素删除并返回。
public Object pop(){
    return list.pop();
} 

//获取元素个数
public int size(){
    return list.size();
}

//使用LinkedList模拟队列的存储方式
class TeamList{

LinkedList list;

public TeamList(){
    list = new LinkedList();
}

public void add(Object o){
    list.offer(o);
}

public Object remove(){
    return list.poll();
}

//获取元素个数
public int size(){
    return list.size();
}
}

public class Demo9 {

public static void main(String[] args) {
    TeamList list=  new TeamList();
    list.add("李嘉诚");
    list.add("马云");
    list.add("王健林");

    int size = list.size();
    for(int i = 0 ; i<size ; i++){
        System.out.println(list.remove());
    }
}
}