English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Java 基礎教程

Javaのフロー制御

Java配列

Javaオブジェクト指向(I)

Javaオブジェクト指向(II)

Javaオブジェクト指向(III)

Java 異常処理

Javaリスト(List)

Java Queue（キュー）

Java Mapコレクション

Java Setコレクション

Java入出力(I/O)

Java Reader/Writer

Javaの他のトピック

Java LinkedList(リンクリスト)

このチュートリアルでは、LinkedListクラスについて多くの例を通じて詳細に学びます。

JavaコレクションフレームワークのLinkedListクラスはリンクリストデータ構造の機能を提供します。

LinkedListによって実装されたインターフェース

JavaでのLinkedList実装

Java LinkedListクラスはダブルリンクリストの実装を提供します。

リンクリストの各要素はノード。これは、3フィールドがあります：

  • Prev - 前の要素のアドレスをリストに保存します。最初の要素はnullです。

  • Next - 次の要素のアドレスをリストに保存します。最後の要素はnullです。

  • Data - 実際のデータを保存します。

リンクリストの要素は順序で保存されていません。代わりに、分散しており、リンク（PrevおよびNext）で結ばれています。

ここでは、リンクリストに3要素です。

  • Dog - 一番目の要素はnullを前アドレスとして、Catのアドレスを次のアドレスとして持つ

  • Cat - 二番目の要素はDogのアドレスを前アドレスとして、Cowのアドレスを次のアドレスとして持つ

  • Cow - 最後の要素はCatのアドレスを前アドレスとして、nullを次の要素として持つ

LinkedListを作成します

これがJavaでリンクリストを作成する方法です：

LinkedList<Type> linkedList = new LinkedList<>();

ここでは、Typeはリンクリストのタイプを表します。例えば、

//整数のリンクリストを作成する
LinkedList<Integer> linkedList = new LinkedList<>();
//文字列のリンクリストを作成する
LinkedList<String> linkedList = new LinkedList<>();

インターフェースを使用してLinkedListを作成する

例を示しましょう。

List<String> animals1　= new LinkedList<>();

ここでは、Listインターフェースを使用してリンクリストanimalsを宣言しました1、リンクリストはListインターフェースのメソッドしかアクセスできません。

もう一つの例を示しましょう。

Queue<String> animals2　= new LinkedList<>();
Deque<String> animals3　= new LinkedList<>();

ここでは、animal2Queueインターフェースのメソッドにアクセスできます。

しかし、animal3DequeやQueueインターフェースのメソッドしかアクセスできません。なぜなら、DequeはQueueのサブインターフェースだからです。

LinkedListのメソッド

LinkedListは、リンクリスト内でさまざまな操作を実行できるさまざまなメソッドを提供します。

LinkedListに要素を追加

1.要素の追加：}add()メソッドを使用

リストの末尾に要素（ノード）を追加するには、add()メソッドを使用します。例えば、

import　java.util.LinkedList;
class　Main　{
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String>　animals　=　new　LinkedList<>();
　　　　　　　　//LinkedListに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　}
}

出力結果

LinkedList: [Dog, Cat, Horse]

2.要素の追加：インデックスを使用

要素（ノード）をリストの末尾に追加するには、add()メソッドを使用します。例えば、

import　java.util.LinkedList;
class　Main　{
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String>　animals　=　new　LinkedList<>();
　　　　　　　　//インデックスを使用して要素を追加
　　　　　　　　animals.add(0,"Dog");
　　　　　　　　animals.add(1,"Cat");
　　　　　　　　animals.add(2,"Horse");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　}
}

出力結果

LinkedList: [Dog, Cat, Horse]

3.要素の追加：リストを別のリストに追加

リストのすべての要素を別のリストに追加するには、addAll()メソッドを使用します。例えば、

