Java动态数组大小？

我有一个类 – xClass，我想加载到一个xClass的数组，所以我声明：

xClass mysclass[] = new xClass[10]; myclass[0] = new xClass(); myclass[9] = new xClass(); 

但是，我不知道我是否需要10.我可能需要8或12或任何其他号码。 我将不知道，直到运行时。 我可以随时更改数组中元素的数量吗？ 如果是这样，怎么样？

Answer 1

不，你不能改变创建数组的大小。 你必须把它分配得比你想象的要大，或者接受重新分配它需要增长的开销。 当它发生时，您将不得不分配一个新的数据，并将数据从旧数据复制到新数据：

 int oldItems[] = new int[10]; for (int i=0; i<10; i++) { oldItems[i] = i+10; } int newItems[] = new int[20]; System.arraycopy(oldItems, 0, newItems, 0, 10); oldItems = newItems; 

如果你发现自己在这种情况下，我强烈推荐使用Java集合。 特别是ArrayList实际上包装了一个数组，并根据需要照顾了增长数组的逻辑：

 List<xClass> mysclass = new ArrayList<xClass>(); myclass.add(new xClass()); myclass.add(new xClass()); 

一般来说， ArrayList是一个最好的解决方案，无论如何由于几个原因。 首先，数组是可变的。 如果你有一个这样的课程：

 class Myclass { private int items[]; public int[] getItems() { return items; } } 

你已经创建了一个问题，因为调用者可以改变你的私人数据成员，这导致各种防御性复制。 比较这个列表版本：

 class Myclass { private List<Integer> items; public List<Integer> getItems() { return Collections.unmodifiableList(items); } } 

Answer 2

在java中数组的长度是固定的。

