List接口与实现类

List子接口概述

• 特点：有序、有下标、元素可以重复；
• 方法
  • void add(int index（角标）, Object o) //在indwx位置插入对象o；
  • boolean addAll(int index, Collection c) //将一个集合中的元素添加到集合中的index位置；
  • Object get(int index) //返回集合中指定位置的元素；
  • List subList(int fromIndex, int toIndex) //返回fromIndex和toIndex之间的集合元素；
•  关于listIterator的相关方法：

  方法	说明
  add(E e)	将指定的元素插入列表
  hasNext()	以正向遍历列表，如果列表迭代器有多个元素返回true
  hasPrevious()	以逆向遍历列表，如果列表迭代器有多个元素返回true
  next()	返回列表中的下一个元素
  nextIndex()	返回对next的后续调用所返回元素的索引（下标）
  previous()	返回列表中的前一个元素
  previousIndex()	返回对previous的后续调用所返回元素的索引（下标）
  remove()	从列表中移除next或previous返回后的最后一个元素
  set(E e)	用指定元素替换next或previous返回的最后一个元素

   

  //List子接口的使用  有序、有下标、可重复
  public class Demo01 {
      public static void main(String[] args){
          //创建集合对象
          List list = new ArrayList<>();
          //1.添加元素
          list.add("A");
          list.add("B");
          list.add("C");
          list.add(1,"E");//将元素添加到角标为1的位置
          System.out.println("元素数："+list.size());
          System.out.println(list.toString());
          //2.删除元素
          list.remove(1);
          System.out.println("删除之后元素数："+list.size());
          System.out.println(list.toString());
          //3.遍历元素
          //3.1使用增强for遍历
          System.out.println("=====使用增强for遍历=====");
          for (Object object:list) {
              System.out.println(object+" ");
          }
  
          //3.2使用for遍历
          System.out.println("=====使用for遍历=====");
          for(int i=0;i<list.size();i++){
              System.out.println(list.get(i)+" ");
          }
  
          //3.3使用迭代器遍历
          System.out.println("=====使用迭代器遍历=====");
          Iterator it = list.iterator();
          while(it.hasNext()){
              System.out.println(it.next()+" ");
          }
  
          //3.4使用列表迭代器 listIterator可以向前或向后任意遍历，可以添加、删除、修改
          System.out.println("=====使用列表迭代器遍历=====");
          ListIterator lit = list.listIterator();
          System.out.println("=====从前往后遍历=====");
          while(lit.hasNext()){
              System.out.println(lit.nextIndex()+":"+lit.next());
          }
          System.out.println("=====从后往前遍历=====");
          while(lit.hasPrevious()){
              System.out.println(lit.previousIndex()+":"+lit.previous());
          }
  
          //4.判断列表
          System.out.println(list.contains("A"));
          System.out.println(list.isEmpty());
  
          //5.获取位置
          System.out.println(list.indexOf("A"));
      }
  }

List实现类 

• ArrayList【重点】
  • 数组结构实现，查询快、增删慢；
  • JDK1.2版本，运行效率快，线程不安全；
• Vector
  • 数组结构实现，查询快、增删慢；
  • JDK1.0版本，运行效率慢、线程安全；
• LinkedList
  • 链表结构实现，增删快，查询慢；

ArrayList的使用 

储存结构：数组，查找遍历速度快，增删速度慢；

public class Demo01 {
    public static void main(String[] args){
        ArrayList arrayList = new ArrayList<>();
        //1.添加元素
        Student s1 = new Student("Ale",18);
        Student s2 = new Student("Flan",23);
        Student s3 = new Student("Clear",26);
        Student s4 = new Student("Mark",24);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        arrayList.add(s4);
        System.out.println("元素个数为："+arrayList.size());
        System.out.println(arrayList.toString());
        //2.删除元素
        arrayList.remove(new Student("Mark",24));//重写equals方法后通过对比属性来判断
        System.out.println("删除之后的元素个数："+arrayList.size());
        //3.遍历元素
        //3.1使用迭代器
        Iterator iterator = arrayList.iterator();
        System.out.println("使用迭代器遍历");
        while(iterator.hasNext()){
            Student s = (Student)iterator.next();
            System.out.println(s.toString());
        }
        //3.2列表迭代器
        ListIterator listIterator = arrayList.listIterator();
        System.out.println("使用列表迭代器正序遍历");
        while(listIterator.hasNext()){
            Student s = (Student)listIterator.next();
            System.out.println(s.toString());
        }
        System.out.println("使用列表迭代器逆序遍历");
        while(listIterator.hasPrevious()){
            Student s = (Student)listIterator.previous();
            System.out.println(s.toString());
        }
        //4.判断元素
        System.out.println(arrayList.contains(s1));
        //5.查找元素
        System.out.println(arrayList.indexOf(s1));
    }
}

public class Student {
    public String name;
    public int age;

    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 o) {
        //1.判断是否为同一个对象
        if (this == o){
            return true;
        }
        //2.判断是否为空
        if (o == null){
            return false;
        }
        //3.判断是否为Student类型
        if (o instanceof Student){
         Student s = (Student)o;
         //4.比较属性
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }
}