import　java.util.LinkedList;
class　Main　{
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> mammals = new LinkedList<>();
　　　　　　　　mammals.add("Dog");
　　　　　　　　mammals.add("Cat");
　　　　　　　　mammals.add("Horse");
　　　　　　　　System.out.println("Mammals: ")　+　mammals);
　　　　　　　　LinkedList<String>　animals　=　new　LinkedList<>();
　　　　　　　　animals.add("Crocodile");
　　　　　　　　//mammalsのすべての要素をanimalsに追加
　　　　　　　　animals.addAll(mammals);
　　　　　　　　System.out.println("Animals: ")　+　animals);
　　　　}
}

出力結果

Mammals: [Dog, Cat, Horse]
Animals: [Crocodile, Dog, Cat, Horse]

4.要素の追加：listIterator()メソッドを使用

リストに要素を追加するには、listsIterator()メソッドを使用できます。これを使用するには、java.util.ListIteratorパッケージをインポートする必要があります。例えば、

import java.util.ArrayList;
import java.util.ListIterator;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//ListIteratorオブジェクトを生成します
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.add("Dog");
　　　　　　　　listIterate.add("Cat");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　}
}

出力結果

LinkedList: [Dog, Cat]

LinkedList要素へのアクセス

1.要素へのアクセス：get()メソッドを使用

リストの要素にアクセスするには、get()メソッドを使用できます。例えば、

import　java.util.LinkedList;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//リストから要素を取得
　　　　　　　　String str = animals.get(1);
　　　　　　　　System.out.print("インデックス1の要素: "　+　str);
　　　　}
}

出力結果

LinkedList:　[Dog,　Horse,　Cat]
インデックス1の要素: Horse

2.要素へのアクセス：iterator()メソッドを使用

リストの要素を巡回するには、iterator()メソッドを使用できます。このメソッドを使用するには、java.util.Iteratorパッケージをインポートする必要があります。例えば、

import　java.util.LinkedList;
import　java.util.Iterator;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　//Iteratorのオブジェクトを作成します
　　　　　　　　Iterator<String>　iterate　=　animals.iterator();
　　　　　　　　System.out.print("LinkedList:　");
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　}
}

出力結果

LinkedList:　Dog,　Cat,　Horse,

ここでは、

  • hasNext() - 次の要素が存在する場合、trueを返します

  • next() - 次の要素を返します

3.要素のアクセス：listIterator()メソッドを使用します

リンクリストの要素をイテレートするためにlistIterator()メソッドを使用することもできます。このメソッドを使用するには、java.util.ListIteratorパッケージをインポートする必要があります。

listsIterator()メソッドはリンクリストに適しています。これは、listIterator()オブジェクトが後方に進むこともできるためです。例えば、

import　java.util.LinkedList;
import java.util.ListIterator;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　//ListIteratorオブジェクトを生成します
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　System.out.print("LinkedList:　");
　　　　　　　　while(listIterate.hasNext())　{
　　　　　　　　　　　　System.out.print(listIterate.next());
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　　　　　//　後方に進む
　　　　　　　　System.out.print("\n逆順LinkedList:　");
　　　　　　　　while(listIterate.hasPrevious())　{
　　　　　　　　　　　　System.out.print(listIterate.previous());
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　}
}

出力結果

LinkedList:　Dog,　Horse,　Cat,
逆順LinkedList:　Cat,　Horse,　Dog,

ここでは、

  • hasNext() - 次の要素が存在する場合、trueを返します

  • next() - 次の要素を返します

  • hasPrevious() - 前の要素が存在する場合、trueを返します

  • previous() - 前の要素を返します

1.要素の検索：contains()メソッドを使用します

特定の要素がリンクリストに含まれているかを確認するには、contains()メソッドを使用します。例えば、

import　java.util.LinkedList;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//Dogがリンクリストに存在するか確認します
　　　　　　　　if(animals.contains("Dog"))　{
　　　　　　　　　　　　System.out.println("DogはLinkedListにあります。");
　　　　　　　　}
　　　　}
}

出力結果

LinkedList:　[Dog,　Horse,　Cat]
DogはLinkedListにあります。

