Split java.util.stream.Stream

Question

Ich habe eine Textdatei, die URLs und E-Mails enthält. Ich muss alle aus der Datei extrahieren. Jede URL und E-Mail kann mehr als einmal gefunden werden, aber das Ergebnis sollte keine Duplikate enthalten. Ich kann alle URLs extrahieren mit dem folgenden Code:

Files.lines(filePath). 
    .map(urlPattern::matcher) 
    .filter(Matcher::find) 
    .map(Matcher::group) 
    .distinct(); 

ich alle E-Mails extrahieren kann mit dem folgenden Code:

Files.lines(filePath). 
    .map(emailPattern::matcher) 
    .filter(Matcher::find) 
    .map(Matcher::group) 
    .distinct(); 

Kann ich extrahieren alle URLs und E-Mails, den Strom von Files.lines(filePath) zurück Lesen nur ein Zeit? So etwas wie das Aufteilen von Streams von Zeilen in einen Stream von URLs und E-Mail-Streams.

Answer 1

Sie können partitioningBy Sammler verwenden, obwohl es immer noch nicht sehr elegante Lösung ist.

Map<Boolean, List<String>> map = Files.lines(filePath) 
     .filter(str -> urlPattern.matcher(str).matches() || 
         emailPattern.matcher(str).matches()) 
     .distinct() 
     .collect(Collectors.partitioningBy(str -> urlPattern.matcher(str).matches())); 
List<String> urls = map.get(true); 
List<String> emails = map.get(false); 

Wenn Sie regexp zweimal nicht anwenden möchten, können Sie es das Zwischenpaar Objekt machen (zum Beispiel SimpleEntry):

public static String classify(String str) { 
    return urlPattern.matcher(str).matches() ? "url" : 
     emailPattern.matcher(str).matches() ? "email" : null; 
} 

Map<String, Set<String>> map = Files.lines(filePath) 
     .map(str -> new AbstractMap.SimpleEntry<>(classify(str), str)) 
     .filter(e -> e.getKey() != null) 
     .collect(Collectors.groupingBy(e -> e.getKey(), 
      Collectors.mapping(e -> e.getValue(), Collectors.toSet()))); 

würde meine freie StreamEx Bibliothek den letzten Schritt verwenden sei kürzer:

Answer 2

Da Sie einen Stream nicht wiederverwenden können, wäre die einzige Option "tun Sie es manuell", denke ich.

File.lines(filePath).forEach(s -> /** match and sort into two lists */); 

Wenn es eine andere Lösung dafür gibt, würde ich mich freuen, darüber zu erfahren!

Answer 3

Die allgemeine Frage sollte sein: Warum möchten Sie nur einmal streamen?

Das Extrahieren der URLs und das Extrahieren der E-Mails sind verschiedene Operationen und sollten daher in ihren eigenen Streaming-Operationen behandelt werden. Selbst wenn die zugrunde liegende Stream-Quelle Hunderttausende von Datensätzen enthält, kann die Zeit für die Iteration im Vergleich zu den Mapping- und Filteroperationen vernachlässigt werden.

Die einzige Sache, die Sie als mögliches Leistungsproblem betrachten sollten, ist der IO-Betrieb. Die sauberste Lösung ist daher die Datei nur einmal zu lesen und dann zweimal auf eine resultierende Sammlung streamen:

List<String> allLines = Files.readAllLines(filePath); 
allLines.stream() ... // here do the URLs 
allLines.stream() ... // here do the emails 

Natürlich erfordert dies eine Erinnerung.

Answer 4

Sie können die passende führen innerhalb eines Collector:

Map<String,Set<String>> map=Files.lines(filePath) 
    .collect(HashMap::new, 
     (hm,line)-> { 
      Matcher m=emailPattern.matcher(line); 
      if(m.matches()) 
       hm.computeIfAbsent("mail", x->new HashSet<>()).add(line); 
      else if(m.usePattern(urlPattern).matches()) 
       hm.computeIfAbsent("url", x->new HashSet<>()).add(line); 
     }, 
     (m1,m2)-> m2.forEach((k,v)->m1.merge(k, v, 
            (s1,s2)->{s1.addAll(s2); return s1;})) 
    ); 
Set<String> mail=map.get("mail"), url=map.get("url"); 

Beachten Sie, dass diese leicht angepasst werden kann, mehrere Spiele innerhalb einer Zeile zu finden:

Map<String,Set<String>> map=Files.lines(filePath) 
    .collect(HashMap::new, 
     (hm,line)-> { 
      Matcher m=emailPattern.matcher(line); 
      while(m.find()) 
       hm.computeIfAbsent("mail", x->new HashSet<>()).add(m.group()); 
      m.usePattern(urlPattern).reset(); 
      while(m.find()) 
       hm.computeIfAbsent("url", x->new HashSet<>()).add(m.group()); 
     }, 
     (m1,m2)-> m2.forEach((k,v)->m1.merge(k, v, 
            (s1,s2)->{s1.addAll(s2); return s1;})) 
    );