Please enable JavaScript.

Coggle requires JavaScript to display documents.

for JVM languages Java java - besides and all around Scala …

- - - - Overriding the method in heir classes:
        
        @Override <out-type> <meth-name> (<par-type> <par-name>) { }
        :!!: Java cannot restrict access to methods in inherited classes, unlike C++.
    - - the keyword order:
        
        public static int funcname(<params>){}
      - Java BeanClass
        
        class that potentially encapsulate multiple others
        
        implements java.io.Serializable
        (i. e. its state can be written to file)
        
        class is itself public, but with all private attributes. However, they need to have all
        public setters and getters
        
        hence constructor should also be no-argument
      - Private/protected attributes' values should not be serialized (excluded from object when being written to any files, their value changed to default)
        
        for this,
        transient (after private|protected) modifier uses
        
        transience is also used when attribute is computable from others
        
        same is used for private and security data
    - - Classes and their methods
        can be virtual with abstract keyword
        (any abstract method implies abstract class)
      - Java Methods can be
        native if they are actually not implemented in Java anywhere, instead being part of a C/C++ Java Native Interface
        native int callJava();
      - Java Marker
        
        is an interface with
        
        no defined or implemented methods
        
        e. g. Cloneable, Serializable
- - - - Array Declaration:
        (a mutable instance, hence new constr)
        .toArray()
        :!!: the size is immutable
        var <arr-name>:Array[<sub-type>] = new Array[<sub-type>](arr-length)
        typim here is optional as usual, one can just write
        var <name> = Array(<val1>, <val2>, ... )
        length is given like in Pascal, C
        
        Reference by index in Scala (and Java):
        
        <arr-name>(index), <arr-name>{index}
        
        skrives in REPL in single square brackets
        
        vertical stacking:
        a ++ Array(b) - object becomes untransposable!
        inplace change
        <collection>.copyToArray(sequence, <start>, <length>)
        
        Multidim array declaration:
        
        var <arr-name> = Array.ofDim[<var-type>](<dim1>, <dim2> , ...) -- creates array with zeroes
        concat(<arr-1> , <arr-2> ) = + or paste
        
        multi-index selection with {i}{j} only
        
        .transpose - do support this
        vstack arrays to make matrix:
        
        Array(arr1, arr2, ..)
        
        Exploding//unpacking the vector:
        
        <vector-name>: _* - so the vector is unpacked
        ("пэ-зэ", "подчёркивание-звёздочка")
        (sic, with space!, but spaces can be none or arbitrarily many)
        (however, it is allowed not vastly as *list in python)
        e.g. it EJ allows for typecasting, thf. only <col-list>.map(col) in .select expression
        
        ArrayBuffer:
        extendable array
        
        Array class notation:
        
        [<type>:
        [D - of doubles
        [I - of int, [C -- of char
        all greater types notes as Ljava.lang.....
        or Lscala....
        
        Scala tuple:
        
        val <name>: (<type1>, <type2) = (<val1>, <val2>);
        OR
        val name: TupleX[Tuple1, Tuple2] = (<val1>, <val2>)
        :!!: there are 22 classes (`Tuple in scala for tuples of size from 1 to 22 incl., for greater tuples either define a custom case class :!!:
        (before Scala 2.11 in 2014, even case classes with more than 22 parameters weren't allowed)
        :!!: element referencing is done diferently!
        <name>._<index> : tup._1, tup._2
        :red_cross: due to security reasons, ordinary lists can't convertes to tuples in scala &other compiled languages
        
        Scala list:
        
        :!!: (unlike arrays, lists are immutable, hence always val)
        :red_cross: unlike python, lists do NOT iterate over collections and List() on collection rather becomes a list of one elm
        in REPL lists are written in double square [[ ]] brackets to distinguish them from arrays
        val spisok = List(<el1>, <el2>, ,...)
        .toList()
        .reverse
        list sorting:
        
        https://alvinalexander.com/scala/how-sort-scala-sequences-seq-list-array-buffer-vector-ordering-ordered/
        basic is .sorted
        this can uses, .sorted(Sorting)
        sorting according to custom sort:
        scala.util.Sorting.quickSort(...)
        
        sets do not preserve order, use .distinct to get unique elms
        
        Adding elements to lists and vectors with prepending operator:
        (:!!: since lists are immutable, this always recreates a list and vector resp. !)
        <list-2>= <el> :: <list>
        <vec-2> = <el> :+ <list>
        
        Scala buffer list
        :check: mutable list, hence always var
        supports traditional operations
        a = ListBuffer(<el1>, <el2>, ...)
        a += <elem>
        a ++= b
        (binary + and ++ applies to scala lists as well)
        
        Scala Vector
        
        an immutable instance,
        
        Scala map anonymous function onto list:
        
        <list>.map(x => fun(x))
        named func:
        <list>.map(<fun>)
        a function can be implemented as hash-table (see next .):
        <list>.map(dict)
        function with simple condition (displaces ternary operator):
        <list>.map(x => if (cond) <val1> else <val2>)
        
        CASE MATCH expression is required to capture inner structure of arrays:
        
        list.map{case (k:Int, v:Str) => (....)}
        Placeholder for function parameter _ (underscore)
        
        <list>.map(fun(_))
        OR
        <list>.map(_(0)) ETC
        
        Scala maps (like dictionaries)
        like python, without index
        unlike python, simple maps are immutable
        
        (void requires type specification, then types should be observed , but otherwise multitypes are allowed )
        a = Map[<key-type>, <val-type>]( "key" -> "value") == Map(("key1","value1"), ("key2", ""value2"))
        usage:
        a get <key> == a.get(<key>) -- returns type Option[<Type>], None if KeyNotPresent
        check null value (with present key!) a.contains(null)
        
        a(<key>) -- returns type Type, :!: raises NoSuchElementException if null
        safe usage: a getOrElse (<key>, <def-val>) --- this should be used instead of "default dictionaries", like in Python
        
        checking:
        a contains <key>
        .keys, .values
        updating:
        a + (<newkey> -> <newvalue>) == a.updated(<nkey>, <nvalue>)
        a ++ b
        filtering on condition:
        a filterKeys <predicate> == a.filterKeys(f(_)),
        where f is bool func
        filter by values
        a.filter({x => pred(x._2)==1)
        a mapValues <fun> -- map onto a map!!
        for ((k, v) <- <map>) yield (v, k)
        Create a Map from two lists:
        
        <l1>.zip(<l2>).toMap == <l1> zip <l2>.toMap
        (:!!: this goes to Ordinary Map ONLY, not to arbitrary map)
        (zip yet is not an array of tuples)
        on iteration, every map key:value pair is interpreted as a tuple, hence for pair:
        key = pair._1. value= pair._2
        
        Scala listmaps:
        (immutable dictionaries with "strict order", )
        until an update :!!:, so this is virtually useless
        import scala.collection.immutable.{ListMap, HashMap}
        Scala hashmaps:
        (immutable dictionaries with no order)
        Scala linkedhashmaps:
        (mutable dictinoaries with strict order)
        import scala.collection.mutable.LinkedHashMap
        .put(<key>, <value>) , .remove(<key>)- inplace operations, same as 'pythonic' assignment;
        a(<key>) = <value>
        
        Scala match:
        
        analog to switch expression in C++/Pascal/Octave/Java/ etc.
        (note that the order is converse, <param> goes first)
        <param> match { case <val1> => <code-to-do> case <val2> => <code-to-do> ... case _ => <fallback-code> }
        scala matches support default behaviour out-of-the-box, thus outfunctioning maps, but match can't be saved into map
        :!!: match outputs a value, thus the best way to save a match itself is to write it as a function body
        :check: complex exception catching expressions
        :check: replace all java switch statements
        
        subconditions for matches:
        
        <param> match { case <var1> if <var1-pred> => ... case Kvar1> if <var1-pred-2> ... }
        
        Scala Set:
        from scala.collections.immutable
        :!!: different types allowes
        a = Set(<el1>, <el2>)
        additions:
        a + "<el3>"
        a + b
        subtractions:
        a - "<el3>"
        a--b
        unions:
        a.union(b) == a | b
        a.diff(b) == a &~ b
        a.intersect(b) == a & b
        belonging:
        a contains x == a(x)
        a subsetOf b
        :?!: genset problems
        
        Scala Bitset:
        allows only non-negative values
        (both in mutable and immutable)
        Scala Hashset and TreeSet:
        
        implements set as a binary tree and doesn't preserve order
        Scala ListSet:
        maintain
        
        Seq in scala:
        
        .toSeq()
        val a = Seq(<el1>, <el2>, ...)
        
        Scala queues:
        (mutable fix size collection handling inhold in FIFO manner)
        Queue(<el1>, <el2>,...)
        .dequeue - retrieve first elm
        .enqueue(<el>) -- add to the end
        
        Scala stacks:
        (mutable fixed-size collection handling elms in LIFO manner)
        Stack(<el1>, ...)
        add value to top:
        stack.push(<elm>)
        retrieve
        .top
        remove top;
        .pop
        
        Scala stream:
        
        ([immutable] list with lazy evaluation, i. e. when sth is needed)
        scala.collections.mutable.Stream
        val strom = <el1> #:: <el2> #:: ... #:: Stream.empty
        strom.take(<n>) - the only possilble call
    - - Regular Expression:
        
        import scala.util.matching.Regex
        
        Scala-regex:
        
        <s1>.r--interprets as regex expression (as if calling "Regex(<s1>)" -- :!!: this does not work :!!: )
        find Element (pattern should be already a regexp!):
        <pattern> findOneIn <full-str>
        or <pattern> findFirstIn <full-str>
        find All
        <pattern>.findAllIn(<full-str>).toList (method returns iterator)
        
        Simple matching check:
        
        <string>.matches("<pattern-perl-string>")
    - - Scala string methods:
        
        <str>.charAt(<n>) == <str>{<n>}
        <s1>.compareTo(<s2>) -- compute lexicographical distance (negative if s2 needs reduction)
        <s1>.compareToIgnoreCase(<s2>)
        <s1>.concat(<s2>)
        <s1>*<scalar> -- replicate string
        String substitution:
        
        <s1>.replaceAll(<s2>)
        <s1>.replaceFirst(<s2>)
        String slicing:
        <s1>.subSequence(<start>, <end>), start counts , end ej coutns
        breaking by separator/ index:
        <s1>.split(<char>|<string>) - sep removes
        <s1>.splitAt(<idx>) - nought removes
        <s1>.trim - fjern padding and trailing spaces
        <s1>.stripLineEnd
        :!!: scala supports regex (for strings, not char) out-of-the-box, and splitting by "., \ " etc leads to unpredictable results =>split by char
        
        list To string:
        
        <list>.mkString(["<prefix-str>"], "<sep>", ["<postfix-string>"])
        :!!: this is required, otherwise renderes L-value :!!:
        IDEA suggests rendering with .mkString("Array(", ",", ")") for formal representation
        :!!: this works on arbitrary Spark RDD as well sparkDf.take(n).mkString(",")
        
        Multiline Strings:
        well skrives with """ (triple quotemarks) ,
        however padding enters preserves if newline insertes
        , thus in Scala Redactors with Linting,
        autoinsertes | (vbars) in place of new line (real ) beginning, and the .stripMargin method applies to string, cutting the spaces
      - SCALA string interpolation
        (analog to F-strings in Python)
        the compiler alters the strings s.t. they would match the respective formatting statements:
        s-interpolation:
        s-prefix, direct indtasting
        println(s"$<var> is a var")
        :check: this works if <var> is of lower type (e.g. int into string)
        arb exprs to paste, incl. those with vars, writes in figure brackets
        println(s"${f(var)} is a function of var)
        f-interpolation
        f-prefix, format necessary, hence typesafe
        println(f"$<var>%s is a var")
        raw interpolation
        'raw'-prefix, same as s-, but escape symbols are not interpreted
        println(raw"$var \n is a var") - takes a single line
    - - Scala read .JSON from file:
        
        val json = Source.fromFile(filename) // ( a file object) val mapper = new ObjectMapper() with ScalaObjectMapper mapper.registerModule(DefaultScalaModule) val parsedJson = mapper.readValue[Map[String, Object]](json.reader())
        source:
        https://code.dblock.org/2017/03/21/whats-the-simplest-way-to-parse-json-in-scala.html
        
        Better reading JSON from file:
        
        import org.json4s.native.Json
        import org.json4s.DefaultFormats
        import org.json4s.native.JsonMethods
        convert json to map:
        :check:
        val jObject = JsonMethods.parse(optionStrings) implicit val formats = DefaultFormats val readingOptions: Map[<typ1>, <typ2>] = jObject.extract[Map[<typ1>, <typ2>]]
        :warning: EXCEPTIONS:
        parseException -- invalidJSON
        MappingException -- .extract() method failure,
        consider extracting Map[<T>, Any]
        
        For JSON encoding:
        
        base64 codec:
        
        import org.apache.commons.codec.binary.Base64
        .encodeBase64String(<sample-string>)
        reverse:
        .decodeBase64(<string>)
        
        Java read JSON from objects:
        
        GSON
        import com.google.gson.Gson
    - - Generate UUID in scala
        
        import java.util.UUID
        UUID.randomUUID().toString -- generate
        UUID.fromString(<string>) -- parse
  - - - Scala List Comrehension:
        
        for { <iter> <- <array>
      - Direct .foreach method application:
        
        <coll>.foreach{<element> => <do-smth> }
        Enumerate a list:
        to get sequence of index:value pairs
        
        ll.zipWIthIndex().foreach{pair = > ...}
    - - Scala list comprehension ej works
        with column-wise aggregation inside select expression,
        instead, a map function should with sum and resultant list explosion
        should be applied:
        
        df.select( df.columns.map( c=> sum(col(c).isNull().cast("int")).alias(c)): _*)
        
        :!!: === (triple equality) is used for checking
        <=> null-safe equality checking
  - - - `
      - Configure
        user parameters in Java
        Properties object:
        import java.util.Properties
        Properties.set("username","<username>)
        ss.read.jdbc("<url>, "<schema>.<table>", <properties>)
    - - Make scala spark dataframe from
        
        collections with data types specified by schema
        
        import org.apache.spark.sql.Row
        Row.fromSeq(<array>) -- takes from array as well
        Row.fromTuple(<array>)
        Specify type schema:
        
        import.org.apache.spark.sql.types.{FloatType, IntegerType, DoubleType, StringType, StructType, StructField}
        for EVERY column:
        StructField(<col-name>, <col-type-object>, true)
        <col-type-object> rendres e.g. from map
        
        the entire schema is thus StructType(Array[StructField])
        finally:
        sc.parallelize(List(<row1>, <row2> , ...), <str-type>)
        Retrieve data from Schema:
        
        .fields -> Array[StructField]
        .simpleString -> String
        fieldNames -> Array[String]
        
        Extract known type from dataframe column(s):
        
        :check: (without this, anything collected is of type Any)
        <df>.select(<column>).rdd.map(_.getInt(<col-index>)).collect()
        Row.getAs[<type>](<col-index>)
        
        Specify specific BigDecimal Type:
        
        import org.apache.spark.sql.types. DataTypes
        .createDecimalType(<n-before-comma>, <n-after-comma>) -- this can then uses in StructType building
      - Insert Null/None into Spark Dataframe:
        
        the null should be inside a tuple, wherefrom Spark devises its type automatically (later can reconvertes with SQL)
        
        the tuple ej exceeds 22 in length
        
        for the tuple, all components' types should explicitly announces in declaration: (Option[T])
        and respective values/variables puttes as None
        
        :red_cross: mh use "null", any such attempt results in NPE!
        the recommended None: Option[...] does little when used simultaneously with different types
  - - - Scala case classes:
        
        should contain immutable data
        
        is final, ej inherites :!!:
        
        .apply() (initialising) method is written by default
        
        :!!: beware that scala classes have constructors, and these constructors typically, but
        not necessarily equal .apply()'s.
        
        new is used to call constructor for an object, otherwise .apply() is used
        
        Ordinary class:
        
        class <className>(param1: ..., param2: ...) { <constructor-code> def main(){ } def apply(){ } def method2(){ } }
        
        a simple CASE class with, almost like a struct in C/C++
        
        syntax:
        case class <class-name>(<par1>:<type1>, <par2>:<type2>);
        .copy() objects of class
        
        Scala classes Notes
        
        the most handy basis for all classes & objects is App
        
        basic an object on a trait App makes
        
        available the args array containing cmdline args
        
        makes the object code body a main method itself
        
        class members can be
        private and protected, but ~~public~~ ej exists, it's by default :check:
        
        class methods parameters are always vals! they cannot be modified within a method
        
        for a class constructor itself, it still important to spec if param x is val of var, if neither, it cannot uses as attr, it can only consumes in class implementation
        
        override - writes with no @
        
        protected means like in Python, only heirs can access this trait, not all objects in containing the package
        
        class methods should be pure functions. they should always return something, not modify objects. A simple .fit() method is unacceptable for scala.
        
        a
        
        Auxiliary constructors:
        
        after the primary constr has been defined:
        there can be arbitrary number of methods like;
        def this( param:type1, param2:type2) { ... }
        where reference to object itself is done with this (like self)
        
        Scala traits:
        
        :check: an encapsulation of methods and fields that can be inherited by class
        
        however unlike classes, many traits can be inherited (like a characteristic)
        
        :check: methods can be unimplemented for traits per se (but implementated for classes extending them)
        
        :check: a trait can extend another
        
        usage of a trait in a class is with with
        
        :check: since 2.12 , Scala traits compiles to Java 1.8 interface(exactly when default methods were allowed, before, it compiled to a class with some defined methods and an interface)
        
        keyword:
        
        <class1> extends <class2> with <trait1>
        :red_cross: traits can ej reuses in Java => write abstract classes
        :red_cross: traits cannot be very useful per se, in such case, they should be abstract classses
        :red_cross: traits EJ have constructors
        
        Write class to a file & send over network
        
        class should implement Trait Serializable
        (for saving classes to files & sending files over networks)
        @SerialVersionUID(<class-id>) class XXX(var yy:...) extends Serializable { }
        import java.io.{ObjectOutputStream, ObjectInputStream, FileInputStream, FileOutputStream}
        writing to file
        
        OOS(new F.O.S("/path/to/file"))
        .writeObject(<obj-name>)
        .close
        reading from a file
        ObjectInputStream(F.I.S.("/path/to/file"))
        <obj> = <O.I.S.>.readObject.asInstanceOf[<custom-class>]
        
        Scala sealed classes:
        :check: such that only subclasses (incl. case classes) defined in same source file may exist
        :!: any class can inherit from sealed class child
- - - - Labels and Breaks:
        
        to be broken out, the loop has to
        have its own label in front of for or while keyword:
        skrives so: <my-label>@ for (<variable> in <init> ... <end>)
        in loop body:
        break@<loop-label>
        continue@<loop-label>
- - - - STL forward list:
        
        "односвязный список"
        
        расходует на 1/3 меньше памяти
    - - STL iterators:
        
        vector<int>::iterator <pointer-name>
        Iterators are dereferenceable
        
        Input operators: single-pass algorithms only
      - STD foreach loops in STL:
        
        with std vec operators:
        
        std::for_each(<start-ptr>, <end-ptr>, <function>)
        OR
        pointer to array may uses as counter
        `for(ptr = vec.begin(), ptr < vec.end(), ptr++) { }
        std::advance(ptr, <index>) - switch pointer to next [info "in which array" is already stored]
        std::next(ptr, <index>)
        std::prev(ptr, <index>)
    - - C++ file I/O
        
        std::basic_ifstream() = ifstream() input
        std::basic_ofstream() = ofstream() output
        
        std::basic_fstream()
        (:!!: basic brings no sense)
        
        std::auto_ptr() - automatic pointer that self-destructs - :!!: THIS POINTER CANNOT NORMALLY COPIES - always use std::unique_ptr() instead
        
        .reset() - reset memory in unique pointer
        to resolve the place where pointer should go away, use bare {}
        the unique pointer from non-unique creates with std::make_unique()
        use header #include <fstream>
        write a file
        
        a file stream is created and put on place of cin//cout. :!!: in (iostream-header file)
        std::ofstream("filestream", std::ios::binary).write("tekst")
        read a file
        
        std::ifstream <op-file object> (<filename>, std::ios::binary);
        catch error
        if (!i<opfile>.isopen() ) {
        std::cout << "Failed to open";
        } {<fileopen-obj>.read(<new-var-name>, <size>)
        }
        RAII (рэи) in Python looks like with open() as f: ....
        
        Read entire content of stream:
        
        "content" = <ifstream>.rdbuf()
- - - - Const method in func:
        
        int <func-name> (<params>) const { }
        this becomes thus immutable
        :!!: better ti note so ALL methods that do not alter anything in object
  - - - typecasting functions:
        
        std::stoi("<string>") - find a number in string an convert it to integer
        std::stol("<string>") - find a number in string and convert to long
        std::stoll("<string>")
        find a number and convert to long long
        
        atoi() -- legacy
        
        C-like way:
        
        snprintf(<string-arr>, sizeof(<str-arr>) , value)
- - - - Convert numeral characters to integers:
        
        (stdlib.h)
        atoi(<char>) - convert to the integer
        
        atof(<char>) - conver to the float
    - - Cleaning memory in C++
        dynamically allocated for arrays
        delete[] <arr-name>
        for single var:
        delete <variable>
        can also delete NULL pointers
        :!!: local stack variables cannot destroyes so!
        free() can't uses to destroy memory made with new
        
        Class destructor:
        in class description:
        after instance declaration:
        Class()
        ~Class() {delete p[] stack-ptr }
        destructor extractes from class in same way as others:
        class-name:~class-name
        :!!: calles automatisk in end of program, of func
        
        no argument taken
        
        not static, not const.
        
        no returns, their type is not void = no return type!!!
        
        destructord objects can't take part in Union
        
        always in Public
        
        address inaccessible
      - Malloc in c++:
        
        IMalloc::Alloc()
        must followes:
        IMalloc::Free()
        simple malloc
        code doesn't allow for constructors and destructors
- - - - for-loop
        
        for (<iter-type> <start-i>; <cond>; <incr>) { <statement> }
        increment stt example: a = a + 1 , typically noted as a++ l
        
        condition is a normal condition expression, like in while loop
        
        Although as usual, infinite loops can be while loops, but in C++ they can be for loop wo params for ( ; ; )
      - Dowhile:
        
        do { <statement> ; } while (<condition>)
        identical to repeat-until
    - - No Foreach/ While (!) cycle in C, so
        with no index-based exit condition - the while -loop is more preferable
        while (string[i]!= '\0') { i++ }
        Foreach cycle in C++:
        actually requires a certain func to be applied to element:
        (over arbitrary array)
        for_each(arr.begin(), arr.end(), map-func)
        Read cycle in C++ while
        
        while (bool)(std::cin >> $var) { <something> }
        input casts to boolean
        :!!: for C and CPython (Assembler), it's unimportant whether.
- - - - :!!: Abstract classes can only be base for another classes =, they cannot beget objects themselves!!
        
        since for some actions of the class there is no adequate default variant!
        Abstract classes CAN have pointers and references
        
        :!!: Heir classes that have non-overriden virtual function, become abstract classes
        
        :!!: abstract classes MAY have constructors
        
        Since interface is a collection of methods declared, but none of which are implemented,
        an abstract class with ALL funcs pure virtual emulates an interface