2.検索要素：indexOf()メソッドを使用します

  • indexOf() - 要素が最初に出现したインデックスを返します

  • lastIndexOf() - 要素が最後に出现したインデックスを返します

例如，

import　java.util.LinkedList;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//　リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//Dogが最初に出现しました
　　　　　　　　int index1　=　animals.indexOf("Dog");
　　　　　　　　System.out.println("Dogが最初に出现した索引値:　"　+　index1);
　　　　　　　　//最後にDogが出现しました
　　　　　　　　int index2　= animals.lastIndexOf("Dog");
　　　　　　　　System.out.println("Dogの最後のインデックス値: ")　+　index2);
　　　　}
}

出力結果

LinkedList: [Dog, Horse, Cat, Dog]
Dogの最初のインデックス値: 0
Dogの最後のインデックス値:　3

注意：指定された要素が見つからない場合、indexOf()とlastIndexOf()はすべてのものが-1.

LinkedList要素の変更

1.要素の変更：set()メソッドの使用

リンクリストの要素を変更するには、set()メソッドを使用できます。例えば、

import　java.util.LinkedList;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//変更するインデックス値が3の要素
　　　　　　　　animals.set(3, "Zebra");
　　　　　　　　System.out.println("新しいLinkedList:　");　+　animals);
　　　　}
}

出力結果

LinkedList: [Dog, Horse, Cat, Dog]
新しいLinkedList: [Dog, Horse, Cat, Zebra]

2.要素の変更：listIterator()メソッドの使用

リンクリストの要素を変更するためにlistIterator()メソッドを使用することもできます。例えば、

import java.util.ArrayList;
import java.util.ListIterator;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//　リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//ListIteratorオブジェクトを生成します
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//next()が返す要素を変更します
　　　　　　　　listIterate.set("Cow");
　　　　　　　　System.out.println("新しいLinkedList:　");　+　animals);
　　　　}
}

出力結果

LinkedList: [Dog, Cat, Horse]
新しいLinkedList: [Cow, Cat, Horse]

LinkedList要素の削除

1.要素の削除：remove()メソッドの使用

リンクリストから要素を削除するには、remove()メソッドを使用できます。例えば、

import　java.util.LinkedList;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Zebra");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//削除するインデックス値が1の要素
　　　　　　　　String str = animals.remove(1);
　　　　　　　　System.out.println("削除する要素: ")　+　str);
　　　　　　　　System.out.println("新しいLinkedList:　");　+　animals);
　　　　}
}

出力結果

LinkedList: [Dog, Horse, Cat, Zebra]
削除する要素: Horse
新しいLinkedList: [Dog, Cat, Zebra]

2.要素の削除：listIterator()メソッドの使用

リンクリストから要素を削除するためにlistsIterator()メソッドを使用することもできます。例えば、

import java.util.ArrayList;
import java.util.ListIterator;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//ListIteratorオブジェクトを生成します
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//next()が返す要素を削除します
　　　　　　　　listIterate.remove();
　　　　　　　　System.out.println("新しいLinkedList:　");　+　animals);
　　　　}
}

出力結果

LinkedList: [Dog, Cat, Horse]
新しいLinkedList: [Cat, Horse]

3.要素の削除：clear()メソッドの使用

リンクリストからすべての要素を削除するには、clear()メソッドを使用します。例えば、

import　java.util.LinkedList;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//すべての要素を削除します
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("新しいLinkedList:　");　+　animals);
　　　　}
}

出力結果

LinkedList: [Dog, Cat, Horse]
新しいLinkedList: []

注意：removeAll()メソッドを使用してすべての要素を削除することもできますが、clear()メソッドはremoveAll()メソッドよりも効率的です。

4.要素の削除：removeIf()メソッドの使用

特定の条件を満たす要素がある場合、リンクリストからこれらを削除することもできます。これにはremoveIf()メソッドを使用します。例えば、

