するために使用されLinkedList上ArrayList Java?
https://stackoverflow.com/questions/322715
-
11-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian質問
私はいつも一つとして単に利用:
List<String> names = new ArrayList<>();
私のインターフェースの型名 携帯性, する場合には、このような私に質問をどこまでリワークは私のコードです。
べきであ LinkedList 定することが ArrayList 逆?
解決
概要 ArrayList と ArrayDeque 好 多くの 以上利用の場合よ LinkedList.まだ—として無料でご利用いただけ ArrayList.
LinkedList や ArrayList 二つの異なる実装のリストインタフェース。 LinkedList を実装しているとの二重リンク一覧です。 ArrayList 実装では、動的にリサイジング配列の型になります。
標準リンクリストに配列し、業務の様々な方法が異なるアルゴリズム-トラン
のための LinkedList<E>
get(int index)は O(n) （ n/4 段平均)add(E element)は O(1)add(int index, E element)は O(n) （ n/4 段平均), が O(1) 時index = 0<---主に利益をLinkedList<E>remove(int index)は O(n) （ n/4 段平均)Iterator.remove()は O(1).<---主に利益をLinkedList<E>ListIterator.add(E element)は O(1) この主な特典LinkedList<E>
注意：多くの作業が必要 n/4 段平均 一定の ステップ数の場合（例えば指数=0)、および n/2 手順最悪の場合中のリスト）
のための ArrayList<E>
get(int index)は O(1) <---主に利益をArrayList<E>add(E element)は O(1) 償却が O(n) 最悪の場合の配列が必要なサイズおよびコピーadd(int index, E element)は O(n) （ n/2 段平均)remove(int index)は O(n) （ n/2 段平均)Iterator.remove()は O(n) （ n/2 段平均)ListIterator.add(E element)は O(n) （ n/2 段平均)
注意：多くの作業が必要 n/2 段平均 一定の ステップ数の場合のリスト n 手順は、最悪の場合（一覧）
LinkedList<E> できるために一定時間の挿入または吸収量 反復子の使用, が、順次アクセスの要素の集まりです。つまり、歩くことができ、リストの転送、それとも後退が、このリストは時間に比例したサイズをクリックします。Javadocと "作業指数のリストのトラバースのリストから始または終了する方向に掃引するには、", での方法 O(n) (n/4 ステップ）平均的にも O(1) のための index = 0.
ArrayList<E>, 一方、ランダムに高速で読み込みアクセスできますので掴む要素には一定の時間。が追加または削除のどこからでもものが必要で移動すべてに後者の要素、のいずれかに開始スイッチを入れたりする。また、追加要素の能力の基になる配列の新しい配列(1.5倍)が割り当てられ、古くからの配列はコピーになるには、添加すること ArrayList は O(n) 最悪の場合も定数の平均値。
によって運営まで、選択すべき実装します。繰り返し処理を行いずれかのようなリストは実質的にも安いです。(繰り返し処理を行は、 ArrayList 技術的に高速化がないという性能-高感度な心配す--いconstants.)
主な特典を利用す LinkedList 生じたときに再利用、既存の反復子を挿入および削除します。これらの業務での実施日-実施会場は限られている O(1) による変更のリスト地域のみです。配列リストの残りの部分配列が必要 移転 （ます。に求めている、 LinkedList とは以下のリンク O(n) (n/2 ステップ)のための最悪の場合は、 ArrayList ご希望の位置を算出することが可能で数学的には、アクセス O(1).
もう一つの利点を利用 LinkedList 生じたときの追加と削除からの来の業務 O(1), にとって O(n) のための ArrayList.ご注意 ArrayDeque するのも良い代替 LinkedList ための追加と削除からのものではな List.
また、大型のリスト、メモリ使用量も違います。各要素の LinkedList が架からのポインタの前の要素も保存されます。 ArrayLists ないこのオーバーヘッド。しかし、 ArrayLists げているメモリが割り当てられたのかどうかにかかわらず、要素として追加されます。
デフォルトの初期容量 ArrayList か小さい（10Java1.4-1.8).の基本となる実装は、配列の必要サイズ変更を追加した場合、多くの要素の集まりです。を避けるため高コストのサイズ変更が分かっている場合は、また追加の要素を構築する ArrayList 高い初期容量です。
他のヒント
これまでに誰もいないようにしてメモリフットプリントのそれぞれのリスト以外の一般的なコンセンサスがとれ LinkedList する"ロットより"よ ArrayList いった数延をどのくらいの両方のリストを取るためにNがnullの参照です。
以降、参考文献から32または64ビットによってのみ呼び出されます）の相対的なシステム、付属の4セットデータ32ビット版および64ビット版 LinkedLists や ArrayLists.
注意： のサイズを記載 ArrayList ラインのための グリスト -実際に、容量のバッキング配列、 ArrayList 一般的によりその現在の要素数です。
注2: （感謝BeeOnRope) としてCompressedOopsはデフォルトの現在から中旬にはjdk6には、サの値は以下の64ビット機では基本的には合致32ビットカーなので具体的にはoffにします。
の結果から LinkedList で全体の以上に多く ArrayList, 特に、非常に高い要素数です。メモリが必要のなか LinkedLists.
計算式を使って、いっても違いまでしっかり固定します。"b"のいずれか4 8 32または64ビットのシステムは'n'です。注このmodがすべてのオブジェクトにjavaに取り上げたいのは、複数の8バイトスペースであるか否かを問わずすべて使います。
ArrayList:
ArrayList object header + size integer + modCount integer + array reference + (array oject header + b * n) + MOD(array oject, 8) + MOD(ArrayList object, 8) == 8 + 4 + 4 + b + (12 + b * n) + MOD(12 + b * n, 8) + MOD(8 + 4 + 4 + b + (12 + b * n) + MOD(12 + b * n, 8), 8)
LinkedList:
LinkedList object header + size integer + modCount integer + reference to header + reference to footer + (node object overhead + reference to previous element + reference to next element + reference to element) * n) + MOD(node object, 8) * n + MOD(LinkedList object, 8) == 8 + 4 + 4 + 2 * b + (8 + 3 * b) * n + MOD(8 + 3 * b, 8) * n + MOD(8 + 4 + 4 + 2 * b + (8 + 3 * b) * n + MOD(8 + 3 * b, 8) * n, 8)
ArrayList あると考えている。 LinkedList が近い（性能）す。
なぜ LinkedList 吸い込み:
- をふんだんに使って小型メモリオブジェクト、その影響性能のプロセス。
- 小さな体に悪いのキャッシュ-産地.
- 他の物価連動運転が必要でフォーカストラバーサル、すなわちはO(n)時間です。このしないことが明らかではないこと、ソースコード、アルゴリズムをO(n)時間より遅くなる場合
ArrayList使用した。 - 良い性能する話です。
- もbig-O性能と同じ
ArrayList, すでしょうが著しく遅くなります。 - でjarring見
LinkedListソースなので、間違った選択です。
ていることにして操作性工学の非常に大規模SOAサービスにつ、しっくりくるかもしれませんの挙動LinkedList上ArrayList.ながらの定常状態のスループットLinkedListが悪くても買取り、ハードウェアの挙動のArrayListの圧力に繋がるアプリクラスターの拡充を配列の近くの追随性、大型の配列サイズが不足対応のアプリや停電、圧力、壊滅的な行動です。
同様に、より良いスループットをアプリからデフォルトのスループットのテニュアガベージコレクタがロサンゼルス生まれのjavaアプリケーションに10GB盛き風のロックのアプリのための25秒間フルGCsの原因となるタイムアウトや失敗SOAリーが吹くおSlaの場合発生しますが多すぎる。でも、CMS集にありますので資源を上げていないのと同じ原スループットでは、より良い選択肢では将来の予測が容易な小型の待ち時間をゼロにすることに
ArrayListのみ選択肢がパフォーマンスのすべてを利用することにより性能のプロトコルのスループットとので無視して構いませんの待ち時間をゼロにすることに私の経験が私の仕事は無視できない最悪の場合の待ち時間をゼロにすることに
Algorithm ArrayList LinkedList
seek front O(1) O(1)
seek back O(1) O(1)
seek to index O(1) O(N)
insert at front O(N) O(1)
insert at back O(1) O(1)
insert after an item O(N) O(1)
ArrayListsは良く一度に読み込みの多くはアペンダが悪い時の追加と削除からのフロントに。
ああ、そうそう、ここは古代の質問ですが、私の中で投げるにあたっては、自分のセント:
LinkedListは ほとんど 間違った選択は、性能ました。ある特定のアルゴリズムがLinkedListればならないものの、それは非常に珍しいアルゴリズムは、通常、具体的には依存LinkedListの能力の挿入や削除の要素のリストが比較的迅速に、お客さま人数小児-幼児にナビゲーションにあり、ListIterator.
ある共用の場合LinkedList能ArrayList:このキューに挿入しますただし、目標業績ではなく、LinkedListすることも検討していくべき使用ArrayBlockingQueue(きる上限おのキューサイズ早めにできるの配分のすべてのメモリのフロント)、またはこの CircularArrayList実施.(あり、2001年からくる必要がありまgenerifyでも同等の性能比を行う最近のJVM)
ので効率の質問です。 LinkedList は高速の追加および削除する要素が遅アクセスの特定の要素となります。 ArrayList では迅速にアクセスの特定の要素がゆっくりできるの追加は、特に遅れを削除したいです。
訂正または誤った:を実行してください試験地を決めます。
編集/削除するよりも早いスピードで LinkedList 以上 ArrayList.
ArrayList, 背景には、 Array, 必要な時に必要なだけ、ダブルのサイズが大量願います。
以下のユニット試験結果の各動作します。タイミングが言えます。
Operation ArrayList LinkedList
AddAll (Insert) 101,16719 2623,29291
Add (Insert-Sequentially) 152,46840 966,62216
Add (insert-randomly) 36527 29193
remove (Delete) 20,56,9095 20,45,4904
contains (Search) 186,15,704 189,64,981
こちらのコード:
import org.junit.Assert;
import org.junit.Test;
import java.util.*;
public class ArrayListVsLinkedList {
private static final int MAX = 500000;
String[] strings = maxArray();
////////////// ADD ALL ////////////////////////////////////////
@Test
public void arrayListAddAll() {
Watch watch = new Watch();
List<String> stringList = Arrays.asList(strings);
List<String> arrayList = new ArrayList<String>(MAX);
watch.start();
arrayList.addAll(stringList);
watch.totalTime("Array List addAll() = ");//101,16719 Nanoseconds
}
@Test
public void linkedListAddAll() throws Exception {
Watch watch = new Watch();
List<String> stringList = Arrays.asList(strings);
watch.start();
List<String> linkedList = new LinkedList<String>();
linkedList.addAll(stringList);
watch.totalTime("Linked List addAll() = "); //2623,29291 Nanoseconds
}
//Note: ArrayList is 26 time faster here than LinkedList for addAll()
///////////////// INSERT /////////////////////////////////////////////
@Test
public void arrayListAdd() {
Watch watch = new Watch();
List<String> arrayList = new ArrayList<String>(MAX);
watch.start();
for (String string : strings)
arrayList.add(string);
watch.totalTime("Array List add() = ");//152,46840 Nanoseconds
}
@Test
public void linkedListAdd() {
Watch watch = new Watch();
List<String> linkedList = new LinkedList<String>();
watch.start();
for (String string : strings)
linkedList.add(string);
watch.totalTime("Linked List add() = "); //966,62216 Nanoseconds
}
//Note: ArrayList is 9 times faster than LinkedList for add sequentially
/////////////////// INSERT IN BETWEEN ///////////////////////////////////////
@Test
public void arrayListInsertOne() {
Watch watch = new Watch();
List<String> stringList = Arrays.asList(strings);
List<String> arrayList = new ArrayList<String>(MAX + MAX / 10);
arrayList.addAll(stringList);
String insertString0 = getString(true, MAX / 2 + 10);
String insertString1 = getString(true, MAX / 2 + 20);
String insertString2 = getString(true, MAX / 2 + 30);
String insertString3 = getString(true, MAX / 2 + 40);
watch.start();
arrayList.add(insertString0);
arrayList.add(insertString1);
arrayList.add(insertString2);
arrayList.add(insertString3);
watch.totalTime("Array List add() = ");//36527
}
@Test
public void linkedListInsertOne() {
Watch watch = new Watch();
List<String> stringList = Arrays.asList(strings);
List<String> linkedList = new LinkedList<String>();
linkedList.addAll(stringList);
String insertString0 = getString(true, MAX / 2 + 10);
String insertString1 = getString(true, MAX / 2 + 20);
String insertString2 = getString(true, MAX / 2 + 30);
String insertString3 = getString(true, MAX / 2 + 40);
watch.start();
linkedList.add(insertString0);
linkedList.add(insertString1);
linkedList.add(insertString2);
linkedList.add(insertString3);
watch.totalTime("Linked List add = ");//29193
}
//Note: LinkedList is 3000 nanosecond faster than ArrayList for insert randomly.
////////////////// DELETE //////////////////////////////////////////////////////
@Test
public void arrayListRemove() throws Exception {
Watch watch = new Watch();
List<String> stringList = Arrays.asList(strings);
List<String> arrayList = new ArrayList<String>(MAX);
arrayList.addAll(stringList);
String searchString0 = getString(true, MAX / 2 + 10);
String searchString1 = getString(true, MAX / 2 + 20);
watch.start();
arrayList.remove(searchString0);
arrayList.remove(searchString1);
watch.totalTime("Array List remove() = ");//20,56,9095 Nanoseconds
}
@Test
public void linkedListRemove() throws Exception {
Watch watch = new Watch();
List<String> linkedList = new LinkedList<String>();
linkedList.addAll(Arrays.asList(strings));
String searchString0 = getString(true, MAX / 2 + 10);
String searchString1 = getString(true, MAX / 2 + 20);
watch.start();
linkedList.remove(searchString0);
linkedList.remove(searchString1);
watch.totalTime("Linked List remove = ");//20,45,4904 Nanoseconds
}
//Note: LinkedList is 10 millisecond faster than ArrayList while removing item.
///////////////////// SEARCH ///////////////////////////////////////////
@Test
public void arrayListSearch() throws Exception {
Watch watch = new Watch();
List<String> stringList = Arrays.asList(strings);
List<String> arrayList = new ArrayList<String>(MAX);
arrayList.addAll(stringList);
String searchString0 = getString(true, MAX / 2 + 10);
String searchString1 = getString(true, MAX / 2 + 20);
watch.start();
arrayList.contains(searchString0);
arrayList.contains(searchString1);
watch.totalTime("Array List addAll() time = ");//186,15,704
}
@Test
public void linkedListSearch() throws Exception {
Watch watch = new Watch();
List<String> linkedList = new LinkedList<String>();
linkedList.addAll(Arrays.asList(strings));
String searchString0 = getString(true, MAX / 2 + 10);
String searchString1 = getString(true, MAX / 2 + 20);
watch.start();
linkedList.contains(searchString0);
linkedList.contains(searchString1);
watch.totalTime("Linked List addAll() time = ");//189,64,981
}
//Note: Linked List is 500 Milliseconds faster than ArrayList
class Watch {
private long startTime;
private long endTime;
public void start() {
startTime = System.nanoTime();
}
private void stop() {
endTime = System.nanoTime();
}
public void totalTime(String s) {
stop();
System.out.println(s + (endTime - startTime));
}
}
private String[] maxArray() {
String[] strings = new String[MAX];
Boolean result = Boolean.TRUE;
for (int i = 0; i < MAX; i++) {
strings[i] = getString(result, i);
result = !result;
}
return strings;
}
private String getString(Boolean result, int i) {
return String.valueOf(result) + i + String.valueOf(!result);
}
}
ArrayList が本質的には配列の型になります。 LinkedList 実際に参加者が見学できるのはダブルリンク一覧です。
の get には明らかでない。O(1) ArrayList, ので、 ArrayList をランダムアクセスを使用。O(n) LinkedList, で、ニーズの指数です。注意：あのバージョンが異なっていると add や remove.
LinkedList であり、これらの追加および削除が遅くなり、取得します。簡単に言えば、 LinkedList 必要望の場合:
- 大きな番号のランダムアクセスの要素
- 多数の追加/削除の操作
=== ArrayList ===
- add(E e)
- 末尾に追加しますのArrayList
- 必要メモリサイズ変更。
- O(n)時間、O(1)償
- add(int index,E element)
- 追加特定のインデックス位置
- 必要と移&メモリサイズ変更コスト
- O(n)
- remove(int index)
- 削除指定された要素
- 必要と移&メモリサイズ変更コスト
- O(n)
- remove(Object o)
- 削除する最初の指定された要素をこのリストから
- 必要な検索の要素として移動可能＆メモリサイズ変更コスト
- O(n)
=== LinkedList ===
add(E e)
- 追加リストの末尾に
- O(1)
add(int index,E element)
- 挿入時に指定された位置に
- する必要はあるとの位置ず
- O(n)
- remove()
- 削除最初の要素のリスト
- O(1)
- remove(int index)
- 削除の要素と指定されたインデックス
- の重要な要素の最初の
- O(n)
- remove(Object o)
- 削除し、最初に指定された要素
- の重要な要素の最初の
- O(n)
この図から programcreek.com (add や remove 最初のタイプ、要素を追加末リストの要素を削除し、リストの指定された位置にある.):
ジョシュア-ブロッホの著者LinkedList:
なものを実際に利用しLinkedList?書いたので、私は決して使用します。
リンク: https://twitter.com/joshbloch/status/583813919019573248
すみません、回答している情報としてのその他の答えだと思って最も興味深います。
ArrayList ランダムにアクセスな LinkedList は本当に格安の拡大および削除の要素です。ほとんどの場合には、 ArrayList に影響はありません。
ない限り、作成した大型のリストおよび測定のボトルネックだないでしょう気にする必要もあります。
の場合コード add(0) や remove(0), を使用し LinkedList での見 addFirst() や removeFirst() ます。その他、利用 ArrayList.
ともちろん、 グァバ's ImmutableList ることができます。
ごきげんよう、トメ子です、する必要がありますが、私は正直にすることが可能で誰もいないこ LinkedList 具 Deque.ただ一つの方法 Deque （ Queue);したい場合は公正に比較してみて走行 LinkedList 対 ArrayDeque い機能のために機能と比較しました。
こちらはBig-O記法も ArrayList や LinkedList とも CopyOnWrite-ArrayList:
ArrayList
get O(1)
add O(1)
contains O(n)
next O(1)
remove O(n)
iterator.remove O(n)
LinkedList
get O(n)
add O(1)
contains O(n)
next O(1)
remove O(1)
iterator.remove O(1)
CopyOnWrite-ArrayList
get O(1)
add O(n)
contains O(n)
next O(1)
remove O(n)
iterator.remove O(n)
これまでどのようになるのかを選択します。:)
TL;DR による現代のコンピュータ-アーキテクチャ ArrayList を大幅に効率化のための近くの可能な利用の場合ることができ、結果として LinkedList は避けること以外はとてもユニークで、極端な例です。
理論上は、LinkedListはO(1) add(E element)
またの追加を要素の中のリストは非常に効率的です。
練習は非常に異なるLinkedListは キャッシュ敵対的 データ構造です。から性能モデル-テクスチャが非常に少ない場合 LinkedList きよの キャッシュフ ArrayList.
この結果、ベンチマークテストの挿入要素がランダムです。ご覧のとおりの一覧がより効率的は、論文中に必要な"動き"の n 後の配列の要素（下の値より):
作業後の世代のハードウェアができ、より効率的なキャッシュ)の結果で決定的な:
LinkedList多大な時間が必要達の仕事です。 源 ソースコード
が主な要因は:
主に -このノードの
LinkedListが点在しランダムに全メモリの内容を消去します。RAM(Random Access Memory")最初がやりたかっただけでランダムやブロックメモリを必要とする取得できますこの操作に時間がかかり、場を取り出しが起こる頻度の高いメモリのページのキャッシュ交換することになりの時間>キャッシュヌ->キャッシュのない効率的です。ArrayList要素が格納される連続メモリ-これこそ正に現代のCPUアーキテクチャ最適化します。二次
LinkedListを保有することが重要であってはポインタで、3倍のメモリ使用量に格納された値と比べArrayList.
DynamicIntArray,ちなみに、カスタムArrayListの実装を持 Int (プリミティブ型）のない物があり、すべてのデータが格納され隣接につながっていてもより効率的です。
キー要素を覚えているのは、コストの取得メモリブロックでは、以上のコストにアクセスの単一のメモリー細胞。そのリーダー1MBの連続メモリはx400倍の読みこのデータ量の異なるブロックメモリ:
Latency Comparison Numbers (~2012)
----------------------------------
L1 cache reference 0.5 ns
Branch mispredict 5 ns
L2 cache reference 7 ns 14x L1 cache
Mutex lock/unlock 25 ns
Main memory reference 100 ns 20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy 3,000 ns 3 us
Send 1K bytes over 1 Gbps network 10,000 ns 10 us
Read 4K randomly from SSD* 150,000 ns 150 us ~1GB/sec SSD
Read 1 MB sequentially from memory 250,000 ns 250 us
Round trip within same datacenter 500,000 ns 500 us
Read 1 MB sequentially from SSD* 1,000,000 ns 1,000 us 1 ms ~1GB/sec SSD, 4X memory
Disk seek 10,000,000 ns 10,000 us 10 ms 20x datacenter roundtrip
Read 1 MB sequentially from disk 20,000,000 ns 20,000 us 20 ms 80x memory, 20X SSD
Send packet CA->Netherlands->CA 150,000,000 ns 150,000 us 150 ms
ソース： 遅延の数毎にプログラマーからの
かの点でもより明確にし、ご確認くださいベンチマークに追加要素の開始をクリックします。この使用の場合には、理論、 LinkedList うに輝き、 ArrayList 現在はさらに悪化した場合の結果:
注意：これはベンチマークのC++Std libが、私の経験のC++とJavaを利用できるようになります。 ソースコード
コピーシスのメモリ操作により最適化された現代のCpu数を変える理論と実際に、再度、 ArrayList/Vector より効率的な
単位:すべてのベンチマークを掲載して作成される ひぇHedström.もより多くのデータが 彼のブログ
うLinkedListとArrayListれました。r.t.以下のパラメータ:
1.実施
ArrayList のサイズ変更配列実装のリストインタフェースを
LinkedList の二重リンクリスト実装のリストインタフェース。
2.性能
get(int index)検索の操作
ArrayList get(int index)の操作に一定の時間ん。e O(1)
LinkedList get(int index)動作時はO(n)
の理由 ArrayList ているよLinkedListはこのArrayListの使用を指標に基づくシステム要素となりますので使用して配列データ構造の一方で、
LinkedList 提供いたしませんのインデックスにアクセスのためにその要素のどれを繰り返して調べていずれかから始または終了する方向に掃引するには、取得のノードの指定された要素の指数です。
insert()、add(Object)操作
挿入に LinkedList 一般的に高速比較しArrayList.にLinkedListの追加または挿入はO(1)動作します。
中 ArrayList, の場合、配列はどのようにしたらできますか.e最悪の場合には、軒のレストランで食事を楽しむのリサイズ配列のコピー要素の配列で、ランタイムの追加操作ArrayList O(n)、それ以外はO(1)です。
remove(int)操作
RemoveオペレーションにLinkedList測アンケートを実施しているArrayListO(n)
に LinkedList, が過負荷削除します。一つはremove()なパラメータを除去するヘッドのリストに一定の時間O(1)です。その他の過負荷の削除方法LinkedListはremove(int)またはremove(Object)を除去するオブジェクトまたはintにパラメータとして渡された.この方法ではもっぱらLinkedListを見つけるまではオブジェクトとのリンクを解除してから元の一覧です。そのためこの方法はランタイムはO(n)
中 ArrayList remove(int)メソッドはコピー要素の配列を新しく更新しい配列れており、それにも習ってこのランタイムはO(n)
3.逆反復子
LinkedList できる反復逆方向に使用descendingIterator()が
ありませんdescendingIterator()に ArrayList いを書く必要がある当社自身のコードに対して繰り返し処理を実行するのArrayList逆方向です。
4.初期容量
の場合はコンストラクタでは多すぎない、その ArrayList を作成し、空のリストの初期容量10、
LinkedList みを構築しますの空のリストなので初期容量です。
5.メモリ架
メモリのオーバーヘッド LinkedList あと比較してArrayListとしてノードLinkedListのニーズを維持するアドレスの横と前のノードです。ながら
に ArrayList 各指数のみを保持する実際オブジェクト(データ).
また、その他の引数は、上記すべき知 ArrayList 具 RandomAccess インタフェースを LinkedList 具 Queue.
なので、何とかそのアドレスは若干異なる問題との差異の効率化や行動を深めることにより、リストの方法)。
配列リストは基本的に配列方法項目の追加等。(そのものを使用できる汎用の一覧ます。では収集できる画面アイテムにアクセスを通じてindexer(例えば[0]).このことですから一項目かつ一る。
リンクされたリスト内の指定の進展から一項目次の項目には、品目b）。を得ることができたのと同じ効果と配列リストでもリンクされたリストは絶対に言う項目がのつようになりました。
により何らかの業務まいりました。
ArrayList より速やかにアクセスはインデックス値とします。でもない場合の挿入-削除するオブジェクト。
が施されているものもあり、読み込み条この違いは配列やリンクのリストが表示されます。
私は、通常、一つ以上のその他の時間の複雑な操作をいいを行うこと。
|---------------------|---------------------|--------------------|------------|
| Operation | ArrayList | LinkedList | Winner |
|---------------------|---------------------|--------------------|------------|
| get(index) | O(1) | O(n) | ArrayList |
| | | n/4 steps in avg | |
|---------------------|---------------------|--------------------|------------|
| add(E) | O(1) | O(1) | LinkedList |
| |---------------------|--------------------| |
| | O(n) in worst case | | |
|---------------------|---------------------|--------------------|------------|
| add(index, E) | O(n) | O(n) | LinkedList |
| | n/2 steps | n/4 steps | |
| |---------------------|--------------------| |
| | | O(1) if index = 0 | |
|---------------------|---------------------|--------------------|------------|
| remove(index, E) | O(n) | O(n) | LinkedList |
| |---------------------|--------------------| |
| | n/2 steps | n/4 steps | |
|---------------------|---------------------|--------------------|------------|
| Iterator.remove() | O(n) | O(1) | LinkedList |
| ListIterator.add() | | | |
|---------------------|---------------------|--------------------|------------|
|--------------------------------------|-----------------------------------|
| ArrayList | LinkedList |
|--------------------------------------|-----------------------------------|
| Allows fast read access | Retrieving element takes O(n) |
|--------------------------------------|-----------------------------------|
| Adding an element require shifting | o(1) [but traversing takes time] |
| all the later elements | |
|--------------------------------------|-----------------------------------|
| To add more elements than capacity |
| new array need to be allocated |
|--------------------------------------|
重要な機能のリンク先一覧（なかった読別の回答は、連結の一覧表も掲載しています。配列を持つことはO(n)(+のオーバーヘッドの一部再配）にリンクリストこれはO(1)又はO(2);-)
重要:Javaの場合、その LinkedList このはない。見 が高速concat方法のためのリンクリストにJava?
私の回答が多いですが、シナリオがいつも使LinkedListの上ArrayListしたいシェアを聞いて意見:
毎回あったかの方法をリストで返しますデータから得られたDBい、LinkedList.
私の理由ることが不可能ですので正確に知るかに多くの成果私はこの映画に影響をうけましたがいないメモリを無駄にしてArrayListに係る能力と実際の要素数）が時間を無駄にしようと重複します。
として変わることなく続けられたArrayListいことに同意少なくともしなければなりません使用のコンストラクタの初期容量を極小化し、複製、配列などが可能です。
ArrayList、LinkedList独自の一長一短がある。
ArrayList用連続したメモリアドレスに比べてLinkedListの利用のポインタの次のノードです。できていない商品については要素ArrayListよりはるかに高いn繰り返しとLinkedList.
一方、挿入、削除、LinkedListも容易になっているためには、ただひたすら変更のポインタはArrayListことを意味している利用シフト操作のための他の挿入や削除に応じます。
ま頻繁に回収作業にアプリを使用ArrayList.が多く挿入-削除-利用LinkedList.
ArrayList や LinkedList の両方を実装し List interface その方法及び結果はほとんど同じです。ただし機会がありましたがその中の一つのより良い他にもよります。
ArrayList Vs LinkedList
1) Search: ArrayList 検索操作が速いのに比べて LinkedList 検索動作します。 get(int index) に ArrayList の性能 O(1) ながら LinkedList 性能 O(n).
Reason: ArrayList を維持し指数に基づくシステム要素を用い配列データ構造では、より迅速に検索する要素のリスト。側 LinkedList 器二重リンクリストにフォーカストラバーサルを通じてすべての要素を検索する要素になります。
2) Deletion: LinkedList removeオペレーションを与え O(1) パフォーマンスが ArrayList 与える可変性: O(n) 最悪の場合を除最初の要素)、 O(1) 最高のものに合を除去する最後の要素).
結論:LinkedListの要素を削除する高速比 ArrayList.
理由:LinkedListの各要素を保つポイント(ア)ポイントの両隣の要素のリスト。そのために除去する必要がな変化のポインタの位置に隣接ノード(要素)のノードは撤廃されなければなりません。中ArrayListすべての要素を必要とする移入により成立する空間除要素となります。
3) Inserts Performance: LinkedList 追加方法 O(1) パフォーマンスが ArrayList 与 O(n) 最悪の場合.その理由と同じなので説明します。.
4) Memory Overhead: ArrayList の維持を目指すとと要素データ LinkedList 維持要素データ、二つのヒントに隣接ノード
そのためのメモリ消費量は高LinkedList比較した。
あとこれらのクラスは以下の通りである。
- 両方のArrayList、LinkedListは実装のリストインタフェース。
- その両方を維持する要素を挿入順のことながら表示ArrayList、LinkedListの要素は、結果セットするのと同じ順序で要素をも挿入されます。
- これらの授業は非同期させることができるのは同期化によって明示的に使用ます。synchronizedList方法です。
- の
iteratorやlistIterator返されるこれらのクラスfail-fast場合のリストが構造的に変更を加えた後に、反復子を作成し、いずれの方法を使ってもよる場合を除き、iterator’s自体のremoveまたはaddメソッドの反復子throwaConcurrentModificationException).
するために使用されLinkedListとするために使用されArrayList?
- 前述の挿入や削除の操作性能
(O(1))にLinkedList比ArrayList(O(n)).そのためがある場合の要件を頻繁に追加-削除を申請しLinkedListはうまくコーデにとりいれる方法
- 検索
get method業が急速にArraylist (O(1))なLinkedList (O(n))である場合は以下の追加や削除の操作と検索操作条件ArrayListすることで最高のベット。
操作get(i)ArrayListによLinkedListので:
ArrayList: サイズ変更可能な配列の実装のリストインターフェイス
LinkedList: 二重リンクリスト実装のリストは、Dequeェ
作業指数のリストのトラバースのリストから始または終了する方向に掃引するには、指定されたインデックス.
1)配下のデータ構造
最初の差ArrayList、LinkedListが、このArrayListッ配列をLinkedListッLinkedList.これにより、更なる性能の違い.
2)LinkedListを実装しDeque
もう一つの違いとArrayList、LinkedList以外のリストインタフェース、LinkedListも実施しDequeインタフェースを提供する先入れ先出し作業のためのadd()およびpoll()やその他複数のDequeます。3)添加元素のArrayListの追加要素ArrayListはO(1)操作っていることを確認してください再トリガ-サイズの配列の場合でO(log(n))の追加要素LinkedListはO(1)運営しています。
4)除去からの要素の位置
除去するために要素から、特定のインデックスなどを呼び出しを削除（インデックス),ArrayListをコピー操作であるO(n)をLinkedListのニーズをトラバースするものではO(n/2)としてできるトラバースのいずれかからの方向に基づく近接度によっております。
5)繰り返し処理を行ArrayListはLinkedList
繰り返し処理はO(n)時間で運用するLinkedListとArrayList nは多数の要素になります。
6）取得素子の位置から
の(index)操作はO(1)ArrayListをO(n/2)LinkedList、そのままのニーズへの移動までを入力します。ものの、大O記法にはO(n/2)はO(n)のため無視する定数である。
7)メモリ
LinkedList用ラッパーオブジェクトの入力であるクラスを使用するデータを格納するため、二つのノードの次、前とがArrayListで店舗のデータ配列になります。
でメモリー要件は少なくなってきていると思い場合のArrayListよLinkedListる場合を除き、配列実行のサイズで動作する場合にコピーしますからコンテンツにつ配列です。
の場合配列であるのに十分な大きさで多くのメモリーでポイントをトリガーガーベッジコレクション、きの遅い応答時間が実現されています。
すべての上の差異の繰vs LinkedListのように見えArrayListのよくLinkedList、ほとんどの場合を除きだけど、頻繁にadd()操作によremove()、().
く変更リンクリストによArrayListである場合は特に、追加または削除の要素から開始または終了がリンクリストを内部で常に参考文献の位置およびそのアクセスにはO(1)時間。
つまり、必要なトラバースを通じて、リンクリストのどの位置に追加したい要素、その場合は、ほかなりO(n)時間で動作します。例えば、挿入または削除する要素のリンク一覧です。
私の考えでは、利用ArrayList上LinkedListのための実践的な目的のJava.
両方のremove()およびinsert()の実行時の効率はO(n)の両方のArrayListsとLinkedLists.しかし、背景には、線形処理時間が二つの異なる理由:
内ArrayListできる要素にはO(1)が実際に削除や挿入する事柄についてお話しようと思いまO(n)で以下の全ての要素を変更する必要があり
にLinkedList、O(n)は、実際に希望の要素がを開始しておりますので、初めまして、目標値に到達する。実際の削除や挿入が一定であっても変更1参考にremove()および2を参照のための挿入().
の高速化のための挿入や削除に依存しています。い場合の初めに、LinkedListがなくなりますので、して比較的少数です。い場合に近づくに終了するArrayListがなくなりますので、まあ、一定の時間だけは残り少ない要素が追従します。場合に的確な中、LinkedListがなくなりますので行くような要素で以上に早く移動n値です。
ボーナス:があることでこれら二つの方法はO(1)ArrayListが実際にはこLinkedLists.ということかしたいの全リストの削除や挿入に。通常、開始当初からの各要素を用いLinkedListることができ保存する""現在の要素に取り組んでおりますと、Iterator.の反復子によって、O(1)効率化のためのremove()およびinsert()の際に、LinkedList.での性能の利益の知識がLinkedListはいつもよりArrayList.
繰延ばす作業量を最小限に抑え、Listインタフェースを実装す.ArrayListは動的な配列になります。
こん作成の弱点の配列
のLinkedListクラスはAbstractSequentialListを実施すリスト、Deque、キューにインターフェース。
性能
arraylist.get() O(1)は、 linkedlist.get() はO(n)
arraylist.add() O(1) linkedlist.add() 0(1)
arraylist.contains() はO(n)linkedlist.contains() はO(n)
arraylist.next() O(1) linkedlist.next() O(1)
arraylist.remove() はO(n)に対し linkedlist.remove() O(1)
内arraylistiterator.remove() はO(n)
はlinkedlist iterator.remove()O(1)
を試験したここだけを試験します。私の気づきのことを実行する必要がありますこれらの試験も多く、最終的にその時代までの収束を見る基本的には、JVMのニーズを温めます。私の特定の使用例を追加/削除アイテムを例文、ネイティブ昨成長を遂げている約500ます。私の試験 LinkedList 出てきたの速度リンク LinkedList 今頃50,000NS、 ArrayList で約90,000NS...いてはいかがでしょうか。をコードします。
public static void main(String[] args) {
List<Long> times = new ArrayList<>();
for (int i = 0; i < 100; i++) {
times.add(doIt());
}
System.out.println("avg = " + (times.stream().mapToLong(x -> x).average()));
}
static long doIt() {
long start = System.nanoTime();
List<Object> list = new LinkedList<>();
//uncomment line below to test with ArrayList
//list = new ArrayList<>();
for (int i = 0; i < 500; i++) {
list.add(i);
}
Iterator it = list.iterator();
while (it.hasNext()) {
it.next();
it.remove();
}
long end = System.nanoTime();
long diff = end - start;
//uncomment to see the JVM warmup and get faster for the first few iterations
//System.out.println(diff)
return diff;
}
