[データ構造] Sequence ListとArrayList

著者ホームページ：ペーパージーのブログ

この記事の著者: 皆さんこんにちは、paper jie です。この記事を読んでいただきありがとうございます。Yijiansanlian へようこそ。

この記事は「JAVA データ構造」コラムに収録されており、大学生やプログラミング初心者向けに丁寧に作成されています。著者は、JavaSE の基本的な知識をすべて網羅するために、多大な費用 (時間とエネルギー) を費やして構築しました。

その他コラム：「アルゴリズムの詳細解説」「C言語」「javaSE」など

コンテンツ共有: 今回はデータ構造におけるシーケンステーブルについて説明します。

リニアテーブル

シーケンステーブル

簡易シーケンステーブルのシミュレーション実装

シーケンステーブル ArrayList の格納構造の長所と短所

リニアテーブル

線形リストは、同じ属性を持つ複数のデータ要素の有限シーケンスです。線形リストは、私たちの仕事で広く使用できるデータ構造です。一般的な線形リスト: シーケンシャルリスト、リンクリスト、スタック、キュー...

線形テーブルは論理的には線形構造、つまり連続した直線です。しかし、物理的な構造としては連続的ではない可能性があります。線形テーブルを物理的に保存する場合、通常は配列およびリンクされた構造に保存されます。

シーケンステーブル

シーケンステーブルは、連続した物理アドレスを持つ記憶装置を使用してデータ要素を順番に格納する線形構造であり、一般的には配列ストレージが使用されます。アレイ上のデータの追加、削除、確認、変更を完了します。

簡易シーケンステーブルのシミュレーション実装

コードを見るには私の Gitee にアクセスしてください。コードはたくさんあるので、ここでは示しません: Structure_code/java2023.9.12/src/mylist · Peng Zijie/Data Structure-Code Cloud-Open Source China ( gitee.com)

コレクションフレームワーク

Java コレクションフレームワークはコンテナとも呼ばれ、java.util パッケージで定義されたインターフェイスとその実装クラスのセットです。その主な機能は、複数の要素を 1 つのユニットに配置して、これらの要素の保存、取得、操作 (通常、追加、削除、変更と呼ばれるもの) を迅速かつ便利に行うことです。

クラスとインターフェースの概要:

ArrayList の概要

Javaのコレクションフレームワーク(コンテナ)において、ArrayListはシーケンスリストであり、Listインタフェースを実装した通常のクラスであり、フレームワークは以下の通りです。

知らせ：

ArrayList は汎用的な方法で実装されており、使用前にインスタンス化する必要があります。

ArrayList は RandomAccess インターフェイスを実装し、ArrayList がランダムアクセスをサポートしていることを示します。

ArrayList はクローン可能なインターフェイスを実装し、ArrayList をクローンできることを示します

ArrayList は Serializable インターフェイスを実装し、ArrayList がシリアル化をサポートしていることを示します

Vector とは異なり、ArrayList はスレッドセーフではなく、シングルスレッドで使用できますが、マルチスレッドでは Vector または CopyOnWriteArrayList を選択できます。

ArrayList の最下層は連続した空間であり、動的に展開することができ、動的に型付けされた配列リストです。

ArrayList の使用

ArrayList の構築

public class Test {

    public static void main(String[] args) {
// ArrayList创建，推荐写法
// 构造一个空的列表
        List<Integer> list1 = new ArrayList<>();
// 构造一个具有10个容量的列表
        List<Integer> list2 = new ArrayList<>(10);
        list2.add(1);
        list2.add(2);
        list2.add(3);
// list2.add("hello"); // 编译失败，List<Integer>已经限定了，list2中只能存储整形元素
// list3构造好之后，与list中的元素一致
        ArrayList<Integer> list3 = new ArrayList<>(list2);
// 避免省略类型，否则：任意类型的元素都可以存放，使用时将是一场灾难
        List list4 = new ArrayList();
        list4.add("111");
        list4.add(100);
    }
}

ArrayList の基本メソッド

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("JavaSE");
        list.add("JavaWeb");
        list.add("JavaEE");
        list.add("JVM");
        list.add("测试课程");
        System.out.println(list);
// 获取list中有效元素个数
        System.out.println(list.size());
// 获取和设置index位置上的元素，注意index必须介于[0, size)间
        System.out.println(list.get(1));
        list.set(1, "JavaWEB");
        System.out.println(list.get(1));
