Esempio n. 1
0
  public void testClosedStream() throws IOException {
    try (Stream<Path> s = Files.list(testFolder)) {
      s.close();
      Object[] actual = s.sorted().toArray();
      fail("Operate on closed stream should throw IllegalStateException");
    } catch (IllegalStateException ex) {
      // expected
    }

    try (Stream<Path> s = Files.walk(testFolder)) {
      s.close();
      Object[] actual = s.sorted().toArray();
      fail("Operate on closed stream should throw IllegalStateException");
    } catch (IllegalStateException ex) {
      // expected
    }

    try (Stream<Path> s = Files.find(testFolder, Integer.MAX_VALUE, (p, attr) -> true)) {
      s.close();
      Object[] actual = s.sorted().toArray();
      fail("Operate on closed stream should throw IllegalStateException");
    } catch (IllegalStateException ex) {
      // expected
    }
  }
Esempio n. 2
0
 @Override
 protected BackEndDataProvider<StrBean, SerializablePredicate<StrBean>> createDataProvider() {
   return dataProvider =
       new BackEndDataProvider<>(
           query -> {
             Stream<StrBean> stream =
                 data.stream().filter(t -> query.getFilter().orElse(s -> true).test(t));
             if (!query.getSortOrders().isEmpty()) {
               Comparator<StrBean> sorting =
                   query
                       .getSortOrders()
                       .stream()
                       .map(this::getComparator)
                       .reduce((c1, c2) -> c1.thenComparing(c2))
                       .get();
               stream = stream.sorted(sorting);
             }
             List<StrBean> list =
                 stream
                     .skip(query.getOffset())
                     .limit(query.getLimit())
                     .collect(Collectors.toList());
             list.forEach(s -> System.err.println(s.toString()));
             return list.stream();
           },
           query ->
               (int)
                   data.stream().filter(t -> query.getFilter().orElse(s -> true).test(t)).count());
 }
Esempio n. 3
0
 public void testWalk() {
   try (Stream<Path> s = Files.walk(testFolder)) {
     Object[] actual = s.sorted().toArray();
     assertEquals(actual, all);
   } catch (IOException ioe) {
     fail("Unexpected IOException");
   }
 }
Esempio n. 4
0
  public static void main(String[] args) throws IOException {
    try (Stream<Path> stream = Files.list(Paths.get(""))) {
      String joined =
          stream
              .map(String::valueOf)
              .filter(path -> !path.startsWith("."))
              .sorted()
              .collect(Collectors.joining("; "));
      System.out.println("List: " + joined);
    }

    Path start = Paths.get("");
    int maxDepth = 5;
    try (Stream<Path> stream =
        Files.find(start, maxDepth, (path, attr) -> String.valueOf(path).endsWith(".java"))) {
      String joined = stream.sorted().map(String::valueOf).collect(Collectors.joining("; "));
      System.out.println("Found: " + joined);
    }

    try (Stream<Path> stream = Files.walk(start, maxDepth)) {
      String joined =
          stream
              .map(String::valueOf)
              .filter(path -> path.endsWith(".java"))
              .sorted()
              .collect(Collectors.joining("; "));
      System.out.println("walk(): " + joined);
    }

    List<String> lines = Files.readAllLines(Paths.get("src/golf.sh"));
    lines.add("puts 'foobar'");
    Path path = Paths.get("src/golf-modified.sh");
    Files.write(path, lines);

    try (Stream<String> stream = Files.lines(path)) {
      stream.filter(line -> line.contains("puts")).map(String::trim).forEach(System.out::println);
    }

    System.out.println("a" == "a");
    System.out.println("a" != new String("a"));
    System.out.println(null != "a");
    System.out.println("a".equals("a"));

    try (BufferedReader reader = Files.newBufferedReader(path)) {
      while (reader.ready()) System.out.println(reader.readLine());
    }

    try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("hello-world.sh"))) {
      writer.write("puts 'Hello world'");
    }

    try (BufferedReader reader = Files.newBufferedReader(path)) {
      long countPuts = reader.lines().filter(line -> line.contains("put")).count();
      System.out.println(countPuts);
    }
  }
