Au fait, il n'y a pas d'édition de base
Java est que Utiliser des classes et des méthodes Si vous pouvez utiliser l'instruction if et for statement, ce sera d'une manière ou d'une autre.
Pour les personnes
Il n'y a pas beaucoup d'amélioration des performances car j'ai changé le style d'écriture (bien qu'il y en ait) Si vous gonflez {} comme un renard, vous voyez. C'est dur à voir
Difficile de voir.java
package dummy;
import java.util.ArrayList;
import java.util.List;
/**
*Échantillon difficile à voir
*
* @auteur moi
*
*/
public class Dummy {
/**
*fonction principale
*
* @argument param args
*/
public static void main(String[] args) {
run();
}
/**
*Traitement difficile à voir
*/
public static void run() {
//Déclarer une liste de chaînes
List<String> strList = new ArrayList<String>();
//Mettre un en désordre
for (int i = 0; i < 100; i++) {
strList.add("a");
}
//À propos des chaînes de caractères
for (String str : strList) {
if (str.isEmpty()) {
//Caractères vides
System.out.println("Je ne dis pas oui");
} else if (str.equals("a")) {
// a
System.out.println("C'est un");
} else {
//Autre
for (int l = 0; l < 100; l++) {
System.out.println(str);
}
}
}
}
}
Hmm, c'est difficile à voir Nettoyons ça
Intelligent.java
package dummy;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;
/**
*Échantillon difficile à voir<br>
* ->Modifié
* <p>
*
* @auteur moi
* @auteur
*
*/
public class Dummy {
/**
*fonction principale
*
* @argument param args
*/
public static void main(String[] args) {
run();
}
/**
*Traitement difficile à voir
* ->Modification
*/
public static void run() {
//Déclarer une liste de chaînes
List<String> strList = new ArrayList<String>();
//Mettre un en désordre
IntStream.range(0, 100).forEach(i -> strList.add("a"));
//À propos des chaînes de caractères
strList.forEach(Dummy::conditions);
}
/**
*La sortie change en fonction de la valeur d'entrée<br>
*État de la branche
* <p>
* <ul>
* <li>Caractères vides-> "Je ne dis pas oui"
* <li>"a" -> "C'est un"
* <li>Autre->Sortie de la valeur d'entrée telle quelle
* </ul>
* @param str Chaîne de caractères d'entrée
*/
public static void conditions(String str) {
if (str.isEmpty())
System.out.println("Je ne dis pas oui");
else if (str.equals("a"))
System.out.println("C'est un");
else
IntStream.range(0, 100).forEach(i -> {System.out.println(str);});
}
}
Qu'est ce qui a changé ・ Pour la déclaration qui spécifie le nombre de fois est mis sur une ligne ・ Puisqu'il est difficile de voir s'il est enveloppé dans une grande déclaration for, il est sur une seule ligne ・ La branche conditionnelle à l'intérieur est changée en une autre méthode
Eh bien, cela n'a pas de sens car c'est une branche avec du code mort. Si vous n'avez pas à vous connecter si des instructions comme celle-ci, vous n'avez besoin que d'une seule condition C'est comme ça?
sensationnel.java
package dummy;
import java.util.Arrays;
import java.util.List;
public class Dummy {
public static void main(String[] args) {
run("a");
}
/**
*Pour la chaîne de caractères saisie<br>
* <p>
* a,b,c,d,e,f,Si cela correspond à la lettre g<br>
*Sortie avec un wahoi ajouté à l'arrière
*
* @condition de recherche param str
*/
public static void run(String str) {
List<String> list = Arrays.asList("a", "b", "c", "d", "e", "f", "g");
list.stream().filter(v -> v.equals(str)).map(v -> v + "sensationnel").forEach(Dummy::echo);
}
/**
*Traitement pour sortir la valeur d'entrée vers la console
*
* @param obj Valeur d'entrée
*/
public static void echo(Object obj) {
System.out.println(obj);
}
}
Le supérieur est omis car c'est un obstacle. Il n'est pas nécessaire de séparer la fonction d'écho,
C’est un flux mortel.
`flux pour la source cible 0 ou plusieurs opérations intermédiaires + 1 opération de terminaison
C'est un gars formidable à faire
kwsk
Ça y est.java
package mk42;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;
public class Stream {
public static void main(String[] args) {
run();
}
public static void run() {
// instance Initializer
List<String> list = new ArrayList<String>() {
{
//C'est facile de voir si tu n'ose pas casser
IntStream.range(0, 100).forEach(i -> {add("a");});
}
};
/**Déclarer utiliser stream pour une source appelée liste*/
list.stream();
/**Fonctionnement intermédiaire(Tu peux le faire) */
//Pour l'élément"a"Ajouter(Abréviation de valeur, v ou variable est attachée, tout k)
list.stream().map(v -> v + "a");
//Filtrer les éléments et collecter uniquement ceux qui remplissent les conditions
list.stream().filter(v -> v.equals("a"));
//Un double fonctionnement intermédiaire est également possible
list.stream().filter(v -> v.equals("a")).map(v -> v + "a");
/**Opération de terminaison*/
list.stream().forEach(v -> {
//Traitement dans l'instruction for
});
/**Forme définitive*/
list.stream().filter(v -> v.equals("a")).map(v -> v + "a").forEach(v -> {
System.out.println(v);
});
}
}
Hoisa
En d'autres termes.java
list.stream().filter(v -> v.equals("a")).map(v -> v + "a").forEach(v -> {
System.out.println(v);
});
ʻUtiliser le flux dans un tableau → collecter ceux dont les éléments sont égaux à "a" → ajouter "a" aux éléments collectés → les sysouter` C'est. Ceci est une ligne.
Veuillez passer par les types d'opération intermédiaire et d'opération de terminaison Référence officielle du flux
La plupart des opérations intermédiaires sont basiques et pratiques
・ S'il n'y a qu'une seule condition, elle remplacera l'instruction if filter
・ Carte des éléments de manipulation (ajout)
«For Each» est pratique pour les opérations de terminaison.
L'initialiseur d'instance est complètement cool. S'il vous plaît, regardez bien.
Au fait, si vous n'utilisez que pour Each sans opération intermédiaire, vous pouvez passer sans flux
Approprié ★.java
list.forEach( v -> {sysout(v);};
Comme
Il s'appelait un type lambda, je l'aime car c'est facile à comprendre Puisque v est une variable qui est attachée de manière appropriée, cela peut être n'importe quoi. C'est une abréviation pour valeur, mais j'utilise v parce que c'est cool. stream amusant
Non seulement c'est amusant, mais c'est généralement plus lisible, donc C'est autre chose que ce que vous pensez que l'instruction for est plus facile à lire Utilisons stream!
Dans l'ensemble, si le branchement conditionnel est compliqué, il est difficile à gérer avec une seule ligne dans le flux, ou il est difficile à voir. Vaut-il mieux utiliser la condition de branchement comme méthode séparée ou utiliser l'instruction for docilement?
J'aime le nom stream Beau
c'est tout
Recommended Posts