• not every combination makes sense
• some combinations are abstract, so you must implement

 Concurrent | Linked | Array | List Navigable | Hash | Map Priority | Tree | Set | Queue | Table Basicaly the meanings - concurrent = thread-safe - Array = index-based, better random access - Linked = doubly-linked nodes, order preserved - hash = hashed LinkedHashMap = order-oreserved + hashed into buckets + k,v based store 

Performances insert delete get - Array O(n) O(n) O(1) - Linked O(1) O(1) O(n) - Map O(1) O(1) O(1) 

• Map means, one key = one value, But if you put a List<V>, you can hold many values for one key
• default initial bucket = 16, load factor 0.75
• if (size = lf * initial) -> resize *= 2
• use .entrySet().stream() for streaming
• no duplicate key

 - Map<k, v>, unsorted, no-null-key - HashMap, unsorted, null-key, - LinkedHashMap, insert-order, null-key - ConcurrentHashMap, no-null-key, trade-safe - TreeMap, sorted natural-order or Comparator-based 

• Stream<String> xx = Pattern.compile("\\w+).matcher("source").results()

• define PATH = "..." as absolute path
• Stream<String> xx = Files.lines(Paths.get(PATH))

• IntStream<Integer> xx = Arrays.stream(int[])
• then .boxed to get Stream<Integer>, if you need!

• List<Integer> xx = new ArrayList<>(Arrays.asList(1, 3, 4))
• Stream<Integer> yy = xx.stream()

• if it is not parallel, same thread, sequential (beginning2end), gets a person then completes all-intermediate-steps. And, repeats the same as person and other tasks

  1 thread 1 time (so no need for combiner) !! no need combiner (never enters addAll step) collect:::new N times sequentially map::: -> collect:::add N times, last step. terminal ops. sequential forEach::: 

• If it is parallel, leverages multi-threads, and all intermediate-steps can be happened in any order!. So, combiner is must!.

  N thread N times collect::new (no optimization, which is interesting, that's why we need combiner!) -> collect::map -> collect::new -> collect::new -> collect::map -> collect::add ......... -> collect::addAll -> collect::new ...... N Thread -> colect returns ArrayList<>, so we need .parallelStream() again. Otherwise, it is not multi-threaded. @last step, foreach steps, (terminal operation) 

some critical things changes the methods we may see!

• min vs Collectors.minBy
• Stream vs Stream (clipping to an integer type)
• IntStream vs Stream
• Transformation: IntStream -> boxed() -> Stream
• stream().map() is the same as collect(Collectors.toMap()
• map (one by one mapping) vs Collectors.groupingBy (One by List mapping, so in downstream you may reduce it T also)
• (:Map<T extends Integer, List)
• if you have Map<k, v>, use .entrySet().stream() to do computing

 .stream() .map(::getIntegerTypeSomething) //Stream<Integer> .min(Comparator.naturalOrder()) --- .stream() .map(::getIntegerTypeSomething) //Stream<Integer> .collect(Collectors.minBy(Comparator.naturalOrder())) 

 .stream() .mapToInt(::getIntegerTypeSomething) //IntStream .summaryStatistics() --- .stream() .collect(Collectors.summarizingInt(::getIntegerTypeSomething))