scala入门（一）

最新推荐文章于 2022-06-27 18:33:59 发布
最新推荐文章于 2022-06-27 18:33:59 发布
阅读量239 收藏
点赞数
分类专栏： scala 文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44273391/article/details/101097085
版权

scala入门（一）

数据类型 变量名；
数据类型 变量名 = 初始化值；
scala 定义变量
var 变量名 = 初始化值
var 变量名：数据类型=初始化值
var a=1
定义变量的时候需要初始化值
定义变量的时候可以不指定变量的数据类型，系统会根据变量的初始化值推断变量的数据类型
scala定义常量
val 变量 =初始化值
val 变量：数据类型=初始化值
val修饰的变量，相当于java中final修饰的变量
val 修饰的变量，变量的类型的值类型（相当于java的基本数据类型，Int DOUBLE）；值是不可以修改的

  var a=10
  a=100//不可以
  val修饰的变量，变量的类型是引用类型，引用不可变，引用的内容可变
  val a1=Array(1,2,3)
  val a2=Array(4,5,6)
  a1=a2//不可以，引用不可变
  a1（0）=10 //可以，引用内容可变
  val的变量还可以用lazy修饰，值在需要获取或使用的时候赋值
  lazy val a =100

val ? var
官方推荐使用val
数据类型和操作符
数据类型
值类型和引用类型
值类型是类类型，相当于java的包装类，没有基本数据类型和包装类之分

操作符

