Lambda expression
1. It is a simplification of the format of anonymous inner class objects
2.A new one is introduced in Java8 The operator "->" is called the arrow operator, or the lambda operator
3. Its function is to divide the front and rear parts into two parts
4. The left side: represents the Lambda expression. Parameter list (parameters of the abstract method defined in the interface)
5. The right side: represents the method body of the method, Lambda body
Writing syntax format
1 .There are no parameters and no return value
The left parenthesis cannot be omitted, and the right brace can be omitted or not
2 .There is one parameter, no return value
There are multiple parameters, no return value
The left bracket may or may not be omitted, the right brace may or may not be omitted
3. There are many methods that need to be rewritten in the interface. You need to add curly brackets to multiple sentences
Note Note: If there is only one statement in the lambda body, the braces can be omitted; if there is only one statement in the brace, and it is a return statement, the return keyword can be omitted
Functional interface
The premise for using Lambda expressions is that the interface must be a functional interface. If there is only one abstract method in the interface, then the interface is a functional interface. A common annotation is To check whether the current interface is a functional interface @FunctionalInterface, if it is not a functional interface, a compilation error will be reported
Function:
What I want to express is the content of a method , since the method is not in any class, all are called functions. What the interface actually wants to express is the declaration of a function. Next, the implementation class object of this interface is used to express the embodiment of a function
Consumption interface:
Abstract method: void accept(T t)
When a function can accept a data and process the data, after the processing is completed, there is no need To return any data, this function needs to be passed as data, so use the consumer interface
package cn.ujiuye.function; import java.util.function.Consumer; import cn.ujiuye.domin.Mobile; /** * @author liugang * 消费型接口方式 */ public class CustmoerTest { public static void main(String[] args) { Mobile m = new Mobile("华为",3000); //lambad表达式实现赋值 内部显然是对消费者接口的使用，故是对函数式接口编程的新东西 updateMobile(m, x -> x.setPrice(x.getPrice() + 1000 )); System.out.println(m); } //调用其使用的方法 private static void updateMobile(Mobile m, Consumer con) { for (int i = 0; i < 3; i++) { con.accept(m); } } }
Method reference
1. When writing a functional interface, the method Implementation has been implemented by some other object, so there is no need to call this implementation again in Lambda. Instead, you can use the directly defined method
2. Format
Function Functional interface: Name = Object name:: Method name
Functional interface: Name = Class name:: Static method name
3. Function
Treat what has been implemented as A piece of data, as a reference, is assigned to a reference of a functional interface. This reference can be used as the return value of a method, or as an implementation class object
StreamingAPI
In jdk1.8, a stream type is provided, which can easily operate the data in the container. Data filtering, output and other operations can be completed without manually defining a loop
Getting the type of Stream and common methods
Getting Collection:
Call the stream() method and call back the Stream object
Termination method: foreach count
Delay method: filter limit skip, etc.
package cn.ujiuye.stream; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.stream.Stream; /** * @author liugang * */ public class StreamApiDemo03Demo03 { public static void main(String[] args) { //定义一个集合,并获取stream类型的数据 List list = new ArrayList(); Collections.addAll(list, 12,32,-13,50,100); Stream stream = list.stream(); stream.forEach(x ->System.out.println(x - 100)); System.out.println(list.stream().count()); } } package cn.ujiuye.stream; import java.util.ArrayList; import java.util.Collections; import java.util.stream.Stream; /** * @author liugang * Stream中一些方法的使用 */ public class StreamApiDemo04 { public static void main(String[] args) { ArrayList list = new ArrayList<>(); Collections.addAll(list, -4,-12,-199,0,15,25,36,100); Stream stream = list.stream(); stream.filter(x -> x > 0) //过滤 .skip(1) //跳过 .limit(2) //限制 .sorted((x,y) -> -1) //排序 .forEach(System.out::println); } }
Exercise
There are two Arraylist collections that store the names of multiple members in the team. Use the Stream method to perform the following steps
1. The first team only needs the name of the member with a name of 3 characters
2. The first team only needs the first three people after screening
3. The second Teams only need people with the surname Zhang
4. After the second team is screened, the first two people are not required
5. Merge the two teams into one team
6. After the merger Person (custom type) objects of everyone in the team are stored in an ArrayList collection
Team 1: Miyamoto Musashi, Song Gongming, Su Youpeng, Stone Man, Shi Chuanxiang, Li Er, Zhuang Zi, Hong Qigong
Team 2: Pavarotti, Zhang Sanfeng, Zhao Weiwei, Zhang Zizhong, Borzhijin Temujin, Zhang Tianai, Zhang Cuihua
public class StreamApiTest { @SuppressWarnings("unused") public static void main(String[] args) { //创建集合 List list1 = new ArrayList(); List list2 = new ArrayList(); //把元素添加到集合中 Collections.addAll(list1, "宫本武藏","宋公明","苏有朋","石头人","时传祥","李耳","庄子","洪七公"); Collections.addAll(list2, "帕瓦罗蒂","张三疯","赵薇薇","张自忠","孛儿只斤铁木真","张天爱","张翠花"); //创建Stream对象 Stream stream1 = list1.stream(); Stream stream2 = list2.stream(); //创建筛选后的元素 Stream limit1 = stream1.filter(x -> x.length() == 3).limit(3); Stream limit2 = stream2.filter(x -> x.startsWith("张")).skip(2); //将两对的人合到同一个对里 Stream concat = Stream.concat(limit1, limit2); //定义一个集合用来存对象 List list = new ArrayList(); //想要的是一个Person对象的流 //Stream map = concat.map(x -> new Person(x); Stream map = concat.map(Person::new); //将流对象添加到集合中 map.forEach(list::add); System.out.println(list); } }
The above is the detailed content of Java8 new features lambda, functional interface, StreamingAPI. For more information, please follow other related articles on the PHP Chinese website!