动态更新数组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();
}

}

辛苦自己打得 希望对你有帮助