Resumo da compreensão de seta de expressões Java Lambda
Diretório de artigos
O seguinte é uma expressão lambda. Se você está confuso, pode aprender aqui.
//示例1：lambda表达式排序
String[] players = {"11", "22", "99", "88", "55"};
Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2)));
//示例2：系统源码中的一段示例：
Executor mExecutor = XXX;
mExecutor.execute(() -> mSoftApListener.onConnectedClientsChanged());
//示例3：系统源码中的一段示例：
IWifiIface iface = XXX；
iface.getName((WifiStatus status, String name) -> {
if (status.code == WifiStatusCode.SUCCESS) {
nameResp.value = name;
} else {
Log.e(TAG, "Error on getName: " + statusString(status));
}
});
Como você pode ver no código acima, a expressão lambda é para escrever uma grande string de códigos nos parâmetros do método.
Já vi lambda antes, mas às vezes acho que os métodos no código-fonte do sistema são um pouco confusos, então é necessário resumir.
Geralmente, não uso expressões lambda ao escrever código. Embora o código seja conciso, parece um pouco abstrato.
E para escrever uma expressão Lambda, você deve estar muito familiarizado com o objeto de parâmetro, como quantos parâmetros de retorno de chamada no método de implementação e se um valor de retorno é necessário.
Nem todos os métodos podem ser escritos como expressões Lambda,
a condição necessária é que os parâmetros do método tenham objetos, e quando o objeto é novo, um método dentro dele deve ser implementado.
O entendimento simples da expressão Lambda é omitir o novo processo e o método de retorno de chamada.
Seta da expressão lambda -> o entendimento é:
a frente da seta é o parâmetro do método de retorno de chamada
e a parte de trás da seta é o valor que o método de retorno de chamada precisa retornar ou a operação que precisa ser executada.
1. Pontos básicos de conhecimento do Lambda simples:
1. 无参数,返回值为 5
() -> 5
方法参数对象的实现方法无回调参数，并且需要返回一个int值。
2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
方法参数对象的实现方法有一个回调参数，并且需要返回回调参数的两倍。
3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y
方法参数对象的实现方法有两个回调参数，并且需要返回回调参数的x-y。
// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y
方法参数对象的实现方法有两个回调int（可省略）参数，并且需要返回回调参数的x-y。
比如示例1 的代码。就是基于这个知识点。
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)
方法参数对象的实现方法有一个回调String（可省略）参数，无需返回值，可执行其他操作比如加个打印。
实现方法无返回值时，可以使用{}并且在里面执行多条语句，比如示例3 的代码，就是基于这个知识点。
O acima é o conhecimento básico das expressões Lambda. Não importa se você não entende. Você pode entender esses pontos de conhecimento por meio dos exemplos a seguir.
Na verdade, existem quatro casos, se há parâmetros no método de retorno de chamada do objeto de parâmetro e se o método de retorno de chamada tem um valor de retorno.
A frente da seta é para os parâmetros no método de retorno de chamada do objeto de parâmetro e a parte de trás da seta é para o valor de retorno do método de retorno de chamada.
2. Exemplo de expressão Lambda
1. O método de implementação não tem parâmetros e nenhum valor de retorno
Thread comum Thread executa comparação de escrita de expressão Lambda:
//普通的Java表达式：
new Thread(new Runnable() {
@Override
public void run() {
Log.i("TAG", "test Thread");
}
}).start();
//Lambda表达式，打印一个日志
new Thread(()->Log.i("TAG", "test Thread")).start();
Aqui você pode ver que a expressão Lambda omite a criação da classe anônima no objeto de parâmetro e o método de retorno de chamada nele.
Olhar o código dessa forma é bem mais simples,
na verdade é mais razoável pensar nessa forma de escrever,
pois nós chamadores não precisamos saber a classe anônima e o método callback na hora da leitura,
só precisamos saber que existe é um retorno de chamada e precisamos fazer algo nele.
2. O método de implementação possui parâmetros e nenhum valor de retorno
Comparação de gravação de expressão Lambda de evento de clique de controle do Android:
TextView textView = new TextView(this);
//普通的Java表达式：
textView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Log.i("TAG", "test");
}
});
//Lambda表达式，打印一个日志
textView.setOnClickListener((View view) -> Log.i("TAG", "test")); //这里也可以用{}执行多个命令
//Lambda表达式，执行多行命令
textView.setOnClickListener(view -> {
Log.i("TAG", "test");
Log.i("TAG", "test2");
});
Vale a pena notar que os parâmetros aqui podem definir diretamente o nome do parâmetro ou adicionar o tipo de parâmetro.
View view ->... e view ->... têm o mesmo significado.
Quando há vários parâmetros, adicionar um tipo de parâmetro pode distingui-los facilmente.
3. O método de implementação possui parâmetros e um valor de retorno
Classifique os dados da matriz de pequeno a grande.
List<String> players = {"11", "22", "99", "88", "55"};
// 1.1 使用匿名内部类根据 name 排序 players
Comparator<String> comparatorName = new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return (s1.compareTo(s2));
}
};
Arrays.sort(players, comparatorName);
// 1.2 使用 lambda expression 排序 players
comparatorName = (String s1, String s2) -> (s1.compareTo(s2));
//如果需要执行多个语句并且需要返回值，可以用{}并在里面进行return。
comparatorName = (String s1, String s2) -> {
Log.i("TAG", "test compareTo");
return s1.compareTo(s2);
};
Arrays.sort(players, comparatorName);
// 1.3 也可以采用如下形式:
Arrays.sort(players, (s1, s2) -> (s1.compareTo(s2)));
// 1.4 也可以采用如下形式:
Arrays.sort(players, String::compareTo);//这个特殊写法记忆一下就行
Aqui você pode ver que o monitoramento de vários parâmetros deve ser escrito em () na frente dele. Quando um parâmetro não declara um tipo, () não pode ser usado na frente da seta.
Depois de aprender o exemplo de código acima e ponderá-lo lentamente, o -> da expressão Lambda básica não apresenta dislexia.
Vamos finalmente resumir o entendimento da flecha Lambda:
1、Lambda表达式必定有方法的参数是一个对象的情况，并且new这个对象有必须实现的方法。
2、Lambda表达式就是省略了参数对象中的匿名类的创建和里面的回调方法名，方法参数类型也可以省略；
3、Lambda表达式箭头->前面是回调方法的参数，箭头->后面是回调需要返回的值或者需要是回调方法需要执行的代码；
4、方法参数对象回调方法，如果回调方法没有参数就用()写在箭头->前面
如果回调方法的参数有一个或者多个就在()里面，参数类型可写可不写；
需要注意的是要么全部不要参数类型，要么全部带参数类型，否则会报错；
5、方法参数对象回调方法，如果直接返回一个值或者执行一条代码写在箭头->后面即可
如果回调方法中需要执多行代码，可以把代码写在{}里面。
O acima é um resumo do uso geral deste Lambda.
Dê uma olhada no resumo acima. Depois disso, a situação em que um método tem várias setas -> não será confusa; apenas
analise o relacionamento dentro lentamente. Em situações reais, haverá objetos de parâmetro nos parâmetros dos métodos
e Existem expressões Lambda no código executado pelo método de retorno de chamada do objeto de parâmetro
ou existem vários parâmetros e não há problema na análise passo a passo.
Mas também existem alguns casos especiais, que precisam ser simplesmente memorizados.
outro
1. Liste a impressão de dados na expressão Lambda
String[] atp = {"Rafael Nadal", "Novak Djokovic", "Stanislas Wawrinka"};
List<String> players = Arrays.asList(atp);
// 以前的循环方式
for (String player : players) {
System.out.print(player + "; ");
}
// 使用 lambda 表达式以及函数操作(functional operation)
players.forEach((player) -> System.out.print(player + "; "));
// 在 Java 8 中使用双冒号操作符(double colon operator)
players.forEach(System.out::println);
O sistema basicamente não é usado no Android, então isso é inútil.
2. Se a expressão Lambda não precisar retornar um valor, mas o código retornar diretamente um valor (por exemplo: ->5), o que acontecerá?
这个是会编译报错，就是不允许这样写，
要么你写成->{} //执行空操作
要么你写成->method() //执行一个方法，不管这个方法有没有返回值都可以正常编译