How do I remove objects from an Array in java?

Question

Given an Array of n Objects, let's say is an Array of Strings, and it has the following values:

foo[0]="a";
foo[1]="cc";
foo[2]="a";
foo[3]="dd";

What do I have to do to delete/remove all the Strings/Objects equal to "a" in the Array?
Thanks!

Answer 1

Make a List out of the array with Arrays.asList(), and call remove() on all the appropriate elements. Then call toArray() on the 'List' to make back into an array again.

Not terribly performant, but if you encapsulate it properly, you can always do something quicker later on.

Answer 2

Assign null to the array locations.

Answer 3

[If you want some ready-to-use code, please scroll to my "Edit3" (after the cut). The rest is here for posterity.]

To flesh out Dustman's idea:

List<String> list = new ArrayList<String>(Arrays.asList(array));
list.removeAll(Arrays.asList("a"));
array = list.toArray(array);

Edit: I'm now using Arrays.asList instead of Collections.singleton: singleton is limited to one entry, whereas the asList approach allows you to add other strings to filter out later: Arrays.asList("a", "b", "c").

Edit2: The above approach retains the same array (so the array is still the same length); the element after the last is set to null. If you want a new array sized exactly as required, use this instead:

array = list.toArray(new String[0]);

---

Edit3: If you use this code on a frequent basis in the same class, you may wish to consider adding this to your class:

private static final String[] EMPTY_STRING_ARRAY = new String[0];

Then the function becomes:

List<String> list = new ArrayList<String>(Arrays.asList(array));
list.removeAll(Arrays.asList("a"));
array = list.toArray(EMPTY_STRING_ARRAY);

This will then stop littering your heap with useless empty string arrays that would otherwise be newed each time your function is called.

cynicalman's suggestion (see comments) will also help with the heap littering, and for fairness I should mention it:

array = list.toArray(new String[list.size()]);

I prefer my approach, because it may be easier to get the explicit size wrong (e.g., calling size() on the wrong list).

Answer 4

Something about the make a list of it then remove then back to an array strikes me as wrong. Haven't tested, but I think the following will perform better. Yes I'm probably unduly pre-optimizing.

boolean [] deleteItem = new boolean[arr.length];
int size=0;
for(int i=0;i<arr.length;i==){
   if(arr[i].equals("a")){
      deleteItem[i]=true;
   }
   else{
      deleteItem[i]=false;
      size++;
   }
}
String[] newArr=new String[size];
int index=0;
for(int i=0;i<arr.length;i++){
   if(!deleteItem[i]){
      newArr[index++]=arr[i];
   }
}

Answer 5

arrgh can't get code to show up correctly. sorry got it working. sorry again i don't think I read the question properly

String  foo[] = {"a","cc","a","dd"},
       remove = "a";
     boolean gaps[] = new boolean[foo.length];
     int newlength = 0;

     for(int c = 0;c<foo.length;c++)
     {
      if(foo[c].equals(remove))
      {
       gaps[c] = true;
       newlength++;
      }
      else gaps[c] = false;

      System.out.println(foo[c]);
     }

     String newString[] = new String[newlength];

     System.out.println("");

     for(int c1=0,c2=0 ;c1<foo.length;c1++)
     {
      if(!gaps[c1])
      {
       newString[c2] = foo[c1];
       System.out.println(newString[c2]);
       c2++;
      }
     }

Answer 6

EDIT:

The point with the nulls in the array has been cleared. Sorry for my comments. Greetz GHad

Original:

Ehm... the line

array = list.toArray(array);

replaces all gaps in the array where the removed element has been with null. This might be dangerous, because the elements are removed, but the length of the array remains the same!

If you want to avoid this, use a new Array as parameter for toArray(). If you don`t want to use removeAll, a Set would be an alternative:

     String[] array = new String[] { "a", "bc" ,"dc" ,"a", "ef" };

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

     Set<String> asSet = new HashSet<String>(Arrays.asList(array));
     asSet.remove("a");
     array = asSet.toArray(new String[] {});

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

Gives:

[a, bc, dc, a, ef]
[dc, ef, bc]

Where as the current accepted answer from Chris Yester Young outputs:

[a, bc, dc, a, ef]
[bc, dc, ef, null, ef]

with the code

 String[] array = new String[] { "a", "bc" ,"dc" ,"a", "ef" };

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

 List<String> list = new ArrayList<String>(Arrays.asList(array));
 list.removeAll(Arrays.asList("a"));
 array = list.toArray(array);  

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

without any null values left behind.

Greetz GHad

Answer 7

You can always do:

int i, j;
for (i = j = 0; j < foo.length; ++j)
  if (!"a".equals(foo[j])) foo[i++] = foo[j];
foo = Arrays.copyOf(foo, i);

Answer 8

It depends on what you mean by "remove"? An array is a fixed size construct - you can't change the number of elements in it. So you can either a) create a new, shorter, array without the elements you don't want or b) assign the entries you don't want to something that indicates their 'empty' status; usually null if you are not working with primitives.

In the first case create a List from the array, remove the elements, and create a new array from the list. If performance is important iterate over the array assigning any elements that shouldn't be removed to a list, and then create a new array from the list. In the second case simply go through and assign null to the array entries.

Answer 9

Thanks a lot!! very helpful

Answer 10

i dont know...i have been trying this for a while for my java assignment///but couldnt find any soln/....anybody please post the solution

Answer 11

Insert new object: This command adds a new object to an array of objects. The added data is stored in a file. The file is a text file that is comma delimited in which each entry (object) is found on a separate line.