Java · List的使用 · List的常用方法 · ArrayList顺序表 · LinkedList链表 · 打牌小程序 · 杨辉三角List实现

一、List 的使用

1.1 常见方法

List（线性表）

方法	解释
boolean add(E e)	尾插 e
void add(int index, E element)	将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)	尾插 c 中的元素
E remove(int index)	删除 index 位置元素
boolean remove(Object o)	删除遇到的第一个 o
E get(int index)	获取下标 index 位置元素
E set(int index, E element)	将下标 index 位置元素设置为 element
void clear()	清空
boolean contains(Object o)	判断 o 是否在线性表中
int indexOf(Object o)	返回第一个 o 所在下标
int lastIndexOf(Object o)	返回最后一个 o 的下标
List subList(int fromIndex, int toIndex)	截取部分 list

ArrayList（顺序表）

方法	解释
ArrayList()	无参构造
ArrayList(Collection<? extends E> c)	利用其它 Collection 构造 ArrayList
ArrayList(int initialCapacity)	指定顺序表初始容量

LinkedList（链表）

方法	解释
LinkedList()	无参构造

3.2 List（线性表）方法示例

        List<Integer> list1 = new ArrayList<>();
        list1.add(111);
        list1.add(1,222);
        list1.add(0,333);
        List<Integer> list2 = new ArrayList<>();
        list2.add(1);
        list2.add(2);
        list2.addAll(list1);
//        list2.remove(0);
//        list2.remove(4);
//        System.out.println(list1);
//        System.out.println(list2);

        List<String> list3 = new ArrayList<>();
        list3.add("111");
        list3.add("222");
        list3.add("333");
//        list3.remove("111");
//        System.out.println(list3.get(0));
//        list3.set(0,"one");
//        list3.clear();
//        System.out.println(list3.contains("222"));
//        System.out.println(list3.indexOf("333"));
//        System.out.println(list3.lastIndexOf("333"));
        List<String> list4 = list3.subList(1, 2);
        list4.set(0,"2");
        System.out.println(list4);
        System.out.println(list3);

注意事项：

使用 subList 方法截取的部分 list，如果去修改，会影响到原来的数据和截取的数据。

因为 subList 方法只是生成一个引用，去指向你参数划分的范围。

        List<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        List<Integer> list2 = list1.subList(1, 2);
        System.out.println("修改前：" + list1);
        list2.set(0,777);
        System.out.println("截取修改后：" + list1);

//运行结果
修改前：[1, 2, 3, 4]
截取修改后：[1, 777, 3, 4]

3.3 ArrayList（顺序表）方法示例

//无参构造
List<Integer> list1 = new ArrayList<>();

//利用其它 Collection 构建 ArrayList
List<Integer> list2 = new ArrayList<>(list1);

//指定顺序表初始容量
List<Integer> list3 = new ArrayList<>(10);      

3.4 LinkedList（链表）方法示例

LinkedList 底层代码其实是一个双向链表。

//无参构造方法
List<String> list1 = new LinkedList<>();

//利用其它 Collecttion 构建 ArrayList
List<String> list2 = new LinkedList<>(list1);

3.5 关于 ArrayList 的一些补充

当你只是List<Integer> list = new ArrayList<>();这个时候，ArrayList 的大小是 0。

在你第一次使用 add 方法的时候，源码底层最终会找到 grow 扩容函数，初始值就变成 10 了。

如果这 10 容量使用满，那么它就会扩容，方式是 1.5 倍扩容！！！

---

二、三道 List 练习题

第一道：

创建若干学生对象（学生对象放在一个 List 中），
每个学生有一个姓名（String）、班级（String）和考试成绩属性（double）。

某次考试结束后，每个学生都获得了一个考试成绩。遍历 list 集合，并且把学生对象的属性打印出来。

class Student{
    private String name;
    private String classes;
    private double score;

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

    public String getName() {
        return name;
    }

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

    public String getClasses() {
        return classes;
    }

    public void setClasses(String classes) {
        this.classes = classes;
    }

    public double getScore() {
        return score;
    }

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

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

public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("林逸","19",88));
        list.add(new Student("楚梦瑶","19",95));
        list.add(new Student("陈雨舒","18",97));
        for (Student s : list) {
            System.out.println(s);
        }
    }
}

