2022.4.25 集合 List 子接口与其中的实现类

List 子接口

特点：有序、有下标、元素可重复

有序的 collection(也称为序列)。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引(在列表中的位置)访问元素，并搜索列表中的元素。

 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之间的集合元素。

 package com.xing.list;
 ​
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 ​
 public class Demo01 {
     public static void main(String[] args) {
         //List为接口，只能实例化其下面的实现类
         List list = new ArrayList();
         //添加元素
         list.add("苹果");
         list.add("小米");
         list.add(0,"华为");//在下标0添加元素
         System.out.println("元素个数: "+list.size());
         System.out.println( list);//默认调用重写的toString（）
 ​
         //删除元素
         //list.remove("苹果");
         //list.remove(0);//移除集合中下标为0的元素
         System.out.println("删除之后:"+list.size( ));
         System.out.println(list.toString());
         
         //判断
         System.out.println(list.contains("苹果"));//是否包含苹果这个对象
         System.out.println(list.isEmpty());//判断是否为空
         
         //获取下标
         System.out.println(list.indexOf("苹果"));//返回苹果对象的下标
 ​
         //遍历  1.可以使用for 因为有下标
         for (int i = 0; i < list.size(); i++) {
             //get(int index);根据下标获取元素  返回Object类型  可根据实际类型进行强转
             System.out.println(list.get(i));
         }
         //2.使用增强for
         for (Object o : list) {
             System.out.println(o);
         }
 ​
         //迭代器
         Iterator iterator = list.iterator();
         while (iterator.hasNext()) {
             System.out.println(iterator.next());
             // 可以使用iterator.remove(); 进行移除元素
             // collection.remove(); 不能用collection其他方法 会报并发修改异常
         }
                 
         //列表迭代器  list接口独有的  listIterator();返回值列表迭代器
         ListIterator listIterator = list.listIterator();
         //从前向后
         while (listIterator.hasNext()) {
             //next()初始指针指向下标-1 指针向后移动,然后返回下标对应的对象
             System.out.print(listIterator.nextIndex()+":"+listIterator.next());//0:华为1:苹果2:小米
         }
 ​
         //由于上一个从前向后的遍历使指向元素的指针指到了下标为2的元素
         //从后向前
         System.out.println("==================");
         while (listIterator.hasPrevious()) {
             //previous()返回当前元素,之后指针向前移动
             System.out.print(listIterator.previousIndex()+":"+listIterator.previous());
         }
     }
 }

列表迭代器ListIterator

 int nextIndex()返回由后续调用next()返回的元素的索引（如果列表迭代器位于列表的末尾，则返回列表大小。）
 int previousIndex()返回由后续调用previous()返回的元素的索引（如果列表迭代器位于列表的开头，则返回-1）
 next()初始指针指向下标-1 指针向后移动,然后返回下标对应的对象
 previous()返回当前元素,之后指针向前移动

 

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

与Iterator的区别：ListIterator可以向前或向后遍历，添加、删除、修改元素

• 相同点

  • 都是迭代器，当需要对集合中元素进行遍历不需要干涉其遍历过程时，这两种迭代器都可以使用。

• 不同点

  • 使用范围不同，Iterator可以应用于所有的集合，Set、List和Map和这些集合的子类型。而ListIterator只能用于List及其子类型。

  • ListIterator有add方法，可以向List中添加对象，而Iterator不能。

  • ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator不可以。

  • ListIterator可以定位当前索引的位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。

  • 都可实现删除操作，但是ListIterator可以实现对象的修改，set()方法可以实现。Iterator仅能遍历，不能修改。

 

 package com.xing.list;
 ​
 import java.util.ArrayList;
 import java.util.List;
 ​
 public class Demo02 {
     public static void main(String[] args) {
         List list = new ArrayList();
 ​
         //添加数字元素  集合不能存储基本数据类型  通过自动装箱变为包装类
         list.add(10);
         list.add(20);
         list.add(30);
         list.add(40);
         list.add(50);
 ​
 ​
         //当删除数字与索引矛盾时 对数字强转
         list.remove((Object) 10);
         list.remove(new Integer(10));
 ​
         //返回子集合 sublist(x, y);左闭右开
         List subList = list.subList(1, 3);//返回下标1和2的元素
         System.out.println(subList);
     }
 }

