List集合

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

1. boolean add(E e) — 元素

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        System.out.println(list);	//[1, 2]

2. void add(int index, E element) —下标，元素

		List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(1,5);
        System.out.println(list);	//[1, 5, 2]

3. boolean addAll(Collection<? extends E> c) — arraylist或者linkedlist

List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(1,5);
        System.out.println(list);
        List<Integer> arraylist = new ArrayList<>();
        arraylist.add(6);
        arraylist.addAll(list);
        System.out.println(arraylist);  //[6, 1, 5, 2]

4. E remove(int index) —下标

List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.remove(1);
        System.out.println(list);   //[1]

5. boolean remove(Object o) — 元素

List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        Integer a = 1;
        list.remove(a);
        System.out.println(list);   //[2]

6. E get(int index) — 下标

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        System.out.println(list.get(1));    //2

7. E set(int index, E element) — 下标，元素

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.set(1,5);
        System.out.println(list);   //[1,5]

8. void clear()

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.clear();
        System.out.println(list);   //[]

9. boolean contains(Object o) — 元素

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        System.out.println(list.contains(1)); //true

10. int indexOf(Object o) —元素

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(1);
        System.out.println(list.indexOf(1));    //0

11. int lastIndexOf(Object o) — 元素

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(1);
        System.out.println(list.lastIndexOf(1));    //1

12. List subList(int fromIndex, int toIndex) — 首，尾 [ )

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        List<Integer> a = list.subList(1,3);    
        System.out.println(a);  //[2, 3]
        a.set(0,99);
        System.out.println(a);  //[99, 3]
        System.out.println(list);   //[1, 99, 3, 4, 5]

注：这里的subList是一个浅拷贝，改变截取的顺序表也会改变原顺序表的内容

ArrayList（顺序表）

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

ArrayList底层是一个数组，那么数组有多大？

1. new ArrayList<>() ，调用的是不带有参数的构造方法，那么大小默认是0.
2. 当调用了默认的构造方法之后，当你添加第一个元素的时候，会进行扩容，大小为10.
3. 当后续进行扩容的时候，是以1.5倍的方式进行扩容

LinkedList（链表）

方法	解释
LinkedList()	无参构造

迭代器

迭代器可以专门遍历集合的所有元素来实现打印集合

		List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

迭代器从0下标的前一个开始遍历，如果下一个格子有元素，则打印，若没有，则跳出循环。

此时我们再使用remove方法

        iterator.remove();
        System.out.println(list);   //[1, 2, 3, 4]

会发现它把5删了，那是因为跳出循环的死后iterator走到了4号下标，删的自然是4号下标的元素

---

总结四种打印集合方式

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

public class Work4 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("星星",12,88));
        list.add(new Student("狒狒",22,68));
        list.add(new Student("阿星",32,55));
        //fori
        for(int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //foreach
        for(Student student : list) {
            System.out.println(student);
        }
        //iterator
        Iterator<Student> it = list.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        //sout
        System.out.println(list);
    }
}

Collections.sort排序

        List<Integer> list = new ArrayList<>();
        list.add(12);
        list.add(5);
        list.add(16);
        list.add(81);
        list.add(22);
        Collections.sort(list);
        System.out.println(list);   //[5, 12, 16, 22, 81]

练习题

练习1：

删除第一个字符串当中出现的第二个字符串中的字符
str1 = “welcome to my home”
str2 = “come”
输出：“wl t y h”

    //用集合arraylist
    public static List<Character> delete(String a, String b) {
        ArrayList<Character> list = new ArrayList<>();
        for(int i = 0; i < a.length(); i++) {
            if(b.contains(a.charAt(i)+"")) {
                continue;
            }
            list.add(a.charAt(i));
        }
        return list;
    }
    
    //用stringbuilder
    public static String delete1(String a, String b) {
        StringBuilder s = new StringBuilder();
        for(int i = 0; i < a.length(); i++) {
            if(b.contains(a.charAt(i)+"")) {
                continue;
            }
            s.append(a.charAt(i));
        }
        return s.toString();
    }

    public static void main(String[] args) {
        String a = "welcome to my home";
        String b = "come";
        System.out.println(delete(a,b));
        String c = delete1(a,b);
        System.out.println(c);
    }

