Java基础学习之List（18-1）

1. List

public interface List
extends Collection
List是一个接口继承自Collection，是一个有序集合，用户可

• 以精确控制列表中每个元素的插入位置。List是有索引的，通过整数索引可以访问元素。
• 与Set集合不同，列表通常允许重复的元素

List集合的特点

• 有序：存储和取出的元素顺序一致
• 可重复：存储的元素可以重复

package Java18.List;

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

public class demo {
    public static void main(String[] args){
        //创建集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("world");

        //输出集合对象
        System.out.println(list);

        //迭代器遍历List集合
        Iterator<String> it = list.iterator();

        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

1.2 List集合特有的方法

add(int index,E element)、remove(int index)、set(int index,E element)、get(int index)

package Java18.List;

import java.util.ArrayList;
import java.util.List;

public class demo2 {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");

/*        //在指定位置加入元素
        list.add(2,"lyy");
//        list.add(11,"lyy");//IndexOutOfBoundsException索引越界

        //删除指定位置元素,返回删除的元素
        System.out.println(list.remove(1));

        //修改指定索引处的元素，返回被修改的元素
        System.out.println(list.set(1,"lyq"));

        //返回指定索引处的元素
        System.out.println(list.get(1));

        //输出集合对象
        System.out.println(list);
*/
        //遍历集合，利用get
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        for(int i=0;i<list.size();i++){
            String s = list.get(i);
            System.out.println(s);
        }
    }
}

遍历学生类对象

package Java18.List;

public 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 +
                '}';
    }
}

package Java18.List;

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

public class StudentDemo {
    public static void main(String[] args) {
        //创建List集合
        List<Student> list = new ArrayList<Student>();

        //创建学生对象
        Student s1 = new Student("lyy",23);
        Student s2 = new Student("lyq",23);
        Student s3 = new Student("xxx",22);

        //把学生对象添加到List
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //迭代器方式
        Iterator<Student> it = list.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s);
        }

        //遍历List集合对象
        for(int i=0;i<list.size();i++){
            Student s = list.get(i);
            System.out.println(s);
        }
    }
}

1.3 并发修改异常

参考该博客的文章：
并发修改异常详细阐述

1.4 ListIterator

ListIterator：列表迭代器

• 通过List集合的listIterator()方法得到，是list集合特有的迭代器
• 用于允许程序员沿任一方向遍历列表的列表的迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置。

---

ListIterator中常用的方法

• boolean hasNext()：列表迭代器有多个元素，返回true
• E next()：返回列表中的下一个元素，并且前进光标位置
• boolean hasPrevious()：遍历反向列表，列表迭代器有多个元素，则返回true
• E previous()：返回列表中的上一个元素，并向后移动光标位置。
• void add(E e)将指定的元素插入列表（可选操作）。

package Java18.List;

//        - boolean hasNext()：列表迭代器有多个元素，返回true
//        - E next()：返回列表中的下一个元素，并且前进光标位置
//        - boolean hasPrevious()：遍历反向列表，列表迭代器有多个元素，则返回true
//        - E previous()：返回列表中的上一个元素，并向后移动光标位置。
//        - void add(E e)将指定的元素插入列表（可选操作）
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Listiterator {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();

        list.add("hello");
        list.add("world");
        list.add("java");

//        ListIterator<String> lit = list.listIterator();
//        while(lit.hasNext()){
//            String s = lit.next();
//            System.out.println(s);
//        }
//
//        System.out.println("------------");

//        while(lit.hasPrevious()){
//            String s1 = lit.previous();
//            System.out.println(s1);
//        }

        //获取列表迭代器
        ListIterator<String> lit = list.listIterator();
        while(lit.hasNext()){
            String s = lit.next();
            if(s.equals("world")){
                lit.add("javaee");
            }
        }
        System.out.println(list);

    }
}

1.5增强for循环

增强for：简化数组和Collection集合的遍历

• 实现Iterable接口的类允许其对象成为增强型for语句的目标
• 其内部原理是一个Iterator迭代器

格式：

for(元素数据类型 变量名 : 数组或Collection集合){
	//在此处使用变量即可，该变量就是元素
}

package Java18.List;

import java.util.ArrayList;
import java.util.List;

public class fordemo {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};

        for(int i : arr){
            System.out.println(i);
        }

        System.out.println("-------------");
        String[] st = {"hello","world","java"};
        for(String s : st){
            System.out.println(s);
        }

        System.out.println("-------------------");
        List<String> list = new ArrayList<String>();
        list.add("java");
        list.add("hello");
        list.add("world");
        for (String s : list){
            System.out.println(s);
        }

        System.out.println("----------------");
        //验证内部原理是一个Iterator迭代器,
        // 迭代器遍历集合无法添加元素，会抛出并发修改异常
        //ConcurrentModificationException
        for(String s:list){
            if(s.equals("world")){
                list.add("javaee");
            }
        }
    }
}

案例：List集合存储学生对象用三种方式遍历

package Java18.List;

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

public class ListStudent {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<Student>();

        //添加学生对象
        Student s1 = new Student("lyy",23);
        Student s2 = new Student("lyq",23);
        Student s3 = new Student("fqy",24);

        //学生对象加入List集合
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //三种遍历方式
        //Iterator
        Iterator<Student> it = list.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s);
        }
        System.out.println("------------");
        //for循环
        for(int i=0;i<list.size();i++){
            Student s = list.get(i);
            System.out.println(s);
        }
        System.out.println("-------------");
        //增强for循环
        for(Student s : list){
            System.out.println(s);
        }
    }
}

2. List集合子类的特点

List集合常用子类：ArrayList、LinkedList

• ArrayList：底层数据结构是数组，查询快、增删慢
• LinkedList：底层数据结构是链表，查询慢、增删快

练习：分别使用ArrayList和LinkedList完成存储字符串并遍历

package Java18.List;

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

public class demo4 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> array = new ArrayList<String>();

        array.add("hello");
        array.add("world");
        array.add("beautiful");

        //遍历
        Iterator<String> it = array.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("----------------");

        for(String s : array){
            System.out.println(s);
        }
        System.out.println("----------------");

        for (int i=0;i<array.size();i++){
            String s = array.get(i);
            System.out.println(s);
        }

        LinkedList<String> linked = new LinkedList<String>();

        linked.add("lyy");
        linked.add("lyq");
        linked.add("sss");

        for(String s : linked){
            System.out.println(s);
        }
        System.out.println("-----------");

        Iterator<String> it2 = linked.iterator();
        while(it2.hasNext()){
            String s = it2.next();
            System.out.println(s);
        }
        System.out.println("-----------");
        
        for(int i=0;i<linked.size();i++){
            String s = linked.get(i);
            System.out.println(s);
        }
    }
}

LinkedList 集合的特有功能

package Java18.LinkedList;

import java.util.LinkedList;

public class demo {
    public static void main(String[] args){
        LinkedList<String> link = new LinkedList<String>();

        //添加元素
        link.add("hello");
        link.add("world");
        link.add("nice");
        link.add("day");

        //列表开头添加元素
        link.addFirst("say");
        //列表结尾添加元素
        link.addLast("good");

        //返回列表第一个元素
        System.out.println(link.getFirst());
        //返回列表最后一个元素
        System.out.println(link.getLast());

        //移除第一个元素
        System.out.println(link.removeFirst());
        //移除最后一个元素
        System.out.println(link.removeLast());

        System.out.println(link);
    }
}