Java switch-case (pair value)
Scala is not only for values, but also for types, collections (map,list metadata matching), Object,class
Scala uses a lot of pattern matching (Match case)
Scala's pattern match, which differs from the Java switch case:
1. Not only can match the value, can match type
2. Can match the collection of arrays
An array of the same array, the same length, and an array beginning with an element
Automatic variable assignment for arrays of the same length
3. Match Class-Sample case Class
Like a bean in Java
Generally not change, the default is only getter
Can be used for message communication
The base class passes the parameters and matches the different subclasses with match to receive and process
Some () and none (), which indicate matching to and not matched when pattern matches
A case class and case object distinguish the former from producing multiple instances, the latter having only one instance, which is itself
Data input, which is a string
The underscore indicates neither spark nor Hadoop
Simple Example
Similar to the switch case statement
Underline represents the default condition
You can use the if to branch judgment by default
def bigData(dataage: Int){data match{case"Spark" => println("Wow!!"case"Hadoop" => println("OK!!")caseif(age>18) => println("adult")case _ => println("nothing")}}
Two parameters passed in
Pass in two parameter overrides
Variables outside of match can be automatically passed to the match variable
Data assignment to Data_
def bigData(data : String){ data match{ case"Spark" => println("wow") case"Hadoop" => println("ok") caseif"Flink" => println("cool"+data_) case _ => println("something else") }}
Output results
type Match
The exception type matches, the first type matches, the match filenotfound,exception itself prints out, including the full package name, the class name, followed by the fill in the information oops
exception(e :Exception){e match{case fileException : FileNotFoundException => println("File Not Found:"+fileException)caseException => println("Exception getting thread dump from $executorId",e)}}
Collection Match
arrays, arrays of specified elements, arrays of specified number of elements, and arrays beginning with an array of elements, set,list consistent
Pattern matching for array
Pass in three elements, assigned to Spark,hadoop,flink (they are three variables)
def data(array:Array[String]){array match{caseArray("Scala") => println("Scala")caseArray(spark,hadoop,flink) => println(spark+" : "+hadoop+" : "+flink)caseArray("Spark", _*) => println("Spark ...")//以Spark开头case _ => println("Unknown")}
class Matching
Case class is equivalent to Java in JavaBean default is the Val type only getter method, through case class can make the class pattern matching
def sayHi(person:Person){person match{ case Student(name,score) => println("I am a studnet:"+name+score) case Worker(name,salary) => println("I am a worker:"+name+salary) case _ =>println("Unknow") } }
Automatically match to worker (Worker,student is a subclass of person)
Case class generates multiple instances
Case object has only one instance
Generic functions
class Person[T](val content : T){def getContent(id : T) = id + " _ " + content }val p = new Person[String]("Spark")p.getContent("Scala")//必须为String 类型
Type System
generic classes, generic functions, type definitions (upperbound), view Bounds, covariance, and contravariance
Type parameters, mainly used for type qualification, to enhance the robustness of the Code
1. Generic classes and generic functions
2. Type definition
A type can also qualify a boundary, Upperbounds (<: denotes, upper boundary, is it or its subclass), (A;: Represents, the next boundary, is the parent of a class, or the class itself)
3. View definition
View definition (Bounds)
View Bounds Implicit conversion
Implicit implicit conversion of a type
implict def rddToSequendeFileRDDFuncions[K <% Wirtable:ClassTag,V <% Writable:ClassTag]
Type [T], the implicit value is injected into the context, and the injected process is automatic
class Compare[T :ordering](val n1:T,val n2:T){def bigger(implicit ordered :Ordering[T])=}
Manifest->classtag
T:classtag,t is generic, run-time has a more complete type match, and reflection gets the type of information
Scala pattern matching, type system and spark source reading