// 在list的index位置插入指定元素，index及后续的元素统一往后搬移一个位置
        list.add(1, "Java数据结构");
        System.out.println(list);
// 删除指定元素，找到了就删除，该元素之后的元素统一往前搬移一个位置
        list.remove("JVM");
        System.out.println(list);
// 删除list中index位置上的元素，注意index不要超过list中有效元素个数,否则会抛出下标越界异常
        list.remove(list.size()-1);
        System.out.println(list);
    } // 查找指定元素第一次出现的位置：indexOf从前往后找，lastIndexOf从后往前找
        list.add("JavaSE");
        System.out.println(list.indexOf("JavaSE"));
        System.out.println(list.lastIndexOf("JavaSE"));
        // 使用list中[0, 4)之间的元素构成一个新的SubList返回,但是和ArrayList共用一个elementData数组
        // List<String> ret = list.subList(0, 4);
        System.out.println(ret);
        list.clear();
        System.out.println(list.size());
}

ArrayList の走査

ArrayList は、for ループ、foreach、イテレータの 3 つの方法で走査できます。

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
// 使用下标+for遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        } System.out.println();
// 借助foreach遍历
        for (Integer integer : list) {
            System.out.print(integer + " ");
        } System.out.println();
// 使用迭代器遍历        
        Iterator<Integer> it = list.listIterator();
        while(it.hasNext()){
            System.out.print(it.next() + " ");
        } System.out.println();
    }

ここでのイテレータは設計パターンの一種です。

ArrayList 展開メカニズム

まず、コードの一部を見てみましょう。

public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            list.add(i);
        }
    }

ArrayList は動的に型指定されたシーケンスリストであること、つまり要素の挿入プロセス中に自動的に展開されることがわかっています。ソースコードを見てみましょう。

Object[] elementData; // 存放元素的空间
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 默认空间
private static final int DEFAULT_CAPACITY = 10; // 默认容量大小
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
} r
eturn minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
// 获取旧空间大小
int oldCapacity = elementData.length;
// 预计按照1.5倍方式扩容
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 如果用户需要扩容大小 超过 原空间1.5倍，按照用户所需大小扩容
if (newCapacity - minCapacity < 0) 
newCapacity = minCapacity;
// 如果需要扩容大小超过MAX_ARRAY_SIZE，重新计算容量大小
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 调用copyOf扩容
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
// 如果minCapacity小于0，抛出OutOfMemoryError异常
if (minCapacity < 0)
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

図面解析

【まとめ】

本当に展開が必要かどうかを確認し、g が row を呼び出したら展開の準備をします。

必要なストレージ容量を見積もる

当初は1.5倍に拡大

ユーザーの要求サイズが1.5倍を超える場合は、ユーザーの要求サイズに応じて容量を拡張します。

実際に拡張する前に、拡張が大きすぎて拡張が失敗することを防ぐために、拡張が成功するかどうかを確認してください。

展開にはcopyofを使用します

ArrayList の具体的な使用法

簡単なシャッフルアルゴリズムを次に示します。

public class Card {
public int rank; // 牌面值
public String suit; // 花色
@Override
public String toString() {
return String.format("[%s %d]", suit, rank);
}
}

import java.util.List;
import java.util.ArrayList;
import java.util.Random;
public class CardDemo {
public static final String[] SUITS = {"♠", "♥", "♣", "♦"};
// 买一副牌
private static List<Card> buyDeck() {
List<Card> deck = new ArrayList<>(52);
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();
card.rank = rank;
card.suit = suit;
deck.add(card);
}
} 
return deck;
}
private static void swap(List<Card> deck, int i, int j) {
Card t = deck.get(i);
deck.set(i, deck.get(j));
deck.set(j, t);
}
private static void shuffle(List<Card> deck) {
Random random = new Random(20190905);
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);
// 三个人，每个人轮流抓 5 张牌
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));
}
}

シーケンステーブル ArrayList の格納構造の長所と短所

アドバンテージ

要素間の関係を明確に表現するために追加の記憶域を追加する必要はありません。

テーブル内の任意の位置の要素にすばやくアクセスできます

欠点がある

任意の位置での要素の削除と挿入の時間計算量は O(N) であるため、多数の要素を移動する必要があります。

順序テーブルの長さが大きく変化すると、記憶領域の容量を決定することが困難になります。

ストレージスペースの断片化が起こりやすく、スペースの無駄になります。