Esempio n. 5
0
 public void testWalkFollowLink() {
   // If link is not supported, the directory structure won't have link.
   // We still want to test the behavior with FOLLOW_LINKS option.
   try (Stream<Path> s = Files.walk(testFolder, FileVisitOption.FOLLOW_LINKS)) {
     Object[] actual = s.sorted().toArray();
     assertEquals(actual, all_folowLinks);
   } catch (IOException ioe) {
     fail("Unexpected IOException");
   }
 }
  @Test
  public void shouldExecuteValiableOrderDesc() {

    Stream<MonetaryAmount> stream =
        Stream.of(Money.of(7, EURO), Money.of(9, BRAZILIAN_REAL), Money.of(8, DOLLAR));
    List<MonetaryAmount> list =
        stream.sorted(MonetaryFunctions.sortValuableDesc(provider)).collect(Collectors.toList());

    Assert.assertEquals(Money.of(7, EURO), list.get(0));
    Assert.assertEquals(Money.of(8, DOLLAR), list.get(1));
    Assert.assertEquals(Money.of(9, BRAZILIAN_REAL), list.get(2));
  }
Esempio n. 7
0
  public static void main(String[] args) {
    // 스트림 생성
    Stream<String> song = Stream.of("gently", "down", "the", "stream");

    // 난수 100개
    Stream<Double> randoms = Stream.generate(Math::random).limit(100);

    //
    Stream<String> uniqueWords = Stream.of("merrily", "merrily", "merrily", "gentyl").distinct();

    Stream<Double> greatFirst =
        randoms.sorted(Comparator.comparing(Double::doubleValue).reversed());
    greatFirst.forEach(System.out::println);
  }
Esempio n. 8
0
  public void testBasic() {
    try (Stream<Path> s = Files.list(testFolder)) {
      Object[] actual = s.sorted().toArray();
      assertEquals(actual, level1);
    } catch (IOException ioe) {
      fail("Unexpected IOException");
    }

    try (Stream<Path> s = Files.list(testFolder.resolve("empty"))) {
      int count = s.mapToInt(p -> 1).reduce(0, Integer::sum);
      assertEquals(count, 0, "Expect empty stream.");
    } catch (IOException ioe) {
      fail("Unexpected IOException");
    }
  }
 protected Date getFirstDate(Stream<Date> allDates) {
   return allDates.sorted().findFirst().get();
 }
Esempio n. 10
0
 static void filesTest() {
   // Files.list
   try {
     try (Stream<Path> stream = Files.list(Paths.get("/opt"))) {
       String joined =
           stream
               .map(String::valueOf)
               .filter(path -> !path.startsWith("."))
               .sorted()
               .collect(Collectors.joining("; "));
       System.out.println("List path /opt : " + joined);
     }
   } catch (IOException e) {
     e.printStackTrace();
   }
   // Files.find
   Path start = Paths.get("/Users/alibaba/Downloads/2016113");
   int maxDepth = 5;
   try (Stream<Path> stream =
       Files.find(start, maxDepth, (path, attr) -> String.valueOf(path).endsWith(".js"))) {
     String joined = stream.sorted().map(String::valueOf).collect(Collectors.joining("; "));
     System.out.println("Files find : " + joined);
   } catch (IOException e) {
     e.printStackTrace();
   }
   // Files.walk
   try (Stream<Path> stream = Files.walk(start, maxDepth)) {
     String joined =
         stream
             .map(String::valueOf)
             .filter(path -> path.endsWith(".js"))
             .sorted()
             .collect(Collectors.joining("; "));
     System.out.println("Files walk : " + joined);
   } catch (IOException e) {
     e.printStackTrace();
   }
   // Files.readAllLines
   try {
     String p = "/Users/alibaba/linuxsir.txt";
     List<String> lines = Files.readAllLines(Paths.get(p));
     lines.add("print('foobar');");
     Files.write(Paths.get(p), lines);
     lines.remove(lines.size() - 1);
     System.out.println("readAllLines " + lines);
     Files.write(Paths.get(p), lines);
   } catch (IOException e) {
     e.printStackTrace();
   }
   // Files.lines
   try (Stream<String> stream = Files.lines(Paths.get("/Users/alibaba/linuxsir.txt"))) {
     stream.filter(line -> line.contains("w")).map(String::valueOf).forEach(System.out::println);
   } catch (IOException e) {
     e.printStackTrace();
   }
   // Files.newBufferedReader&Files.newBufferedWriter
   Path path = Paths.get("/Users/alibaba/linuxsir.txt");
   try (BufferedReader reader = Files.newBufferedReader(path)) {
     System.out.println(reader.readLine());
   } catch (IOException e) {
     e.printStackTrace();
   }
   path = Paths.get("/Users/alibaba/output.txt");
   try (BufferedWriter writer = Files.newBufferedWriter(path)) {
     writer.write("print('Hello World')");
   } catch (IOException e) {
     e.printStackTrace();
   }
 }
Esempio n. 11
0
 @Override
 public Stream<T> apply(Stream<T> input) {
   return comparator != null ? input.sorted(comparator) : input.sorted();
 }