-
Formato básico: (lista de parâmetros) -> {bloco de código de execução}
-
Três elementos compõem uma expressão Lambda: parâmetros formais, setas e blocos de código
-
Pré-requisitos para usar expressões Lambda: 1) Existe uma interface; 2) Existe apenas um método abstrato na interface
Lambda modo conciso:
-
O tipo de parâmetro pode ser omitido e apenas um tipo de parâmetro não pode ser omitido no caso de vários parâmetros
-
Existe apenas um parâmetro, os parênteses podem ser omitidos
-
Se houver apenas um bloco de código, chaves e ponto e vírgula podem ser omitidos. Se houver retorno, o retorno também deve ser omitido
Considerações sobre a expressão lambda:
-
Existe uma interface e existe apenas um método abstrato na interface
-
O uso do Lambda deve ter um contexto para deduzir a interface correspondente do Lambda
A diferença entre Lambda e classe interna anônima:
-
O Lambda só pode se envolver em interfaces
-
O Lambda não pode lidar com o caso em que há dois métodos na interface
-
O princípio de implementação é diferente. Após a compilação da classe interna anônima, um arquivo de bytecode .class separado será gerado.
-
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程已经启动");
}
}).start();
//使用lambda表达式书写
new Thread(() -> {
System.out.println("启动一个新的线程");
}).start();
}Criar uma transmissão
Coleção de coluna única: coleção object.stream()
List<Author> author =new ArrayList<>();
author.stream()Arrays: Arrays.stream(array) ou use Stream.of() para criar
Integer [] arr={1,2,3,4,5}
Stream<Integer> stream = Arrarys.stream(arr);
Stream<Integer> stream1=Stream.of(arr)
Coleção de duas colunas: criar depois de converter em uma coleção de coluna única
HashMap<String, Integer> map = new HashMap<>();
map.put("林聪",32);
map.put("图图",32);
map.put("郭大侠",23);
Stream<Map.Entry<String, Integer>> stream = map.entrySet().stream();Existem 4 maneiras de percorrer a coleção de mapas:
HashMap<String, Integer> map = new HashMap<>();
map.put("林聪",32);
map.put("图图",32);
map.put("郭大侠",23);
//方法1：通过获取key的set集合遍历key
Set<String> keySet = map.keySet();
for (String s : keySet) {
System.out.println(s+map.get(s));
}
//方法2：通过拿到netrySet直接进行遍历
for (Map.Entry<String, Integer> entry : map.entrySet()) {
}
//方法3：通过拿到entrySet使用Iterator进行遍历
Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()){
Map.Entry<String, Integer> next = iterator.next();
}
//方法4:通过map获取所有的值进行遍历
Collection<Integer> values = map.values();
for (Integer value : values) {
}Filtro para operação intermediária de fluxo
List<Author> authors = getAuthors();
//打印所有作家名称大于2个字符的名称
authors.stream().filter(author -> author.getName().length()>2).forEach(author -> System.out.println(author.getName()));
//原始方式:
List<Author> authors = getAuthors();
//打印所有作家名称大于2个字符的名称
authors.stream().filter(new Predicate<Author>() {
@Override
public boolean test(Author author) {
return author.getName().length() > 2;
}
}).forEach(new Consumer<Author>() {
@Override
public void accept(Author author) {
System.out.println(author.getName());
}
});
//使用熟练后可以直接装成lambda表达式
Mapa da operação intermediária do Stream
A operação de mapa pode calcular ou converter o fluxo
//只打印作者的姓名，lambda方式
authors.stream().map(Author::getName).forEach(System.out::println);
//匿名内部类方式：
authors.stream().map(new Function<Author, String>() {
@Override
public String apply(Author author) {
return author.getName();
}
}).forEach(System.out::println);
//对所有的年龄加10
authors.stream().map(Author::getAge).map(age->age+10).forEach(System.out::println);
Operação intermediária distinta da Stream
distinto pode remover dados de fluxo duplicados
Nota: O método distinto depende do método equals de Object para determinar se é o mesmo objeto. Portanto, você precisa prestar atenção ao reescrever o método equals.
Pontuação (classificação) da operação intermediária do Stream
Se você usar escorted com parâmetros vazios, precisará reescrever a interface Compare para os objetos no fluxo
//lambda方式
authors.stream().sorted((o1, o2) -> o1.getAge()-o2.getAge()).forEach(author -> System.out.println(author.getAge()));
//匿名内部类方式
authors.stream().sorted(new Comparator<Author>() {
@Override
public int compare(Author o1, Author o2) {
return o1.getAge()-o2.getAge();
}
}).forEach(author -> System.out.println(author.getAge()));limit(n) do operador intermediário do Stream
Definir o comprimento máximo do fluxo será descartado.
//截取前10个
authors.stream().limit(10).forEach(System.out::println);
Skip(n) do operador intermediário do Stream
Pule os primeiros N elementos no fluxo
//忽略流中第一个元素
authors.stream().skip(1).forEach(System.out::println);operador intermediário flatMap do Stream
map só pode converter um objeto em outro objeto como um elemento no fluxo, enquanto flatMap pode converter um objeto em vários objetos como elementos no fluxo, obter a propriedade de um List<Book> no objeto e convertê-lo em um fluxo.
//匿名内部类实现
authors.stream().flatMap(new Function<Author, Stream<? extends Book>>() {
@Override
public Stream<? extends Book> apply(Author author) {
return author.getBooks().stream();
}
}).forEach(book -> System.out.println(book.getName()));
//lambda方式实现
authors.stream().flatMap(author -> author.getBooks().stream()).forEach(book -> System.out.println(book.getName()));
//打印现有数据的全部分类，要求对分类进行去重
//使用lambda方式实现
authors.stream().flatMap(author -> author.getBooks()
.stream()).flatMap(book -> Arrays.stream(book.getCategory().split("、"))).distinct()
.forEach(System.out::println);
//使用匿名内部类实现
authors.stream().flatMap(new Function<Author, Stream<? extends Book>>() {
@Override
public Stream<? extends Book> apply(Author author) {
return author.getBooks()
.stream();
}
}).flatMap(new Function<Book, Stream<? extends String>>() {
@Override
public Stream<? extends String> apply(Book book) {
return Arrays.stream(book.getCategory().split("、"));
}
}).distinct()
.forEach(System.out::println);
Operador de terminal de fluxo paraEarch()
//打印作者名称
authors.forEach(author -> System.out.println(author.getName()));
//匿名类实现
authors.forEach(new Consumer<Author>() {
@Override
public void accept(Author author) {
System.out.println(author.getName());
}
});Contagem do operador do terminal de streaming ()
Obter o número de streams
long count = authors.stream().flatMap(author -> author.getBooks().stream()).distinct().count();
System.out.println(count);## Operadores de terminal de stream max() e min()
Obtenha o máximo valor no fluxo
//获取最大值
Optional<Integer> max = authors.stream().flatMap(author -> author.getBooks().stream()).map(Book::getScore)
.max(Comparator.comparingInt(o -> o));
System.out.println(max.get());collect() do operador do terminal Stream
Converter o fluxo atual em uma coleção
//获取所有存放作者名字的合集
List<String> list = authors.stream().map(Author::getName).collect(Collectors.toList());
list.forEach(System.out::println);
//获取所有书名的set
Set<String> set = authors.stream().flatMap(author -> author.getBooks().stream()).map(Book::getName).collect(Collectors.toSet());
set.forEach(System.out::println);
//获取键值为作者名，值为书名的map集合，使用匿名内部类实现
Map<String, List<Book>> listMap = authors.stream().collect(Collectors.toMap(new Function<Author, String>() {
@Override
public String apply(Author author) {
return author.getName();
}
}, new Function<Author, List<Book>>() {
@Override
public List<Book> apply(Author author) {
return author.getBooks();
}
}));
listMap.forEach((s, books) -> {System.out.println(s);
books.forEach(book -> System.out.println(book.getName()));
});
//使用lambda表达式实现
Map<String, List<Book>> listMap = authors.stream().collect(Collectors.toMap(Author::getName, Author::getBooks));
listMap.forEach((s, books) -> {System.out.println(s);
books.forEach(book -> System.out.println(book.getName()));
});