Skip to content

Latest commit

 

History

History
178 lines (137 loc) · 4.8 KB

README.md

File metadata and controls

178 lines (137 loc) · 4.8 KB
Raw

java fundamentals - streams

This project is about

  • Collections API
  • Stream API
  • Collectors API
  • Functional API
  • parallelStreams

Stream concepts

Collections API ::: General combinations
  • 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)
Collections API ::: Map
  • 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
Get a stream from Regex
  • Stream<String> xx = Pattern.compile("\\w+).matcher("source").results()
Get a stream from File
  • define PATH = "..." as absolute path
  • Stream<String> xx = Files.lines(Paths.get(PATH))
Get a stream from SecureRandom 
new SecureRandom()
           .ints(10, 1, 7)                //IntStream
           .mapToObj(String::valueOf)     //Stream<String>
           .forEach(System.out::println)
Get a stream from int[] ::: primitives
  • IntStream<Integer> xx = Arrays.stream(int[])
  • then .boxed to get Stream<Integer>, if you need!
Get a stream from Collections ::: wrappers
  • List<Integer> xx = new ArrayList<>(Arrays.asList(1, 3, 4))
  • Stream<Integer> yy = xx.stream()
Threading ::: in java-streams

  • 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:::
Threading ::: in java-parallelStreams

  • 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)
Methods ::: Stream API vs Collectors API

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))