Traitement des listes à comprendre avec des images --java8 stream / javaslang --bonus

Autre que lorsque vous voulez coupler ʻA et B, par exemple, si vous voulez connaître la taille de chaque espace dans la liste de ʻInteger, essayez zip en décalant la même liste de un. Il y a un moyen.

List<Integer> times = List.of(10, 15, 35, 60); //cette[15 - 10, 35 - 15, 60 - 35]Vouloir

times
    .zip(times.subSequence(1))
    .map(t -> t._2 - t._1);                    // [5, 20, 25]

Utilisez-vous «réduire» lorsque vous pensez au traitement depuis le début? Vous pourriez penser, mais si vous faites une image, c'est complètement différent. (Réduire ne calcule pas avec le voisin, mais calcule la somme (ou quelque chose) jusqu'à ce point un par un, de sorte que le calcul de l'écart ne peut pas être simple.)

Si vous faites bien filtrer et mapper sur un fichier journal, zip, prenez la différence de temps de traitement pour chaque ligne, et essayez tri inversé et takeWhile, les lignes qui prennent 500 ms ou plus sont affichées par ordre de lenteur Tu peux le faire.

[Bonus-java8 stream / javaslang]: Avantages de la carte

Il y aura certainement des discussions telles que "Je ne connais pas les mérites" et "N'est-ce pas d'accord pour?"

Il y en a quelques-uns, mais j'en énumérerai brièvement trois.

1. Vous pouvez séparer la situation de ce que vous voulez faire

Par exemple, il existe une fonction telle que String-> Integer.

private static Integer toIntAndTwice(String s) {
    return Integer.valueOf(s) * 2;
}

Si vous écrivez le code qui applique cette fonction à "quand il y a plusieurs Strings", "quand il y a un maximum d'une" chaîne "", et "quand il y a une" chaîne "qui peut être malformée", Devenir.

Exemple de liste

List<Integer> result = List.empty();

List<String> org = ...; // List.of(1, 2, 3) or empty

for (String x : org) {
    result.append(toIntAndTwice(x));
}

return result;

Exemple de ʻOption`

Option<Integer> result;

Option<String> org = ...; // Option.of(1) or empty

if (org.isEmpty()) {
    result = Option.none();
} else {
    result = Option.of(toIntAndTwice(org.get()));
}

return result;

Exemple try

Integer result;

String org = ...; // "1" or "x"

try {
    result = toIntAndTwice(org);
} catch (Throwable t) {
    result = null;
}

return result;

Vous devez écrire un code complètement différent pour appliquer toIntAndTwice à String dans une situation particulière.

Si vous écrivez ceci avec map, ce sera comme ça.

Exemple de liste

List<String> org = ...;
List<Integer> mapped = org.map(JSMain::toIntAndTwice);
return mapped;

Exemple de ʻOption`

Option<String> org = ...;
Option<Integer> mapped = org.map(JSMain::toIntAndTwice);
return mapped;

Exemple Try

Try<String> org = ...;
Try<Integer> mapped = org.map(JSMain::toIntAndTwice);
return mapped;

C'est pareil! Ceci est dû au fait que "les règles de List et de ʻOption dans une situation spécifique" et "ce que vous voulez réellement faire (" toIntAndTwice) "sont séparées, et la première est suivie par la langue.

Au fait, si le code est similaire jusqu'à présent, je pense qu'il peut être rendu plus courant, non? Puisque List et ʻOption de javaslang héritent de Value`, vous pouvez également le faire.

Si vous définissez une telle Valeur <T> -> Valeur <R>,

private static Value<Integer> mapAnyType(Value<String> org) {
    return org.map(JSMain::toIntAndTwice);
}

Cela fonctionne que l'argument soit List ou ʻOption`!

Exemple de liste

Value<Integer> m1 = mapAnyType(List.of("1", "2", "3")); // List(2, 4, 6)

