Lambda und Streams verstehen

Bitte aktiviere JavaScript!
Hallo,

ich habe keinen universitären Hintergrund und auch keinen Prof zum fragen. Nachdem ein TO hier verschwunden ist, interessiert mich doch die Antwort. Es ging darum, einen Index mit Keywords in Context zu erstellen. Um das zu vereinfachen habe ich drei Zeilen erstellt, bei denen das "a" jeweils ein Füllwort darstellt, das rausgefiltert werden soll. Momentan stecke ich aber einen Schritt vorher fest. Wie kann ich die Einträge der Liste "res" sortieren, und wie kann ich dafür sorgen, dass Zeilennummern mitgenommen werden. Das habe ich jetzt noch nicht angedacht. Aber würde man die Zeilennummern den String mit aufnehmen oder seperat führen. Dann wäre es aber kein Stream of Strings mehr.Mmh?

Hier der Code:
Java:
package lambda;


import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;


public class Baguette {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
            List<String> al=new ArrayList<String>();
            al.add("A a D");      
            al.add("B a E");
            al.add("C a F");
            List<String> res= new ArrayList<>();
            for (String s : al) {
                String[] sl=s.split("\\s");
                //Liste aus Einzelteilen anlegen
                List<String> za=new ArrayList<>();
                for(String b : sl){
                    za.add(b);
                }
                String rs;
                for (int i=0;i<sl.length;i++) {
                    rs=rotateListByN(i,za);
                res.add(rs);
                }
            }  
            Stream<String> st=res.stream();
            long anz= st.count();
            for (String a : res ) {
                System.out.println(a);
            }
            System.out.println(anz);      
           
    }

    static String rotateListByN(int n, List<String> input) {
        List<String> a = new ArrayList<>();
        a.addAll(input);
        Collections.rotate(a, n);
        return String.join(" ", a);
        }
}
 
A

Anzeige


Vielleicht hilft dir dieser Kurs hier weiter: (hier klicken)
Mir ist nicht 100%ig klar, was genau deine Frage ist, bzw. was du wissen willst.
Wie kann ich die Einträge der Liste "res" sortieren
Collections.sort() ?
wie kann ich dafür sorgen, dass Zeilennummern mitgenommen werden
Indem du eine Datenstruktur/Klasse benutzt, in der du die Zeile und die Zeilennummer ablegst.

Jetzt heißt der Titel des Threads auch noch `Lambda und Streams verstehen`. Das heißt, du willst das ganze noch mit Streams und funktional mit Lambdas umsetzen?

Kannst du dein konkretes Problem auf eine einzige abgrenzbare Frage eingrenzen?

EDIT: Wenn du das, was du schon hast, noch zusammen mit Zeilennummern haben willst und das ganze noch mit Streams und Lambdas/funktional, dann bitte (unter Verwendung von jOOL zum "zip"pen zweier Streams und für Tuple-Datentypen):
Java:
import static java.util.stream.Collectors.joining;
import static java.util.stream.IntStream.iterate;
import static org.jooq.lambda.Seq.*;
import static org.jooq.lambda.tuple.Tuple.*;
import java.util.stream.Stream;
import org.jooq.lambda.tuple.Tuple2;
public class Baguette {
  private static Stream<Integer> from(int start) {
    return iterate(start, i -> i + 1).boxed();
  }
  private static Stream<Tuple2<Integer, String>> zipWithIndex(Stream<String> lines) {
    return zip(from(1), lines);
  }
  private static String rotate(int n, String[] input) {
    return range(0, input.length)
          .map(i -> input[(input.length + i - n) % input.length])
          .collect(joining(" "));
  }
  private static Stream<Tuple2<Integer, String[]>> strings(String s) {
    String[] sp = s.split("\\s+");
    return zip(from(0), generate(sp)).limit(sp.length);
  }
  public static void main(String[] args) {
    Stream<Tuple2<Integer, String>> seq = 
        zipWithIndex(of(
            "A a D", 
            "B a E", 
            "C a F"
    ));
    System.out.println(seq
        .flatMap(t -> 
            strings(t.v2)
           .map(j -> tuple(
               t.v1, rotate(
                   j.v1, j.v2))))
        .peek(System.out::println).count());
  }
}
 
@ mihe7: Genau das meine ich.

Java:
import java.nio.file.*;
import java.util.*;
import java.util.stream.*;

public class Test {
    public static void main(String[] args) throws Exception {
        Set<String> filters = Files.lines(Paths.get(args[1])).collect(Collectors.toSet());
        Files.lines(Paths.get(args[0]))
            .flatMap(row -> rotated(row, filters))
            .distinct()
            .sorted()
            .forEach(System.out::println);
    }

    static Stream<String> rotated(String row, Set<String> filters) {
        List<String> words = Stream.of(row.split("\\s+")).collect(Collectors.toList());

        return IntStream.range(0, words.size())
            .filter(n -> !filters.contains(words.get(n)))
            .mapToObj(n -> rotateListByN(-n, words));
    }

    static String rotateListByN(int n, List<String> input) {
        List<String> a = new ArrayList<>();
        a.addAll(input);
        Collections.rotate(a, n);
        return String.join(" ", a);
    }
}
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben