java动态数组,JAVA中如何动态改变数组长度 动态数组 arraycopy

java动态数组,JAVA中如何动态改变数组长度 动态数组 arraycopy详细介绍

本文目录一览： Java静态与动态数组特点分析

　　平常我们接触到的大多都是静态数组 其实在很多的时候 静态数组根本不能满足我们编程的实际需要 比方说我需要在程序运行过程中动态的向数组中添加数据 这时我们的静态数组大小是固定的 显然就不能添加数据 要动态添加数据必须要用到动态数组 动态数组中的各个元素类型也是一致的 不过这种类型已经是用一个非常大的类型来揽括 Object类型 Object类是JAVA LANG包中的顶层超类 所有的类型都可以与Object类型兼容 所以我们可以将任何Object类型添加至属于Object类型的数组中 能添加Object类型的的集合有ArrayList Vector及LinkedList 它们对数据的存放形式仿造于数组 属于集合类 下面是他们的特点
　　 同步性
　　ArrayList LinkedList是不同步的 而Vestor是的 所以如果要求线程安全的话 可以使用ArrayList或 LinkedList 可以节省为同步而耗费开销 但在多线程的情况下 有时候就不得不使用Vector了 当然 也可以通过一些办法包装 ArrayList LinkedList 使他们也达到同步 但效率可能会有所降低
　　 数据操作效率
　　ArrayList和Vector中 从指定的位置(用index)检索一个对象 或在集合的末尾插入 删除一个对象的时间是一样的 可表示为 O( ) 但是 如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长 O(n i) 其中n代表集合中元素的个数 i代表元素增加或移除元素的索引位置 为什么会这样呢?以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行(n i)个对象的位移操作 LinkedList 中 在插入 删除集合中任何位置的元素所花费的时间都是一样的 O( ) 但它在索引一个元素的时候比较慢 为O(i) 其中i是索引的位置

　　 容量扩充性
　　从内部实现机制来讲ArrayList和Vector都是使用Objec的数组形式来存储的 当你向这两种类型中增加元素的时候 如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度 Vector缺省情况下自动增长原来一倍的数组长度 ArrayList是原来的 % 所以最后你获得的这个集合所占的空间总是比你实际需要的要大 所以如果你要在集合中保存大量的数据那么使用Vector有一些优势 因为你可以通过设置集合的初始化大小来避免不必要的资源开销
lishixinzhi/Article/program/Java/JSP/201311/20263

java动态创建数组并给其赋值

import java.util.Scanner;public class Test { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("请输入创建的数组的大小: "); int size = sc.nextInt(); int[] a = new int[size]; System.out.println("手动为每个数组元素赋值: "); for(int i = 0; i < size; i++){ a[i] = sc.nextInt(); } System.out.println("动态创建的数组为: "); for(int i = 0; i < size; i++){ System.out.print(a[i] + " "); } }}

java中如何创建动态数组

JAVA中的数组没有动态的
要是想用动态的数据结构就用向量Vector
采用Vector
import java.until.Vector;
例如：
Vector vet==new Vector();
String str="test1";
double t1=0.124;
vet.add(str);
vet.add(String.valueOf(t1));
可以用 vet.size()获取其大小。
通过vet.get(i);获取第i个元素（i从0开始），类型为Object，转换一下就可以了。
具体可以查看jdk api文档
Java动态数组是一种可以任意伸缩数组长度的对象，在Java中比较常用的是ArrayList，ArrayList是javaAPI中自带的java.util.ArrayList。下面介绍一下ArrayList作为Java动态数组的创建以及用法。
Java动态数组是一种可以任意伸缩数组长度的对象，在Java中比较常用的是ArrayList，ArrayList是javaAPI中自带的java.util.ArrayList。下面介绍一下ArrayList作为Java动态数组的用法。
1.语法：add()是添加一个新的元素,

