u012045045的博客

object ImplicitDemo2 extends App {var a: Int = 10var b: Double = 10.99b = 100b = a//定义一个隐式转换函数，把double转换成intimplicit def doubleToInt(x: Double) = x toInt//可以编译通过a = ba = 90.99//会有数据的精度损失println(a)}...

//定义一个隐式类object ImplicitClass {//定义一个隐式类//隐式类只能定义在类、trait、object内部//隐式类的构造函数只能带一个非隐式参数implicit class IntWithTimes(x: Int) {def time[A](f: => A): Unit = {//递归方法需要指明返回类型def loop(current: Int): Unit = {if (current > 0) {floop

//隐式引用//默认会给引入三个包import java.io.Fileimport java.lang._import scala._import scala.Predef._import scala.io.Sourceobject ImplicitDemo extends App {val a: Int = 1println(a)val map = Map("a" -> 1)val aa = 1 to 10val aaa = 1.

object MethodDemo extends App {//方法的嵌套：方法体里面定义其他嵌套//阶乘def factorial(x: Int): Int = {def fact(x: Int, accumulator: Int): Int = {if (x <= 1) accumulatorelse fact(x - 1, x * accumulator)}fact(x, 1)}println(factorial(4))/

柯里化是把接收多个参数的函数变成接收一个单一参数的函数，返回一个接收余下参数的新函数。object CurryDemo extends App {//创建一个普通方法def add(x: Int, y: Int) = x + yprintln(add(1, 2))//柯里化后的方法def curryAdd(x: Int)(y: Int) = x + yprivate val function: Int => Int = curryAdd(1)printl

什么是闭包闭包是一个函数，函数的返回值依赖于函数外部的一个或者多个变量object FunDemo1 extends App {var factor = 5val mul = (x: Int) => x * 5val mul2 = (x: Int) => x * factorprintln(mul2(10))factor = 10println(mul2(10))val mul3 = (x: Int) => {factor = factor

参数是函数 返回值是函数 参数和返回值都是函数object HFunctionDemo extends App {//传入的参数是函数private val array = Array(1, 2, 3)val fun = (x: Int) => x * 2val res = array.map(fun)println(res.toBuffer)//传入匿名函数val res1 = array.map((x: Int) => x * 2)println(res

import scala.util.matching.Regexobject RegeDemo extends App {//构建一个正则表达式val pattern1 = "[0-9]+".rval pattern2 = new Regex("[0-9]+")// 如果正则表达式含有斜杠或者引号 可以使用三引号"""..."""val pattern3 ="""\s+[0-9]+\s+"""val matchStr = "99qazwsxedc100dfsf"//fin

import java.io.PrintWriter import scala.io.Source object FileDemo extends App { //读取文件行 val source = Source.fromFile("src/test.txt") //获取文件的行迭代器 private val lines: scala.Iterator[String] = source.getLines() for (elem pri...

object StringDemo { def main(args: Array[String]): Unit = { //插值器 f s raw //s字符串插值器 val name = "zhangsan" val res = s"Hello,$name" println(res) //对${}里面的表达式进行计算或者转换 val res1 = s"1+1=${1 + 1}" println(res1) //f插值器...

object OptionDemo { def main(args: Array[String]): Unit = { val map = Map("a" -> 1, "b" -> 2) println(map("a")) // println(map("c")) //可见通过这个方式去取数据的话，如果不存在的话会报错 println(map.getOrElse("c", 0)) val a: Option[Int] = map.get("...

用sealed修饰的类或者特质约束：不能在类定义文件之外定义它的子类作用避免滥用继承 用在模式匹配中 sealed abstract class Furniture case class Couch() extends Furniture case class Chair() extends Furniture object SealedDemo { def findPlaceToSite(furniture: Furniture): String =

//学习偏函数 object PartialFunctionDemo { //定义一个普通的函数 val div1 = (x: Int) => 100 / x val div2 = new PartialFunction[Int, Int] { override def isDefinedAt(x: Int): Boolean = x != 0 override def apply(v1: Int): Int = 100 / v1 }...

类似java switch常量模式匹配变量模式匹配通配符模式匹配 object PatternDemo { def main(args: Array[String]): Unit = { //常量模式匹配 // 常量字面值的匹配 val site = "baidu.com" site match { case "baidu.com" => println("success") ///下划线相当于java中的default，不

object CaseClassDemo { def main(args: Array[String]): Unit = { //定义样例类 //默认带有apply方法 //构造函数的参数默认是public val修饰的 //虽然可以显示的将其改为var修饰的，但是不推荐这种方法 case class Message(sender: String, var recipient: String, body: String) val message...

package testScalaimport testScala.Teamobject printTest {def test(spark: SparkSession): Unit = {val teamArr = spark.SparkContext.parallelize(Range(1, 10))val teamArr2 = teamArr.map(id => {val team = new Teamteam.setId(id)team})teamArr

//把瘦接口变成胖接口 trait Logger2 { def log(msg: String) def info(msg: String): Unit = { log(s"INFO:$msg") } def error(msg: String): Unit = { log(s"ERROR:$msg") } def warn(msg: String): Unit = { log(s"WARN:$msg") }...

trait Logger { def log(msg: String) } //子特质实现父特质里面的抽象方法 trait ConsoleLogger extends Logger { override def log(msg: String): Unit = println(msg) } //给日志加上一个时间戳 trait TimestampLogger extends ConsoleLogger { override de...

//定义一个带有抽象方法的特质 trait Iterator[T] { def hasNext: Boolean def next(): T } trait ConsoleLogger { def log(msg: String): Unit = { println(msg) } } //特质类似java中的接口，但是比接口更强大 //定义一个类，实现我们的特质 //如果是一个特质 使用extends ，...

//抽象类不可以被实例化 abstract class Person { //抽象字段 没有初始化值 var name: String //抽象方法：没有方法体 def id: Int def smile: Unit ={ println("hahahhha") } } //继承抽象类 class Employ extends Person{ //覆盖父类字段方法override可加可不加 ove...

class Point(val xc: Int, val xy: Int) { var x: Int = xc var y: Int = xy def move(dx: Int, dy: Int): Unit = { x = x + dx y = y + dy //打印移动后的坐标 println("x 坐标:" + x) println("y 坐标:" + y) }}//继承了父类的所有属性和方法//重写父类的非抽象方法，要用overr.

class User(val name: String, val password: String) {}object User { //apply方法 注入器 def apply(name: String, password: String) = new User(name, password) //unapply 提取器 def unapply(arg: User): Option[(String, String)] = { if (arg == null) .

//对象的伴生类class AcountInfo { var id = AcountInfo.newUniqueNumber}//类的伴生对象：伴生对象和类可以互相访问彼此的私有属性或者方法object AcountInfo { private var last = 0 private def newUniqueNumber: Int = { last += 1 last } def main(args: Array[String]): Uni.

/*class ConstructorDemo { var a: Int = 0 println(" Constructor study") //定义辅助构造函数 def this(a1: Int) { //需要调用主构造函数或者其他辅助构造函数 this() this.a = a1 }}*///定义带有参数的主构造函数/*class ConstructorDemo(var b: Int) { var a: Int = 0 printl.

class PersonS { //相当与final类型的数据，编译后只会生成与其对应的get方法 val a: Int = 1234 //会生成public修饰的get/set方法 var b: String = "" //会生成private修饰的get/set方法 private var c: Int = 0 //啥也不会生成，只可以在当前类中使用，只有当前对象可以调用该属性 private[this] var d: Int = 0 object test {.

object CollectionLearn { //学习常用的集合函数 def main(args: Array[String]): Unit = { //1-sum、max、min val list1 = List(1, 2, 3) println("求和" + list1.sum) println("最大值" + list1.max) println("最小值" + list1.min) //2-filter-过滤 println.

set中的元素不允许重复 元素无序随机object SetLearn { //学习set def main(args: Array[String]): Unit = { //默认创建的set是不可变的 val set1 = Set(1, 2, 3) println(set1) println(set1 + 4) println(set1 - 1) //如果想创建可变的set集合，需要使用scala.collection.mutable.S

object YuanZuLearn { //元组的学习 def main(args: Array[String]): Unit = { val t1 = (1, 2, 3) val t2 = ("zhansgan", "lisi", 3) //元组的元素是不可以修改的 println(t1._1) println(t2._2) val t3, (a, b, c) = ("wangwu", "zhaoliu", 4) println(t3.

object MapLearn { def main(args: Array[String]): Unit = { //创建Map val map1 = Map("zhangsan" -> 10, "lisi" -> 5) println(map1) println(map1.getClass.getName) val map2 = Map(("zhangsan", 10), ("lisi", 5)) println(map2) .

import scala.collection.mutable.ListBufferobject ListLearn { def main(args: Array[String]): Unit = { //不可变list var list1 = List(1, 2, 3) println(list1) println(list1.getClass.getName) //在list头部添加一个元素 val list2 = 10 :: list1.

import scala.collection.mutable.ArrayBufferobject ArrayLearn2 { def main(args: Array[String]): Unit = { //变长数组的定义 val arr1 = ArrayBuffer("a", "b") println(arr1) val arr2 = ArrayBuffer[String]("a", "b") println(arr2) val ...

object ArrayLearn { def main(args: Array[String]): Unit = { //定长数组的定义 val arr1 = Array(1, 2, 3) println(arr1) val arr2 = Array[Int](4, 2, 3) println(arr2.length) println(arr2(0)) arr2(0) = 90 println(arr2(0)) val ar.

什么是集合？集合是存储各种数据类型对象的一个容器。是一个容器 一般是存储同种数据类型的对象 一般是存放多个对象集合的分类不可变集合：不可修改，但是可以模拟修改或者删除等。 可变修改：可以修改，可以更新或者扩展三大类set 序列 map...

区别：方法与函数的定义语法不同； 方法一般定义在类、特质、object中； 方法可以共享所在类、特质、object的属性； 可以直接调用函数，也可以将其存放到一个变量中，也可以做为参数传递给其他方法或者函数，也可以作为返回值；练习可以把函数作为参数传递给一个方法； object FunctionAndMethod { def main(args: Array[String]): Unit = { println(m(f)) }

object LearnFunction { def main(args: Array[String]): Unit = { println(fun2(1, 2)) println(fun3(1, 2)) println(fun4(1, 2)) println(fun5(1, 2)) println(fun6(1, 2)) println(fun7(1, 2)) fun8() } //下面这5个方法表示的意思是一样的都是表示加法 .

方法定义的语法：def 方法名称（参数列表）：返回类型=方法体返回类型在方法是递归方法的时候必须指明，其他情况，可以省略。 object HelloWorld { def main(args: Array[String]): Unit = { println("hello world") println(add(1, 2)) println(add2(1, 2)) println(add3(1, 2)) println(a

forfor（i<- 表达式、数组、集合）scala> for(i<- 1 to 10){println(i)}12345678910scala> for(i<- 1 to 10)println(i)12345678910scala> for(i<- 1 until 10)println(i)12...

表达式就是一个语句块，包含一个或者多个语句。特点：（1）表达式是有返回值的；（2）返回值是表达式中的最后一条语句的执行结果。 scala> val a=1 val a: Int = 1 scala> val res=if(a>0) 100 else -100 val res: Int = 100 scala> val res=if(a>0)"success"else"fail" val res:

数据类型（1）值类型（相当于java中的基本数据类型），值类型是类类型，相当于java中的包装类，没有基本类型与包装类型之分；（2）引用类型1.在 scala 中有一个根类型 Any ,他是所有类的父类.2.scala中一切皆为对象，分为两大类AnyVal(值类型)，AnyRef(引用类型)，他们都是Any子类.3.Null 类型是 scalaNull 类型是 scala的特别类型，它只有一个值 null, 他是 bottom calss ,是 所有 AnyRef 类..

定义变量var 变量名=初始化值var 变量名：数据类型=初始化值（1）定义变量的时候需要初始化（抽象字段除外）（2）定义变量的时候可以不指定变量的数据类型，系统会根据变量的初始化值推断变量的数据类型；var a=1一旦确定类型后，则不可改变，比如已经确认a是Int类型，则不可以为其赋值10.9定义常量val 常量名=初始化值val 常量名:数据类型=初始化值注意：val修饰的常量，相当于java中final修饰的变量，就是常量。val修饰的变量，如果类.