動態更新數組java

Ⅰ 請詳細說一下java中append()的方法.

Java中的append( )方法其實是創建了一個新的數組，擴大了長度，將需要添加的字元串給復制到這個新的數組中。

JAVA中Stringbuffer有append( )方法：

而Stringbuffer是動態字元串數組，append( )是往動態字元串數組添加，跟「xxxx」+「yyyy」相當『+』號。

跟String不同的是Stringbuffer是放一起的，String1+String2和Stringbuffer1.append("yyyy")雖然列印效果一樣，但在內存中表示卻不一樣、

String1+String2 存在於不同的兩個地址內存，Stringbuffer1.append(Stringbuffer2)放再一起。

StringBuffer是線程安全的，多用於多線程。

(1)動態更新數組java擴展閱讀

查看StringBuffer的append()方法

如圖所示代碼：

1、進入append方法

@Override

public synchronized StringBuffer append(String str) {

toStringCache = null;

super.append(str);

return this;

}

其中toStringCache是Cleared whenever the StringBuffer is modified.

2、進入AbstractStringBuilder的append()方法

public AbstractStringBuilder append(String str) {

if (str == null)

return appendNull();

int len = str.length();

ensureCapacityInternal(count + len);

str.getChars(0, len, value, count);

count += len;

return this;

}

如果參數str為空返回appendNull(); 該方法最終返回return this.

3、進入ensureCapacityInternal()方法

private void ensureCapacityInternal(int minimumCapacity) {

// overflow-conscious code

if (minimumCapacity - value.length > 0) {

value = Arrays.Of(value,

newCapacity(minimumCapacity));

}

}

Of(char[] original, int newLength)的方法查JDK幫助文檔可知：復制指定的數組，復制具有指定的長度。

4、進入String的getChars()方法

public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {//0,len=5,value=[hello],count=5

if (srcBegin < 0) {

throw new (srcBegin);

}

if (srcEnd > value.length) {

throw new (srcEnd);

}

if (srcBegin > srcEnd) {

throw new (srcEnd - srcBegin);

}

System.array(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);

}

5、最終調用的是System.array的方法:

public static void array(Object src,

int srcPos,

Object dest,

int destPos,

int length)

/*src - 源數組。

srcPos - 源數組中的起始位置。

dest - 目標數組。

destPos - 目的地數據中的起始位置。

length - 要復制的數組元素的數量。

*/

System.array([world], 0, [hello], 5, 5);

將指定源數組中的數組從指定位置復制到目標數組的指定位置。

Ⅱ JAVA如何實現動態數組

動態數組用ArrayList 它的底層就是動態數組

ArrayList

ArrayList 集合的存取方式和數組操作很類似，可以按照index順序來存取集合中的元素，但是還是建議採用更通用的迭代器來進行ArrayList的遍歷。
ArrayList與數組最大的區別就是它是可變數組，在初始化ArrayList集合的時候，可以指定一個初始化容量（Capacity 集合中可容納元素的數量），不指定的時候，系統會指定一個默認的容量值。當我們向ArrayList集合添加元素的時候，實際上是存放元素數量（size）在不斷的增加，當容量不變，當數量增長到初始容量大小的時候，因為沒有空間導致元素添加阻塞，這時候該集合的容量會按照一定增長策略自動增長，容量增長後，可以繼續向集合中添加元素。可變數組是ArrayList的優點，但從另外一個角度考慮，容量的增長是需要付出額外的代價的，所以在性能上有所損失。性能問題的一種解決思路是我們可以在向集合添加大量元素之前，根據欲添加元素的數量，預先擴充容量，採用的是ensureCapacity方法。
ArrayList是一種線性表，在內存中是連續存儲的，適合於元素的隨機存取。添加和刪除操作是需要依據添加的位置來定，如果在ArrayList最後元素後面添加和刪除元素，在性能方面還算好，但是如果是在ArrayList中間添加和刪除元素的話，代價就會很大。因為，ArrayList需要維護整個集合元素的順序存儲，所以需要處理欲添加和刪除元素位置之後的所有元素。
ArrayList的實現不是線程安全的。也就是說，如果有多個線程同時操作ArrayList集合對象，而且其中至少有一個線程的操作涉及到集合對象中元素的修改（添加和刪除），則該線程內對集合對象操作的方法需要實現同步。這也是ArrayList與Vector的主要區別。在新的集合框架的實現上，基於性能的考慮，大部分的集合設計都是線程不安全的。如果有同步需求，在用戶自己的實現中可以實現同步，實現的方法有2種：
1、在操作集合對象的方法上使用synchronized關鍵字。
2、如果方法不可修改，則可在定義集合的時候，定義同步化的集合對象（採用Collections工具類的方法），類似：
List list = Collection.synchronizedList(new ArrayList(.....));
（此處深入說明下，在採用Iterator遍歷集合的時候，如果有其他線程修改了集合（添加或刪除操作），那麼Iterator的處理會中止並拋出異常,這是集合處理中的Fail-safe特性）
ArrayList提供的方法中，除了Collection和List的公用方法外，又加入了一些新的方法。

