52 java集合和泛型_2 _Collection父接口的一个子接口List接口

52 java集合和泛型_2 _Collection父接口的一个子接口List接口

List集合–List子接口

1. 特点：有序、有下标、元素可以重复。

2. 方法：（与Collection父接口相对比，List是有下标的，所有方法会有所不同）

   • void add(int index, 0bject o) //在index位置插入对象o。
   • boolean addAll(int index, Collection c) //将一个集合中的元素添加到此集合中的index位置。
   • 0bject get(int index) //返回集合中指定位置的元素。
   • List subList (int fromIndex, int toIndex) //返回fromIndex和toIndex之间的集合元素。
   • 等…（可查看api学习）

3. jdk的介绍：

   • 有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
   • List 接口提供了特殊的迭代器，称为 ListIterator（extends Iterator），除了允许 Iterator 接口提供的正常操作外，该迭代器还允许元素插入和替换，以及双向访问。还提供了一个方法来获取从列表中指定位置开始的列表迭代器。

List接口的使用

代码：（List的使用1）

package com.wlw.collection.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * List 集合的 使用
 * 特点: 有序 有下标  可重复
 *  * 1.添加
 *  * 2.删除
 *  * 3.遍历(*****重点，有四种方式，与Collection有不同之处)
 *  * 4.判断
 */
public class List_Demo01 {
    public static void main(String[] args) {

        //创建List集合，实现ArrayList类
        List list = new ArrayList();

        //1.添加
        list.add("苹果");
        list.add("小米");
        list.add(0,"华为");//通过下标在指定位置插入元素
        System.out.println("元素个数："+list.size());
        System.out.println(list.toString());

        //2.删除
        /*
        list.remove("苹果");
        list.remove(0);
        System.out.println("删除之后，元素个数："+list.size());
        System.out.println("删除之后："+list.toString());
        */

        //3.遍历，四种方式
        //3.1 普通for循环
        System.out.println("---------------3.1 普通for循环---------------");
        for(int i = 0; i <list.size(); i++){
            System.out.println(list.get(i));
        }

        //3.2增强for循环
        System.out.println("---------------3.2增强for循环---------------");
        for(Object o : list){
            System.out.println(o);
        }

        //3.3 Iterator迭代器
        System.out.println("---------------3.3 Iterator迭代器---------------");
        Iterator iterator =list.iterator();
        while (iterator.hasNext()){
            Object o = iterator.next();
            String s = (String) o;
            System.out.println(s);
            //System.out.println(o);
            //System.out.println(iterator.next());
        }

        //3.4 列表迭代器ListIterator，和Iterator的区别：ListIterator可以向前也可以向后遍历、添加、修改、删除元素
        System.out.println("---------------3.4 列表迭代器ListIterator---------------");
        ListIterator listIterator = list.listIterator();
        System.out.println("从前往后");
        while (listIterator.hasNext()){
            System.out.println(listIterator.nextIndex()+":"+listIterator.next());
        }
        System.out.println("从后往前");
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previousIndex()+":"+listIterator.previous());
        }

        //4.判断
        System.out.println(list.contains("小米"));//true
        System.out.println(list.isEmpty()); //false
        
        //5.获取位置(下标，索引)
        System.out.println(list.indexOf("华为"));//0
    }
}

/*
执行结果：
元素个数：3
[华为, 苹果, 小米]
---------------3.1 普通for循环---------------
华为
苹果
小米
---------------3.2增强for循环---------------
华为
苹果
小米
---------------3.3 Iterator迭代器---------------
华为
苹果
小米
---------------3.4 列表迭代器ListIterator---------------
从前往后
0:华为
1:苹果
2:小米
从后往前
2:小米
1:苹果
0:华为
true
false
0
*/

代码：（List的使用2）

package com.wlw.collection.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * List 集合的 使用
 * 特点: 有序 有下标  可重复
 *
 */
public class List_Demo02 {
    public static void main(String[] args) {

        //创建List集合，实现ArrayList类
        List list = new ArrayList();

        //1.添加 （添加数字数据，会自动装箱，将其转换成对象的引用类型）
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);
        System.out.println("元素个数："+list.size());
        System.out.println(list.toString()); //打印集合 lsit 相当于调用 list.toString()

        //2.删除,list.remove(),有两种形式，
        // 一个是根据内容删除，一个是根据下标来删除，如果list里面的内容就是数字数据，
        // 此时如果选择第一种方式来删除，就要注意转换
        /*
        //list.remove(20); //会报异常：下标越界
        //list.remove(0);
        list.remove((Object) 20);
        //list.remove(new Integer(20));
        System.out.println("删除之后,元素个数：："+list.size());
        System.out.println("删除之后："+list.toString());
        */

        //补充方法：subList()，利用索引（含头不含尾）
        List subList = list.subList(1, 3);
        System.out.println("subList:"+subList.toString());
    }
}
/*
执行结果：
元素个数：5
[20, 30, 40, 50, 60]
subList:[30, 40]
*/

ListIterator 列表迭代器

1. ListIterator 列表迭代器 是Iteraror迭代器的子类。

2. 列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。ListIterator 没有当前元素；它的光标位置 始终位于调用 previous() 所返回的元素和调用 next() 所返回的元素之间。长度为 n 的列表的迭代器有 n+1 个可能的指针位置，

3. 注意，remove() 和 set(Object) 方法不是 根据光标位置定义的；它们是根据对调用 next() 或 previous() 所返回的最后一个元素的操作定义的。

4. 方法：

   方法名	说明
   void add(E e)	将指定的元素插入列表（可选操作）。
   boolean hasNext()	以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。
   boolean hasPrevious()	如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
   E next()	返回列表中的下一个元素。
   int nextIndex()	返回对 next 的后续调用所返回元素的索引。
   E previous()	返回列表中的前一个元素。
   int previousIndex()	返回对 previous 的后续调用所返回元素的索引。
   void remove()	从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
   void set(E e)	用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

List实现类

1. ArrayList【重点】：（内部实质也是数组）
   • 数组结构实现，查询快、增刪慢;
   • JDK1.2版本，运行效率快、线程不安全。
2. LinkedList：链表结构实现，增删快，查询慢
3. Vector:（基本不再使用）
   • 数组结构实现，查询快、增删慢;
   • JDK1. 0版本，运行效率慢、线程安全。