ArrayList与顺序表

文章目录

• ArrayList与顺序表
• • 线性表
  • 1.顺序表
  • 2.ArrayList的简介
  • 3.ArrayList的使用
  • 4.ArrayList的遍历
  • 5.ArrayList的扩容机制
  • 6.使用示例
  • • 6.1扑克牌
    • 6.2杨辉三角
  • 7.心得

线性表

1.顺序表

​ 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

2.ArrayList的简介

3.ArrayList的使用

各种方法：

注意subList：这里的截取只是把要截取的顺序表下标的地址拿去了，操作的就是原来的顺序表，所以对截取后的顺序表的任何操作对原来的顺序表都有影响。

4.ArrayList的遍历

        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("刘宇豪");
        arrayList.add("今年");
        arrayList.add("20岁啦!");
        System.out.println(arrayList);

        System.out.println("==========================");
        //for遍历
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }
        System.out.println("==========================");
        //foreach遍历
        for (String e: arrayList) {
            System.out.println(e);
        }
        System.out.println("==========================");
        //迭代器 iterator用的多一些
        Iterator<String> it = arrayList.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        ListIterator<String> it2 = arrayList.listIterator();
        while(it2.hasNext()){
            System.out.println(it2.next());
        }

5.ArrayList的扩容机制

去看源码

【总结】

1. 检测是否真正需要扩容，如果是调用grow准备扩容
2. 预估需要库容的大小
   • 初步预估按照1.5倍大小扩容
   • 如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容
   • 真正扩容之前检测是否能扩容成功，防止太大导致扩容失败
3. 使用copyOf进行扩容

6.使用示例

6.1扑克牌

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

//抽象牌
class Card{
    private int rank;
    private String suit;

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

    @Override
    public String toString() {
        return "" + suit + " " + rank;
    }
}
public class CardDemo {
    private String[] suit = {"❤","♠","♣","♦"};
    //准备一副牌
    public List<Card> buyCards(){
        List<Card> cards = new ArrayList<>(52);
        for (int i = 1; i < 14; i++) {
            for (int j = 0; j < 4; j++) {
                String s = suit[j];
                Card card = new Card(i,s);
                cards.add(card);
            }
        }
        return cards;
    }
    private void swap(List<Card> cards, int i, int j){
        Card tmp = cards.get(i);
        cards.set(i,cards.get(j));
        cards.set(j,tmp);
    }
    //洗牌
    public void shuffle(List<Card> cards){
        Random random = new Random();
        for (int i = cards.size()-1; i > 0 ; i--) {
            int index = random.nextInt(i);
            swap(cards,i,index);
        }
    }
    //揭牌
    public void test(List<Card> cards){
        List<Card> hand1 = new ArrayList<>();
        List<Card> hand2 = new ArrayList<>();
        List<Card> hand3 = new ArrayList<>();

        List<List<Card>> hands = new ArrayList<>();
        hands.add(hand1);
        hands.add(hand2);
        hands.add(hand3);
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                Card card = cards.remove(0);
                hands.get(j).add(card);
            }
        }
        for (int i = 0; i < hands.size(); i++) {
            System.out.println("第"+ (i+1) + "个人的牌");
            System.out.println(hands.get(i));
        }
        System.out.println("剩余的牌 ");
        for (int i = 0; i < cards.size(); i++) {
            System.out.print(cards.get(i)+" ");
        }
    }
}

6.2杨辉三角

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

        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(1);//每行第一列元素都是1
        ret.add(list1);//第一行元素
        //从第二行开始
        for (int i = 1; i < numRows; i++) {
            ArrayList<Integer> list2 = new ArrayList<>();
            list2.add(1);//每行第一个元素准备
            //准备前一行
            List<Integer> prevRow = ret.get(i-1);
            //从每行第二列开始
            for (int j = 1; j < i; j++) {
                //从第三行第二列开始，每列等于上一行的同一列的值+前一列的值
                list2.add(prevRow.get(j)+prevRow.get(j-1));
            }
            //每行最后一列元素都是1
            list2.add(1);
            ret.add(list2);
        }
        return ret;
    }

[118. 杨辉三角 - 力扣（LeetCode）]()

7.心得

d(1);
ret.add(list2);
}
return ret;
}

[[118. 杨辉三角 - 力扣（LeetCode）](https://leetcode.cn/problems/pascals-triangle/submissions/)]()

## 7.心得

顺序表适合用于查找数据，对于查找时间复杂度是O（1），是一个简单的哈希表。