Filter Java 8 Stream Strings by Length
Can a stream be used to check which two consecutive strings have the greatest sum of their length?
For example, I have 5 valid usernames and I only have to print Johnny
and Frank
:
String line = "James Jack Johnny Frank Bob";
String regexForValidUserName = "[a-zA-Z][a-zA-Z0-9_]{2,24}";
Pattern patternForUserName = Pattern.compile(regexForValidUserName);
Matcher matcherForUserName = patternForUserName.matcher(line);
List<String> listOfUsers = new LinkedList<>();
if (matcherForUserName.find()) {
listOfUsers.add(matcherForUserName.group());
}
listOfUsers.stream().map((a,b,c,d) -> a.length + b.length > c.length + d.length).foreach(System.out::println);
source to share
Here's a thread based solution. I'm not sure if I will use it in a for loop, but it does what you want with streams and is relatively easy to understand.
As I said in the comment, the trick is to have a stream of name pairs, not a stream of names.
List<String> userNames = Arrays.asList("James", "Jack", "Johnny", "Frank", "Bob");
List<String> longestPair =
IntStream.range(0, userNames.size() - 1)
.mapToObj(i -> Arrays.asList(userNames.get(i), userNames.get(i + 1)))
.max(Comparator.comparing(pair -> pair.get(0).length() + pair.get(1).length()))
.orElseThrow(() -> new IllegalStateException("the list should have at least 2 elements"));
System.out.println("longestPair = " + longestPair);
Please don't do this with LinkedList, because random access to a linked list is very inefficient. But you will never use a linked list anyway. Prefer ArrayList. This is more efficient for almost all realistic use cases.
You can also create a Pair class to make this more readable, instead of using a two-element list.
source to share
To make this work, you have to break the original fragment List<String>
into List<Pair>
, then the work is very simple. and chunk2
lazily as a stream of intermediate operations . eg:
Comparator<List<String>> length = comparing(pair -> {
return pair.get(0).length() + pair.get(1).length();
});
List<String> longest = chunk2(asList(line.split(" "))).max(length).get();
// ^--- ["Johnny", "Frank"]
import java.util.Spliterators.AbstractSpliterator;
import static java.util.stream.StreamSupport.stream;
import static java.util.Spliterator.*;
<T> Stream<List<T>> chunk2(List<T> list) {
int characteristics = ORDERED & SIZED & IMMUTABLE ;
int size = list.size() - 1;
return stream(new AbstractSpliterator<List<T>>(size, characteristics) {
private int pos;
@Override
public boolean tryAdvance(Consumer<? super List<T>> action) {
if (pos >= size) return false;
action.accept(list.subList(pos, ++pos + 1));
return true;
}
}, false);
}
source to share
Supporting this kind of operations for arbitrary streams (i.e., without a random access source that allows streaming by index) requires a custom collector:
String line = "James Jack Johnny Frank Bob";
String regexForValidUserName = "[a-zA-Z][a-zA-Z0-9_]{2,24}";
Pattern patternForUserName = Pattern.compile(regexForValidUserName);
Matcher matcherForUserName = patternForUserName.matcher(line);
Stream.Builder<String> builder = Stream.builder();
while(matcherForUserName.find()) builder.add(matcherForUserName.group());
class State {
String first, last, pair1, pair2;
int currLength=-1;
void add(String next) {
if(first==null) first=next;
else {
int nextLength=last.length()+next.length();
if(nextLength>currLength) {
pair1=last;
pair2=next;
currLength=nextLength;
}
}
last=next;
}
void merge(State next) {
add(next.first);
if(currLength<next.currLength) {
pair1=next.pair1;
pair2=next.pair2;
currLength=next.currLength;
}
last=next.last;
}
String[] pair() {
return currLength>=0? new String[]{ pair1, pair2 }: null;
}
}
String[] str = builder.build()
.collect(State::new, State::add, State::merge).pair();
System.out.println(Arrays.toString(str));
A Collector can have a mutable data structure that allows you to hold state like the previous item. To support the merging of two such state objects, you also need to keep track of the first element, since the last element of one object State
can pair with the first element of the next object State
, if one exists.
So, the loop will be easier to program, while the collector supports parallel processing, which pays off if you really have a lot of items.
The thread creation itself would be more direct if we were already Java 9s factory method :
String line = "James Jack Johnny Frank Bob";
String regexForValidUserName = "[a-zA-Z][a-zA-Z0-9_]{2,24}";
Pattern patternForUserName = Pattern.compile(regexForValidUserName);
String[] str = patternForUserName.matcher(line).results()
.map(MatchResult::group)
.collect(State::new, State::add, State::merge).pair();
System.out.println(Arrays.toString(str));
(The class State
would not change)
source to share
You can iterate through the stream with using a .forEach
custom mutable data structure to keep track of the longest pairs, for example:
class Tracker {
List<String> pairs = Collections.emptyList();
String prev = "";
int longest = 0;
public void check(String name) {
int length = prev.length() + name.length();
if (length > longest) {
longest = length;
pairs = Arrays.asList(prev, name);
}
prev = name;
}
public List<String> pairs() {
return pairs;
}
}
String line = "James Jack Johnny Frank Bob";
Tracker tracker = new Tracker();
Stream.of(line.split(" ")).forEach(tracker::check);
System.out.println(tracker.pairs());
Will open [Johnny, Frank]
.
source to share