ArrayList（int initialCapacity） 構造器方法增加了集合初始化的最小容量
Void ensureCapacity(int minCapacity) 預擴充ArrayList的容量
Void trimToSize() 把集合的Capacity縮小到Size的大小

下面做一個ArrayList小例子：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
* @功能：ArrayList的應用小例子
* @author JackRui
* @時間：2009.03.31
*/
public class ArrayListDemo {

public static void main(String[] args) {
//利用ArrayList本身的特性
System.out.println("利用ArrayList本身的特性");
ArrayList list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.remove("bbb");
list.add("ddd");
for (int i=0,lsize=list.size();i<lsize;i++){
System.out.println(list.get(i));
}
//利用Iterator遍歷
System.out.println("利用Iterator遍歷");
Collection clist = new ArrayList();
clist.addAll(list);//添加元素不能採用Iterator介面
Iterator iter = clist.iterator();
while(iter.hasNext()){
String s = (String)iter.next();
if(s.equals("ddd")){
iter.remove();//可以通過Iterator介面對元素進行刪除
}else{
System.out.println(s);
}
}
//利用ListIterator遍歷
System.out.println("利用ListIterator遍歷");
List list2 = new ArrayList();
ListIterator lit = list2.listIterator();
if(!lit.hasNext()){
lit.add("haha");//可以通過ListIterator介面進行集合元素的添加
lit.previous();
System.out.println(lit.next());
}

}

}
運行結果如下：
利用ArrayList本身的特性
aaa
ccc
ddd
利用Iterator遍歷
aaa
ccc
利用ListIterator遍歷
haha

解析：3種方法中，第一種方法不通用，不建議使用。第2種方法最通用，但僅支持單向遍歷，而且對象的添加需要分開實現。第3種方法可以雙向遍歷，而且可以直接使用ListIterator介面來添加對象。

參考資料：http://fusanjiao.javaeye.com/blog/639963
希望能幫到您，O(∩_∩)O謝謝！

Ⅲ Java動態數組

ArrayList就是一個可以變成的數組（你可以這樣理解）
ArrayList<E> 其中E是一個泛型，例如，ArrayList<String> array=new ArrayList<String>();則表示新建一個存放String的可變長數組。
ArrayList<Object> array1=new ArrayList<Object>()則為一個存放Object的可變長數組。
記住，這種樣式的E，有的用T表示，它的意思為泛型。泛型是什麼就不介紹了。
而且，E只能是一個類的類名，如果你是變為ArrayList<int>則是錯誤的，要用ArrayList<Integer>才可以

Ⅳ java 中 String 數組怎麼動態賦值

首先明確一下數組的初始化：

//靜態初始化
inta[]={1，2，3};
//動態初始化
inta[];a=newint[3];a[0]=1;a[1]=2;a[2]=3;
//默認初始化
inta[]=newint[5];

