打造屬於自己的Array
查看JDK1.8中ArrayList源碼時,其中的Arrays.copyOf爲Native方法,具體怎麼實現的並沒有。所以打算自己實現,來深入瞭解一下Array這個數據結構。
靜態數組
創建增刪改查方法
-
自己創建數組無非就是數組的 增刪改查 方法的創建,即 add,remove,set,get 方法。
-
首先創建一個簡單的int集合來表示數組,默認大小爲10,添加一些常規的方法之後,再對重要的方法進行單獨書寫
-
add方法:在指定索引位置插入數字,就相當於把指定索引處後的值往後移一位,即把值賦給下一個索引,一層for循環就可以,同時不要忘記size++,然後再在指定索引處賦值。
-
remove方法:在指定索引位置刪除數字,就相當於把指定索引處後的值往前移一位,即把值賦給上一個索引,一層for循環就可以,同時不要忘記size–。這裏有所不同,即int[size]的值需不需要刪除,其實這裏刪不刪除並不影響數組的邏輯和功能實現,但本着嚴謹的態度,將int[size]賦值爲null,節省一點內存空間。
package design.Array; /** * @program: design * @description: Array類 * @author: cyj * @create: 2019-03-18 21:23 **/ public class Array { private int[] data; private int size; /** * 構造函數,傳入數組的容量capacity構造Array * * @param capacity */ public Array(int capacity) { data = new int[capacity]; size = 0; } /** * 無參數的構造函數,默認數組的容量capacity=10 */ public Array() { this(10); } /** * 獲取數組中的元素個數 * * @return */ public int getSize() { return size; } /** * 獲取數組的容量 * * @return */ public int getCapacity() { return data.length; } /** * 返回數組是否爲空 * * @return */ public boolean isEmpty() { return size == 0; } /** * 向所有元素後添加一個新元素e * * @param e */ public void addLast(int e) { // if (size == data.length) { // throw new IllegalArgumentException("AddLast failed.Array is full."); // } // data[size] = e; // size++; add(size, e); } /** * 向所有元素前添加一個新元素e * * @param e */ public void addFirst(int e) { add(0, e); } /** * 在第index個位置插入一個新元素e * * @param index * @param e */ public void add(int index, int e) { if (size == data.length) { throw new IllegalArgumentException("Add failed.Array is full."); } if (index < 0 || index > size) { throw new IllegalArgumentException("Add failed.Require index >=0 is full."); } for (int i = size - 1; i >= index; i--) { data[i + 1] = data[i]; } data[index] = e; size++; } /** * 獲取index索引位置的元素 * * @param index * @return */ int get(int index) { if (index < 0 || index > size) { throw new IllegalArgumentException("Get failed.Require index is illegal."); } return data[index]; } /** * 修改index索引位置的元素爲e * * @param index * @param e */ void set(int index, int e) { if (index < 0 || index > size) { throw new IllegalArgumentException("Set failed.Require index is illegal."); } data[index] = e; } /** * 查找數據中是否有元素e * * @param e * @return */ public boolean contains(int e) { for (int i = 0; i < size; i++) { if (data[i] == e) { return true; } } return false; } /** * 查找數組中元素e所在的索引,如果不存在則返回索引爲-1 * * @param e * @return */ public int find(int e) { for (int i = 0; i < size; i++) { if (data[i] == e) { return i; } } return -1; } /** * 從數組中刪除index位置的元素,返回刪除的元素 * * @param index * @return */ public int remove(int index) { if (index < 0 || index > size) { throw new IllegalArgumentException("Remove failed.Require index is illegal."); } int ret = data[index]; for (int i = index + 1; i < size; i++) { data[i - 1] = data[i]; } size--; return ret; } /** * 從數組中刪除index位置的元素,返回刪除的元素 * * @return */ public int removeFirst() { return remove(0); } /** * 從數組中刪除index位置的元素,返回刪除的元素 * * @return */ public int removeLast() { return remove(size - 1); } /** * 從數組中刪除元素e * 1. 可以返回boolean 2.重複數組的考量,刪除所有的元素e,設計上的考慮,具體需求具體分析 * * @param e */ public void removeElement(int e) { int index = find(e); if (index != -1) { remove(index); } } @Override public String toString() { StringBuilder res = new StringBuilder(); res.append(String.format("Array: size=%d , capacity=%d\n", size, data.length)); res.append('['); for (int i = 0; i < size; i++) { res.append(data[i]); if (i != size - 1) { res.append(","); } } res.append(']'); return res.toString(); } }
測試靜態數組類
package design.Array;
/**
* @program: design
* @description: 測試Array類
* @author: cyj
* @create: 2019-03-19 10:02
**/
public class ArrayTest {
public static void main(String[] args) {
Array arr = new Array(20);
for (int i = 0; i < 10; i++) {
arr.addLast(i);
}
System.out.println(arr);
arr.add(1, 100);
System.out.println(arr);
arr.addFirst(-1);
//[-1,0,100,1,2,3,4,5,6,7,8,9]
System.out.println(arr);
arr.remove(2);
//[-1,0,1,2,3,4,5,6,7,8,9]
System.out.println(arr);
arr.removeElement(4);
//[-1,0,1,2,3,5,6,7,8,9]
System.out.println(arr);
arr.removeFirst();
//[0, 1, 2, 3, 5, 6, 7, 8, 9]
System.out.println(arr);
}
}
輸出結果(重寫類的toString方法):
Array: size=10 , capacity=20
[0,1,2,3,4,5,6,7,8,9]
Array: size=11 , capacity=20
[0,100,1,2,3,4,5,6,7,8,9]
Array: size=12 , capacity=20
[-1,0,100,1,2,3,4,5,6,7,8,9]
Array: size=11 , capacity=20
[-1,0,1,2,3,4,5,6,7,8,9]
Array: size=10 , capacity=20
[-1,0,1,2,3,5,6,7,8,9]
Array: size=9 , capacity=20
[0,1,2,3,5,6,7,8,9]
泛型和動態數組的實現
泛型
在實際運用中,我們不能只是簡單的用整數型數組來表示,這裏就要引出泛型的概念。
-
泛型,即“參數化類型”。一提到參數,最熟悉的就是定義方法時有形參,然後調用此方法時傳遞實參。那麼參數化類型怎麼理解呢?
顧名思義,就是將類型由原來的具體的類型參數化,類似於方法中的變量參數,此時類型也定義成參數形式(可以稱之爲類型形參),然後在使用/調用時傳入具體的類型(類型實參)。
泛型的本質是爲了參數化類型(在不創建新的類型的情況下,通過泛型指定的不同類型來控制形參具體限制的類型)。也就是說在泛型使用過程中,操作的數據類型被指定爲一個參數,這種參數類型可以用在類、接口和方法中,分別被稱爲泛型類、泛型接口、泛型方法。
-
因爲不能直接定義泛型,所以可以通過定義Object的方式來強轉爲泛型
-
定義了泛型之後就可以接收的多種類型,因爲泛型把具體的參數類型泛化,模糊化,使得傳參可以有更多種的選擇。
動態數組
動態數組的實現即實現了數組的擴容。擴容的過程是
-
是否超出了默認的數組長度,超出則執行擴容方法
-
擴容是新建一個數組,新建數組的長度爲原數組的2倍(ArrayList爲1.5倍,通過位運算來計算),接着把原數組的值通過for循環來賦值到新數組,在接着把原數組的引用指向新數組。
-
在增加和刪除的時候進行擴容和縮容(新建一個爲原數組長度1/2的新數組)
-
在數組縮容的問題上,爲了防止複雜度的震盪,數組在長度邊緣瘋狂的試探,頻繁的進行擴容和縮容。(即數組長度爲10,增加一個元素擴大爲20,之後緊接着又刪除一個元素,又縮容爲10)。
所以縮容的時候判斷數組實際長度爲1/4時才進行縮容,就可以減少瘋狂的試探,從而防止方法的時間複雜度一直爲O(n)。
package design.Array;
/**
* @program: design
* @description: Array類
* @author: cyj
* @create: 2019-03-18 21:23
**/
public class ArrayObject<E> {
private E[] data;
private int size;
/**
* 構造函數,傳入數組的容量capacity構造Array
*
* @param capacity
*/
public ArrayObject(int capacity) {
data = (E[]) new Object[capacity];
size = 0;
}
/**
* 無參數的構造函數,默認數組的容量capacity=10
*/
public ArrayObject() {
this(10);
}
/**
* 獲取數組中的元素個數
*
* @return
*/
public int getSize() {
return size;
}
/**
* 獲取數組的容量
*
* @return
*/
public int getCapacity() {
return data.length;
}
/**
* 返回數組是否爲空
*
* @return
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 向所有元素後添加一個新元素e
* 時間複雜度:O(1)
*
* @param e
*/
public void addLast(E e) {
// if (size == data.length) {
// throw new IllegalArgumentException("AddLast failed.Array is full.");
// }
// data[size] = e;
// size++;
add(size, e);
}
/**
* 向所有元素前添加一個新元素e
* 時間複雜度:O(n)
*
* @param e
*/
public void addFirst(E e) {
add(0, e);
}
/**
* 在第index個位置插入一個新元素e
* 時間複雜度:O(n/2)=>O(n)
*
* @param index
* @param e
*/
public void add(int index, E e) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("Add failed.Require index >=0 is full.");
}
if (size == data.length) {
resize(2 * data.length);
}
for (int i = size - 1; i >= index; i--) {
data[i + 1] = data[i];
}
data[index] = e;
size++;
}
/**
* 獲取index索引位置的元素
* 時間複雜度:O(1)
*
* @param index
* @return
*/
public E get(int index) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("Get failed.Require index is illegal.");
}
return data[index];
}
/**
* 修改index索引位置的元素爲e
* 時間複雜度:O(1)
*
* @param index
* @param e
*/
public void set(int index, E e) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("Set failed.Require index is illegal.");
}
data[index] = e;
}
/**
* 查找數據中是否有元素e
* 時間複雜度:O(n)
*
* @param e
* @return
*/
public boolean contains(E e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e)) {
return true;
}
}
return false;
}
/**
* 查找數組中元素e所在的索引,如果不存在則返回索引爲-1
* 時間複雜度:O(n)
*
* @param e
* @return
*/
public int find(E e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e)) {
return i;
}
}
return -1;
}
/**
* 從數組中刪除index位置的元素,返回刪除的元素
* 時間複雜度:O(n/2)=>O(n)
*
* @param index
* @return
*/
public E remove(int index) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("Remove failed.Require index is illegal.");
}
E ret = data[index];
for (int i = index + 1; i < size; i++) {
data[i - 1] = data[i];
}
size--;
//loireting objects !=memory leak,不寫的話邏輯上也正確
data[size] = null;
//防止複雜度震盪,所以1/4 防止刪到最後一位
if (size == data.length / 4 && data.length / 2 != 0) {
resize(data.length / 2);
}
return ret;
}
/**
* 從數組中刪除index位置的元素,返回刪除的元素
* 時間複雜度:O(n)
*
* @return
*/
public E removeFirst() {
return remove(0);
}
/**
* 從數組中刪除index位置的元素,返回刪除的元素
* 時間複雜度:O(1)
*
* @return
*/
public E removeLast() {
return remove(size - 1);
}
/**
* 從數組中刪除元素e
* 1. 可以返回boolean 2.重複數組的考量,刪除所有的元素e,設計上的考慮,具體需求具體分析
*
* @param e
*/
public void removeElement(E e) {
int index = find(e);
if (index != -1) {
remove(index);
}
}
@Override
public String toString() {
StringBuilder res = new StringBuilder();
res.append(String.format("Array: size=%d , capacity=%d\n", size, data.length));
res.append('[');
for (int i = 0; i < size; i++) {
res.append(data[i]);
if (i != size - 1) {
res.append(", ");
}
}
res.append(']');
return res.toString();
}
private void resize(int newCapacity) {
E[] newData = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newData[i] = data[i];
}
data = newData;
}
}
測試動態數組類
泛型測試類
package design.Array;
/**
* @program: design
* @description: 測試泛型類數組實體類
* @author: cyj
* @create: 2019-03-19 11:44
**/
public class Test {
private String name;
private String age;
public Test(String name, String age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return String.format("Student(name: %s, age: %s)", name, age);
}
public static void main(String[] args) {
ArrayObject<Test> arrayObject = new ArrayObject<>();
arrayObject.addLast(new Test("sangsan", "21"));
arrayObject.addLast(new Test("lisi", "22"));
arrayObject.addLast(new Test("wangwu", "23"));
System.out.println(arrayObject);
}
}
輸出結果:
Array: size=3 , capacity=10
[Student(name: sangsan, age: 21), Student(name: lisi, age: 22), Student(name: wangwu, age: 23)]
動態數組測試類
package design.Array;
/**
* @program: design
* @description: 測試ArrayObject類
* @author: cyj
* @create: 2019-03-19 10:02
**/
public class ArrayTestObject {
public static void main(String[] args) {
ArrayObject<Integer> arr = new ArrayObject<>();
for (int i = 0; i < 10; i++) {
arr.addLast(i);
}
System.out.println(arr);
arr.add(1, 100);
System.out.println(arr);
arr.addFirst(-1);
System.out.println(arr);
arr.remove(2);
System.out.println(arr);
arr.removeElement(4);
System.out.println(arr);
arr.removeFirst();
System.out.println(arr);
}
}
輸出結果(可以看出來數組的長度在變化了):
Array: size=10 , capacity=10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array: size=11 , capacity=20
[0, 100, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array: size=12 , capacity=20
[-1, 0, 100, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array: size=11 , capacity=20
[-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array: size=10 , capacity=20
[-1, 0, 1, 2, 3, 5, 6, 7, 8, 9]
Array: size=9 , capacity=20
[0, 1, 2, 3, 5, 6, 7, 8, 9]
數組的底層實現就先寫到這裏,可以看出效果還是可以的,之後會繼續基於數組來實現棧,隊列。