In Java, remove empty elements from a list of Strings
JavaArraysJava Problem Overview
In Java, I have an ArrayList of Strings like:
[,Hi, ,How,are,you]
I want to remove the null and empty elements, how to change it so it is like this:
[Hi,How,are,you]
Java Solutions
Solution 1 - Java
List<String> list = new ArrayList<String>(Arrays.asList("", "Hi", null, "How"));
System.out.println(list);
list.removeAll(Arrays.asList("", null));
System.out.println(list);
Output:
[, Hi, null, How]
[Hi, How]
Solution 2 - Java
Its a very late answer, but you can also use the Collections.singleton
:
List<String> list = new ArrayList<String>(Arrays.asList("", "Hi", null, "How"));
list.removeAll(Collections.singleton(null));
list.removeAll(Collections.singleton(""));
Solution 3 - Java
Another way to do this now that we have Java 8 lambda expressions.
arrayList.removeIf(item -> item == null || "".equals(item));
Solution 4 - Java
If you are using Java 8 then try this using lambda expression and org.apache.commons.lang.StringUtils, that will also clear null
and blank
values from array
input
public static String[] cleanArray(String[] array) {
return Arrays.stream(array).filter(x -> !StringUtils.isBlank(x)).toArray(String[]::new);
}
Solution 5 - Java
-
If you were asking how to remove the empty strings, you can do it like this (where
l
is anArrayList<String>
) - this removes allnull
references and strings of length 0:Iterator<String> i = l.iterator(); while (i.hasNext()) { String s = i.next(); if (s == null || s.isEmpty()) { i.remove(); } }
-
Don't confuse an
ArrayList
with arrays, anArrayList
is a dynamic data-structure that resizes according to it's contents. If you use the code above, you don't have to do anything to get the result as you've described it -if yourArrayList
was ["","Hi","","How","are","you"], after removing as above, it's going to be exactly what you need -["Hi","How","are","you"]
.
However, if you must have a 'sanitized' copy of the original list (while leaving the original as it is) and by 'store it back' you meant 'make a copy', then krmby's code in the other answer will serve you just fine.
Solution 6 - Java
Going to drop this lil nugget in here:
Stream.of("", "Hi", null, "How", "are", "you")
.filter(t -> !Strings.isNullOrEmpty(t))
.collect(ImmutableList.toImmutableList());
I wish with all of my heart that Java had a filterNot
.
Solution 7 - Java
There are a few approaches that you could use:
-
Iterate over the list, calling
Iterator.remove()
for the list elements you want to remove. This is the simplest. -
Repeatedly call
List.remove(Object)
. This is simple too, but performs worst of all ... because you repeatedly scan the entire list. (However, this might be an option for a mutable list whose iterator didn't supportremove
... for some reason.) -
Create a new list, iterate over the old list, adding elements that you want to retain to a new list.
-
If you can't return the new list, as 3. above and then clear the old list and use
addAll
to add the elements of the new list back to it.
Which of these is fastest depends on the class of the original list, its size, and the number of elements that need to be removed. Here are some of the factors:
-
For an
ArrayList
, each individualremove
operation isO(N)
, whereN
is the list size. It is expensive to remove multiple elements from a large ArrayList using theIterator.remove()
method (or theArrayList.remove(element)
method).By contrast, the
Iterator.remove
method for aLinkedList
isO(1)
. -
For an
ArrayList
, creating and copying a list isO(N)
and relatively cheap, especially if you can ensure that the destination list's capacity is large enough (but not too large).By contrast, creating and copying to a
LinkedList
is alsoO(N)
, but considerably more expensive.
All of this adds up to a fairly complicated decision tree. If the lists are small (say 10 or less elements) you can probably get away with any of the approaches above. If the lists could be large, you need to weigh up all of the issues in the list of the expected list size and expected number of removals. (Otherwise you might end up with quadratic performance.)
Solution 8 - Java
- This code compiles and runs smoothly.
- It uses no iterator so more readable.
- list is your collection.
- result is filtered form (no null no empty).
public static void listRemove() {
List<String> list = Arrays.asList("", "Hi", "", "How", "are", "you");
List<String> result = new ArrayList<String>();
for (String str : list) {
if (str != null && !str.isEmpty()) {
result.add(str);
}
}
System.out.println(result);
}
Solution 9 - Java
If you get UnsupportedOperationException
from using one of ther answer above and your List
is created from Arrays.asList()
, it is because you can't edit such List
.
To fix, wrap the Arrays.asList()
inside new LinkedList<String>()
:
List<String> list = new LinkedList<String>(Arrays.asList(split));
Source is from this answer.
Solution 10 - Java
Regarding the comment of Andrew Mairose - Although a fine solution, I would just like to add that this solution will not work on fixed size lists.
You could attempt doing like so:
Arrays.asList(new String[]{"a", "b", null, "c", " "})
.removeIf(item -> item == null || "".equals(item));
But you'll encounter an UnsupportedOperationException at java.util.AbstractList.remove
(since asList
returns a non-resizable List).
A different solution might be this:
List<String> collect =
Stream.of(new String[]{"a", "b", "c", null, ""})
.filter(item -> item != null && !"".equals(item))
.collect(Collectors.toList());
Which will produce a nice list of strings :-)
Solution 11 - Java
private List cleanInputs(String[] inputArray) {
List<String> result = new ArrayList<String>(inputArray.length);
for (String input : inputArray) {
if (input != null) {
String str = input.trim();
if (!str.isEmpty()) {
result.add(str);
}
}
}
return result;
}
Solution 12 - Java
List<String> list = new ArrayList<String>(Arrays.asList("", "Hi", "", "How"));
Stream<String> stream = list .stream();
Predicate<String> empty = empt->(empt.equals(""));
Predicate<String> emptyRev = empty.negate();
list= stream.filter(emptyRev).collect(Collectors.toList());
OR
list = list .stream().filter(empty->(!empty.equals(""))).collect(Collectors.toList());
Solution 13 - Java
lukastymo's answer seems the best one.
But it may be worth mentioning this approach as well for it's extensibility:
List<String> list = new ArrayList<String>(Arrays.asList("", "Hi", null, "How", "are"));
list = list.stream()
.filter(item -> item != null && !item.isEmpty())
.collect(Collectors.toList());
System.out.println(list);
What I mean by that is you could then add additional filters, such as:
.filter(item -> !item.startsWith("a"))
... although of course that's not specifically relevant to the question.