第二道：

删除第一个字符串中出现的第二个字符串中的字符。

例如：
String str1 = "welcome to it";
String str2 = "come";
输出结果：
wl t it

    public static void main(String[] args) {
        String str1 = "welcome to it";
        String str2 = "come";
        List<Character> list = new ArrayList<>();
        for (int i = 0; i < str1.length(); i++) {
            char ch = str1.charAt(i);
            if (!str2.contains(ch + "")) {
                list.add(ch);
            }
        }
        for (Character c : list) {
            System.out.print(c);
        }
    }

第三道：

有一个 List 当中存放的是整形数据，要求使用 Collections.sort 对 List 进行排序。

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(9);
        list.add(8);
        list.add(4);
        list.add(5);

        Collections.sort(list);

        System.out.println(list);
    }

---

三、练习：打牌！

程序能生成一副牌，一共 52 张，算四种花色(♠ ♥ ♣ ♦)，不算大小王。

程序能洗牌，将 52 张牌洗乱。

程序能发牌，三个人依次发五张牌，还能查看剩余的牌数。

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

class Card {
    public int rank;    //牌面值
    public String suit; //花色

    @Override
    public String toString() {
        return String.format("[%s %d]", suit, rank);
    }
}

public class CardDemo {
    public static final String[] SUITS = {"♠", "♥", "♣", "♦"};

    //生成一副牌
    private static List<Card> buyDeck() {
        List<Card> deck = new ArrayList<>(52);
        for (int i = 0; i < 3; i++) {
            for (int j = 1; j <= 13; j++) {
                String suit = SUITS[i];
                int rank = j;
                
                Card card = new Card();
                card.rank = rank;
                card.suit = suit;

                deck.add(card);
            }
        }
        return deck;
    }

    //换牌
    private static void swap(List<Card> deck, int i, int j) {
        Card tmp = deck.get(i);
        deck.set(i,deck.get(j));
        deck.set(j,tmp);
    }

    //洗牌
    private static void shuffle(List<Card> deck) {
        Random random = new Random();
        for (int i = deck.size() - 1; i > 0; i--) {
            int r = random.nextInt(i);
            swap(deck, i, r);
        }
    }

    public static void main(String[] args) {
        List<Card> deck = buyDeck();
        System.out.println("刚刚生成的牌：");
        System.out.println(deck);
        
        shuffle(deck);
        System.out.println("洗牌后：");
        System.out.println(deck);

		//发牌
        List<List<Card>> hands = new ArrayList<>();
        hands.add(new ArrayList<>());
        hands.add(new ArrayList<>());
        hands.add(new ArrayList<>());

        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                hands.get(j).add(deck.remove(0));
            }
        }

        System.out.println("剩余的牌");
        System.out.println(deck);
        
        System.out.println("A 手中的牌");
        System.out.println(hands.get(0));
        System.out.println("B 手中的牌");
        System.out.println(hands.get(1));
        System.out.println("C 手中的牌");
        System.out.println(hands.get(2));


    }



}

---

四、练习：杨辉三角

给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。

在杨辉三角中，每个数是它左上方和右上方的数的和。

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

public class Solution {
    public static List<List<Integer>> generate(int numRows) {
        List<List<Integer>> ret = new ArrayList<>();

        //第一行随便存储个1
        List<Integer> list1 = new ArrayList<>();
        list1.add(1);
        ret.add(list1);

        //从第二行开始计算
        for (int i = 1; i < numRows; i++) {
            List<Integer> cur = new ArrayList<>();
            
            //每行开始第一个元素都是 1
            cur.add(1);
            
            //计算中间的数据
            for (int j = 1; j < i; j++) {
//                cur.add(ret.get(i-1).get(j-1) + ret.get(i-1).get(j));
                List<Integer> list = ret.get(i - 1);
                int val = list.get(j) + list.get(j-1);
                cur.add(val);
            }
            
            //每行最后一个元素都是 1
            cur.add(1);
            ret.add(cur);
        }
        return ret;
    }


    public static void main(String[] args) {
        List<List<Integer>> lists = generate(5);
        for (List<Integer> list : lists) {
            System.out.println(list);
        }
    }
}