Shulou(Shulou.com)06/03 Report--

This article introduces the knowledge of "what are the common pits in Java Stream streaming programming". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

1. What is Stream?

Stream is a new interface to Java8 that allows data collections to be processed declaratively. Stream is not a collection type that does not hold data, but can be thought of as a high-level iterator (Iterator) that traverses the data collection.

Stream operations can be superimposed step by step like Builder to form a pipeline. The pipeline is generally composed of data source + zero or multiple intermediate operations + one terminal operation. Intermediate operations can convert the flow into another stream, such as using filter to filter elements and map mapping to extract values.

Stream and lambda expressions are inextricably linked. This article defaults to you that you have mastered the basics of lambda.

2. Characteristics of Stream

It can only be traversed (consumed) once. The Stream instance can only be traversed once, and the traversal ends after the terminal operation. Traversing again requires the instance to be regenerated, which is similar to the Iterator iterator.

Protect the data source. Changes to any element in the Stream will not cause the data source to be modified, such as filtering and deleting an element in the stream, which can still be obtained by traversing the data source again.

Lazy. Filter and map operations are concatenated to form a series of intermediate operations that can never be performed without a terminal operation (such as collect).

3. The method of creating Stream instance

(1) create a Stream instance with the specified value

/ / static method Stream strStream = Stream.of ("hello", "java8", "stream") where of is Stream; / / or use the basic type stream IntStream intStream = IntStream.of (1, 2, 3); copy the code

(2) use collections to create Stream instances (commonly used)

/ / use the guava library to initialize an immutable list object ImmutableList integers = ImmutableList.of (1,2,3); / / the List interface inherits the Collection interface, and java8 adds the stream method Stream stream = integers.stream () to the Collection interface; copy the code

(3) use arrays to create Stream instances

/ / initialize an array Integer [] array = {1,2,3}; / / use Arrays's static method stream Stream stream = Arrays.stream (array); copy the code

(4) use generator to create Stream instance

/ / randomly generate 100integers Random random = new Random (); / / add limit or Stream stream = Stream.generate (random::nextInt) .limit (100); copy the code

(5) use iterator to create Stream instance

/ / generate 100 odd numbers, plus limit, otherwise Stream stream = Stream.iterate (1, n-> n + 2) .limit (100); stream.forEach (System.out::println); copy the code

(6) use IO API to create Stream instance

/ / get the file information under the specified path. The list method returns Stream type Stream pathStream = Files.list (Paths.get ("/")); copy code 4. Stream common operations

Many operations are defined in the Stream interface, which can be roughly divided into two categories, one is intermediate operations, and the other is terminal operations.

(1) intermediate operation

The intermediate operation returns another stream, and multiple intermediate operations can be joined together to form a query.

The intermediate operation is lazy, and if there is no terminal operation on the stream, the intermediate operation will not do any processing.

Here are some common intermediate operations:

Map operation

Map maps each element in the input stream to another element to form the output stream.

/ / initialize an immutable string List words = ImmutableList.of ("hello", "java8", "stream"); / / calculate the length of each word in the list List list = words.stream () .map (String::length) .length (Collectors.toList ()); / / output: 556 list.forEach (System.out::println); copy the code

FlatMap operation

List list1 = words.stream () .map (word-> word.split ("-")) .copy (Collectors.toList ()); / / output: [Ljava.lang.String;@59f95c5d, / / [Ljava.lang.String;@5ccd43c2 list1.forEach (System.out::println); copy the code

Where? You expect List, but return List, because the split method returns String []

At this point you can think of converting the array to stream, so you have a second version.

Stream arrStream = words.stream () .map (word-> word.split ("-")) .map (Arrays::stream); / / output: java.util.stream.ReferencePipeline$Head@2c13da15, / / java.util.stream.ReferencePipeline$Head@77556fd arrStream.forEach (System.out::println); copy the code

Still, this problem can be solved by using flatMap flat stream, where flatMap takes each element out of the stream and converts it into another output stream.

Stream strStream = words.stream () .map (word-> word.split ("-")) .flatMap (Arrays::stream) .map (); / / output: hello java8 stream strStream.forEach (System.out::println); copy the code

Filter operation

Filter receives the Predicate object, filters it by condition, and generates another stream of eligible elements.

/ filter out words with a length greater than 5 and print out List words = ImmutableList.of ("hello", "java8", "hello", "stream"); words.stream () .filter (word-> word.length () > 5) .words (Collectors.toList ()) .forEach (System.out::println); / / output: stream copy code

(2) Terminal operation

The terminal operation converts the stream flow into a specific return value, such as List,Integer, etc. Common terminal operations are: foreach, min, max, count and so on.

Foreach is very common. Here is an example of max.

/ / find the maximum value List integers = Arrays.asList (6,20,19); integers.stream () .max (Integer::compareTo) .ifPresent (System.out::println); / / output: 20 copy code 5. Practice: using Stream to ReFactor Old Code

Suppose there is a need to filter out students who are older than 20 years old and whose scores are greater than 95.

Write in a for loop:

Private List getStudents () {Student S1 = new Student ("xiaoli", 18,95); Student S2 = new Student ("xiaoming", 21,100); Student S3 = new Student ("xiaohua", 19,98); List studentList = Lists.newArrayList (); studentList.add (S1); studentList.add (S2); studentList.add (S2); return studentList;} public void refactorBefore () {List studentList = getStudents () / / use temporary list List resultList = Lists.newArrayList (); for (Student s: studentList) {if (s.getAge () > 20 & & s.getScore () > 95) {resultList.add (s);} / output: Student {name=xiaoming, age=21, score=100} resultList.forEach (System.out::println);} copy the code

Using the for loop initializes a temporary list to hold the final result, which is not elegant and concise as a whole.

After refactoring with lambda and stream:

Public void refactorAfter () {List studentLists = getStudents (); / / output: Student {name=xiaoming, age=21, score=100} studentLists.stream (). Filter (this::filterStudents) .forEach (System.out::println);} private boolean filterStudents (Student student) {/ / filter out return student.getAge () > 20 & & student.getScore () > 95;} copy codes for students older than 20 years old and with scores greater than 95.

It is convenient to use filter and method references to make the code clear without declaring a temporary list.

6. Common misunderstandings in using Stream

(1) misunderstanding 1: re-consumption of stream objects

Once a stream object is consumed, it cannot be consumed again.

List strings = Arrays.asList ("hello", "java8", "stream"); Stream stream = strings.stream (); stream.forEach (System.out::println); / / ok stream.forEach (System.out::println); / / IllegalStateException copy code

An error is reported after the above code is executed:

Java.lang.IllegalStateException: stream has already been operated upon or closed

(2) misunderstanding 2: modifying data sources

An error was reported when an attempt was made to add a new string object during the stream operation:

List strings = Arrays.asList ("hello", "java8", "stream"); / / expect: HELLO JAVA8 STREAM WORLD, but throw UnsupportedOperationException strings.stream () .map (s-> {strings.add ("world"); return s.toUpperCase ();}) .forEach (System.out::println); copy code

Note: do not modify the data source during the operation flow.

This is the end of the content of "what are the common pits in Java Stream streaming programming". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.