static void lambdaTest() {
Runnable r = () -> System.out.print("hello lambda");
r.run();
List<String> list = Arrays.asList("t1", "t2", "t334", "t4", "t567");
list.parallelStream().filter(s -> s.length() == 2).forEach(System.out::println);
list = Arrays.asList("1", "2", "3", "4", "5", "6", "7", "8", "9", "15", "17");
Map<String, Integer> integers =
list.stream()
.map(Integer::new)
.filter(e -> e % 2 != 0)
.distinct()
.collect(Collectors.toMap(Object::toString, e -> e));
System.out.println(integers);
Stream.generate(Math::random).limit(10).forEach(System.out::println);
new Thread(() -> System.out.println("hello lambda")).start();
new Thread(
() -> {
System.out.println("hello lambda");
})
.start();
List<String> words = Lists.newArrayList("ren", "wang", "li", "zhao", "ma");
words.sort((w1, w2) -> Integer.compare((w1.length()), w2.length()));
List<Integer> ints = Ints.asList(1, 2, 3, 4, 5);
ints.sort(Integer::compare);
// words.forEach(e -> System.out.print(e));
words.forEach(System.out::println);
// words.stream().map(w -> w.length());
words.stream().map(String::length);
// words.stream().map(w -> new StringBuilder(w));
words.stream().map(StringBuilder::new);
Converter<String, Integer> converter; // (f) -> Integer.valueOf(f);
converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted);
String[] arrayStr = new String[] {"a", "ab", "abc", "abcd"};
Arrays.sort(arrayStr, (first, second) -> Integer.compare(first.length(), second.length()));
}
public static void main(String[] args) throws IOException {
Path path = Paths.get("../alice.txt");
String contents = new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
Stream<String> words = Stream.of(contents.split("[\\P{L}]+"));
show("words", words);
Stream<String> song = Stream.of("gently", "down", "the", "stream");
show("song", song);
Stream<String> silence = Stream.empty();
silence = Stream.<String>empty(); // Explicit type specification
show("silence", silence);
Stream<String> echos = Stream.generate(() -> "Echo");
show("echos", echos);
Stream<Double> randoms = Stream.generate(Math::random);
show("randoms", randoms);
Stream<BigInteger> integers = Stream.iterate(BigInteger.ONE, n -> n.add(BigInteger.ONE));
show("integers", integers);
Stream<String> wordsAnotherWay = Pattern.compile("[\\P{L}]+").splitAsStream(contents);
show("wordsAnotherWay", wordsAnotherWay);
try (Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8)) {
show("lines", lines);
}
}
@Test
public void _02_무한_스트림_생성() {
// 상수 무한 스트림
Stream<String> echos = Stream.generate(() -> "Echo");
// 난수 무한 스트림
Stream<Double> randoms = Stream.generate(Math::random);
// 무한 수열 스트림
Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));
}
public static void main(String[] args) {
/** 例①： 打印数列的前10项 */
Stream<Long> fibonacci = Stream.generate(new FibonacciSupplier());
fibonacci.limit(10).forEach(System.out::println);
/** 例②： 打印数列的20~30项 */
Stream<Long> fibonacci2 = Stream.generate(new FibonacciSupplier());
List<Long> list = fibonacci2.skip(20).limit(10).collect(Collectors.toList());
list.forEach(System.out::println);
}
public static void main(String[] args) {
Stream<Double> piStream = Stream.generate(new PiSupplier());
piStream.skip(1000000).limit(10).forEach(System.out::println);
System.out.println("-------------------------------------------");
Stream<Double> piStream_1 = Stream.generate(new PiSupplier());
piStream_1
.map(new EulerTransform())
.map(new EulerTransform())
.map(new EulerTransform())
.map(new EulerTransform())
.map(new EulerTransform())
.map(new EulerTransform())
.skip(10)
.limit(20)
.forEach(System.out::println);
}
@Test
public void _04_서브스트림_추출() {
// limit
Stream<Double> randoms = Stream.generate(Math::random).limit(100);
assertThat(randoms.count(), is(100L));
// skip
Stream<String> words = Stream.of(contents.split("[\\P{L}]+")).skip(1);
assertThat(words.findFirst().get(), is("was"));
}
private ExpressionBuilder(
ExpressionBuilder<T> parent, int defaultLevel, BinaryOperator<T>... precedence) {
this.operations = precedence;
this.parent = parent;
this.defaultLevel = defaultLevel;
this.levelHistory = new Stack<>();
this.currentLevel = 0;
this.operationDeclared = true;
this.elements =
Stream.generate(LinkedList::new).limit(operations.length).toArray(LinkedList[]::new);
}
// Usage example
public static void main(String[] args) {
List<Edge>[] graph = Stream.generate(ArrayList::new).limit(3).toArray(List[]::new);
addEdge(graph, 0, 1, 3, 1);
addEdge(graph, 0, 2, 2, 1);
addEdge(graph, 1, 2, 2, 1);
int[] res = minCostFlow(graph, 0, 2, Integer.MAX_VALUE);
int flow = res[0];
int flowCost = res[1];
System.out.println(4 == flow);
System.out.println(6 == flowCost);
}
private EvolutionStart<G, C> evolutionStart(
final Iterable<Genotype<G>> genotypes, final long generation) {
final Stream<Phenotype<G, C>> stream =
Stream.concat(
StreamSupport.stream(genotypes.spliterator(), false)
.map(gt -> Phenotype.of(gt, generation, _fitnessFunction, _fitnessScaler)),
Stream.generate(() -> newPhenotype(generation)));
final Population<G, C> population = stream.limit(getPopulationSize()).collect(toPopulation());
return EvolutionStart.of(population, generation);
}
private EvolutionStart<G, C> evolutionStart(
final Population<G, C> population, final long generation) {
final Stream<Phenotype<G, C>> stream =
Stream.concat(
population
.stream()
.map(p -> p.newInstance(p.getGeneration(), _fitnessFunction, _fitnessScaler)),
Stream.generate(() -> newPhenotype(generation)));
final Population<G, C> pop = stream.limit(getPopulationSize()).collect(toPopulation());
return EvolutionStart.of(pop, generation);
}
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);
}
/**
* 文字を繰り返します。
*
* @param target 文字
* @param count 繰り返し回数
* @return 文字列
*/
public static String repeat(char target, int count) {
return Stream.generate(() -> target) // targetを延々と連ねるStream<Character>を生成する。
.limit(count) // 個数をcountに制限する。
.map(String::valueOf) // 文字列に変換してStream<String>を生成する。
.collect(Collectors.joining()); // 全要素を文字列連結する。
}
public static String repeat(String s, int count) {
return Stream.generate(() -> s).limit(count).collect(Collectors.joining());
}
public void testIndexAndRelocateConcurrently() throws ExecutionException, InterruptedException {
int halfNodes = randomIntBetween(1, 3);
Settings[] nodeSettings =
Stream.concat(
Stream.generate(() -> Settings.builder().put("node.attr.color", "blue").build())
.limit(halfNodes),
Stream.generate(() -> Settings.builder().put("node.attr.color", "red").build())
.limit(halfNodes))
.toArray(Settings[]::new);
List<String> nodes = internalCluster().startNodes(nodeSettings);
String[] blueNodes = nodes.subList(0, halfNodes).stream().toArray(String[]::new);
String[] redNodes = nodes.subList(halfNodes, nodes.size()).stream().toArray(String[]::new);
logger.info("blue nodes: {}", (Object) blueNodes);
logger.info("red nodes: {}", (Object) redNodes);
ensureStableCluster(halfNodes * 2);
assertAcked(
prepareCreate(
"test",
Settings.builder()
.put("index.routing.allocation.exclude.color", "blue")
.put(indexSettings())
.put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, randomInt(halfNodes - 1))));
assertAllShardsOnNodes("test", redNodes);
int numDocs = randomIntBetween(100, 150);
ArrayList<String> ids = new ArrayList<>();
logger.info(" --> indexing [{}] docs", numDocs);
IndexRequestBuilder[] docs = new IndexRequestBuilder[numDocs];
for (int i = 0; i < numDocs; i++) {
String id = randomRealisticUnicodeOfLength(10) + String.valueOf(i);
ids.add(id);
docs[i] =
client().prepareIndex("test", "type1", id).setSource("field1", English.intToEnglish(i));
}
indexRandom(true, docs);
SearchResponse countResponse = client().prepareSearch("test").get();
assertHitCount(countResponse, numDocs);
logger.info(" --> moving index to new nodes");
Settings build =
Settings.builder()
.put("index.routing.allocation.exclude.color", "red")
.put("index.routing.allocation.include.color", "blue")
.build();
client()
.admin()
.indices()
.prepareUpdateSettings("test")
.setSettings(build)
.execute()
.actionGet();
// index while relocating
logger.info(" --> indexing [{}] more docs", numDocs);
for (int i = 0; i < numDocs; i++) {
String id = randomRealisticUnicodeOfLength(10) + String.valueOf(numDocs + i);
ids.add(id);
docs[i] =
client()
.prepareIndex("test", "type1", id)
.setSource("field1", English.intToEnglish(numDocs + i));
}
indexRandom(true, docs);
numDocs *= 2;
logger.info(" --> waiting for relocation to complete");
ensureGreen("test"); // move all shards to the new nodes (it waits on relocation)
final int numIters = randomIntBetween(10, 20);
for (int i = 0; i < numIters; i++) {
logger.info(" --> checking iteration {}", i);
SearchResponse afterRelocation = client().prepareSearch().setSize(ids.size()).get();
assertNoFailures(afterRelocation);
assertSearchHits(afterRelocation, ids.toArray(new String[ids.size()]));
}
}