您可以使用List来保存这些值，并在需要时调用toArray方法请参阅以下示例：

 import java.util.List; import java.util.ArrayList; import java.util.Random; public class A { public static void main( String [] args ) { // dynamically hold the instances List<xClass> list = new ArrayList<xClass>(); // fill it with a random number between 0 and 100 int elements = new Random().nextInt(100); for( int i = 0 ; i < elements ; i++ ) { list.add( new xClass() ); } // convert it to array xClass [] array = list.toArray( new xClass[ list.size() ] ); System.out.println( "size of array = " + array.length ); } } class xClass {} 

Answer 3

正如其他人所说，你不能改变现有的Java数组的大小。

ArrayList与标准Java对动态大小的数组最接近。 但是，有一些关于ArrayList（实际上是List接口）不是“数组”的东西。 例如：

• 您不能使用索引列表。 你必须使用get(int)和set(int, E)方法。
• ArrayList是用零个元素创建的。 你不能简单的用20个元素创建一个ArrayList，然后调用set(15, foo) 。
• 您不能直接更改ArrayList的大小。 你使用各种add ， insert和remove方法间接地做到这一点。

如果你想要更类似数组的东西，你将需要设计自己的API。 （也许有人可以和现有的第三方图书馆合作……我用2分钟的“研究”找不到一个使用Google的人:-)）

如果你真的只需要一个在初始化时增长的数组，那么解决方案就是这样的。

 ArrayList<T> tmp = new ArrayList<T>(); while (...) { tmp.add(new T(...)); } // This creates a new array and copies the element of 'tmp' to it. T[] array = tmp.toArray(new T[tmp.size()]); 

Answer 4

您在创建元素时将元素的数量设置为任何您想要的值：

 xClass[] mysclass = new xClass[n]; 

然后你可以初始化循环中的元素。 我猜这是你需要的。

如果您在创建元素后需要添加或删除元素，那么您将不得不使用ArrayList 。

Answer 5

你可以使用ArrayList：

 import java.util.ArrayList; import java.util.Iterator; 

…

 ArrayList<String> arr = new ArrayList<String>(); arr.add("neo"); arr.add("morpheus"); arr.add("trinity"); Iterator<String> foreach = arr.iterator(); while (foreach.hasNext()) System.out.println(foreach.next()); 

Answer 6

是的，包装它并使用集合框架。

 List l = new ArrayList(); l.add(new xClass()); // do stuff l.add(new xClass()); 

然后在必要时使用List.toArray（），或者只是遍历所述List。

Answer 7

正如其他用户所说，您可能需要java.util.List的实现。

如果出于某种原因，你最终需要一个数组，你可以做两件事情：

• 使用List，然后使用myList.toArray（）将其转换为数组

• 使用一定大小的数组。 如果您需要更多或更少的大小，可以使用java.util.Arrays方法修改它。

最好的解决方案将取决于你的问题;）

Answer 8

我建议使用矢量。 非常容易使用，并有许多预定义的方法来实现。

 import java.util.*; Vector<Integer> v=new Vector<Integer>(5,2); 

添加一个元素只需使用：

 v.addElement(int); 

在（5,2）中 ，前5个是矢量的初始大小。 如果超过初始大小，矢量将增加2个位置。 如果再次超过，则会再次增加2个位置等等。

Answer 9

Arrays.copyOf()方法有很多选项来解决动态增加数组长度的问题。

Java API

Answer 10

你在哪里声明myclass []数组为：

 xClass myclass[] = new xClass[10] 

，只需传入您需要的XClass元素的数量即可。 那么你知道你需要多少？ 通过将数组声明为有10个元素，您不是声明10个XClass对象，而只是创建一个包含10个xClass类型元素的数组。

Answer 11

获得您需要先存储的数量然后初始化数组是个好习惯。

例如，您会询问用户需要存储多少数据，然后对其进行初始化，或查询需要存储多少个数据的组件或参数。 如果你想要一个动态数组，你可以使用ArrayList()并使用al.add(); 函数继续添加，然后您可以将其转移到一个固定的数组。

 //Initialize ArrayList and cast string so ArrayList accepts strings (or anything ArrayList<string> al = new ArrayList(); //add a certain amount of data for(int i=0;i<x;i++) { al.add("data "+i); } //get size of data inside int size = al.size(); //initialize String array with the size you have String strArray[] = new String[size]; //insert data from ArrayList to String array for(int i=0;i<size;i++) { strArray[i] = al.get(i); } 

这样做是多余的，但只是为了向您展示这个想法， ArrayList可以容纳不同于其他原始数据类型的对象，并且非常容易操作，从中间删除任何东西也很容易，完全dynamic.asl与List和Stack

Answer 12

Java数组的大小是固定的，你不能像在C ++中那样制作动态数组。

Answer 13

我不知道是否可以在运行时更改大小，但可以在运行时分配大小。 尝试使用此代码：

 class MyClass { void myFunction () { Scanner s = new Scanner (System.in); int myArray []; int x; System.out.print ("Enter the size of the array: "); x = s.nextInt(); myArray = new int[x]; } } 

这会将您的数组大小指定为在运行时输入到x的数组大小。

Answer 14

这是一个不使用ArrayList的方法。 用户指定的大小，你可以添加一个do-while循环递归。

 import java.util.Scanner; public class Dynamic { public static Scanner value; public static void main(String[]args){ value=new Scanner(System.in); System.out.println("Enter the number of tests to calculate average\n"); int limit=value.nextInt(); int index=0; int [] marks=new int[limit]; float sum,ave; sum=0; while(index<limit) { int test=index+1; System.out.println("Enter the marks on test " +test); marks[index]=value.nextInt(); sum+=marks[index]; index++; } ave=sum/limit; System.out.println("The average is: " + ave); } } 

Answer 15

在Java中，Array的大小始终是固定长度的，但是有一种方法可以在运行时本身动态增加数组的大小

这是最“使用”，以及首选的方式来做到这一点 –

  int temp[]=new int[stck.length+1]; for(int i=0;i<stck.length;i++)temp[i]=stck[i]; stck=temp; 

在上面的代码中，我们正在初始化一个新的temp []数组，并进一步使用for循环来初始化temp的内容与原始数组的内容即。 STCK []。 然后再把它复制回原来的，给我们一个新的SIZE的新阵列。

毫无疑问，它会产生一个CPU开销，因为重复使用for循环重新初始化一个数组。 但是你仍然可以在你的代码中使用和实现它。 如果您希望将数据动态存储在内存中，则可以使用“链接列表”而不是“数组”。

下面是一个基于动态堆栈的实时示例，在运行时增加阵列大小

文件名：DStack.java

 public class DStack { private int stck[]; int tos; void Init_Stck(int size) { stck=new int[size]; tos=-1; } int Change_Stck(int size){ return stck[size]; } public void push(int item){ if(tos==stck.length-1){ int temp[]=new int[stck.length+1]; for(int i=0;i<stck.length;i++)temp[i]=stck[i]; stck=temp; stck[++tos]=item; } else stck[++tos]=item; } public int pop(){ if(tos<0){ System.out.println("Stack Underflow"); return 0; } else return stck[tos--]; } public void display(){ for(int x=0;x<stck.length;x++){ System.out.print(stck[x]+" "); } System.out.println(); } } 

文件名：Exec.java
（与主类）

 import java.util.*; public class Exec { private static Scanner in; public static void main(String[] args) { in = new Scanner(System.in); int option,item,i=1; DStack obj=new DStack(); obj.Init_Stck(1); do{ System.out.println(); System.out.println("--MENU--"); System.out.println("1. Push a Value in The Stack"); System.out.println("2. Pop a Value from the Stack"); System.out.println("3. Display Stack"); System.out.println("4. Exit"); option=in.nextInt(); switch(option){ case 1: System.out.println("Enter the Value to be Pushed"); item=in.nextInt(); obj.push(item); break; case 2: System.out.println("Popped Item: "+obj.pop()); obj.Change_Stck(obj.tos); break; case 3: System.out.println("Displaying..."); obj.display(); break; case 4: System.out.println("Exiting..."); i=0; break; default: System.out.println("Enter a Valid Value"); } }while(i==1); } } 

希望这可以解决您的查询。

Answer 16

是的，我们可以这样做。

 import java.util.Scanner; public class Collection_Basic { private static Scanner sc; public static void main(String[] args) { Object[] obj=new Object[4]; sc = new Scanner(System.in); //Storing element System.out.println("enter your element"); for(int i=0;i<4;i++){ obj[i]=sc.nextInt(); } /* * here, size reaches with its maximum capacity so u can not store more element, * * for storing more element we have to create new array Object with required size */ Object[] tempObj=new Object[10]; //copying old array to new Array int oldArraySize=obj.length; int i=0; for(;i<oldArraySize;i++){ tempObj[i]=obj[i]; } /* * storing new element to the end of new Array objebt */ tempObj[i]=90; //assigning new array Object refeence to the old one obj=tempObj; for(int j=0;j<obj.length;j++){ System.out.println("obj["+j+"] -"+obj[j]); } } }