Remove first N selectively from list using java 8

Question

See comments for question. Remove N elements selectively (Condition is that list element matches 'remove')

List<String> mylist = new ArrayList<>();
mylist.add("remove");
mylist.add("all");
mylist.add("remove");
mylist.add("remove");
mylist.add("good");
mylist.add("remove");

//  Remove first X "remove".
//  if X is 2, then result list should be "all, remove, good, remove"
//  Use java 8 features only, possibly single line code.
//  Please don't answer with looping, iterating, if conditions etc.
//  Answer should use JDK 8 new features.

If you really really want to do it in one line, IntStream.range(0,x).forEach(i -> mylist.remove("remove"));, but it's going to be unnecessarily O(N*x) and just a bad idea. — Misha
– Misha, Commented Jun 13, 2016 at 5:00
Or Collections.nCopies(x, "remove").forEach(mylist::remove);, but @Misha’s comment applies to this as well. — Holger
– Holger, Commented Jun 13, 2016 at 9:52
IntStream.range(0,x).forEach(i -> mylist.remove("remove")); Condition could be anything. ex: Remove if string contains "remov" — J J
– J J, Commented Jun 14, 2016 at 4:46
Sometimes a good old for-loop is much more readable than a stream. This seems like a homework assignment question, but IRL in such cases, for loops are better. — Somaiah Kumbera
– Somaiah Kumbera, Commented Jun 14, 2016 at 7:02

alexbt · Accepted Answer · 2016-06-13 03:27:07Z

6

How about this:

List<String> filter(List<String> mylist, int x){
    AtomicInteger index = new AtomicInteger(0);
    mylist.removeIf(p -> p.equals("remove") && index.getAndIncrement() < x);
    return myList;
}

With x=0, it prints:

[remove, all, remove, remove, good, remove]

With x=1, it prints:

[all, remove, remove, good, remove]

With x=2, it prints:

[all, remove, good, remove]

With x=3, it prints:

[all, good, remove]

edited Jun 13, 2016 at 3:27

answered Jun 13, 2016 at 3:08

alexbt

17.2k6 gold badges81 silver badges89 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Holger Over a year ago

A good example of how to replace a good old for loop with something more complicated, less readable and less efficient at the same time…

Holger Over a year ago

I think, “more complicated” and “less efficient” are categories, which work independently of familiarity.

J J Over a year ago

Works for me. Because I can add any condition (For ex: String contains instead of equals) I tried same approach with type "int" and didnt work. Got compiler error which stated that type int should be final. Still some fine tuning is needed. because removeIf will run on all elements in list unnecessarily. Ex: If list has 100 elements and I need to remove 2, then I guess it will go through all 100 elements unnecessarily.

Holger Over a year ago

@J J: that’s why I said “less efficient”. It processes all elements and repeatedly accesses a heap variable with thread synchronization semantics. While it is possible that the HotSpot optimizer sorts this out, it’s still inferior to a simple for loop wich uses a local variable and short circuits in the first place.

Seek Addo · Accepted Answer · 2016-06-13 16:31:55Z

1

try this:

List<String> mylist = new ArrayList<>();
    mylist.add("remove");
    mylist.add("all");
    mylist.add("remove");
    mylist.add("remove");
    mylist.add("good");
    mylist.add("remove");
    IntStream.range(0,2).forEach(a-> mylist.remove("remove"));

    System.out.println(mylist);

answered Jun 13, 2016 at 16:31

Seek Addo

1,9033 gold badges22 silver badges31 bronze badges

Comments

user140547 · Accepted Answer · 2016-06-14 09:28:15Z

1

A not entirely serious solution with streams which avoids state (updated):

        IntStream.range(0, mylist.size()) //1
             .mapToObj(x -> new AbstractMap.SimpleEntry<>(x, mylist.get(x))) //2
             .collect(Collectors.partitioningBy(x->x.getValue().equals("remove"))) //3
             .entrySet()
             .stream()
             .flatMap( x->x.getKey()?x.getValue().stream().skip(2):x.getValue().stream()) //4
             .sorted(Map.Entry.comparingByKey()) //5
             .map(Map.Entry::getValue) //6
             .collect(Collectors.toList());

An IntStream is used to preserve the original sorting of the list.
Tuples are created
The list is partitionized depending on if the string equals "remove"
only elements from the list containing "remove" are skipped
the original sorting if restored
finally, the orignal Strings are restored from the Tuple

Since the list is wrapped and unwrapped two times, partitionized and sorted, it is unfortunately not a very efficient solution. So probably, a simple for-loop is more efficient than a stream-based solution.

edited Jun 14, 2016 at 9:28

answered Jun 13, 2016 at 14:55

user140547

8,2404 gold badges36 silver badges85 bronze badges

2 Comments

Holger Over a year ago

Note that besides the construction of the entry instances, you can use Map.Entry instead of AbstractMap.SimpleEntry, e.g. .map(Map.Entry::getValue) which is shorter and generalizes the solution. Also, you can use .sorted(Map.Entry.comparingByKey()). Starting with Java 9, you will likely be able to use Map.entry(x, mylist.get(x)) instead of new AbstractMap.SimpleEntry<>(x, mylist.get(x)), assuming that all follow-up operation refer to Map.Entry instead of AbstractMap.SimpleEntry.

Holger Over a year ago

You got my +1 for the creativity. While this is obvious overkill for this specific task, it allows to learn a lot about the Stream API and how you could solve certain kind of problems.

Collectives™ on Stack Overflow

Remove first N selectively from list using java 8

3 Answers 3

4 Comments

Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

4 Comments

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related