remove()删除一个元素,
size()获得ArrayList的长度。
ArrayList的下标是从0开始。
2.示例代码
import java.util.ArrayList;
public class JavaArrayList {

public static void main(String[]args)
{

//Java动态数组的初始化

ArrayList al=new
ArrayList();

//向Java动态数组中添加数据

al.add("a");

al.add("b");

al.add("c");

//输出Java动态数组

for(int i=0;i
<al.size();i++)
{

String

alEach=(String)al.get(i);

System.out.println(alEach);

}

//删除数组中的某个元素,删除第二个元素

al.remove(1);

//修改Java动态数组，把新的元素放到第二个位置

al.add(1,"2");

//输出Java动态数组

for(int i=0;i
<al.size();i++)
{

String

alEach=(String)al.get(i);

System.out.println(alEach);

}

}

}

输出如下：

a

b

c

a

2

c

PS：java的一维动态数组一般是使用集合的：ArrayList,HashMap等

泛型：

ArrayList

a = new ArrayList

();

T是你数组里 存的类型

比如String类型的 比如int的

java如何定义动态数组

Java.util.Vector提供了向量(Vector)类以实现类似动态数组的功能。在Java语言中是没有指针概念的，但如果能正确灵活地使用指针又确实可以大大提高程序的质量，比如在C、C++中所谓“动态数组”一般都由指针来实现。为了弥补这点缺陷，Java提供了丰富的类库来方便编程者使用，Vector类便是其中之一。事实上，灵活使用数组也可完成向量类的功能，但向量类中提供的大量方法大大方便了用户的使用。
ArrayList本身就是动态数组。
List arraylist = new ArrayList（）；
当你把相关内容add到arraylist的时候，本身是放在一个数组当中的，当你使用add，remove等改变数组结构的方法时，他就会重新new一个合适长度的数组，在把以前的内容和修改的内容存放进去。
去看看jdk中ArrayList的内部机制就知道如何定义了，它基础原理就是先声明并初始化一个指定大小的数组，当用户往数组里添加元素时去判断是否达到数组是最大下标，如果大于了数组下标会新建一个比原数组大数组再将原数组的内容copy过来，至于里边的实现和算法肯定不是这么简单，详细了解就去打开来读读
int a...;
jdk5以后才有的,记住是数据组名后面跟三个点
java无动态数组
可以用Vector类替代 C++的一些特性已经在java中取消
JAVA中的数组没有动态的
要是想用动态的数据结构就用向量Vector
采用Vector
import java.until.Vector;
例如：
Vector vet==new Vector();
String str="test1";
double t1=0.124;
vet.add(str);
vet.add(String.valueOf(t1));
可以用 vet.size()获取其大小。
通过vet.get(i);获取第i个元素（i从0开始），类型为Object，转换一下就可以了。
具体可以查看jdk api文档

JAVA如何实现动态数组

int[] = {1,2,3,4,5,...}，里面可以是N个，不知道你是不是想实现这样的功能，希望能帮助到你
就是这样写啊String[] = {"a","b"}，但这个只能在初始化的时候写。如果是参数的话有一种是用...来代替表示可以无限个
还有，你可以通过先定义，到知道具体的长度后再初始化的做法
java中有多种定义好的动态数组，这里就说ArrayList。
ArrayList list = new ArrayList.
//动态数组添加元素
list.add("a")
//动态数组获取第一个元素
list.get(0)
//动态数组删除第一个元素
list.remove(0)
ArrayList
真受不了. 数组必须确定一个length,如果不确定,就不是数组,是arrayList
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的处理会中止并抛出ConcurrentModificationException异常,这是集合处理中的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动态二维数组 怎么动态定义

int[][] num;
int[] a={1,23,4,5};//一个数组
int h=1;//多少行
num=new int[h][a.length];//这里用两个变量来就可以实现动态定义了.
for(int i=0;i
<h;i++)
{

for(int j=0;j
<a.length;j++)
{

num[i][j]=a[i];//这里实现动态赋值了

}

}

有两种实现方法：

可以用List数组来实现

可以用map来实现

方法一：用map来实现

比如要创建一个1行、3列的数组，实现方法如下：