---

练习2：模拟一副扑克牌，然后分别发5张牌给3个人

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

/**
 * Created with IntelliJ IDEA.
 * Description:模拟一副扑克牌，然后分别发5张牌给3个人
 * User: starry
 * Date: 2021 -03 -09
 * Time: 16:42
 */

//扑克牌
class Card {
    public String suit; //花色
    public int rank;    //数字

    public Card(String suit, int rank) {
        this.suit = suit;
        this.rank = rank;
    }

    @Override
    public String toString() {
//        return "Card{" +
//                "suit='" + suit + '\'' +
//                ", rank=" + rank +
//                '}';
        return "["+suit+","+rank+"]";
    }
}

//生成扑克牌
class DeckCard {
    public static final String[] suits = {"♥","♠","♦","♣"};

    //买一副牌
    public List<Card> buyCard() {
        List<Card> cardList = new ArrayList<>();

        for(int i = 0; i < 4; i++) {
            for(int j = 1; j < 13; j++) {
                String suit = suits[i];
                int rank = j;
                Card card = new Card(suit,rank);
                cardList.add(card);
            }
        }
        return cardList;
    }

    //交换两张牌
    public void swap(List<Card> cardList, int i, int j) {
        Card tmp = cardList.get(i);
        cardList.set(i,cardList.get(j));
        cardList.set(j,tmp);
    }

    //洗牌
    public void washCard(List<Card> cardList) {
        for (int i = cardList.size()-1; i > 0; i--) {
            Random random = new Random();
            int rand = random.nextInt(i);
            swap(cardList,i,rand);
        }
    }

}

public class Work2 {

    public static void main(String[] args) {
        DeckCard deckCard = new DeckCard();
        List<Card> cardList = deckCard.buyCard();
        System.out.println("========买牌=========");
        System.out.println(cardList);
        deckCard.washCard(cardList);
        System.out.println("========洗牌=========");
        System.out.println(cardList);

        //三个人
        List<Card> hands1 = new ArrayList<>();
        List<Card> hands2 = new ArrayList<>();
        List<Card> hands3 = new ArrayList<>();
        //存放三个人手里牌的数组
        List<List<Card>> hands = new ArrayList<>();
        hands.add(hands1);
        hands.add(hands2);
        hands.add(hands3);
        System.out.println("========发牌=========");
        //一个人一次发五张牌
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 5; j++) {
                Card card = cardList.remove(0);
                hands.get(i).add(card);
            }
        }
/*
        //三人轮流发牌，一人一共发5张牌
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                Card card = cardList.remove(0);
                hands.get(j).add(card);
            }
        }
*/
        System.out.println("第一个人：");
        System.out.println(hands1);
        System.out.println("第二个人：");
        System.out.println(hands2);
        System.out.println("第三个人：");
        System.out.println(hands3);
        System.out.println("剩下的牌：");
        System.out.println(cardList);
    }

}

---

练习3：杨辉三角
Leetcode链接

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> ret = new ArrayList<>();
        if(numRows <= 0) return ret;
        //第一行的list
        List<Integer> list = new ArrayList<>();
        list.add(1);
        //把第一行的list放到ret当中
        ret.add(list);
        for(int i = 1;i < numRows;i++) {
            List<Integer> curRow = new ArrayList<>();
            curRow.add(1);
            for(int j = 1 ;j < i;j++) {
                //确定的是当前行的每个元素  ==  上一行的当前列+上一行的前一列就是我当前需要添加的字
                List<Integer> qianRow = ret.get(i-1);
                int num = qianRow.get(j)+qianRow.get(j-1);
                curRow.add(num);
            }
            //手动在当前行的最后一个位置 添加一个1
            curRow.add(1);
            ret.add(curRow);
        }
        return ret;
    }
}