자바 핵심 기술 의 jdk 소스 코드 폭로 (1)
collection 과 map
JDK 는 데이터 구조 에 대해 Collection 과 Map 을 포함 하여 자바 util 패키지 에 넣 고 conlection 은 List 와 Set 를 포함 하 며 주로 하나의 데이터 저장 에 사 용 됩 니 다. Map 은 HashMap, TreeMap, Hashtable 등 을 포함 하고 키 값 이 맞 는 데이터 저장 에 사 용 됩 니 다.
List 인터페이스 에서 자주 사용 하 는 실현 클래스 는 Array List, LinkedList, Vector, Stack 등 을 포함한다.다음은 이러한 실현 류 의 구체 적 인 실현 과 주요 방법 을 소개 한다.
ArrayList
우선 그것 은 비 동기 적 이 며 중복 이 허용 된다.add, get, remove 등 방법 이 포함 되 어 있 습 니 다.원본 코드 는 다음 과 같 습 니 다.
package java.util;
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
//
private static final long serialVersionUID = 8683452581122892189L;
// ArrayList
private transient Object[] elementData;
// ArrayList
private int size;
// ArrayList 。
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
//
this.elementData = new Object[initialCapacity];
}
// ArrayList 。 10。
public ArrayList() {
this(10);
}
// collection ArrayList
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
size = elementData.length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}
// =
public void trimToSize() {
modCount++;
int oldCapacity = elementData.length;
if (size < oldCapacity) {
elementData = Arrays.copyOf(elementData, size);
}
}
// ArrarList 。
// ArrayList ， =“( x3)/2 + 1”
public void ensureCapacity(int minCapacity) {
// “ ”+1
modCount++;
int oldCapacity = elementData.length;
// ， =“( x3)/2 + 1”
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
int newCapacity = (oldCapacity * 3)/2 + 1;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
// e
public boolean add(E e) {
// ArrayList
ensureCapacity(size + 1); // Increments modCount!!
// e ArrayList
elementData[size++] = e;
return true;
}
// ArrayList
public int size() {
return size;
}
// ArrayList Object(o)
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
// ArrayList
public boolean isEmpty() {
return size == 0;
}
// ，
public int indexOf(Object o) {
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;
}
// ，
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
// ( )， (o)
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
// ArrayList Object
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
// ArrayList 。 ， T
public <T> T[] toArray(T[] a) {
// a < ArrayList ；
// T[] ， “ArrayList ”， “ArrayList”
if (a.length < size)
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
// a >= ArrayList ；
// ArrayList a 。
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
// index
public E get(int index) {
RangeCheck(index);
return (E) elementData[index];
}
// index element
public E set(int index, E element) {
RangeCheck(index);
E oldValue = (E) elementData[index];
elementData[index] = element;
return oldValue;
}
// e ArrayList
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
ensureCapacity(size+1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
// ArrayList
public E remove(int index) {
RangeCheck(index);
modCount++;
E oldValue = (E) elementData[index];
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // Let gc do its work
return oldValue;
}
// ArrayList
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;
}
// index
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
// "index+1" ， 。
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// null
elementData[--size] = null; // Let gc do its work
}
//
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
// ArrayList， “ o”， ， true。
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
// ArrayList， null
public void clear() {
modCount++;
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
// c ArrayList
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
// index ， c ArrayList
public boolean addAll(int index, Collection<? extends E> c) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: " + index + ", Size: " + size);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
// fromIndex toIndex 。
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// Let gc do its work
int newSize = size - (toIndex-fromIndex);
while (size != newSize)
elementData[--size] = null;
}
private void RangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
}
//
public Object clone() {
try {
ArrayList<E> v = (ArrayList<E>) super.clone();
// ArrayList v
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
// java.io.Serializable
// ArrayList “ ， ”
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// “ ”
s.writeInt(elementData.length);
// “ ”
for (int i=0; i<size; i++)
s.writeObject(elementData[i]);
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
// java.io.Serializable ：
// ArrayList “ ” ， “ ”
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in size, and any hidden stuff
s.defaultReadObject();
// ArrayList “ ”
int arrayLength = s.readInt();
Object[] a = elementData = new Object[arrayLength];
// “ ”
for (int i=0; i<size; i++)
a[i] = s.readObject();
}
}원본 코드 를 통 해 알 수 있 듯 이 그 는 Object 배열 을 초기 화 했 습 니 다. 이 배열 의 크기 는 처음에 10 으로 초기 화 되 었 습 니 다. 왜 10 인지 잘 모 르 겠 습 니 다. 작가 의 행운 의 숫자 일 수도 있 습 니 다. 이 배열 의 크기 는 동태 적 입 니 다. 우리 가 add 방법 으로 요 소 를 추가 한 후에 먼저 판단 할 것 입 니 다. 만약 에 배열 의 크기 가 현재 배열 의 크기 보다 작 으 면 + 1.그러면 object 배열 을 다시 만 듭 니 다. 이 배열 의 크기 는 현재 배열 크기 * 1.5 + 1 입 니 다.이 클래스 에 포 함 된 것 은 일부 배열 의 조작 입 니 다. 세심 하면 Array. copyof () 를 발견 할 수 있 습 니 다. 이 배열 에 관 한 복사 방법 은 맨 밑 에 system. array copy () 입 니 다. array copy 의 구체 적 인 실현 은 jni 를 호출 하 는 것 입 니 다. 즉, dll 을 호출 하 는 것 입 니 다. dll 내부 가 어떻게 실현 되 는 지 는 C + 에 달 려 있 습 니 다.
소스 코드 를 통 해 우 리 는 기본적으로 그의 상용 사용 방법 과 그의 내부 의 구체 적 인 실현 을 익 혔 다.앞으로 우리 가 그의 방법 을 사용 할 때 마음속 에 도 자신 이 있다. 우 리 는 스스로 그의 add, remove, get, contains, size, indexof 등 방법 을 실현 할 수 있다.
LinkLIst
다음은 링크 리스트 의 구체 적 인 소스 코드 실현 을 살 펴 보 겠 습 니 다.
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
다양한 언어의 JSONJSON은 Javascript 표기법을 사용하여 데이터 구조를 레이아웃하는 데이터 형식입니다. 그러나 Javascript가 코드에서 이러한 구조를 나타낼 수 있는 유일한 언어는 아닙니다. 저는 일반적으로 '객체'{}...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
