Practically I know ways to reduce duplicate trought distinct(), or assign List to Set, but I have a little different issue.
How to solve smart way below problem in JAVA 8 using stream or may be StreamEx ?
Let's say we have a objects in List
A, A, A, B, B, A, A, A, C, C, C, A, A, B, B, A
Now I need
A, B, A, C, A, B, A
So duplicated was removed but only if appear as next, but should stay if next to then is different object. I tried a few solutions but ware ugly, and not readable.
You could write a stateful filter, but you should never do that, because it violates the contract of filter(Predicate<? super T> predicate):
predicate- a non-interfering, stateless predicate to apply to each element to determine if it should be included
public class NoRepeatFilter<T> implements Predicate<T> {
private T prevValue;
@Override
public boolean test(T value) {
if (value.equals(this.prevValue))
return false;
this.prevValue = value;
return true;
}
}
Test
List<String> result = Stream
.of("A", "A", "A", "B", "B", "A", "A", "A", "C", "C", "C", "A", "A", "B", "B", "A")
// .parallel()
.filter(new NoRepeatFilter<>())
.collect(Collectors.toList());
System.out.println(result);
Output
[A, B, A, C, A, B, A]
The reason it must be stateless is that it'll fail if the stream is parallel, e.g. running test again with .parallel() uncommented:
[A, A, B, B, A, C, C, C, A, B, B, A]
A valid solution is to create your own Collector using of(...):
public class NoRepeatCollector {
public static <E> Collector<E, ?, List<E>> get() {
return Collector.of(ArrayList::new,
NoRepeatCollector::addNoRepeat,
NoRepeatCollector::combineNoRepeat);
}
private static <E> void addNoRepeat(List<E> list, E value) {
if (list.isEmpty() || ! list.get(list.size() - 1).equals(value))
list.add(value);
}
private static <E> List<E> combineNoRepeat(List<E> left, List<E> right) {
if (left.isEmpty())
return right;
if (! right.isEmpty())
left.addAll(left.get(left.size() - 1).equals(right.get(0))
? right.subList(1, right.size()) : right);
return left;
}
}
Test
List<String> result = Stream
.of("A", "A", "A", "B", "B", "A", "A", "A", "C", "C", "C", "A", "A", "B", "B", "A")
// .parallel()
.collect(NoRepeatCollector.get());
System.out.println(result);
Output (with and without .parallel())
[A, B, A, C, A, B, A]
If your input is a List (or other Iterable), you could remove repeating values using a simple loop:
public static <E> void removeRepeats(Iterable<E> iterable) {
E prevValue = null;
for (Iterator<E> iter = iterable.iterator(); iter.hasNext(); ) {
E value = iter.next();
if (value.equals(prevValue))
iter.remove();
else
prevValue = value;
}
}
Test
List<String> list = new ArrayList<>(Arrays.asList(
"A", "A", "A", "B", "B", "A", "A", "A", "C", "C", "C", "A", "A", "B", "B", "A"));
removeRepeats(list);
System.out.println(list);
Output
[A, B, A, C, A, B, A]
It's quite simple without using streams.. Something like this:
public List<T> noConsecutiveDuplicates(final List<T> input) {
final List<T> output = new ArrayList<>();
for (final T element : input) {
if (!element.equals(lastElement(output))) {
output.add(element);
}
}
return output;
}
private T lastElement(final List<T> list) {
if (list.size() == 0) {
return null;
}
return list.get(list.size() - 1);
}
I would give StreamEx a shot and use StreamEx::collapse:
List<String> strings = Arrays.asList("A", "A", "A", "B", "B", "A", "A", "A", "C", "C", "C", "A", "A", "B", "B", "A");
List<String> collect = StreamEx.of(strings)
.collapse(Objects::equals)
.collect(Collectors.toList());
It is also possible by using vanilla Java and utilize the idea of "edge detection":
List<String> collect = IntStream.range(0, strings.size())
.filter(i -> i == 0 || !Objects.equals(strings.get(i - 1), strings.get(i)))
.mapToObj(strings::get)
.collect(Collectors.toList());
List<String> lst = Arrays.asList("A", "A", "A", "B", "B", "A", "A", "A", "C", "C", "C", "A", "A", "B", "B", "A");
List<String> result = IntStream.range(0, lst.size())
.filter(index->index ==0 || !lst.get(index).equals(lst.get(index-1)))
.mapToObj(i->lst.get(i)).collect(Collectors.toList());
result.stream().forEach(System.out::print);
You can simply iterate over the indexes from the source of the data and filter those elements which are not same as previous element.
This may not be the cleanest solution, but you could use a filter, that remembers previous stream value.
class noDuplicateFilter implementsd Function<T>{
private T previous=null;
public boolean test(T input){
boolean distinct= !Objects.equals(input, previous);
this.previous = input;
return distinct;
}
}
Then use it inside of your stream.
Probably there is a bleaner solutino in JavaRx.
There are also some solutions here
I think the most concise way is to use the reduce method as below;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Stack;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
public class Main {
public static void main(String[] args) {
List<String> ss =Arrays.asList("A","A","A","B","B", "A","A","A", "C", "C", "C","A","A","B","B","A");
BiFunction<ArrayList<String>, String, ArrayList<String>> acc = new BiFunction<ArrayList<String>, String, ArrayList<String>>() {
@Override
public ArrayList<String> apply(ArrayList<String> strings, String s) {
if(strings.isEmpty() || !strings.get(strings.size()-1).equals(s)){
strings.add(s);
}
return strings;
}
};
BinaryOperator<ArrayList<String>> combiner = new BinaryOperator<ArrayList<String>>() {
@Override
public ArrayList<String> apply(ArrayList<String> strings, ArrayList<String> strings2) {
strings.addAll(strings2);
return strings;
}
};
ss.stream().reduce(new ArrayList<String>(), acc, combiner).forEach(System.out::println);
}
}
