因為陣列是在記憶體中連續的一段儲存空間，所以陣列一旦被建立，空間就固定了，長度是不能擴增的。

陣列的長度是固定的，如果需要擴充**，必須建立新陣列，原陣列的長度要複製到新陣列中 。**

java中，陣列型別的變數傳值的時候，事實上傳遞的是陣列的地址 。

Java陣列擴容的原理

1）Java陣列物件的大小是固定不變的，陣列物件是不可擴容的。

2）利用陣列複製方法可以變通的實現陣列擴容。

3）System.arraycopy()可以複製陣列。

4）Arrays.copyOf()可以簡便的建立陣列副本。

5）建立陣列副本的同時將陣列長度增加就變通的實現了陣列的擴容。

陣列擴容的三種方式：

新建一個數組，把原來陣列的內容搬到 新陣列中。

用系統定義函式system.arraycopy實現擴容；

用系統定義函式copyof函式實現擴容；

下面用程式來實現這三種擴容

class expand2{
 //利用函式的方法進行陣列的擴充
 public static void main(String[] args) {
 //定義一個小型的陣列
 int[] a={1,2,3,5};
 //呼叫擴容函式
 //a=expand2(a);
 //a=expand3(a);
 a=expand4(a);
 //測試是否擴容完成，輸出此時陣列a中的值
 for (int i=0;i<a.length;i++) {
 System.out.println("aaaa:"+a[i]);
 }
 }

 //擴容函式，
 public static int[] expand2(int a[]){
 //定義一個新陣列b，併為其賦值長度為陣列a的二倍
 int b[] = new int[a.length*2];
 //將陣列a的元素迴圈遍歷到陣列b中
 for (int i=0;i<a.length;i++) {
 b[i] = a[i];
 }
 //返回擴容後的陣列b
 return b;
 }

 //陣列擴容方法3，利用系統函式arraycopy進行擴容
 public static int[] expand3(int a[]){
 int[] b = new int[a.length*2];
 //系統函式進行擴容，將a[]的值賦值到b[]中，共a.length個長度。
 //相當於第19-21行
 System.arraycopy(a,b,a.length);
 return b;
 }
 
 //陣列擴容方法4，利用系統函式copy進行擴容
 public static int[] expand4(int a[]){
 //可以檢視api文件，java.util.Arrays.copyOf的詳細使用；
 return java.util.Arrays.copyOf(a,a.length*2);
 }
}

實現案例：

案例1 : 統計一個字元在字串中的所有位置.

字串: 統計一個字元在字串中的所有位置

字元: '字'

返回: {4,7}

public class CountCharDemo {
 public static void main(String[] args) {
  char key = '字';
  String str = "統計一個字元在字串中的所有位置";
  int[] count=count(str,key);
  System.out.println(Arrays.toString(count));//[4,7]
 }
 public static int[] count(String str,char key){
  int[] count={};
  for(int i=0;i<str.length();i++){
   char c=str.charAt(i);
   if(c==key){
    //擴充套件陣列
    count=Arrays.copyOf(count,count.length+1);
    //新增序號i
    count[count.length-1]=i;
   }
  }
  return count;
 }
}

char[]、String、StringBuilder

char[]:字元序列,只有字元資料,沒有操作,如果演算法優秀,效能最好。

String: char[] + 方法(操作,API功能)

StringBuilder: char[] + 方法(操作char[] 的內容)

String：內部包含內容不可變的char[]，表現為String物件不可變。String包含操作(API方法)，是對char[]操作，但不改變原物件經常返回新的物件，很多String API提供了複雜的效能優化演算法，如：靜態字串池。

StringBuilder：內部也是一個char[]，但是這個陣列內容是可變的，並且自動維護擴容演算法，因為資料內容可變，所以叫：可變字串。StringBuilder API方法，是動態維護char[]內容，都可以改變char[]內容。

public abstract class AbstractStringBuilder {
 /** The value is used for character storage.*/
 char value[];
 /** The count is the number of characters used.*/
 int count;
 /** Returns the length (character count).*/
 public int length() {
  return count;
 }

 public AbstractStringBuilder append(String str) {
  if (str == null)
   str = "null";
  int len = str.length();
  if (len == 0)
   return this;
  int newCount = count + len;
  if (newCount > value.length)
   expandCapacity(newCount);
  str.getChars(0,len,value,count);
  count = newCount;
  return this;
 }

 /**
  * 自動實現Java陣列擴容
  */
 void expandCapacity(int minimumCapacity) {
  int newCapacity = (value.length + 1) * 2;
  if (newCapacity < 0) {
   newCapacity = Integer.MAX_VALUE;
  } else if (minimumCapacity > newCapacity) {
   newCapacity = minimumCapacity;
  }
  value = Arrays.copyOf(value,newCapacity);
 }
}

字串陣列與String類的原理

/** 字串陣列與String類的原理 */
public class CharArrayDemo {
 public static void main(String[] args) {
  /* Java 可以將char[]作為字串處理 */
  char[] ch1={'中','國','北','京'};
  char[] ch2={'歡','迎','您'};
  System.out.println(ch1);//中國北京
  System.out.println(ch2);//歡迎您
  /* char[]運算需要程式設計處理,如連線: */
  char[] ch3=Arrays.copyOf(ch1,ch1.length+ch2.length);
  System.arraycopy(ch2,ch3,ch1.length,ch2.length);
  System.out.println(ch3);//中國北京歡迎您
  /* String API提供了簡潔的連線運算: */
  String str1="中國北京";
  String str2="歡迎您";
  String str3=str1.concat(str2);
  System.out.println(str3);//中國北京歡迎您
  /* 字串轉大寫: */
  char[] ch4={'A','a','c','f'};
  char[] ch5=Arrays.copyOf(ch4,ch4.length);
  for(int i=0;i<ch5.length;i++){
   char c=ch5[i];
   if(c>='a' && c<='z'){
    ch5[i]=(char)(c+('A'-'a'));
   }
  }
  System.out.println(ch5);//AACF,原陣列ch4不變
  String str4="Aacf";
  String str5=str4.toUpperCase();//原字串str4保持不變
  System.out.println(str5);//AACF
 }
}

到此這篇關於java陣列的三種擴容方式以及程式實現詳解的文章就介紹到這了,更多相關java陣列擴容內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！