STREAM

// case 1. 외부 반복
List<String> names = new ArrayList<>();
for(Dish d:menu) {
    names.add(d.getName());
}

// case 2. 내부 반복
List<String> names = menu.stream()
                            .map(Dish::getName)
                            .collect(toList());

public class LazyBoolean {
    public static boolean firstCondition(){
        System.out.println("first condition");
        return true;
    }

    public static boolean secondCondition(){
        System.out.println("second condition");
        return true;
    }

    public static void main(String[] args) {
        if(firstCondition() || secondCondition()){
            System.out.println("condition done!!");
        }
    }
}

// 결과값
// first condition
// condition done!!

public class LazyStreams {
    private static int length(final String name) {
      System.out.println("getting length for " + name);
      return name.length();
    }
    private static String toUpper(final String name ) {
      System.out.println("converting to uppercase: " + name);
      return name.toUpperCase();
    }
    //...

		public static void main(final String[] args) {
				System.out.println("//" + "START:SPLIT_OUTPUT");
		    Stream<String> namesWith3Letters = names.stream()
		                                            .filter(name -> length(name) == 3)
		                                            .map(name -> toUpper(name));
		
		    System.out.println("Stream created, filtered, mapped...");
		    System.out.println("ready to call findFirst...");
		
		    final String firstNameWith3Letters = namesWith3Letters.findFirst().get();
		
		    System.out.println(firstNameWith3Letters);
		    System.out.println("//" + "END:SPLIT_OUTPUT");
		}
}

// 수행 결과 로그
//START:SPLIT_OUTPUT
Stream created, filtered, mapped...
ready to call findFirst...
getting length for Brad
getting length for Kate
getting length for Kim
converting to uppercase: Kim
KIM
//END:SPLIT_OUTPUT

List<String> names = menu.stream()
    .filter(d -> {
        System.out.println("filtering" + d.getName());
        return d.getCalories() > 300;
    })
    .map(d -> {
            System.out.println("mapping" : g.getName());
            return d.getName();
    })
    .limit(3)
    .collect(toList());

// filtering pork
// mapping pork
// filtering beef
// mapping beef
// filtering chicken
// mapping chicken

public class OneUseStream {

    public static void main(String[] args) {
        Stream<String> fruits =Stream.of("apple", "banana", "grape", "orange", "mango");

        String longestName = fruits.sorted(Comparator.comparing(String::length)).findFirst().orElse("");
        String shortestName = fruits.sorted(Comparator.comparing(String::length).reversed()).findFirst().orElse("");
        System.out.println("longestName is " + longestName + ", shortestName is " + shortestName);
    }
}

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
	at java.base/java.util.stream.AbstractPipeline.<init>(AbstractPipeline.java:203)
	at java.base/java.util.stream.ReferencePipeline.<init>(ReferencePipeline.java:94)
	at java.base/java.util.stream.ReferencePipeline$StatefulOp.<init>(ReferencePipeline.java:725)
	at java.base/java.util.stream.SortedOps$OfRef.<init>(SortedOps.java:126)
	at java.base/java.util.stream.SortedOps.makeRef(SortedOps.java:63)
	at java.base/java.util.stream.ReferencePipeline.sorted(ReferencePipeline.java:463)
	at com.example.practice.stream.OneUseStream.main(OneUseStream.java:15)

public class MapStream {

    @Getter
    static class Food {

        private String name;
        private Integer calories;

        public Food(String name, int calories) {
            this.name = name;
            this.calories = calories;
        }
    }

    public static void main(String[] args) {
        Stream<Food> foodStream = Stream.of(new Food("apple", 100),
                                            new Food("banana", 300),
                                            new Food("grape", 50),
                                            new Food("mango", 1000),
                                            new Food("pineapple", 200),
                                            new Food("peach", 300));
        int totalCalories = foodStream.map(Food::getCalories)
            .reduce(0, Integer::sum);

        System.out.println("total calories is " + totalCalories);
    }
}

// 일반 스트림으로 수행한 결과(sequentialSum)
System.out.println("Sequential sum done in: " + 
    measureSumPerf(ParallelStreams::sequentialSum, 10_000_000) + " msecs");

// 결과값
Sequential sum done in: 97 msecs

--- 

// for loop로 실행한 결과(iterativeSum)
System.out.println("Iterative sum done in: " + 
    measureSumPerf(ParallelStreams::iterativeSum, 10_000_000) + " msecs");

// 결과값
Iterative sum done in: 2 msecs

---

// 병렬 스트림으로 실행환 결과(parallelSum)
System.out.println("Parallel sum done in: " + 
    measureSumPerf(ParallelStreams::parallelSum, 10_000_000) + " msecs");

// 결과값
Iterative sum done in: 164 msecs

public static long sideEffectSum(long n) {
    Accumulator accumulator = new Accumulator();
    LongStream.rangeClosed(1, n).forEach(accumulator::add);
    return accumulator.total;
}

public class Accumulator {
    public long total = 0;
    public void add(long value) { total += value; }
}