数学运算符：±/* %
关系运算符：>>=<<=!
逻辑运算符：&&||
位运算符：&|^
比较对象：== ！=
（1）scala中的运算符都是方法的重载，是方法的调用
（2）scala中没有++ --运算符，可以用+= -=来代替

表达式

就是一个语句块，包含一天或者多条语句

特点

（1）表达式是有返回值得

（2）返回值是表达式中最后一条语句的执行结果、

条件表达式

含有if/else的语句块

scala> val res = if(a>0) "success" else -100
res: Any = success
scala> val res = if(a>0) "success" else "wqe"
res: String = success
//缺失else的表达式
scala> val res = if(a>0) 100
res: AnyVal = 100
scala> val res = if(a<0) 100
res: AnyVal = ()//unit类型
scala> val res =if(a>0) 100 else if(a>0) -100 else 0
res: Int = 100
scala> val res = if(a<0) 100 else()
res: AnyVal = ()
块表达式

{一条或多条语句}

scala> val res ={val a=10
     | var b =20
     | a+b
     | }
res: Int = 30
scala> val res ={var a=10
     | a =20 }
scala> println(res)
()
scala> val res ={println("asd")}
asd
scala> println(res)
()
循环语句

for:

for(i <- 表达式、数组、集合)
scala> for(i <- 1 to 10){println(i)}
1
2
3
4
5
6
7
8
9
10

scala> for(i <- 1 to 10)println(i)
1
2
3
4
5
6
7
8
9
10

scala> for(i <- 1 until 10)println(i)
1
2
3
4
5
6
7
8
9

scala> 1 to 10
res5: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> 1 until 10
res6: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)
scala> for(i <- 0 until s.length)println(s(i))
s
c
a
l
a
scala> for(i <-  s)println(i)
s
c
a
l
a
scala> for(i <- 0 until s.length)println(s.charAt(i))
s
c
a
l
a
scala> for (i <- 1 to 3;j <- 1 to 3 if(i!=j))println(10*i+j)
12
13
21
23                                                                   
31
32
scala> var res=for (i <- 1 to 10 )yield i*10
res: scala.collection.immutable.IndexedSeq[Int] = Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
scala> for (i <- 1 to 3){
     | if(i==3){
     | println(3)}
     | for (j <- 1 to 3){
     | if(i != j ){
     | println(i*10+j)}
     | }
     | }
12
13
21
23
3
31
32

​

while

while(条件语句){表达式}
scala> var i =1
i: Int = 1
scala> while(i < 3){println(i)
     | i+=1
     | }
1
2

do while

do {表达式}while{条件语句}
方法

定义语法

def 方法名 （参数列表）： 返回类型（可省略，递归不可省略） = 方法体（表达式）

返回类型在方法是递归方法的时候，一定要指明，其他情况，可以省略

scala> def add(x:Int,y:Int)=x+y
add: (x: Int, y: Int)Int

scala> add(1,2)
res1: Int = 3

scala> add(x=1,y=2)
res2: Int = 3

scala> var c = add(x=2,y=8)
c: Int = 10

scala> print(c)
10
scala> def add(x:Int,y:Int):Unit={x+y
     | print(x+y)}
add: (x: Int, y: Int)Unit

scala> add(1,2)
3

带有参数列表的方法

scala> def addAndMultiply(x:Int,y:Int)(z:Int)=(x+y)*z
addAndMultiply: (x: Int, y: Int)(z: Int)Int

scala> def addAndMultiply(x:Int)(y:Int)(z:Int)=(x+y)*z
addAndMultiply: (x: Int)(y: Int)(z: Int)Int

scala> def addAndMultiply(x:Int,y:Int,z:Int)=(x+y)*z
addAndMultiply: (x: Int, y: Int, z: Int)Int

scala> def addAndMultiply(x:Int,y:Int,z:Int)=(x+y)*z
addAndMultiply: (x: Int, y: Int, z: Int)Int

scala> addAndMultiply(3)(4)(5)
<console>:9: error: not enough arguments for method addAndMultiply: (x: Int, y: Int, z: Int)Int.
Unspecified value parameters y, z.
              addAndMultiply(3)(4)(5)
                            ^

scala> def addAndMultiply(x:Int)(y:Int)(z:Int)=(x+y)*z
addAndMultiply: (x: Int)(y: Int)(z: Int)Int

scala> addAndMultiply(3)(4)(5)
res6: Int = 35

scala> def addAndMultiply(x:Int,y:Int,z:Int)=(x+y)*z
addAndMultiply: (x: Int, y: Int, z: Int)Int

scala> addAndMultiply(3,4,5)
res7: Int = 35

​ 无参方法

scala> def printInfo=println("i love scala")
printInfo: Unit

scala> printInfo
i love scala

scala> printInfo()
<console>:9: error: Unit does not take parameters
              printInfo()
scala> def printInfo()=println("i love scala")
printInfo: ()Unit

scala> printInfo
i love scala

scala> printInfo()
i love scala

带有默认值参数的方法

scala> def printInfo(str:String="helo scala")=println(str)
printInfo: (str: String)Unit

scala> printInfo("asdsa")
asdsa

scala> printInfo()
helo scala
scala> def add(x: Int=1,y:Int,z:Int=3)=println("x="+x,"y="+y,"z="+z)
add: (x: Int, y: Int, z: Int)Unit

scala> add(1)
<console>:9: error: not enough arguments for method add: (x: Int, y: Int, z: Int)Unit.
Unspecified value parameter y.
              add(1)
                 ^

scala> add(1,2)
(x=1,y=2,z=3)

scala> add(2,2,2)
(x=2,y=2,z=2)

scala> add(y=2)
(x=1,y=2,z=3)

可变长参数方法

scala> def add(a:Int*)={
     | for(i <- a)
     | println(a)}
add: (a: Int*)Unit

scala> add(1)
WrappedArray(1)

scala> add(1,2)
WrappedArray(1, 2)
WrappedArray(1, 2)
scala> def add(a:Int*)={
     | for(i <- a)
     | println(a(i-1))}
add: (a: Int*)Unit

scala> add(1)
1

scala> add(1,2,3,4)
1
2
3
4

scala>
函数

scala> (x:Int,y:Int)=>x+y
res18: (Int, Int) => Int = <function2>
scala> res18(1,2)
res22: Int = 3

scala> val fun = (x:Int,y:Int)=>x+y
fun: (Int, Int) => Int = <function2>

scala> fun(1,2)
res23: Int = 3
scala> val fun=((x:Int,y:Int)=>x+y)
fun: (Int, Int) => Int = <function2>

scala> val fun=(_:Int)+(_:Int)
fun: (Int, Int) => Int = <function2>
scala> val fun:(Int,Int)=>Int=(_+_)
fun: (Int, Int) => Int = <function2>

scala> val fun:(Int,Int)=Int=(x,y)=>x+y
<console>:7: error: reassignment to val
       val fun:(Int,Int)=Int=(x,y)=>x+y
                            ^

scala> val fun:(Int,Int)=>Int=(x,y)=>x+y
fun: (Int, Int) => Int = <function2>

scala> val fun =new Function2[Int,Int,Int]{
     | def apply (x:Int,y:Int)=if(x<y)x else y
     | }
fun: (Int, Int) => Int = <function2>

scala> fun(1,2)
res25: Int = 1

scala> val fun =(x:Int,y:Int)=>if(x<y) x else y
fun: (Int, Int) => Int = <function2>

scala> fun (1,2)
res26: Int = 1

无参函数

scala> val fun1 = () =>println("java and scala")
fun1: () => Unit = <function0>

scala> fun1()
java and scala

scala> fun1
res28: () => Unit = <function0>

多参函数

scala> val fun2=(x:Int,y:Int) => x*y
fun2: (Int, Int) => Int = <function2>

scala> fun2(2,3)
res31: Int = 6

scala> fun2(x=2,y=3)
<console>:9: error: not found: value x
              fun2(x=2,y=3)
函数与方法的区别于联系

区别：

1.方法和函数定义的语法不同

2.方法一般定义在类，特质，或者object中

3.方法可以共享所在类、特质、或者object中的属性

4，可以调用函数，也可以存在到一个变量中，作为参数传递给其他的方法或者函数，也可以作为返回值

联系：

1.可以把函数作为参数传递给方法

scala> def m(f:(Int,Int)=>Int)=f(5,1)
m: (f: (Int, Int) => Int)Int

scala> val f =(x:Int,y:Int)=>x-y
f: (Int, Int) => Int = <function2>

scala> m(f)
res36: Int = 4

2.方法可以转换成函数

a,把一个方法作为参数传递给其他方法或函数

b,使用方法名加空格加下划线把方法显示的转换成函数

scala> def m2(x:Int,y:Int) = x-y
m2: (x: Int, y: Int)Int

scala> m(m2)
res37: Int = 4

scala> m(m2 _)
res38: Int = 4

scala>

流浮影
关注
专栏目录
scala入门教程
tortelee的博客
01-30 437
官网教程：http://docs.scala-lang.org/tour/basics.html *********官网还是非常人性化的，可以直接运行调试代码。******************** val，是value的简称，表示一个数值，可以定义类型，但是不能修改。val x:Int = 2 var，是variables的简称，表示一个变量，也是可以定义类型，也可以修改。
Scala 入门
m0_52313753的博客
04-15 444
Scala 入门1. Scala 简介2. 开发环境3. 基本语法4. 基本函数式 1. Scala 简介 Scala 是一门多范式（multi-paradigm）的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。 Scala 运行在 Java 虚拟机上，并兼容现有的 Java 程序。 Scala 源代码被编译成 Java 字节码，所以它可以运行于 JVM 之上，并可以调用现有的 Java 类库。 官网: https://scala-lang.org/ 2. 开发环境 IDEA + Scala
scala 入门
一格博客
07-10 2514
安装配置scala首先scala是基于java开发环境的扩展，系统首先需要保证配置好jre和jdk。官方推荐使用java 6 以上版本， 但事实在即将发布的新版本scala 2.12版本中， 只会支持 java 8， 所以我在这里也首先安装了java 8 jdk。scala需要安装的组件分为两部分， 我的开发环境是在mac下， 所以使用了brew的方法进行了安装， 命令分别是:brew instal
Scala入门必看
CSDN_bird的博客
07-09 246
Scala初识 概述：作为scala入门的第一个单元重点掌握开发scala的工具的配置，以及环境的代表，本单元包括以下几个重点内容，main方法的讲解、方法和函数的区别、变量和常量的定义、懒加载的机制以及其应用、插值器的应用等重点。 （1）数据类型 在Scala中，所有的值都有类型，包括数值 和函数。 ①　图示 ②　描述 Any是所有类型的超类型，也称为顶级类型。Any有两个直接子类：AnyV...
scala学习笔记：集合
白乔专栏
02-06 939
scala> 1 to 10 res9: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)scala> List(1,2,3,4) res10: List[Int] = List(1, 2, 3, 4)scala> (1 to 10).map(_*3).filter(_%2==1).re
Scala入门学习教程.docx
09-22
Scala入门学习教程 本资源摘要信息为 Scala 入门学习教程，旨在帮助读者快速掌握 Scala 语言的基本概念和编程技术。该教程面向具有一定编程经验的读者，尤其是 Java 语言的开发者。 知识点一：Scala 语言简介 ...
Scala入门教程详解
08-25
Scala入门教程详解 Scala是一种能够运行于JVM和.Net平台之上的通用编程语言，具有简洁、优雅、类型安全的编程模式。Scala语言具有两大特点：纯面向对象编程语言和函数式编程语言。 纯面向对象编程语言 Scala语言...
Scala入门教程文档
最新发布
10-02
Scala入门教程文档，原视频地址：https://www.bilibili.com/video/BV1Q5411t74z/?spm_id_from=333.337.search-card.all.click&vd_source=9d8a366730d0394fa41e3b867372fc03
scala入门精华讲义
04-10
总之，"Scala入门精华讲义"是一份全面的学习资源，旨在引导初学者逐步掌握Scala的基础语法、面向对象编程特性以及在大数据处理中的应用。通过深入学习和实践，你将能够利用Scala的强大功能，开启大数据领域的探索之...
Scala编程入门
01-07
Scala源代码(.scala)会被编译成Java字节码(.class)，然后运行于JVM之上，并可以调用现有的Java类库，实现两种语言的无缝对接。 Scala 单作为一门语言来看， 非常的简洁高效 快速入门 在idea中集
关于spark中的问题
hxbdc56的博客
09-09 2009
1.在spark中使用scala语言，它会自动判定一个读取的rdd是键值对还是元组， 当一个键值对和元组合并时就会出现如下错误 Unspecified value parameters: numPartitions: Int. Unspecified value parameters: partitioner: Partitioner. Type mismatch, expected: RDD[(...
Scala编程语言入门学习笔记
m0_37118493的博客
03-01 1245
数据类型和操作符 数据类型 （1）值类型和引用类型 （2）值类型是类类型，相当于java中的包装类，没有基本数据类型和包装类之分 scala> 1 to 10 res4: scala.collection.immutable.Range.Inclusive = Range 1 to 10 scala> 1.to(10) res5: scala.collection.immutable...
聊聊Scala编程中隐式相关的那些事儿（二）
weixin_43620695的博客
06-27 603
接着第一篇讲，说说隐式值和隐式变量，从生活场景出发说说自己的理解，如有谬误敬请指正
Scala之高阶函数（Most Important）
zhikanjiani的博客
05-15 744
高阶函数：******** val l = List(1,2,3,4,5,6,7,8) //List就是一个框，框中装的是1-8这8个数字 //1 * 2 每个元素都做一个相同的操作 l.map((x:Int) => x*2) 提示：unspecified value parameters:f:Int => NotInferedB ...
Flink隐式转换报错
11-19 533
如果在Flink编程中遇到以下报错， 不要慌。 这只是一个隐式转换的问题， 要求我们导入一个包就可以了。 【最后给出】 Error:(9, 32) could not find implicit value for evidence parameter of type org.apache.flink.api.common.typeinfo.TypeInformation[String] val value = dataSet.flatMap(_.split(" ")) Error:(9, 3
大数据面试·Spark篇（一）
正趣果上果
07-01 543
Spark的shuffle算子一、去重二、聚合三、排序四、重分区五、集合或者表操作 一、去重 def distinct() def distinct(numPartitions: Int) 二、聚合 def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)] def reduceByKey(partitioner: Partitioner, func: (V, V) => V): RDD[(K, V)] def gro
Scala2.11.7学习笔记(五）类和对象
weixin_34363171的博客
09-28 143
鲁春利的工作笔记，好记性不如烂笔头类：类是对象的模板，通过构造类，能够使用new关键字声明一系列同结构的对象。对象：除了使用类构造对象模板，还可以使用object构造单例对象。继承：继承是类的拓展。特质：类似于java中的接口，但是可以包含实现方法。一个类只能集成自一个父类，但可以拓展自多个特质。1、类定义classHelloWorld{ ...
scala 方法与函数
sowhat
10-15 661
scala 方法与函数 定义方法 定义方法的基本格式是： def 方法名称 (参数列表):返回值类型 = 方法体，Scala中 方法规则是如果没有入参则尽量只用方法名定义该方法。 def add(x:Int,y:Int):Int = x+y //也可以定义成 //def add(x:Int,y:Int)=x+y //或者 def add(x:Int,y:Int){x+y} //没有...
TimeUnit的使用
每天进步一点点儿
07-18 7986
TimeUnit是java.util.concurrent包下面的一个枚举类，表示给定单元粒度的时间段 主要作用 时间颗粒度转换 延迟执行 常用的颗粒度 NANOSECONDS MICROSECONDS MILLISECONDS SECONDS MINUTES HOURS DAYS 1、时间颗粒度转换 2、延时执行（和Thread.sleep类似...
Scala入门教程：为Java程序员设计
"这篇教程是为有一定Java编程基础的程序员准备的Scala入门指南，由Michel Schinz和Philipp Haller编写，中文版由Bearice翻译，dongfengyee整理。教程涵盖了从简介到高级特性的多个主题，旨在帮助Java开发者理解Scala...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值