public static void main(String[] args) throws CloneNotSupportedException { Map
<double, list
> myMap = create(1, 3);}public static Map
<double, list
> create(double row, double column) { Map
<double, list
> doubleMap = new HashMap
<double, list
>(); for (double x = 0; x < row; x++) { for (double y = 0; y < column; y++) { doubleMap.put(x, new ArrayList

()); } } return doubleMap;}

方法二：

可以用List数组来实现

public static void main(String args[]) {

//list 作为动态二维数组

List
<list
> list = new ArrayList();

List

a1 = new ArrayList

();

List

a2 = new ArrayList

();

List

a3 = new ArrayList

();

list.add(a1);

list.add(a2);

list.add(a3);

a1.add("string1 in a1");

a1.add("string2 in a1");

a2.add("string1 in a2");

a3.add("string1 in a3");

a3.add("string2 in a3");

for (int i = 0; i < list.size(); ++i) {

for (int j = 0; j < list.get(i).size(); ++j)

System.out.println(list.get(i).get(j));

}

}

</list

</a.length;j++)
</h;i++)

JAVA中如何动态改变数组长度 动态数组 arraycopy

arraycopy是数组复制的意思，给你个例子。
public class ArraycopyTest {
// arraycopy(Object src, int srcStartIndex, Object dest, int destStartIndex,
// int length)
// 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
// srcStartIndex：原数组中要开始复制的第一个元素的位置
// destStartIndex: 目标数组中要开始替换的第一个元素的位置
// length: 要复制的元素的个数
public static void main(String[] args) {
// 静态初始化两个长度不同的数组
int src[] = { 1, 2, 3, 4, 5, 6 };
int dest[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
// 将数组src的4个元素copy到数组dest中
System.arraycopy(src, 1, dest, 2, 4);
// 输出数组dest
for (int i = 0; i < 10; i++) {
System.out.println(dest[i]);
}
}
}
arraycopy是数组复制的意思，给你个例子。
public class ArraycopyTest {
// arraycopy(Object src, int srcStartIndex, Object dest, int destStartIndex,
// int length)
// 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
// srcStartIndex：原数组中要开始复制的第一个元素的位置
// destStartIndex: 目标数组中要开始替换的第一个元素的位置
// length: 要复制的元素的个数
public static void main(String[] args) {
// 静态初始化两个长度不同的数组
int src[] = { 1, 2, 3, 4, 5, 6 };
int dest[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
// 将数组src的4个元素copy到数组dest中
System.arraycopy(src, 1, dest, 2, 4);
// 输出数组dest
for (int i = 0; i < 10; i++) {
System.out.println(dest[i]);
}
}
}
java 动态数组一般使用 Vector 或 ArrayList。
Vector v = new Vector();
v.add("123");
v.add("456");
自适应长度变化。
新建一个数组，用Arrays.copy把原来数组的内容复制进新的数组里面就得了。。。
把数组的长度定义为变量就可以了
java中的数组一旦被定义长度是不允许修改长度的，如果题主希望实现类似的功能可以采用ArrayList。ArrayList的底层结构就是数组。当ArrayList实例化时会默认设置一个长度，当长度不够用时会自动扩展现有长度的1/2.（假设初始数组长度为10，现在变成了15）
System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length )能够实现数组复制的功能。
假设有数组a（src），数组b（dest），我们希望把a数组中从下标为2（srcPos）长度为3（length）的元素复制到b的下标为4（destPos）开始的元素中。java代码示例如下：
int a = [1,3,5,7,9];int b = [2,4,6,8,0,2,4];System.arraycopy(a,2,b,4,3);//最终b的内容为[2,4,6,8,5,7,9];但是如果注意API的话会发现arraycopy有几个限制
1、a，b的元素类型必须相同（int和Integer这里也是需要区分的）
2、数组不能越界，也就是srcPos+length不能超过a的长度；desPos+length也不能超过b的长度，否则就会报数组越界的一场。这也说明了无法实现数组长度的动态扩展。

java8中如何动态遍历动态多维数组

有两种实现方法：
可以用List数组来实现
可以用map来实现
方法一：用map来实现
比如要创建一个1行、3列的数组，实现方法如下：
public static void main(String[] args) throws CloneNotSupportedException { Map
<double, list
> myMap = create(1, 3);}public static Map
<double, list
> create(double row, double column) { Map
<double, list
> doubleMap = new HashMap
<double, list
>(); for (double x = 0; x < row; x++) { for (double y = 0; y < column; y++) { doubleMap.put(x, new ArrayList

()); } } return doubleMap;}

方法二：

可以用List数组来实现

public static void main(String args[]) {

//list 作为动态二维数组

List
<list
> list = new ArrayList();

List

a1 = new ArrayList

();

List

a2 = new ArrayList

();

List

a3 = new ArrayList

();

list.add(a1);

list.add(a2);

list.add(a3);

a1.add("string1 in a1");

a1.add("string2 in a1");

a2.add("string1 in a2");

a3.add("string1 in a3");

a3.add("string2 in a3");

for (int i = 0; i < list.size(); ++i) {

for (int j = 0; j < list.get(i).size(); ++j)

System.out.println(list.get(i).get(j));

}

}

</list

如何用java语言创建不定长动态数组

如果是String型其实你可以先把要放入数组中的的元素放进一个StringBuffer里，用分隔符分割，在需要的时候转化成String在用.split()方法分割放进String[]数组里，这样快，需要的代码也不多，int型的话，可以用同样的方法实现，只是数据类型转化可能会影响速度。数组好像不支持动态变量的。
java.util.Arrays
public class intArray {
private int theSize=0;;
private int a_int[]={};
public intArray(int a[]){
this.a_int=a;
this.theSize=a.length;
}
public intArray(){
this.theSize=0;
}
public int getSize(){
return this.theSize;
}
public int getAt(int nIndex){
return this.a_int[nIndex];
}
public void SetAt(int nIndex , int newElement){
this.a_int[nIndex] =newElement;
}
public void add(int nIndex){
int old[] = this.a_int;

this.a_int= new int[this.theSize+1];

for(int i =0;i
<old.length;i++){
a_int[i]= old[i];

}

if(this.theSize>0){

a_int[this.theSize]=nIndex;

}else{

a_int[0]=nIndex;

}

this.theSize++;

}

public static void main(String args[]){

intArray array = new intArray();

array.add(1);

array.add(2);

array.add(3);

array.add(4);

array.add(5);

for(int i = 0;i
<array.getsize();i++){
System.out.println(array.getAt(i));

}

}

}

再给个任意类型的

public class myArray

{

private int theSize=0;

private AnyType theItem[]=null;

public myArray(AnyType a[]){

this.theItem=a;

this.theSize=a.length;

}

public myArray(){

}

public int getSize(){

return this.theSize;

}

public AnyType get(int nIndex){

return this.theItem[nIndex];

}

public void Set(int nIndex , AnyType newElement){

this.theItem[nIndex] =newElement;

}

public void add(AnyType newVal){

AnyType old[]=this.theItem;

this.theItem= (AnyType[]) new Object[theSize+1];

if(theSize!=0){

for(int i =0;i
<old.length;i++){
this.theItem[i]= old[i];

}

}

this.theItem[this.theSize]=newVal;

this.theSize++;

}

public static void main(String args[]){

myArray

array = new myArray

();

array.add("1");

array.add("2");

array.add("3");

array.add("a");

array.add("b");

array.add("c");

for(int i =0;i
<array.thesize;i++){
System.out.println(array.get(i));

}

}

}
</array.thesize;i++){

</old.length;i++){

</array.getsize();i++){
</old.length;i++){

如何在Java里面创建一个动态的二维数组？？

方式一：public Object[][] create(int m,int n){ return new Object[m][n];}方式二：System.arrayCopy();Arrays.copy();都可以实现，你可以百度一下用法，java还可以实现“奇异”数组，数组中的数组长度可以不一致。