JAVA是強類型，數組類型一旦聲明，就不能更改了；

如果數組長度確定，我想所謂的「動態賦值」用循環應該可以搞定；

如果數組的長度是不確定的，我認為你這個提問才有點價值，因為這需要根據具體情況來改變數組的長度，告訴你java是怎麼乾的，用的System.array,jdk里好多操作數組的源碼都是用的這個，比如ArrayList的實現

閑著沒事寫了個小例子玩玩：

importjava.util.Random;
importjava.util.Scanner;
/**
*
*@authorLYTG
*@since2015-12-29上午12:21:09
*/
publicclassDemoTest{
/**
*@authorLYTG
*@paramargs
*/
publicstaticvoidmain(String[]args){
test2();
}
/**
*@authorLYTG
*@paramarray
*/
publicstaticvoidout(String[]array){
if(array==null){
System.out.println("null");
return;
}
if(array.length<1){
System.out.println("{}");
return;
}
StringBuffersb=newStringBuffer();
sb.append("{"");
sb.append(array[0]);
sb.append(""");
for(inti=1;i<array.length;i++){
sb.append(","");
sb.append(array[i]);
sb.append(""");
}
sb.append("}");
System.out.println(sb.toString());
}
/**
*聲明一個長度為5的String類型數組，並為每個數組元素賦值一個隨機整數
*@authorLYTG
*/
publicstaticvoidtest1(){
String[]array=newString[5];
for(inti=0;i<array.length;i++){
array[i]=String.valueOf(newRandom().nextInt());
}
out(array);
}
/**
*在控制台輸入字元，把每次輸入的字元保存到一個數組中，
*如果輸入的字元串中包含空格，則切割後再分別保存到此數組中，
*在每次輸入完成後輸出整個數組，直到手動終止程序
*@authorLYTG
*/
privatestaticString[]array=newString[0];
publicstaticvoidtest2(){
Scannersc=newScanner(System.in);
System.out.println("請輸入一串字元(輸入完請敲回車)：");
Stringinput=sc.nextLine();
if(input.contains("")){
String[]a=input.split("");
intarrayLength=array.length;
intaLength=a.length;
String[]newArray=newString[arrayLength+aLength];
System.array(array,0,newArray,0,arrayLength);
System.array(a,0,newArray,arrayLength,aLength);
array=newArray;
}else{
intarrayLength=array.length;
String[]newArray=newString[arrayLength+1];
System.array(array,0,newArray,0,arrayLength);
newArray[arrayLength]=input;
array=newArray;
}
out(array);
test2();
}
}

Ⅳ java中動態數組運用

import java.util.ArrayList;

public class TestMain {
public static void main(String[] args) {

ArrayList<String> a=new ArrayList<String>();
System.out.println("-----------------增----------------------------");
a.add("測試1");
a.add("測試2");
a.add("測試3");
System.out.println("動態數組的長度為："+a.size());
System.out.println("動態數組增加的元素為："+a.get(0));
System.out.println("數組中 的內容為："+getAll(a));
System.out.println("-----------------刪----------------------------");
System.out.println("即將要刪除的元素為："+a.get(a.size()-1));
a.remove(a.size()-1);
System.out.println("刪除後動態數組的長度為："+a.size());
System.out.println("刪除後數組中 的內容為："+getAll(a));
System.out.println("-----------------改----------------------------");
a.set(0, "修改");
System.out.println("動態數組的長度為："+a.size());
System.out.println("修改後數組中 的內容為："+getAll(a));

}

public static String getAll(ArrayList<String> a){
StringBuffer bf=new StringBuffer();

for(int i=0;i<a.size();i++){
if(i<a.size()-1){
bf=bf.append(a.get(i));
bf.append(" || ");
}else{
bf=bf.append(a.get(i));
}
}
return bf.toString();
}

}

辛苦自己打得 希望對你有幫助