scala编程实战 pdf_scala一般做什么开发

package com.oracle.jt / * Object中类方法都是静态的 */ object Test { def main(args: Array[String]): Unit = { print("山东人民万岁！") //定义变量的格式：[val|var] 变量名[:数据类型]=值; //scala能自己识别数据类型 val a=23 val b="ff" val c:String="33"; var d="wangwu"; var e=33.333 //var val区别：val不能重新赋值 d="wangfeng" //var可以重新赋值 是真正的变量 print(a,b,c,d,e) } }

3.val与var区别（考试）

val变量值不能更改不能重新赋值 var变量的值可以更改

4.scala数据类型（考试）

Scala 和 Java 一样，有7种数值类型 Byte、char、Short、Int、Long、Float 和 Double(无包

装类型)和一个 Boolean 类型。没有包装类

package com.oracle.jt object Test2 { def main(args: Array[String]): Unit = { val v1:Int=23; val v2:Float=34.5f; val v3:Double=34.8d; val v4:Long=23; val v5:Short=23; val v6:Byte=23; val v7:Char='f' val v8:Boolean=true print(v1,v2,v3,v4,v5,v6,v7,v8) } }

5.Scala条件表达式（选择题）

条件表达式： 在给一个变量赋值的时候 大家有没有见到过一个变量的取值 在不同的条件下 变量的值是不一样的 
如果结果不符合条件表达式那么控制台将输出 ( )

package com.oracle.jt object Test3 { def main(args: Array[String]): Unit = { //条件表达式： //在给一个变量赋值的时候 大家有没有见到过一个变量的取值 //在不同的条件下 变量的值是不一样的 var b=23 var a=if(b>20) 56 else 90; println(a) val c=if(b>50) 90 print(c) //如果不符合条件 打印括号（） } }

package com.oracle.jt object Test3 { def main(args: Array[String]): Unit = { //条件表达式： //在给一个变量赋值的时候 大家有没有见到过一个变量的取值 //在不同的条件下 变量的值是不一样的 val str="aa" val f=if(str.equals("aa")) "fff" else "sss" print(f) //如果不符合条件 打印括号（） } }

package com.oracle.jt object Test3 { def main(args: Array[String]): Unit = { //条件表达式： //在给一个变量赋值的时候 大家有没有见到过一个变量的取值 //在不同的条件下 变量的值是不一样的 val a=2; val b=3; val c=if(a+b==5) 66 else 99; print(c) //如果不符合条件 打印括号（） } }

6.块表达式

在Scala中最后一行变量是用来赋值或者当作返回值的

package com.oracle.jt object Test4 { def main(args: Array[String]): Unit = { val a={ //print(0.to(10).toBuffer) var b=0 //求0-10的累加和 for(a <- 0.to(10)) { b=b+a } b // b放在for循环外 表示把b的值赋给a } //{} 块 print(a) } }

7.循环

Scala中 for循环是用来遍历集合的

后面只能跟集合

Java中for循环是用来控制循环次数的

package com.oracle.jt object Test6 { def main(args: Array[String]): Unit = { var a=Array(3,4,5,6,7)//Array()就是Java的数组 //for(变量名<-集合){} for(elm<-a) { println(elm) } } }

在Scala中任何数据都是对象

//如果我想Java那样用for循环生成一串数字 那就只能使用下面的方法 //var b=Array(0,1,2,3,4,5,6,7,8,9) var b1=0.until(10) //产生左闭右开的区间数字 var b2=0.to(10) //产生闭开区间数字 print(b1) println(b2)

1）练习（菜就多练）：

求1-100累加和求1-100偶数和

package com.oracle.jt object Test7 { def main(args: Array[String]): Unit = { val sum= { var s=0 var s1=0 for(sum<-0.to(100)){ s=s+sum } s } println(sum) val sum2={ var s= 0 for(sum2<-0.to(100)){ if(sum2%2==0) s=s+sum2 else s=s+0 } s } print(sum2) } }

2）代码改进

package com.oracle.jt object Test7 { def main(args: Array[String]): Unit = { val sum= { var s=0 var s1=0 for(sum<-0.to(100)){ s=s+sum } s } println("1-100的累加和为："+sum) val sum2={ var s= 0 for(sum2<-0.to(100)){ if(sum2%2==0) s=s+sum2 else s=s+0 } s } println("1-100的偶数和为："+sum2) val sum3={ var s= 0 for(sum3<-0.to(100)){ if(sum3%2==1) s=s+sum3 else s=s+0 } s } print("1-100的奇数和为："+sum3) } }

3）for循环中加判断条件

在for循环中我们可以加判断条件这样的话对于求偶数和就变得更简单了

package com.oracle.jt object Test8 { def main(args: Array[String]): Unit = { val a=1.to(10) var b=0 for(elm <- a;if(elm%2==0)){ b=b+elm println(elm) } print(b) } }

8.Scala函数式编程（核心）

在Scala中所有的算数运算符都是方法

package com.oracle.jt object Test9 { def main(args: Array[String]): Unit = { val a=22 val b=13 val c=a.+(b) val d=a.*(b) val e=a./(b) val f=a.-(b) val g=a.%(b) print(c,d,e,f,g) } }

1）Scala定义方法

package com.oracle.jt object Test10 { //Scala定义方法的格式 / * def 方法名 (a:数据类型,b:数据类型....) [={}] * []表示可以省略 * 关于大括号 如果就一行代码 大括号可以省略 * 关于等号 如果没有返回值 可以省略 */ // 一行代码 可以省略 {} def add()= println("山东人民万岁") //有参数 无返回值 可以省略 = def add(a:Int,b:Double){ val c=a+b println(c) } //有返回值 写 = def add(a:Int,b:Double,c:Int)={ val d=a+b+c if(d>0) d else 13 } def main(args: Array[String]): Unit = { add() //静态方法可以直接调用 add(12,34.7) val res=add(12,34.6,78) //有返回值 接收一下 print(res) } }

①注意:

//有返回值 写 = def add(a:Int,b:Double,c:Int): Unit={ val d=a+b+c if(d>0) d else 13 }

//有返回值 写 = def add(a:Int,b:Double,c:Int)={ val d=a+b+c if(d>0) d else 13 }

②练习1

在主方法中传递一个带 , 的字符串给普通方法普通方法返回以 , 为分隔符之后的数组

在主方法中打印数组中的每个元素

package com.oracle.jt object Test11 { def main(args: Array[String]): Unit = { val s="jhw,yyq" val res=splt(s) for(elm <- res){ println(elm) } } def splt(s:String):Array[String]={ val res=s.split(",") res } }

③练习2

在主方法中创建A对象为A的对象赋值传递A对象给普通方法在普通方法中打印A对象中的值

package com.oracle.jt class A { private var Sname: String=_; private var Ssex: String = _; def getSname():String=Sname def setSname(name:String):String= { Sname=name Sname //返回姓名值 } def getSsex():String=Ssex def setSsex(sex:String):String= { Ssex=sex Ssex //返回性别值 } } package com.oracle.jt object Test12 { def prt(a:A)={ val name=a.getSname() val sex=a.getSsex() println(name) println(sex) } def main(args: Array[String]): Unit = { val a=new A a.setSname("jhw") a.setSsex("nan") prt(a) } }

2）Scala定义函数

①重要思想

目标：

1.学会定义函数（思想：函数是变量函数是方法）

val 函数名=(a:参数类型,b:参数类型....)=>{代码块返回值}

2.学会调用函数

函数名(参数值1,参数值2....)

为什么说Scala的一行代码抵得上Java的很多行代码？

因为Scala的代码都已经以函数的形式写好了

可以直接调用使用

效果如下：

package com.oracle.jt object Test13 { //函数的定义：val 函数名=(a:参数类型,b:参数类型....)=>{代码块 返回值} val add=(a:Int,b:Int)=>a+b def main(args: Array[String]): Unit = { //函数的调用：函数名(参数值1,参数值2....) val d=add(13,45) println(d) } }

②练习：

用函数实现下面的需求：

在主方法中传递一个带 , 的字符串给普通方法普通方法返回以 , 为分隔符之后的数组

在主方法中打印数组中的每个元素

package com.oracle.jt object Test14 { val splitString=(s:String)=>{ val res:Array[String]=s.split(",") for(elm<-res){ println(elm) } } def main(args: Array[String]): Unit = { var s="a,b,c,d,e" splitString(s) } }

③函数的声明及调用

package com.oracle.jt object Test13 { //函数的定义：val 函数名=(a:参数类型,b:参数类型....)=>{代码块 返回值} //val fun=(a:String,b:String,c:String)=>a+b+c //val add=(a:Int,b:Int)=>a+b //函数是变量 现在把它传递给一个方法 //函数声明：把函数实现变为参数类型和返回值类型 然后起个名字就可以了 def myAdd(f:(Int,Int)=>Int): Int ={ //声明以后我们就可以调用了 val res=f(12,23) res //直接写f(12,23)也没错 Scala简洁 } def strconat(s:(String,String,String)=>String):String={ val a="你" val b="好" val c="坏" s(a,b,c) } def main(args: Array[String]): Unit = { //函数的调用：函数名(参数值1,参数值2....) //val d=add(13,45) //println(d) //函数的实现 val res1=myAdd((a:Int,b:Int)=>a+b) //方法右返回值 接收一下 //val res1=myAdd(add) println(res1) val res2=strconat((a:String,b:String,c:String)=>a+b+c) //val res2=strconat(fun) println(res2) } }

练习：写出 a-b 的函数式编程（使用函数的声明和实现）

package com.oracle.jt object Test15 { def mySub(f:(Int,Int)=>Int)={ val a=12; val b=23; f(a,b) } def main(args: Array[String]): Unit = { val res = mySub((a: Int, b: Int) => a + b) print(res) } }

④练习：

定义一个方法包括一个参数参数类型是函数

函数有两个参数 Int String

返回Int和String的拼接

在主方法中调用方法并传递函数实现

package com.oracle.jt object Test16 { def strAdd(f:(Int,String)=>String)={ f(521,"一生一世") // val a=521 // val b="一生一世" // a+b } def intAdd(f:(Int,String)=>Int)={ val a=521 val b="一生一世" a+b } def main(args: Array[String]): Unit = { val res1=strAdd((a:Int,b:String)=>a+b) println(res1) val res2=strAdd((a:Int,b:String)=>a+b) print(res2) } }

package com.oracle.jt object Test17 { def splitStr(f:(String)=>Array[String])={ f("a,c,d,e") } def main(args: Array[String]): Unit = { //在实现的时候 我们可以不写类型 val res=splitStr((f:String)=>f.split(",")) for(elm<-res){ println(elm) } val array=Array[String]("a,b","c,d","e,f") val a = array.map(s => s.split(",")) println(a.toBuffer) } }

⑤Scala中map用法

map是用来对数组中的每个元素做一对一类型转换的 
array.map的参数是String 返回值可以是任何类型

我们可以自己定义一下map的内容

package com.oracle.jt import scala.collection.mutable.ArrayBuffer class ArrayDemo { val array=new ArrayBuffer[String]() def add(s:String): Unit ={ array.append(s) } def map(f:(String => Array[String])): ArrayBuffer[Array[String]] ={ val cvtArray=new ArrayBuffer[Array[String]]() for (elm<-array){ cvtArray.append(f(elm)) } cvtArray } } package com.oracle.jt object Test20 { def main(args: Array[String]): Unit = { val array=new ArrayDemo() array.add("a,d") array.add("c,e") array.add("g,h") val res=array.map(x=>x.split(",")) println(res) } }

我们也可以直接用因为Scala已经给我们写好了

 val array1=new ArrayBuffer[String]() array1.append("1,2") array1.append("3,5") array1.append("3,5") val res1 = array1.map(s => s.split(",")) println(res1)

3）方法转化为函数

package com.oracle.jt object Test21 { def add(a:Int,b:Int)=a+b def main(args: Array[String]): Unit = { //把方法转换成函数 val fun=add _ val res=fun(213,456) println(res) } }

到此这篇scala编程实战 pdf_scala一般做什么开发的文章就介绍到这了,更多相关内容请继续浏览下面的相关推荐文章，希望大家都能在编程的领域有一番成就！

上一篇：每当我想放弃Scala，我就写写Python和Java_为什么不建议学python

下一篇： Scala基础入门：从零开始学习Scala编程

版权声明：
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若内容造成侵权、违法违规、事实不符，请将相关资料发送至xkadmin@xkablog.com进行投诉反馈，一经查实，立即处理！

转载请注明出处，原文链接：https://www.xkablog.com/scalabc/1830.html

Scala编程基础

Scala：简洁优雅，函数式编程之美。

说在前面

1.Scala创建类

2.Scala定义变量