java-stream

So I have some code using Java 8 streams, and it works. It does exactly what I need it to do, and it's legible (a rarity for functional programming). Towards the end of a subroutine, the code runs over a List of a custom pair type: // All names Hungarian-Notation-ized for SO reading class AFooAndABarWalkIntoABar { public int foo_int; public BarClass bar_object; .... } List<AFooAndABarWalkIntoABar> results = ....; The data here must be passed into other parts of the program as arrays, so they get copied out: // extract either a foo or a bar from each "foo-and-bar" (fab) int[] foo_array =

I have the following code which could be much simpler using Java 8 stream API: List<List<String>> listOfListValues; public List<String> getAsFlattenedList() { List<String> listOfValues= new ArrayList<>(); for (List<String> value: listOfListValues) { listOfValues.add(String.valueOf(value)); } return listOfValues; } I searched for a solution on SO and found this: listOfListValues.stream() .flatMap(List::stream) .collect(Collectors.toList()); But this doesn't do the same what I want. You require only a "simple" map here: List<List<String>> listOfListValues; public List<String> getAsFlattenedList(

Is there any reason to specifically insert a stream/parallel stream before a forEach call when using a Collection? Example: Collection<Object> foo; foo.forEach(); // Goes through every item in foo foo.stream().forEach(); // Does stream make a difference here foo.parallelStream().forEach(); // Does this make a difference here? Thanks foo.forEach(); // Goes through every item in foo foo.stream().forEach(); // Does stream make a difference here It is useless unless you need stream operations like map or filter. foo.parallelStream().forEach(); This spawns a new thread for every logical core of

I have a List and a Map as below: public class student { private String name; private String age; private String id; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAge() { return age; } public void setAge(String age) { this.age = age; } public String getId() { return id; } public void setId(String id) { this.id = id; } student(String id,String name,String age) { } } List<student> stulist = Arrays.asList(new student("1", "vishwa",null), new student("3", "Ravi",null), new student("2", "Ram",null)); Map<String,String> newmap = new

From a java.util.function.BiFunction that maps a pair of Enum s into a value, I want to build a EnumMap that reflects that mapping. For instance, let E1 and E2 be enum types and T any given type: BiFunction<E1,E2, T> theBiFunction = //...anything EnumMap<E1,EnumMap<E2,T>> theMap = buildTheMap( // <-- this is where the magic happens E1.values(), E2.values(), theBiFunction); Given any pair of values of type E1 and E2 E1 e1 = //any valid value... E2 e2 = //any valid value.... both values below should be equal: T valueFromTheMaps = theMap.get(e1).get(e2); T valueFromTheFunction = theBiFunction

The below Stream expression works perfectly fine: Stream<String> s = Stream.of("yellow","blue", "white"); s.sorted(Comparator.reverseOrder()) .forEach(System.out::print);` //yellowwhiteblue Why doesn't the equivalent one with method references compile? s.sorted(Comparator::reverseOrder).forEach(System.out::print); The type Comparator does not define reverseOrder(String, String) that is applicable here A method reference is telling Java "treat this method as the implementation of a single-method interface"--that is, the method reference should have the signature int foo(String,String) and thus