Java 之 List集合 的使用

List 的使用

ArrayList类和LinkedList实现了List接口，因此在使用List集合时可以new一个ArrayList 或者一个 LinkedList.

List 的方法：

boolean add(E e)     // 尾插法

这里默认为尾插法

void add(int index,E element) //将e插入到index位置

插入时，list只能按顺序插入数据，不能跳跃插入
若不指定下标，则默认为尾插法

boolean addAll(Collection<? extends E> c) //尾插 c 中的元素

“?” 是一个通配符，起占位的作用
插入的是集合，类型是E的一个实例，或者是E本身

E remove(int index)  // 删除 index 位置元素

删除指定位置的元素
remove方法的返回值为E类型

boolean remove(Object o) // 删除遇到的第一个 o

指定对象删除，删除第一个遇见的指定的对象

E get(int index) // 获取下标 index 位置元素

获取到指定下标位置的元素，该方法的返回值是E类型

E set(int index, E element) // 将下标 index 位置元素设置为element

set犯法用来修改已有位置的元素 0 < index < length

void clear() // 清空

清空List集合中的元素

boolean contains(Object o) // 判断 o 是否在线性表中

判断对象是否在List中

int indexOf(Object o)  //  返回第一个 o 所在下标

返回指定对象的第一个的位置下标

int lastIndexOf(Object o)   //返回最后一个 o 的下标

返回指定对象的最后一个的位置下标

List<E> subList(int fromIndex, int toIndex) //截取部分 list

该方法的返回值为list类型
截取过程中并没有产生新的对象
不包含toIndex,区间为左闭右开

ArrayList（顺序表）的方法：

ArrayList() //无参构造
ArrayList(Collection<? extends E> c) //利用其他 Collection 构建 ArrayList
ArrayList(int initialCapacity) //指定顺序表初始容量

LinkedList（链表）的方法：

LinkedList() //无参构造

List 应用示例

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

public class TestDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(10);
        //add插入时不能跳，只能按顺序添加
        //若不指定下标，则默认为尾插
        list.add("1");
        list.add(1,"f");
        System.out.println("list的内容：");
        System.out.println(list);
        
        List<String> list2 = new ArrayList<>(10);
        list2.add("猫");
        list2.add("狗");
        System.out.println("list2的内容：");
        System.out.println(list2);

        //boolean addAll(Collection<? extends E> c)   ?通配符
        //放入的是集合，类型是E的一个实例，或者是E本身
        list.addAll(list2);
        System.out.println("利用addAll将list2放入list中");
        System.out.println(list);

        //remove的返回值是E类型
        System.out.println("=====给定下标删除====");
        String str = list.remove(0);
        System.out.println(str);
        System.out.println("=====给定对象删除=====");
        list.remove("猫");
        System.out.println(list);

        //get方法的返回值是E类型
        System.out.println("===get方法====");
        String str2 = list.get(0);
        System.out.println(str2);

        //set方法用来修改已有位置的元素 0<index<length
        System.out.println("====set方法=====");
        list.set(1,"hello");
        System.out.println(list);

        list.add("w");
        list.add("e");
        list.add("d");
        list.add("r");
        System.out.println("======新的list===");
        System.out.println(list);

        //返回值是list<E>类型
        //截取过程并没有产生新的对象
        //不包含toIndex,区间为左闭右开
        List<String> list3 = list.subList(0,3);
        System.out.println(list3);


        List<String> otherList = new ArrayList<>(list3);
        System.out.println(otherList);

        List<String> linkedList = new LinkedList<>(list3);
        System.out.println(linkedList);

        //这里发生了向上转型
        ArrayList<String> courses = (ArrayList<String>) otherList;
        LinkedList<String> c = (LinkedList<String>)otherList;
    }
}

对List进行排序

若集合中存放的不是简单类型，要对集合进行排序，需要实现Comparable接口，并重写compareTo 方法。

具体应用：List中存放的是自己写的学生类，不是简单类型，要想进行排序，则需要实现Comparable接口，重写compareTo方法

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/*
对集合进行排序，需要实现Comparable接口，并重写compareTo方法
 */

class Student implements Comparable<Student>{
    private String name;
    private String clas;
    private double score;

    public Student(String name, String clas, double score ) {
        this.name = name;
        this.clas = clas;
        this.score = score;
    }

    public String getName() {
        return name;
    }

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

    public String getClas() {
        return clas;
    }

    public void setClas(String clas) {
        this.clas = clas;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", clas='" + clas + '\'' +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        //以分数大小比较
        //return (int)(this.score - o.score);
        
        //以名字大小比较
        return this.name.compareTo(o.name);
    }
}
public class TestDemo2 {

    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("c", "三", 45));
        list.add(new Student("b", "二", 78));
        list.add(new Student("d", "一", 67));

        //排序 -  比较大小
        Collections.sort(list);
        
        //第一种打印方式，重写了toString方法之后直接打印
        System.out.println(list);

        //第二种打印方式
        for (Student student : list) {
            System.out.println(student);
        }
    }

若List集合中存放的是简单类型如整形，则使用Collections.sort即可对List进行排序，不用手动实现Comparable接口，sort已经自动实现
示例：

   public static void main2(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(4);
        list.add(4);
        list.add(6);
        list.add(2);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
    }