List实现类

• ArrayList 【重点】

  • 数组结构实现，必须要连续空间，查询快、增删慢

  • jdk1.2版本，运行效率快、线程不安全

• Vector

  • 数组结构实现，查询快、增删慢

  • jdk1.0版本，运行效率慢、线程安全

• LinkedList

  • 双向链表结构实现，无需连续空间，增删快，查询慢

ArrayList

源码
    

DEFAULT_CAPACITY = 10; //默认容量
//注意：如果没有向集合中添加任何元素时，容量0，添加一个后，容量为10
//每次扩容是原来的1.5倍
elementData存放元素的数组
size 实际元素个数

package com.xing.list;

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

public class Demo03 {
    public static void main(String[] args) {
        Student s1 = new Student("小明",23);

        ArrayList arrayList = new ArrayList();
        arrayList.add(s1);//添加
        //arrayList.remove(s1);//移除
        //arrayList.remove(new Student("小明",23));//remove中调用了equals,重写此方法可以删除
        System.out.println(arrayList.size());//元素个数
　　　　 System.out.println(arrayList.toString());//必须重写toString
//判断 System.out.println(arrayList.contains(new Student("小明", 23)));// true contains()调用了equals() System.out.println(arrayList.isEmpty()); //查找 System.out.println(arrayList.indexOf(s1));//0 查看下标 //遍历 Iterator iterator = arrayList.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } ListIterator listIterator = arrayList.listIterator(); //从前向后 while (listIterator.hasNext()) { System.out.print(listIterator.nextIndex()+":"+listIterator.next()); } //从后向前 System.out.println("=================="); while (listIterator.hasPrevious()) { System.out.print(listIterator.previousIndex()+":"+listIterator.previous()); } } } class Student { private String name; private int age; public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } @Override public boolean equals(Object obj) { //1 判断是不是同一个对象 if(this == obj){ return true; } //2 判断是否为空 if(obj == null){ return false; } //3 判断是否是Student类型 if(obj instanceof Student){ Student s = (Student) obj; //4 比较属性 if(this.name.equals(s.getName()) && this.age == s.getAge()){ return true; } } //5 不满足条件返回false return false; } }

Vector

package com.xing.vector;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Vector;

public class Demo01 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.add("苹果");
        vector.add("狮子");
        vector.add("老师");

        System.out.println(vector.size());//对象个数
        System.out.println(vector);//调用其重写的toString

//      vector.remove("苹果");//移除
//      vector.remove(0);//根据下标移除
//      vector.clear();//清空

        //判断
        System.out.println(vector.contains("苹果"));//是否包含
        System.out.println(vector.isEmpty());
        

        //遍历  使用枚举器
        Enumeration enumeration = vector.elements();
        //hasMoreElements()   nextElement()   类似于迭代器中的hasNext()   next()
        while(enumeration.hasMoreElements()){
            System.out.println(enumeration.nextElement());
        }
    }
}

 

LinkedList

创建链表集合

常用方法与List一致

package com.xing.linkedlist;

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

public class Demo01 {
    public static void main(String[] args) {
        Student s1 = new Student("张三",20);
        Student s2 = new Student("李四",18);
        Student s3 = new Student("王五",22);

        LinkedList linkedList =new LinkedList();

        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);

        System.out.println(linkedList.size());
        System.out.println(linkedList);//必须重写其toString

//        linkedList.remove();
//        linkedList.clear();

        //遍历与
    }
}

class Student {
    private String name;
    private int age;

    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

 

ArrayList与LinkedList区别

• ArrayList数组实现LinkedList双向链表实现

• ArrayList:必须开辟连续空间，查询快,增删慢。LinkedList:无需开辟连续空间，查询慢,增删快。