Exemple de ʻOption`

Value<Integer> m2 = mapAnyType(Option.none());          // None

Exemple Try

Value<Integer> m3 = mapAnyType(Try.of(() -> "x"));      // Failure(java.lang.NumberFormatException: For input string: "x")

Dans ce cas, le même code peut gérer différentes situations, donc par exemple, préparer un processus d'annulation pour les options payantes, et avoir une" fonction pour tout annuler à la fois (Liste)" et une "fonction pour annuler si vous en avez une (ʻOption". ")" Et "La fonction à annuler parce que vous devriez l'avoir ( Try) "peut être réalisée à la fois.

Je pense que le plus grand mérite est la séparation de la «situation» et du «traitement».

2. Les variables temporaires n'apparaissent pas

Un code hérité que tout le monde aime. Ceci est courant.

//Initialisation
result = 0;
flag = false;

for (i ...) {
    result = ...;

    //Est-ce que ~ ~ est terminé?
    if (i < ...) {
        result = ...;
        flag = true;
    }

    //Si c'est ~~, ça se termine
    if (flag) {
        return result;
    }

    //Puis boucle avec ~ ~
    for (j ...) {
        result = ...;

        //Si c'est ~~, ça se termine
        if (j < ...) {
            return result;
        }
    }
    //Initialisation
    flag = false;
}

//revenir
return result;

Le return result; dans ce code est le même que le texte, mais le contenu est complètement différent. (Peut-être, je ne sais même pas.)

Puisqu'il y a un contexte dans les lignes, vous ne pouvez pas copier et coller uniquement cette ligne, et il semble que vous créez des blocs avec des commentaires, mais en réalité ce n'est qu'un gros bloc.

Si cela ressemble au code ci-dessus, les trois lignes de l'argument fonctionnent indépendamment et il n'y a pas de variables en cours dans la portée de la méthode qui ne devraient pas être «return». (Puisqu'il y en a un ;, ce code est une ligne. Par conséquent, il ne peut y avoir aucun état d'intervalle.)

return cs.stream()
        .reduce(
                Optional.of(0),
                (acc, c) -> c == '(' ? acc.map(n -> n + 1) : acc.map(n -> n - 1).filter(n -> n >= 0),
                (acc1, acc2) -> acc1.flatMap(v1 -> acc2.map(v2 -> v1 + v2))
        ).equals(Optional.of(0));

Je pense que c'est extrêmement réutilisable et de meilleure qualité. (Bien sûr, si vous le faites avec du code partagé, vous devriez être un peu plus prudent. Le deuxième argument doit être nommé correctement et le code de test doit être écrit légèrement. Le troisième argument doit être ReduceUtil :: mergeOptional. Java efficace Je pense que la 3e édition l'a également dit.)

3. Utiliser l'expérience d'une autre langue

Je reviendrai ensuite sur les détails, mais plus vous connaissez l'idée elle-même, mieux ce sera à première vue à moins qu'il ne s'agisse d'un langage spécial.

Si vous apprenez le flux java8 et passez à ruby, vous pourrez utiliser la liste immédiatement, et même si vous êtes nouveau sur java8, si vous êtes expérimenté avec python, vous pourrez diffuser.

[Bonus]: Wordbook

Comme mentionné dans les avantages de dernière minute, la plupart des langues ont mapper, filtrer, réduire.

Lorsque vous devez maintenir une langue que vous ne connaissez pas à la hâte au travail, ou lorsque vous souhaitez apporter des modifications aux outils que vous avez choisis, c'est bien si vous connaissez les mots et le traitement des images. Donc, à la fin, je terminerai par un résumé de la façon de faire le même traitement dans la langue que vous entendez souvent.

(La partie avec (*) donne l'impression que vous pouvez faire quelque chose de similaire si vous l'utilisez bien)

Si vous vous souvenez des mots autour de map / collect, filter, reduction / fold / inject, la plupart des langages fonctionneront.

«map vs collect» et «reduction vs inject» peuvent être intéressants à examiner.

fin

Si quelqu'un a lu jusqu'ici, merci.

C'était bien que l'article soit à l'heure le jour où je l'ai déclaré. C'est tout.