如何动态地向 Java 数组添加项？

Look at java.util.LinkedList or java.util.ArrayList

List<Integer> x = new ArrayList<Integer>();
x.add(1);
x.add(2);

You probably want to use an ArrayList for this -- for a dynamically sized array like structure.

You can use an ArrayList and then use the toArray() method. But depending on what you are doing, you might not even need an array at all. Look into seeing if Lists are more what you want.

See: Java List Tutorial

Use an ArrayList or juggle to arrays to auto increment the array size.

Arrays in Java have a fixed size, so you can't "add something at the end" as you could do in PHP.

A bit similar to the PHP behaviour is this:

int[] addElement(int[] org, int added) {
int[] result = Arrays.copyOf(org, org.length +1);
result[org.length] = added;
return result;
}

Then you can write:

x = new int[0];
x = addElement(x, 1);
x = addElement(x, 2);


System.out.println(Arrays.toString(x));

But this scheme is horribly inefficient for larger arrays, as it makes a copy of the whole array each time. (And it is in fact not completely equivalent to PHP, since your old arrays stays the same).

The PHP arrays are in fact quite the same as a Java HashMap with an added "max key", so it would know which key to use next, and a strange iteration order (and a strange equivalence relation between Integer keys and some Strings). But for simple indexed collections, better use a List in Java, like the other answerers proposed.

If you want to avoid using List because of the overhead of wrapping every int in an Integer, consider using reimplementations of collections for primitive types, which use arrays internally, but will not do a copy on every change, only when the internal array is full (just like ArrayList). (One quickly googled example is this IntList class.)

Guava contains methods creating such wrappers in Ints.asList, Longs.asList, etc.

Apache Commons has an ArrayUtils implementation to add an element at the end of the new array:

/** Copies the given array and adds the given element at the end of the new array. */
public static <T> T[] add(T[] array, T element)

You can dynamically add elements to an array using Collection Frameworks in JAVA. collection Framework doesn't work on primitive data types.

This Collection framework will be available in "java.util.*" package

For example if you use ArrayList,

Create an object to it and then add number of elements (any type like String, Integer ...etc)

ArrayList a = new ArrayList();
a.add("suman");
a.add(new Integer(3));
a.add("gurram");

Now you were added 3 elements to an array.

if you want to remove any of added elements

a.remove("suman");

again if you want to add any element

a.add("Gurram");

So the array size is incresing / decreasing dynamically..

keep a count of where you are in the primitive array

class recordStuff extends Thread
{
double[] aListOfDoubles;
int i = 0;


void run()
{
double newData;
newData = getNewData(); // gets data from somewhere


aListofDoubles[i] = newData; // adds it to the primitive array of doubles
i++ // increments the counter for the next pass


System.out.println("mode: " + doStuff());
}


void doStuff()
{
// Calculate the mode of the double[] array


for (int i = 0; i < aListOfDoubles.length; i++)
{
int count = 0;
for (int j = 0; j < aListOfDoubles.length; j++)
{
if (a[j] == a[i]) count++;
}
if (count > maxCount)
{
maxCount = count;
maxValue = aListOfDoubles[i];
}
}
return maxValue;
}
}

This is a simple way to add to an array in java. I used a second array to store my original array, and then added one more element to it. After that I passed that array back to the original one.

    int [] test = {12,22,33};
int [] test2= new int[test.length+1];
int m=5;int mz=0;
for ( int test3: test)
{
test2[mz]=test3; mz++;
}
test2[mz++]=m;
test=test2;


for ( int test3: test)


{
System.out.println(test3);
}

I have seen this question very often in the web and in my opinion, many people with high reputation did not answer these questions properly. So I would like to express my own answer here.

First we should consider there is a difference between array and arraylist.

The question asks for adding an element to an array, and not ArrayList

The answer is quite simple. It can be done in 3 steps.

1. Convert array to an arraylist
2. Add element to the arrayList
3. Convert back the new arrayList to the array

Here is the simple picture of it

And finally here is the code:

Step 1:

public List<String> convertArrayToList(String[] array){
List<String> stringList = new ArrayList<String>(Arrays.asList(array));
return stringList;
}

Step 2:

public  List<String> addToList(String element,List<String> list){


list.add(element);
return list;
}

Step 3:

public String[] convertListToArray(List<String> list){
String[] ins = (String[])list.toArray(new String[list.size()]);
return ins;
}

Step 4

public String[] addNewItemToArray(String element,String [] array){
List<String> list = convertArrayToList(array);
list= addToList(element,list);
return  convertListToArray(list);
}

In Java size of array is fixed , but you can add elements dynamically to a fixed sized array using its index and for loop. Please find example below.

package simplejava;


import java.util.Arrays;


/**
*
* @author sashant
*/
public class SimpleJava {


/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here


try{
String[] transactions;
transactions = new String[10];


for(int i = 0; i < transactions.length; i++){
transactions[i] = "transaction - "+Integer.toString(i);
}


System.out.println(Arrays.toString(transactions));


}catch(Exception exc){
System.out.println(exc.getMessage());
System.out.println(Arrays.toString(exc.getStackTrace()));
}
}


}