import　java.util.LinkedList;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　LinkedList<Integer> animals = new LinkedList<>();
　　　　　　　　//リストに要素を追加
　　　　　　　　animals.add(2);
　　　　　　　　animals.add(3);
　　　　　　　　animals.add(4);
　　　　　　　　animals.add(5);
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//　すべての小于4の要素
　　　　　　　　animals.removeIf((Integer i)->i <　4);
　　　　　　　　System.out.println("新しいLinkedList:　");　+　animals);
　　　　　　　/**　ここではlambda式を使用しています
　　　　　　　*　　今、これを覚えておいてください
　　　　　　　*　　removeIf()の引数は条件です
　　　　　　　*/
　　　　}
}

出力結果

LinkedList: [2,　3,　4,　5]
新しいLinkedList: [4,　5]

注意： (Integer i)->i<4 これはlambda式です。lambda式について学びたい場合は、Java Lambda式

LinkedListはDequeおよびQueueとして

LinkedListクラスはQueueおよびDequeインターフェースも実装しているため、これらのインターフェースのメソッドを実装することもできます。以下は、一般的に使用されるメソッドの一部です：

addFirst()とaddLast()メソッド

  • addFirst() - 指定された要素をリンクリストの先頭に追加します

  • addLast() - 指定された要素をリンクリストの末尾に追加します

例如，

import　java.util.LinkedList;
import　java.util.Deque;
class　Main　{
　　　　public static void main(String[] args){
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//要素をLinkedListの先頭に追加します
　　　　　　　　animals.addFirst("Cow");
　　　　　　　　animals.addFirst("Dog");
　　　　　　　　animals.addFirst("Cat");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//LinkedListの末尾に要素を追加
　　　　　　　　animals.addLast("Zebra");
　　　　　　　　System.out.println("新しいLinkedList:　");　+　animals);
　　　　}
}

出力結果

LinkedList:　[Cat,　Dog,　Cow]
新的LinkedList:　[Cat,　Dog,　Cow,　Zebra]

getFirst()和getLast()方法

  • getFirst() - 返回第一个元素

  • getLast() - 返回最后一个元素

例如，

import　java.util.LinkedList;
import　java.util.Deque;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　Deque<String>　animals=　new　LinkedList<>();
　　　　　　　　//　リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//从链表中获取第一个元素
　　　　　　　　String　str1　=　animals.getFirst();
　　　　　　　　System.out.println("第一个元素:　"　+　str1);
　　　　　　　　//从链表中获取最后一个元素
　　　　　　　　String　str2　=　animals.getLast();
　　　　　　　　System.out.println("最后一个元素:　"　+　str2);
　　　　}
}

出力結果

LinkedList:　[Dog,　Horse,　Cat]
第一个元素:　Dog
最后一个元素:　Cat

removeFirst()和removeLast()方法

  • removeFirst() - 删除第一个元素

  • removeLast() - 删除最后一个元素

例如，

import　java.util.LinkedList;
import　java.util.Deque;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　Deque<String>　animals=　new　LinkedList<>();
　　　　　　　　//　リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//从LinkedList删除第一个元素
　　　　　　　　String　str1　=　animals.removeFirst();
　　　　　　　　System.out.println("删除的元素:　"　+　str1);
　　　　　　　　//从LinkedList删除最后一个元素
　　　　　　　　String　str2　=　animals.removeLast();
　　　　　　　　System.out.println("删除的元素:　"　+　str2);
　　　　　　　　System.out.println("新しいLinkedList:　");　+　animals);
　　　　}
}

出力結果

LinkedList:　[Dog,　Horse,　Cat]
删除的元素:　Dog
删除的元素:　Cat
新的LinkedList:　[Horse]

peek()方法

peek()方法返回链表的第一个元素（头）。例如，

import　java.util.LinkedList;
import　java.util.Queue;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　Queue<String>　animals=　new　LinkedList<>();
　　　　　　　　//リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//访问LinkedList的第一个元素
　　　　　　　　String　str　=　animals.peek();
　　　　　　　　System.out.println("元素访问:　"　+　str);
　　　　　　　　System.out.println("新しいLinkedList:　");　+　animals);
　　　　}
}

