Java 8, comment puis-je mettre en œuvre une instruction switch à l'aide de flux?

La meilleure façon d'analyser un tel fichier (sans l'aide d'dédié 3ème partie les bibliothèques), à l'est par l'expression régulière de l'API, et son front-end class Scanner. Malheureusement, le meilleur des opérations à mettre en œuvre via des Flux API, sont actuellement manquantes. À savoir, Matcher.les résultats() et Scanner.findAll(...) ne sont pas encore là. De sorte que si nous voulons attendre jusqu'à ce que Java 9, nous avons à créer des méthodes similaires pour Java 8 une solution compatible:

public static Stream<MatchResult> findAll(Scanner s, Pattern pattern) {
    return StreamSupport.stream(new Spliterators.AbstractSpliterator<MatchResult>(
            1000, Spliterator.ORDERED|Spliterator.NONNULL) {
        public boolean tryAdvance(Consumer<? super MatchResult> action) {
            if(s.findWithinHorizon(pattern, 0)!=null) {
                action.accept(s.match());
                return true;
            }
            else return false;
        }
    }, false);
}
public static Stream<MatchResult> results(Matcher m) {
    return StreamSupport.stream(new Spliterators.AbstractSpliterator<MatchResult>(
            m.regionEnd()-m.regionStart(), Spliterator.ORDERED|Spliterator.NONNULL) {
        public boolean tryAdvance(Consumer<? super MatchResult> action) {
            if(m.find()) {
                action.accept(m.toMatchResult());
                return true;
            }
            else return false;
        }
    }, false);
}

À l'aide de méthodes similaires, sémantique nous permet de remplacer leur utilisation avec l'API standard de méthodes, une fois Java 9 est libéré et devient monnaie courante.

À l'aide de ces deux opérations, vous pouvez analyser votre fichier à l'aide de

Pattern groupPattern=Pattern.compile("\\[(.*?)\\]([^\\[]*)");
Pattern attrPattern=Pattern.compile("(.*?)=(.*)\\v");
Map<String, Map<String, String>> m;
try(Scanner s=new Scanner(Paths.get(context.io.iniFilename))) {
    m = findAll(s, groupPattern).collect(Collectors.toMap(
        gm -> gm.group(1),
        gm -> results(attrPattern.matcher(gm.group(2)))
            .collect(Collectors.toMap(am->am.group(1), am->am.group(2)))));
}

la carte m contient toutes les informations d', la correspondance entre les noms de groupe à l'autre de la carte holding les paires clé/valeur, c'est à dire que vous pouvez imprimer un équivalent .ini fichier à l'aide de:

m.forEach((group,attr)-> {
    System.out.println("["+group+"]");
    attr.forEach((key,value)->System.out.println(key+"="+value));
});

OriginalL'auteur Holger

En se concentrant sur la question "est-il un moyen de simuler l'instruction switch comportement", je pense que la réponse est que vous pouvez, avec un peu d'effort. Je me suis demandé qui il y a quelques années, et ne le suit comme un exercice (et puis jamais utilisé de nouveau):

private static <T> Predicate<T> testAndConsume(Predicate<T> pred, Consumer<T> cons) {
    return t -> {
        boolean result = pred.test(t);
        if (result) cons.accept(t);
        return result;
    };
}

public static class SwitchConsumer<T> {
    Predicate<T> conditionalConsumer;
    private SwitchConsumer(Predicate<T> pred) {
        conditionalConsumer = pred;
    }

    public static <C> SwitchConsumer<C> inCase(Predicate<C> pred, Consumer<C> cons) {
        return new SwitchConsumer<>(testAndConsume(pred, cons));
    }

    public SwitchConsumer<T> elseIf(Predicate<T> pred, Consumer<T> cons) {
        return new SwitchConsumer<>(conditionalConsumer.or(testAndConsume(pred,cons)));
    }

    public Consumer<T> elseDefault(Consumer<T> cons) {
        return testAndConsume(conditionalConsumer.negate(),cons)::test;   //::test converts Predicate to Consumer
    }
}

testAndConsume compose d'un Predicate et un Consumer, la création d'un Predicate qui renvoie la même valeur mais les appels de la Consumer comme un effet secondaire si la valeur est true. Que devient la base pour chaque "cas" dans le "switch". Chaque "cas" est enchaînent les unes aux autres par Predicate.or(), qui fournit le court-circuit "sinon si" la nature de l'interrupteur. Enfin, le composé Predicate est transformé en un Consumer en ajoutant ::test à la Predicate.

En l'appliquant à votre extrait de code, il ressemble à ceci:

    Stream.of("Pos=320,5", "Size=550,680", "Collapsed=0")
            .map(s -> s.split("="))
            .forEach(SwitchConsumer.<String[]>
                    inCase(arr -> "Pos".equals(arr[0]), arr -> settings.pos = arr[1])
                    .elseIf(arr -> "Size".equals(arr[0]), arr -> settings.size = arr[1])
                    .elseIf(arr -> "Collapsed".equals(arr[0]), arr -> settings.collapsed = arr[1])
                    .elseDefault(arr -> {}));

C'est sur que de passer à la rigueur, car il peut faire sans un changement réel dans un Consumer corps.

OriginalL'auteur Hank D