怎么在Java中自定義動態數組

這期內容當中小編將會給大家帶來有關怎么在Java中自定義動態數組，文章內容豐富且以專業的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

Java的特點有哪些

Java的特點有哪些 1.Java語言作為靜態面向對象編程語言的代表，實現了面向對象理論，允許程序員以優雅的思維方式進行復雜的編程。 2.Java具有簡單性、面向對象、分布式、安全性、平臺獨立與可移植性、動態性等特點。 3.使用Java可以編寫桌面應用程序、Web應用程序、分布式系統和嵌入式系統應用程序等。

Java自定義動態數組

1、靜態數組向動態數組轉變

（1）靜態數組，數組空間固定長度

這個數組空間總長為4，如果此時新插入一個數據就會報數組空間不足

（2）靜態數組如何轉變成動態數組

第一步：創建一個空間是data數組兩倍的newData數組（擴容）；

第二步：把data數組中的元素全部賦值到newData數組；

2、數組擴容程序

// 數組擴容
private void resize(int newCapacity){
  E[] newData = (E[]) new Object[newCapacity];
  for (int i = 0; i < size; i++) {
    newData[i] = data[i];
  }
  data = newData;
}

數組添加元素：數組空間不夠就會擴容（原來空間2倍）

  // 數組指定位置添加元素
  public void add(int index, E 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 and index <= size");
    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++;
  }

數組刪除元素：數組空間空閑太大就會縮容（原來空間的1/2）

// 從數組中刪除index位置的元素，返回刪除的元素
public E remove(int index) {
  if (index < 0 || index >= size) {
    throw new IllegalArgumentException("Remove failed.Index is illegal");
  }
  E ret = data[index];
  for (int i = index + 1; i < size; i++) {
    data[i - 1] = data[i];
  }
  size--;
  // loitering objects != memory leak 手動釋放內存空間
  data[size] = null;
  if(size == data.length / 2) {
    resize(data.length / 2);
  }
  return ret;
}

3、數組整體代碼

public class Array<E> {
  // 定義數組變量，data.length表示數組容量capacity
  private E[] data;
  // 定義數組中存放數據大小
  private int size;
  // 有參構造方法，傳入數組的容量capacity構造動態數組
  public Array(int capacity) {
    data = (E[])new Object[capacity];
    size = 0;
  }
  // 無參構造方法，默認初始容量為capacity=10
  public Array() {
    this(10);
  }
  // 獲取數組中元素個數
  public int getSize() {
    return size;
  }
  // 獲取數組的容量
  public int getCapacity() {
    return data.length;
  }
  // 判斷數組是否為空
  public boolean isEmpty() {
    return size == 0;
  }
/*  // 在數組末尾添加元素
  public void addLast(E e) {
    if (size == data.length)
      throw new IllegalArgumentException("AddLast failed.Array is full.");
    data[size] = e;
    size++;
  }*/
  // 在數組末尾添加元素（復用add方法）
  public void addLast(E e) {
    add(size, e);
  }
  // 在數組頭部添加元素（復用add方法）
  public void addFirst(E e) {
    add(0, e);
  }
  // 數組指定位置添加元素
  public void add(int index, E 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 and index <= size");
    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索引位置的元素
  public E get(int index) {
    if (index < 0) {
      throw new IllegalArgumentException("Get failed.Index is illegal.");
    }
    return data[index];
  }
  // 修改index索引位置的元素
  public void set(int index, E e) {
    if (index < 0 || index >= size) {
      throw new IllegalArgumentException("Set failed.Index is illegal.");
    }
    data[index] = e;
  }
  // 查找數組中是否存在元素e
  public boolean contains(E e) {
    for (int i = 0; i < size; i++) {
      if (data[i] == e) {
        return true;
      }
    }
    return false;
  }
  // 查找數組中元素e所在的索引，如果不存在元素e，則返回-1
  public int find(E e) {
    for (int i = 0; i < size; i++) {
      if (data[i] == e) {
        return i;
      }
    }
    return -1;
  }
  // 從數組中刪除index位置的元素，返回刪除的元素
  public E remove(int index) {
    if (index < 0 || index >= size) {
      throw new IllegalArgumentException("Remove failed.Index is illegal");
    }
    E ret = data[index];
    for (int i = index + 1; i < size; i++) {
      data[i - 1] = data[i];
    }
    size--;
    // loitering objects != memory leak 手動釋放內存空間
    data[size] = null;
    if(size == data.length / 2) {
      resize(data.length / 2);
    }
    return ret;
  }
  // 刪除數組第一個元素，返回刪除的元素
  public E removeFirst() {
    return remove(0);
  }
  // 刪除數組最后一個元素
  public E removeLast() {
    return remove(size - 1);
  }
  // 刪除數組中指定元素e
  public void removeElement(E e) {
    int index = find(e);
    if (index != -1) {
      remove(index);
    }
  }
  // 數組擴容
  private void resize(int newCapacity){
    E[] newData = (E[]) new Object[newCapacity];
    for (int i = 0; i < size; i++) {
      newData[i] = data[i];
    }
    data = newData;
  }
  // 重寫父類toString()方法
  @Override
  public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
    sb.append('[');
    for (int i = 0; i < size; i++) {
      sb.append(data[i]);
      if (i != size - 1) {
        sb.append(',');
      }
    }
    sb.append(']');
    return sb.toString();
  }
}

4、數組測試代碼

public class ArrayTest {
  public static void main(String[] args) {
    // 測試toString()方法
    Array<Integer> arr = new Array(10);
    for (int i = 0; i < 10; i++) {
      // 測試addLast(int e)方法
      arr.addLast(i);
    }
    System.out.println("添加數組元素：");
    System.out.println(arr);
    // 測試add(int index, int e)方法
    arr.add(1, 200);
    System.out.println("在數組指定索引位置插入元素e：");
    System.out.println(arr);
    // 測試addFirst(int e)方法
    arr.addFirst(-10);
    System.out.println("在數組頭部位置插入元素e：");
    System.out.println(arr);
  }
}

測試結果如下所示：初始化數組空間大小為10，第一次插入10個元素到數組之后，然后再添加一個元素，此時數組會擴容為原來空間的兩倍。

添加數組元素：

Array: size = 10 , capacity = 10
[0,1,2,3,4,5,6,7,8,9]

在數組指定索引位置插入元素e：

Array: size = 11 , capacity = 20
[0,200,1,2,3,4,5,6,7,8,9]

在數組頭部位置插入元素e：

Array: size = 12 , capacity = 20

補充：Java靜態數組和動態數組的定義方式

數組的定義方式

靜態：

//簡化語法常用 定義和初始化同步完成
int [] a = {5,2,6,4,10};

動態：

//數組的定義和初始化同時完成，使用動態初始化語法
int[] prices = new int[5];

補充：

//初始化數組時元素的類型是定義數組時元素類型的子類
Object[] books = new String[4];

上述就是小編為大家分享的怎么在Java中自定義動態數組了，如果剛好有類似的疑惑，不妨參照上述分析進行理解。如果想知道更多相關知識，歡迎關注億速云行業資訊頻道。