出力結果

LinkedList:　[Dog,　Horse,　Cat]
元素访问:　Dog
新しいLinkedList:　[Dog,　Horse,　Cat]

poll()方法

poll()方法返回并从链表中删除第一个元素。例如，

import　java.util.LinkedList;
import　java.util.Queue;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　Queue<String>　animals=　new　LinkedList<>();
　　　　　　　　//リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//返回并删除第一个元素
　　　　　　　　String　str　=　animals.poll();
　　　　　　　　System.out.println("删除的元素:　"　+　str);
　　　　　　　　System.out.println("新しいLinkedList:　");　+　animals);
　　　　}
}

出力結果

LinkedList:　[Dog,　Horse,　Cat]
删除的元素:　Dog
新的LinkedList:　[Horse,　Cat]

offer()方法

该offer()方法将指定的元素添加到链接列表的末尾。例如，

import　java.util.LinkedList;
import　java.util.Queue;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　Queue<String>　animals=　new　LinkedList<>();
　　　　　　　　//リストに要素を追加
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//LinkedListの末尾に要素を追加
　　　　　　　　animals.offer("Cat");
　　　　　　　　System.out.println("新しいLinkedList:　");　+　animals);
　　　　}
}

出力結果

LinkedList:　[Dog,　Horse]
新しいLinkedList:　[Dog,　Horse,　Cat]

LinkedListのイテレータを遍历

1.使用forEach循环を遍历

import　java.util.LinkedList;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//创建一个链表
　　　　　　　　LinkedList<String>　animals　=　new　LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//使用forEach循环
　　　　　　　　System.out.println("访问链表元素:");
　　　　　　　　for(String　animal:　animals)　{
　　　　　　　　　　　　System.out.print(animal);
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　}
}

出力結果

LinkedList: [牛、猫、犬]
访问链表元素:
牛、猫、犬、

2.使用for循环

import　java.util.LinkedList;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//创建一个链表
　　　　　　　　LinkedList<String>　animals　=　new　LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//使用for循环
　　　　　　　　System.out.println("访问链表元素:");
　　　　　　　　for(int　i=0;　i　<　animals.size();　i++)　{
　　　　　　　　　　　　System.out.print(animals.get(i));
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　}
}

出力結果

LinkedList: [牛、猫、犬]
访问链表元素:
牛、猫、犬、

在两个示例中，我们都使用循环访问链表的各个元素。

3.使用iterator()方法

我们可以使用iterator()方法访问链表的元素。为了使用这种方法，我们必须导入java.util.Iteratorパッケージ。

import　java.util.LinkedList;
import　java.util.Iterator;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//创建一个链表
　　　　　　　　LinkedList<String>　animals　=　new　LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList:　");　+　animals);
　　　　　　　　//使用iterator()方法
　　　　　　　　System.out.println("LinkedList使用iterator()方法:");
　　　　　　　　Iterator<String>　iterate　=　animals.iterator();
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　}
}

出力結果

LinkedList: [牛、猫、犬]
LinkedListはiterator()メソッドを使用します：
牛、猫、犬、

LinkedListとArrayList

LinkedListとArrayListはCollectionsフレームワークのListインターフェースを実装しています。しかし、彼らはいくつかの違いがあります。

LinkedListArrayList

単一の場所に保存します。3の値（前のアドレス、データ、次のアドレス）

単一の場所に単一の値を保存します。

リストのダブルリンクリスト実装を提供します。

可変サイズの配列実装を提供します。

要素を追加するたびに、前のと次のアドレスが変更されます。

要素を追加するたびに、その位置以降のすべての要素が移動します。

要素にアクセスするには、要素までの迭代を開始する必要があります。

要素にランダムにアクセスするには、インデックスを使用できます。
Java メソッドオーバーロードJava Dequeインターフェース