23篇大数据系列（二）scala基础知识全集（史上最全，建议收藏）

val f2 = f1 _

val f2: (Int) => Int = f1

object ConstantPattern{　　def main(args:Array[String]) :Unit = {　　　　//模式匹配结果作为函数返回值　　　　def patternShow(x : Any) = x match {          //常量模式　　　　　　case 5 => "五"　　　　　　case true => "真"　　　　　　case "test" => "字符串"　　　　　　case null => "null值"　　　　　　case Nil => "空列表"          //变量模式          case x => "变量"          //通配符模式　　　　　　case _ => "通配符"　　　　}　　}}
变量模式和通配符模式，都可以匹配任意值，他们之间的区别是，变量模式匹配成功后，该变量中会存储匹配成功的值，在后续的代码中还可以引用，而通配符模式匹配成功后，不能再引用匹配到的值。另外要注意的是，由于模式匹配是按顺序匹配的，因此变量模式和通配符模式要写在表达式的最后面。

object TypePattern{　　def main(args:Array[String]) :Unit = {　　//类型匹配模式　　def typePattern(t : Any) = t match {　　　　case t : String => "String"　　　　case t : Int => "Intger"　　　　case t : Double => "Double"　　　　case _ => "Other Type"　　  }　　}}

object CaseClassPattern{　　def main(args:Array[String]) :Unit = {　　//定义一个Person实例　　val p = new Person("nyz",27)   //case class 模式　　def constructorPattern(p : Person) = p match {　　　　 case Person(name,age) => "name =" + name + ",age =" + age　　　　 case _ => "Other"　　　　}　　}}

object ConstantPattern{　　def main(args:Array[String]) :Unit = {　　　　//模式匹配结果作为函数返回值　　　　def patternShow(x : Any) = x match {          //模式守卫          case x if(x == 5) => "守卫"          //通配符模式　　　　　　case _ => "通配符"　　　　}　　}}

class OptionDemo {  val map = Map (("a",18),("b",81))  //get方法返回的类型就是Option[Int]  map.get("b") match {    case some(x) => println(x)    case None => println("不存在")  }}

trait Equal {  def isEqual(x: Any): Boolean  def isNotEqual(x: Any): Boolean = !isEqual(x)}

trait Equal { def isEqual(x: Any): Boolean def isNotEqual(x: Any): Boolean = !isEqual(x)}

class Point(xc: Int, yc: Int) extends Equal {  val x: Int = xc  val y: Int = yc  def isEqual(obj: Any) =    obj.isInstanceOf[Point] &&    obj.asInstanceOf[Point].x == x}
object Test {   def main(args: Array[String]) {      val p1 = new Point(2, 3)      val p2 = new Point(2, 4)      val p3 = new Point(3, 3)
      println(p1.isNotEqual(p2))      println(p1.isNotEqual(p3))      println(p1.isNotEqual(2))   }}

$ scalac Test.scala $ scala -cp . Testfalsetruetrue

// 定义整型 List，其元素以线性方式存储，可以存放重复对象。val x = List(1,2,3,4)
// 定义 Set，其对象不按特定的方式排序，并且没有重复对象。val x = Set(1,3,5,7)
// 定义 Map，把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象。val x = Map("one" -> 1, "two" -> 2, "three" -> 3)
// 创建两个不同类型元素的元组，元组是不同类型的值的集合val x = (10, "Bigdata")
// 定义 Option，表示有可能包含值的容器，也可能不包含值。val x:Option[Int] = Some(5)

val numbers = Seq(11, 2, 5, 1, 6, 3, 9)  numbers.max //11 numbers.min //1

case class Book(title: String, pages: Int)  val books = Seq(  Book("Future of Scala developers", 85),  Book("Parallel algorithms", 240),  Book("Object Oriented Programming", 130),  Book("Mobile Development", 495))  //下面代码返回Book(Mobile Development,495)books.maxBy(book => book.pages)  //下面代码返回Book(Future of Scala developers,85)books.minBy(book => book.pages)

val numbers = Seq(1,2,3,4,5,6,7,8,9,10) numbers.filter(n => n % 2 == 0)//上面返回Seq(2,4,6,8,10)

val books = Seq(  Book("Future of Scala developers", 85),  Book("Parallel algorithms", 240),  Book("Object Oriented Programming", 130),  Book("Mobile Development", 495))
books.filter(book => book.pages >= 300)//上面返回Seq(Book("Mobile Development", 495))

val abcd = Seq('a', 'b', 'c', 'd')val efgj = Seq('e', 'f', 'g', 'h')val ijkl = Seq('i', 'j', 'k', 'l')val mnop = Seq('m', 'n', 'o', 'p')val qrst = Seq('q', 'r', 's', 't')val uvwx = Seq('u', 'v', 'w', 'x')val yz   = Seq('y', 'z')  val alphabet = Seq(abcd, efgj, ijkl, mnop, qrst, uvwx, yz)
alphabet.flatten

List('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z')

val num1 = Seq(1, 2, 3, 4, 5, 6)val num2 = Seq(4, 5, 6, 7, 8, 9)  //返回List(1, 2, 3)num1.diff(num2)  //返回List(4, 5, 6)num1.intersect(num2)  //返回List(1, 2, 3, 4, 5, 6, 4, 5, 6, 7, 8, 9)num1.union(num2)
//合并后再去重，返回List(1, 2, 3, 4, 5, 6, 7, 8, 9)num1.union(num2).distinct

val numbers = Seq(1,2,3,4,5,6)  //返回List(2, 4, 6, 8, 10, 12)numbers.map(n => n * 2)  val chars = Seq('a', 'b', 'c', 'd')  //返回List(A, B, C, D)chars.map(ch => ch.toUpper)

val abcd = Seq('a', 'b', 'c', 'd')  //List(A, a, B, b, C, c, D, d)abcd.flatMap(ch => List(ch.toUpper, ch))

val numbers = Seq(3, 7, 2, 9, 6, 5, 1, 4, 2)  //返回turenumbers.forall(n => n < 10)  //返回falsenumbers.forall(n => n > 5)
//返回truenumbers.exists(n => n > 5)

import scala.io.Source

object ReadFile {  //读取ClasPath下的配置文件  val file = Source.fromInputStream(this.getClass.getClassLoader.getResourceAsStream("app.conf"))    
  //一行一行读取文件,getLines()表示读取文件所有行  def readLine: Unit ={    for(line <- file.getLines()){      println(line)    }  }   //读取网络上的内容  def readNetwork: Unit ={    val file = Source.fromURL("http://www.baidu.com")    for(line <- file.getLines()){      println(line)    }  }
 //读取给定的字符串-多用于调试 val source = Source.fromString("test") }

import scala.collection.JavaConversions.bufferAsJavaListscala.collection.mutable.Buffer => java.util.List

import scala.collection.JavaConversions.asScalaBufferjava.util.List => scala.collection.mutable.Buffer

import scala.collection.JavaConversions._
scala.collection.Iterable <=> java.lang.Iterablescala.collection.Iterable <=> java.util.Collectionscala.collection.Iterator <=> java.util.{ Iterator, Enumeration }scala.collection.mutable.Buffer <=> java.util.Listscala.collection.mutable.Set <=> java.util.Setscala.collection.mutable.Map <=> java.util.{ Map, Dictionary }scala.collection.concurrent.Map <=> java.util.concurrent.ConcurrentMap
scala.collection.Seq         => java.util.Listscala.collection.mutable.Seq => java.util.Listscala.collection.Set         => java.util.Setscala.collection.Map         => java.util.Mapjava.util.Properties   => scala.collection.mutable.Map[String, String]

class SayHello{  def write(content:String) = println(content)}implicit val sayHello=new SayHello
def saySomething(name:String)(implicit sayHello:SayHello){ sayHello.write("Hello," + name)}
saySomething("Scala")
//打印 Hello,Scala

val TEST_REGEX = "home\\*(classification|foundation|my_tv)\\*[0-9-]{0,2}([a-z_]*)".r

//path是用来匹配的字符串TEST_REGEX findFirstMatchIn path match {  case Some(p) => {    //获取TEST_REGEX中的第一个括号里正则片段匹配到的内容    launcher_area_code = p.group(1)    //获取TEST_REGEX中的第二个括号里正则片段匹配到的内容    launcher_location_code = p.group(2)    }}

//由于java和scala中的类型短名称重名，为避免歧义，进行了重命名import java.lang.{Long => JLong, Double => JDouble}//conn为数据库连接，sql为要执行的SQL语句queryRunner.update(conn, sql, new JLong(1L), new JDouble(2.2))