How can I filter my collection with values to be checked for equality ignoring case.
Example: I have
["Value1", "vALue1", "vALue2", "valUE2"]
I need to have
["Value1", "vALue2"]
Any solutions will be good.
For example I can forbid adding new string if I already has one that equals ignoring case
or I can have collection and just filter it to get rid of strings which are equals ignoring case
This seems not to be (easily) possible with Streams alone1, but you can keep track of the already seen elements in a Set (O(1) lookup) and filter elements by whether their lowercased forms are already in that set (Set.add will return false then).
List<String> values = List.of("Value1", "vALue1", "vALue2", "valUE2");
Set<String> seen = new HashSet<>();
List<String> res = values.stream().filter(s -> seen.add(s.toLowerCase()))
.collect(Collectors.toList());
System.out.println(res); // [Value1, vALue2]
1) E.g., distinct does not accept a mapping function and Collectors.groupingBy might does not preserve order.
Some Java libraries which provide distinctBy functionality may be used to resolve this task.
For example, StreamEx library (GitHub, Maven Repo), which stands for Extenstion of Stream API, may be used like this:
import java.util.*;
import one.util.streamex.*;
public class MyClass {
public static void main(String args[]) {
String[] data = {
"Value1", "vALue1", "vALue2", "valUE2"
};
List<String> noDups = StreamEx.of(data)
.distinct(String::toLowerCase)
.toList();
System.out.println(noDups);
}
}
Output:
[Value1, vALue2]
Here is a minimal code example as of how this could work:
String[] array = new String[] {"Value1", "vALue1", "vALue2", "valUE2"};
ArrayList<String> finalArray = new ArrayList<>();
for(String entry : array) {
boolean alreadyContained = finalArray.stream().anyMatch(entry::equalsIgnoreCase);
if(!alreadyContained) {
finalArray.add(entry);
}
}
Basically, you create an ArrayList of all non-duplicate entries. For each entry, check if it already is contained in the ArrayList (ignoring case), add it otherwise.
Here is a genericized example of tobias_k's response:
import java.util.*;
import java.util.stream.Collectors;
public class ArrayUtils {
public static void main(String[] args) {
List<String> values = List.of("Value1", "vALue1", "vALue2", "valUE2");
List<String> deduped = dedupeCaseInsensitive(values);
System.out.println(deduped); // [Value1, vALue2]
}
/* Higher-order function */
public static List<String> dedupeCaseInsensitive(List<String> collection) {
return dedupeWith(collection, String.CASE_INSENSITIVE_ORDER);
}
public static <E> List<E> dedupeWith(List<E> list, Comparator<E> comparator) {
Set<E> seen = new TreeSet<>(comparator);
return list.stream().filter(s -> seen.add(s)).collect(Collectors.toList());
}
}
Here is a stream version:
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
public class ArrayUtils {
public static void main(String[] args) {
String[] items = {"Value1", "vALue1", "vALue2", "valUE2"};
String[] result = dedupeCaseInsensitive(items);
// Print the resulting array.
System.out.println(Arrays.toString(result));
}
public static String[] dedupeCaseInsensitive(String[] items) {
return Arrays.stream(items)
.collect(Collectors.toMap(
String::toLowerCase,
Function.identity(),
(o1, o2) -> o1,
LinkedHashMap::new))
.values()
.stream()
.toArray(String[]::new);
}
}
You can dedupe with case-insensitive logic by populating a Map, grabbing its values and sorting them.
import java.util.*;
public class ArrayUtils {
public static void main(String[] args) {
String[] items = {"Value1", "vALue1", "vALue2", "valUE2"};
String[] result = dedupeCaseInsensitive(items);
// Print the resulting array.
System.out.println(Arrays.toString(result));
}
public static String[] dedupeCaseInsensitive(String[] items) {
Map<String, String> map = new HashMap<String, String>();
// Filter the values using a map of key being the transformation,
// and the value being the original value.
for (String item : items) {
map.putIfAbsent(item.toLowerCase(), item);
}
List<String> filtered = new ArrayList<>(map.values());
// Sort the filtered values by the original positions.
Collections.sort(filtered,
Comparator.comparingInt(str -> findIndex(items, str)));
return collectionToArray(filtered);
}
/* Convenience methods */
public static String[] collectionToArray(Collection<String> collection) {
return collection.toArray(new String[collection.size()]);
}
public static int findIndex(String arr[], String t) {
return Arrays.binarySearch(arr, t);
}
}
If you use a LinkedHashMap, you do not need to sort, because the items retain their insertion order.
import java.util.*;
public class ArrayUtils {
public static void main(String[] args) {
String[] items = {"Value1", "vALue1", "vALue2", "valUE2"};
String[] result = dedupeCaseInsensitive(items);
// Print the resulting array.
System.out.println(Arrays.toString(result));
}
public static String[] dedupeCaseInsensitive(String[] items) {
Map<String, String> map = new LinkedHashMap<String, String>();
// Filter the values using a map of key being the transformation,
// and the value being the original value.
for (String item : items) {
map.putIfAbsent(item.toLowerCase(), item);
}
return collectionToArray(map.values());
}
/* Convenience methods */
public static String[] collectionToArray(Collection<String> collection) {
return collection.toArray(new String[collection.size()]);
}
}}
