ディレクトリ
JDKのソースコード解析--ArrayList
本論文では、JDK1.8
アウトライン
ArrayListの、ベース[]アレイのサポート自動拡張ダイナミックアレイ。それはサポートしているので、配列を比較すると自動拡張の特性が私たちの日常の開発、最も一般的に使用されるコレクションではなく、一つになります。
クラス図
プロパティ
private static final long serialVersionUID = 8683452581122892189L;
/**
* Default initial capacity.默认容量是10
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* Shared empty array instance used for empty instances.
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
* will be expanded to DEFAULT_CAPACITY when the first element is added.
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* The size of the ArrayList (the number of elements it contains).
*
* @serial
*/
private int size;
elementData属性：配列の要素。その中でも、赤いボックスは、我々は要素を追加した図を示し、我々は空白の代理を使用していませんでした。sizeプロパティ：配列サイズ。音符sizeのArrayListを使用表すelementData要素の数は、開発者がのために見ることができ#size()、またサイズ。そして、我々は正確に元素である、新しい要素を追加したときelementDataの位置（下付き）。もちろん、私たちは、ArrayListのことを知っている本当のサイズがあるelementDataサイズ。
コンストラクタ
3つのArrayListのコンストラクタがありますが、私たちは見てみました。
① #ArrayList(int initialCapacity)
#ArrayList(int initialCapacity)施工方法は、渡された初期容量に基づいて、ArrayListの配列を作成します。配列のサイズに事前に割り当てられている場合、我々は、使用している場合は、パフォーマンスだけでなく、メモリの使用の合理化を強化するために、アレイの拡大を避けるために、コンストラクタを使用してください。コードは以下の通りであります：
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}- 初期容量が0の場合、使用の
EMPTY_ELEMENTDATA空の配列。拡張の配列を作成するために要素を追加する場合には、必要とされるであろう。これは、以下の膨張機構を紹介します。
② #ArrayList(Collection<? extends E> c)
#ArrayList(Collection<? extends E> c)入ってくる用いた建設法cのArrayListなどのセットをelementData。コードは以下の通りであります：
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
//JDK8存在BUG，它在 JDK9 中被解决，。
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}③ #ArrayList()
引数なしのコンストラクタ#ArrayList()コンストラクタでなく、私たちの最も使用されるコンストラクタ。コードは以下の通りであります：
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}Q：public ArrayList(0)とpublic ArrayList()2つのコンストラクタの違いは何ですか？
この質問に答える前に、私たちは見てArrayList2つのメンバ変数：
これらは、2つの空のオブジェクトの配列が、これは、オブジェクト== == 2の配列であることに注意する必要があります。
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};私たちは、見ることができるpublic ArrayList(0)意志のelementData配列の割り当てなどEMPTY_ELEMENTDATA
public ArrayList()ウィルのelementData配列の割り当てがあるDEFAULTCAPACITY_EMPTY_ELEMENTDATA、彼らは空の配列ですけれども、これは、2つのオブジェクトであります！
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}以下では、我々が表示されますDEFAULTCAPACITY_EMPTY_ELEMENTDATAに最初の拡張を10、およびEMPTY_ELEMENTDATAに従って1.5倍の拡大が0の代わりに、10から始まります。二つの異なる出発点。
単一の要素を追加します。
#add(E e)この方法は、順序配列に単一の要素を追加するには、この方法は、ブール変数を返します。コードは以下の通りであります：
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}#add(int index, E element)この方法は、配列が単一要素アレイ内に挿入されます。ことを条件とするindex > size || index < 0次のようにコードです。
public void add(int index, E element) {
rangeCheckForAdd(index);//先检查index是否合法
ensureCapacityInternal(size + 1); // Increments modCount!!
// 将 index + 1 位置开始的元素，进行往后挪
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}- ここは注目に値する
#ensureCapacityInternal(int minCapacity)方法を。その役割は、ということを保証することであるelementData配列は、少なくともの容量を有しminCapacity、minCapacity少なくとも1であります
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//如果是DEFAULTCAPACITY_EMPTY_ELEMENTDATA对象，则将minCapacity设为DEFAULT_CAPACITY（10）
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}どちらの#ensureExplicitCapacity(int minCapacity)方法
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)//如果minCapacity超出elementData数组长度，则扩容
grow(minCapacity);
}アレイ拡張
#grow()方法、アレイの拡張とは、それを返します。全体の拡張プロセスは、まず、一般的に新しい、より大きな配列を作成する1.5倍の大きさが（なぜそれは、我々はいくつかの小さな細部があるだろう、後で見るん一般的である）、その後、新しい配列に元の配列をコピーします最後に、新しい配列に戻ります。コードは以下の通りであります：
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//1.5倍扩容
if (newCapacity - minCapacity < 0)
//此时有一种情况：如果elementData为空，newCapacity仍为0，newCapacity置为1
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}その中でも、#hugeCapacity(int minCapacity)次の通り：
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}Q：ArrayListの最大容量の問題？
rivate static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;Integer.MAX_VALUEの-8の最大容量
public ArrayList(int initialCapacity)、初期容量の関数を指定し、最大値にInteger.MAX_VALUE intで上記の構成により-8 OOMを回避するために、VMは、アレイ内の一部のヘッダ情報として格納されてもよいです。したがって、最大容量Integer.MAX_VALUEで-8。しかし、ときMAX_ARRAY_SIZEはまだ十分ではない、容量がInteger.MAX_VALUEでと、HugeCapacityに拡張されます。
private void grow(int minCapacity) {//保证 elementData 数组容量至少有 minCapacity
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//1.5倍扩容
if (newCapacity - minCapacity < 0)//若扩容之后，新容量还不够，就将新容量设为minCapacity
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}減容の配列
#trimToSize()アレイからelementDataの長さが現在の大きさのサイズにクリップ。コードは以下の通りであります：
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA//如果elementData已空，则将EMPTY_ELEMENTDATA赋值过去
: Arrays.copyOf(elementData, size);
}
}
- この点が
HashMap異なっているHashMap使用不可減容方法。
より多くの要素を追加します
#addAll(Collection<? extends E> c)方法は、バッチは、より多くの要素を追加します。我々は明らかに知っている場合はより多くの要素が追加され、この方法ではなく、可能な複数の拡大を避けるために、個々の要素を追加することをお勧めします。コードは以下の通りであります：
//向elementData数组末尾添加元素
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount，保证 elementData 数组容量够用
System.arraycopy(a, 0, elementData, size, numNew);//直接在elementData数组末尾添加元素
size += numNew;
return numNew != 0;//若添加的Collection为空，则返回false
}#addAll(int index, Collection<? extends E> c)この方法は、要素の指定された複数の初期挿入位置から、ことを条件としますindex > size || index < 0。コードは以下の通りであります：
//向elementData数组中间（index处）插入元素
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);//先检查index是否合法
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount，保证 elementData 数组容量够用
int numMoved = size - index;
if (numMoved > 0)
//elementData数组中间（index处）插入元素
//例如elementData数组原来为{"a","b","c","d"},需要在index=1处添加数据{"q","w"}
//插入之后，elementData数组变为{"a","q","w","b","c","d"}
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);//elementData数组index及以后元素往后移位index + numNew
System.arraycopy(a, 0, elementData, index, numNew);//将a数组填入
size += numNew;
return numNew != 0;
}個々の要素を削除します
#remove(int index)要素を除去する方法は、位置を指定し、要素の元の位置に戻ります。コードは以下の通りであります：
public E remove(int index) {
rangeCheck(index);//先检查index是否合法，index >= size则抛异常
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}#remove(Object o)この方法は、配列が表示されますの最初の要素を削除します。コードは以下の通りであります：
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}- その中でも、
#fastRemove(int index)
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
}複数の要素を削除します
#removeAll(Collection<?> c)、のバルク除去elementData指定の複数の要素。
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, false);
}#retainAll(Collection<?> c)保持するにはelementDataより多くの指定した要素の、すべての残りの部分を削除します。
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, true);
}- どちらの方法が使用されている
#batchRemove(Collection<?> c, boolean complement)、達成するために他们的区别就是boolean complement、真かどうか。
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)// 判断符合条件
// 移除的方式，通过将当前值 写入到 w 位置，然后 w 跳到下一个位置。
elementData[w++] = elementData[r];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
if (r != size) {
//如果 contains 方法发生异常，则将 elementData的元素从 r 位置的数据写入到 es 从 w 开始的位置
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
// clear to let GC do its work
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}- あなたが考える、そしてより多くのデバッグの場合は、ポイント・チャートで手描きすることができ、カザフスタンの理解を助けます。
単一の要素を探します
#indexOf(Object o)見つからない場合、このメソッドは、指定された要素への最初の位置を見つけ、それを返します- 1。コードは以下の通りであります：
public int indexOf(Object o) {
//分为o为null和不为null两种情况
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}#contains(Object o)この方法は、法に基づいています。コードは以下の通りであります：
public boolean contains(Object o) {
return indexOf(o) >= 0;
}指定された場所の要素を取得
#get(int index)方法、場所でのアクセス素子。コードは以下の通りであります：
public E get(int index) {
rangeCheck(index);//先检查index是否合法，index >= size则抛异常
return elementData(index);
}場所に要素を設定します
#set(int index, E element)要素を設定する方法は、古い値を返し、位置を指定しました。コードは以下の通りであります：
public E set(int index, E element) {
rangeCheck(index);//先检查index是否合法，index >= size则抛异常
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}配列に
#toArray()ArrayListに変換する方法[]アレイ。コードは以下の通りであります：
// ArrayList.java
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
// Arrays.java
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}- 戻り値があります
Object[]タイプ。
実際のシナリオの下で、我々は指定することもできますTし、我々が使用する必要があり、一般的な配列を#toArray(T[] a)する方法を。コードは以下の通りであります：
public <T> T[] toArray(T[] a) {
if (a.length < size)//如果传入的数组小于 size 大小，则直接复制一个新数组返回
// Make a new array of a's runtime type, but my contents:
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
//将 elementData 复制到 a 中
System.arraycopy(elementData, 0, a, 0, size);
//如果传入的数组大于 size 大小，则将 size 赋值为 null
if (a.length > size)
a[size] = null;
return a;
}- だから、指定された取得するには、2つの方法があります
Tジェネリックの配列:(）String型の配列に、我々はリストにしたいと仮定list.toArray(new Sring[0]);新しい配列を返します。list.toArray(new Sring[list.size()]);これは、返される配列、わずかに高いパフォーマンスです -
サブ配列を作成
#subList(int fromIndex, int toIndex)この方法は、サブアレイのArrayListを作成し、注意が含まれていませんtoIndexああ。コードは以下の通りであります：
public List<E> subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);//检查参数是否合法
return new SubList(this, 0, fromIndex, toIndex);
}
private static class SubList<E> extends AbstractList<E> implements RandomAccess {
/**
* 根 ArrayList
*/
private final ArrayList<E> root;
/**
* 父 SubList
*/
private final SubList<E> parent;
/**
* 起始位置
*/
private final int offset;
/**
* 大小
*/
private int size;
// ... 省略代码
}- 実際の使用では、サブリストではないに注意を払う必要があり、読み取り専用の配列が、根の配列と
root同じ共有するelementData配列を、これに限定言っ[fromIndex, toIndex)範囲を。
System.arraycopyの（）：
public static void arraycopy(
Object src, //源数组
int srcPos, //源数组的起始位置
Object dest, //目标数组
int destPos, //目标数组的起始位置
int length //复制长度
)以下に参考ます。https：//segmentfault.com/a/1190000009922279
ディープまたは浅いコピーコピー
コード：オブジェクトのコピー配列：
public class SystemArrayCopyTestCase {
public static void main(String[] args) {
User[] users = new User[] {
new User(1, "seven", "[email protected]"),
new User(2, "six", "[email protected]"),
new User(3, "ben", "[email protected]") };// 初始化对象数组
User[] target = new User[users.length];// 新建一个目标对象数组
System.arraycopy(users, 0, target, 0, users.length);// 实现复制
System.out.println("源对象与目标对象的物理地址是否一样：" + (users[0] == target[0] ? "浅复制" : "深复制")); //浅复制
target[0].setEmail("[email protected]");
System.out.println("修改目标对象的属性值后源对象users：");
for (User user : users) {
System.out.println(user);
}
//
//
//
}
}
class User {
private Integer id;
private String username;
private String email;
// 无参构造函数
public User() {
}
// 有参的构造函数
public User(Integer id, String username, String email) {
super();
this.id = id;
this.username = username;
this.email = email;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "User [id=" + id + ", username=" + username + ", email=" + email + "]";
}
}示し：オブジェクトコピーイラスト
したがって、それは、と結論されたSystem.arraycopy()結果は、コピーを変更する、一次元配列のコピーに1次元のパス変数の使用を参照しているコピー、配列のコピーに浅いコピーを使用する場合、それは元の配列に影響を与えます。
1次元配列と多次元配列の差分コピー
コード：コピー1次元配列
String[] st = {"A","B","C","D","E"};
String[] dt = new String[5];
System.arraycopy(st, 0, dt, 0, 5);
//改变dt的值
dt[3] = "M";
dt[4] = "V";
System.out.println("两个数组地址是否相同：" + (st == dt)); //false
for(String str : st){
System.out.print(" " + str +" "); // A B C D E
}
System.out.println();
for(String str : dt){
System.out.print(" " + str +" "); // A B C M V
}一次元アレイの再生中にこの方法を使用した後、元のデータ配列に影響を及ぼさない目標は、元の値に影響を及ぼさないコピーを変更し、この属性コピーパスの値が変更されます。
ただし、以下のコードの焦点を見てください。
String[] st = {"A","B","C","D","E"};
String[] dt = new String[5];
System.arraycopy(st, 0, dt, 0, 5);
for(String str : st){
System.out.print(" " + str +" "); // A B C D E
}
System.out.println();
for(String str : dt){
System.out.print(" " + str +" "); // A B C D E
}
System.out.println("数组内对应位置的String地址是否相同:" + st[0] == dt[0]); // trueそれがあるので、属性値が渡され、そしてなぜst[0] == dt[0]我々はそれ以上のテストに等しいだろう行くのですか？：
String[] st = {"A","B","C","D","E"};
String[] dt = new String[5];
System.arraycopy(st, 0, dt, 0, 5);
dt[0] = "F" ;
for(String str : st){
System.out.print(" " + str +" "); // A B C D E
}
System.out.println();
for(String str : dt){
System.out.print(" " + str +" "); // F B C D E
}
System.out.println("数组内对应位置的String地址是否相同:" + st[0] == dt[0]); // falseなぜこのような状況が起こるのだろうか？
で、コードの二枚以上により推測することができるSystem.arraycopy()コピーの時間、リテラル文字列定数プールの量は、存在する場合、プロセスは直接、メモリストレージに対応におけるオープンスペースが存在しないように、対応するメモリアドレスを返すかどうかを最初にチェックこれは、オブジェクト。
コード：2次元配列をコピーします
String[][] s1 = {
{"A1","B1","C1","D1","E1"},
{"A2","B2","C2","D2","E2"},
{"A3","B3","C3","D3","E3"}
};
String[][] s2 = new String[s1.length][s1[0].length];
System.arraycopy(s1, 0, s2, 0, s2.length);
for(int i = 0;i < s1.length ;i++){
for(int j = 0; j< s1[0].length ;j++){
System.out.print(" " + s1[i][j] + " ");
}
System.out.println();
}
// A1 B1 C1 D1 E1
// A2 B2 C2 D2 E2
// A3 B3 C3 D3 E3
s2[0][0] = "V";
s2[0][1] = "X";
s2[0][2] = "Y";
s2[0][3] = "Z";
s2[0][4] = "U";
System.out.println("----修改值后----");
for(int i = 0;i < s1.length ;i++){
for(int j = 0; j< s1[0].length ;j++){
System.out.print(" " + s1[i][j] + " ");
}
System.out.println();
}
// Z Y X Z U
// A2 B2 C2 D2 E2
// A3 B3 C3 D3 E3 これは、コードは、複製の二次元アレイ、アレイの最初の寸法が基準の一次元アレイを装着された第二ビリアル要素の値であることを特徴とします。コピーに二次元配列した後、第一次元参照の最初の次元は、第1の2次元配列が同じに点である新しい配列にコピーされている「ものアレイなど。」そして、元の要素値と新しい配列が同一であるので、実際には、「これらのアレイ」要素の値を変更し、配列の任意の要素の値を変更します。
スレッドセーフ、または安全ではありません
コード：配列のマルチスレッドのコピー（でのJava System.arraycopyスレッドセーフ？）
public class ArrayCopyThreadSafe {
private static int[] arrayOriginal = new int[1024 * 1024 * 10];
private static int[] arraySrc = new int[1024 * 1024 * 10];
private static int[] arrayDist = new int[1024 * 1024 * 10];
private static ReentrantLock lock = new ReentrantLock();
private static void modify() {
for (int i = 0; i < arraySrc.length; i++) {
arraySrc[i] = i + 1;
}
}
private static void copy() {
System.arraycopy(arraySrc, 0, arrayDist, 0, arraySrc.length);
}
private static void init() {
for (int i = 0; i < arraySrc.length; i++) {
arrayOriginal[i] = i;
arraySrc[i] = i;
arrayDist[i] = 0;
}
}
private static void doThreadSafeCheck() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println("run count: " + (i + 1));
init();
Condition condition = lock.newCondition();
new Thread(new Runnable() {
@Override
public void run() {
lock.lock();
condition.signalAll();
lock.unlock();
copy();
}
}).start();
lock.lock();
// 这里使用 Condition 来保证拷贝线程先已经运行了.
condition.await();
lock.unlock();
Thread.sleep(2); // 休眠2毫秒, 确保拷贝操作已经执行了, 才执行修改操作.
modify();
if (!Arrays.equals(arrayOriginal, arrayDist)) {
throw new RuntimeException("System.arraycopy is not thread safe");
}
}
}
public static void main(String[] args) throws Exception {
doThreadSafeCheck();
}
}この例の具体的な動作は以下のとおりです。
- ときarrayOriginalとarraySrcの初期設定は同じですが、arrayDistはすべてゼロです。
- arrayDistにarraySrcをコピーするには、スレッド実行中のコピー（）メソッドを起動します。
- メインスレッドの実行中に（すなわちSystem.arraycopyのをコピー操作の実施を確保するために、2ミリ秒の遅延を前にコピー（）操作は、私は条件を使用）（変更操作することを確実にするためにarraySrcでオーダーの内容を変更し、（）の動作を変更し、 ）変更操作の前に。
- そう、そしてSystem.arraycopyのは、スレッドセーフである場合、第三のポイントによるとSystem.arraycopyのは、スレッドセーフである場合arrayOriginalはarrayDistに等しくなければならないので、[変更操作は、複製の結果に影響を与えないとき、それは、コピー操作を実行します等しくないarrayDistをarrayOriginal。
上記の推論に基づいて、プログラム、次の出力を実行します。
run count: 1
run count: 2
Exception in thread "main" java.lang.RuntimeException: System.arraycopy is not thread safe
at com.test.ArrayCopyThreadSafe.doThreadSafeCheck(ArrayCopyThreadSafe.java:62)
at com.test.ArrayCopyThreadSafe.main(ArrayCopyThreadSafe.java:68)だから、System.arraycopyそれは安全ではありません。
効率的または非効率的
コード：for vs System.arraycopyコピー配列
String[] srcArray = new String[1000000];
String[] forArray = new String[srcArray.length];
String[] arrayCopyArray = new String[srcArray.length];
//初始化数组
for(int index = 0 ; index < srcArray.length ; index ++){
srcArray[index] = String.valueOf(index);
}
long forStartTime = System.currentTimeMillis();
for(int index = 0 ; index < srcArray.length ; index ++){
forArray[index] = srcArray[index];
}
long forEndTime = System.currentTimeMillis();
System.out.println("for方式复制数组：" + (forEndTime - forStartTime));
long arrayCopyStartTime = System.currentTimeMillis();
System.arraycopy(srcArray,0,arrayCopyArray,0,srcArray.length);
long arrayCopyEndTime = System.currentTimeMillis();
System.out.println("System.arraycopy复制数组：" + (arrayCopyEndTime - arrayCopyStartTime));比較的小さいのテスト配列の範囲は、テストアレイリーチ百万レベルの長さは、System.arraycopyの速度の利点が始まった少しの時間の差が、基礎となるシステムの理解によれば、反映するために上記のコードを介し。 arraycopyダイレクト・メモリ・コピーは、それによってパフォーマンスが向上し、サイクルの時間に対処減少しています。
概要
ArrayListのが基づいている
[]容量は、一般に応じて、不足しているときに、リストの実装クラスは、アレイ、アレイのサポートを実装し1.5倍の自動膨張。同時に、それはサポートして手動展開、手動の体積の減少を。移行を含むソースは、配列の多くを複製します
System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
この方法は、それがに比べて、サイクルに対処するための時間を短縮し、浅いコピー、スレッドセーフに属してforパフォーマンスを向上させるためのサイクル。
あなたがテキストをスパイクする場所を持っていない場合は、批判をしてください。
上記。