Is there a way to turn this for loop to use Java stream instead?

Question

Set<String> unique = new HashSet<>();
List<String> duplicates = new ArrayList<>();

for (Animal cat: animals) {
    if (!unique.add(cat.getName())) {
        duplicates.add(cat.getName());
    }
}
return duplicates;

I was wondering if there was a way to simplify this? I'm new to Java streams and I tried using Map but I resorted to the traditional for loop instead.

Answer 1

I was wondering if there was a way to simplify this? I

The stream way is probably not what you need for your requirement and your code is actually simple.

Streams allow to pass from an input (Stream<Foo>) to a result (Foo, List<String>...) thanks to multiple intermediary operations (filter, map, reduce, stream a collected result...).
Each stream operation relies on the returned stream of the next operation :
To simplify it would give a chain :

a -> b (use a)-> c (uses b)-> d (uses c)-> e (uses d)

Actually you code cannot rely on such a logic because the returned List<String> doesn't need only to return the list of names that have duplicates, that could be written such as :

List<String> duplicates =     
    animals.stream()
           .collect(Collectors.groupingBy(Animal::getName))
           .entrySet().stream()
           .filter(e -> e.getValue().size() > 1)
           .map(Entry::getKey)
           .collect(Collectors.toList());

you want return a List of each duplicate appearition in the order these occur.
It means that you don't map Stream<Animal> -> Stream<String> such as

a->b (uses a)

because you need to filter out the element if the Animal name was not added in the result ... but a stream is not designed to populate incrementally the result. So you are stuck.

---

You could write this one but as said that is really not a simplification and still it doesn't apply the same logic as the order of dup names is not the same as in your code :

List<String> duplicates = 
          animals.stream()
                 .collect(Collectors.groupingBy(Animal::getName, LinkedHashMap::new, Collectors.toList()))
                 .values().stream()
                 .flatMap(l-> l.stream().skip(1)) 
                 .map(Animal::getName)
                 .collect(Collectors.toList());

Answer 2

Do you want to extract the duplicate String names of the list of Animal according to their names? Although your code doesn't involve the first found duplicate and returns the List where the duplicates are in the n-1 count, here it is:

Set<String> set = new HashSet<>();
List<String> names = animals.stream()
                            .map(cat -> cat.getName())      // Names to collect and compare
                            .filter(name -> !set.add(name)) // Collect duplicates
                            .collect(Collectors.toList());  // To the List

This solution is based on your for-loop and performs the same thing. However, the documentation of Stream API states that the constructs should be non-infering and stateless - which means independent to sources which could change the state.

---

Here is an alternative working way in regard to the Stream-API documentation - but a bit complicated:

List<String> names = animals.stream()
    .collect(Collectors.groupingBy(
         Animal::getName, 
         Collectors.counting()))            // Collects to Map <name, count>
    .entrySet()                             // Gets the entries
    .stream()                               // Stream of the entries
    .filter(entry -> entry.getValue() > 1)  // Filters the duplicates
    .map(entry -> Collections.nCopies(      // Creates n-1 copies of the key as same as the
        entry.getValue().intValue() - 1,    //   OP's sample consumes the first duplication
        entry.getKey()))                    //   and includes the remainin ones
    .flatMap(List::stream)                  // Flattens the structure
    .collect(Collectors.toList());          // Results in the List

---

Both ways result from the input:

List<Animal> animals = Arrays.asList(
    new Animal("A"), new Animal("A"), new Animal("A"), 
    new Animal("B"), new Animal("B"), new Animal("C"));

The following output (unordered):

[A, B, A]

Answer 3

I don't know whether this could be considered a simplification, but here's one way to do it with streams:

return animals.stream()
        .collect(Collectors.groupingBy(Animal::getName))
        .values()
        .stream()
        .flatMap(group -> group.stream().skip(1))
        .map(Animal::getName)
        .collect(Collectors.toList());

Answer 4

Do not re-invent the wheel and use libraryies like commns-collection.substract()

// I have not tested the code, but I think you get the idea
Set<> unique = new HashSet(animals)
Collection<> dublicates = CollectionUtil.subtract(animals, unique)

Answer 5

there is always a way — still not simple, but much shorter:

List<Animal> duplicates = animals.stream()
  .collect( Collectors.collectingAndThen( Collectors.groupingBy( Animal::getName ),
    map -> {
      map.entrySet().removeIf( e -> e.getValue().size() < 2 );
      return( map.values().stream().flatMap( List::stream ).collect( Collectors.toList() ) );
    } ) );

Answer 6

The question is "how to do it with Streams?" but I consider that a good answer is "Streams are not always a simplification".

The problem of detecting duplicates is classic and there is a canonic way of doing it :

• Sort the collection.
• Iterate on it.
• Every element that equals its predecessor is a duplicate.

So, although it does not really answer the question, the right way of doing it is imho like this :

List<Animal> animals =
        Arrays.asList(
                new Animal("Alice"), 
                new Animal("Alice"), 
                new Animal("Alice"), 
                new Animal("Bob"),
                new Animal("Charlie"), 
                new Animal("Bob"));

List<Animal> duplicates = new ArrayList<>();

animals.sort(Comparator.comparing(Animal::getName));
for (int i = 1; i < animals.size(); i++) {
    Animal current = animals.get(i);
    if (animals.get(i - 1).getName().equals(current.getName())
            //Bonus : Also compare to the previous-previous in order to avoid multiple duplicates
            && (i < 2 || !animals.get(i - 2).getName().equals(current.getName()))) {
        duplicates.add(current);
    }
}

duplicates.forEach(a -> System.out.println(a.getName()));

Output:

Bob
Alice

It might not be easier to understand (depends on your experience) but is by far cleaner than creating an intermediate HashMap for the sake a using a Stream.

So, either do it like this (for performance) or do it as you already do (for readability).