循环、选择结构
import java.util
object Demo9Supply {
def main(args: Array[String]): Unit = {
/**
* scala中的数据类型
*/
//基本数据类型
val byte:Byte = 1
val short:Short = 1
val int:Int = 1
val long:Long = 100
val float:Float = 1.1F
val double:Double = 1.2D
val boolean:Boolean = true
val char:Char = 'c'
//Any 好比是Java中的Object
//AnyRef 是所有引用类型的基类
//AnyVal 是所有基本类型的基类
val str:AnyRef = "abc"
/**
* 循环
*/
//while循环计算1-100的和
var i = 1
var sum = 0
while (i<=100){
sum=sum+i
i+=1
}
println(sum)
//do while循环计算1-100的和
var x = 100
var y = 200
var x_y = 0
do{
x_y = x+y
} while (x>y)
println(x_y)
//for循环
//实际上scala中的for循环和Python类似,只有for each
//也有range函数
//计算1-100的和
val list = new util.ArrayList[Int]()
var sum2 = 0
for (elem <- Range(1, 101, 1)) {
sum2+=elem
}
println(sum2)
//选择结构
val age = 18
if(age>=18){
println("成年")
}else if(age<0){
println("年龄输入不正确")
}else if(age<18){
println("未成年")
}
}
}
样例类
伴生对象
//object B1和class B1互为伴生对象和伴生类,
//创建对象的时候,可以new一个B1类来创建对象
//也可以用伴生对象的apply方法创建对象或者直接省略,直接创建
val lisi: B1 = B1.apply(“002”,“李四”)
val wangwu: B1 = B1(“003”,“王五”)
B1.fun()
object Demo10Apply {
def main(args: Array[String]): Unit = {
val a: A1 = new A1("001","张三")
val b: B1 = new B1("001","张三")
}
}
class A1(id:String,name:String){
val _id:String = id
val _name:String = name
}
class B1(id:String,name:String){
val _id:String = id
val _name:String = name
}
//称之为B1的伴生对象
object B1{
def fun(): Unit ={
println("fun")
}
//这里会返回一个对象,该对象的类型是跟object同名的一个类
def apply(id:String,name:String): B1 ={
val b1 = new B1(id,name)
b1
}
}
函数
函数可以定义在Scala中的 类中、object中、函数中
object Demo11Func1 {
/**
* 函数可以定义在
* 类中、object中、函数中
*/
def fun() ={
println("fun")
}
def main(args: Array[String]): Unit = {
//函数的最后一行代码默认作为返回值
def fun1(): Unit ={
println("hello " + fun2())
}
def fun2(): Unit ={
"world"
}
}
}
/**
* 函数的省略
* 1、return 关键字可以省略 默认最后一行代码作为返回值
* 2、返回值类型可以省略 可以根据返回值自动推断
* 3、只有一行代码的时候 花括号可以省略
* 4、如果函数没有参数 括号可以省略
*/
def fun3(str:String): Int ={
return str.toInt + 100
}
//1.函数return关键字可以省略
def fun4(str:String):Int = {
str.toInt + 100
}
//2.返回值类型可以省略
def fun5(str:String) ={
str.toInt + 100
}
//3.花括号可以省略
def fun6(str:String) = str.toInt + 100
//4.括号可以省略
def fun7 = "hello world" //这是一个函数
函数式编程
Java中是面向对象编程,是把对象传来传去,对象作为参数传入时会有类型限制,对象作为返回值时也会有类型限制
Scala函数式编程,把函数传来传去,函数作为参数传入时会有类型限制,函数作为返回值时也会有类型限制
有两类,一类是以函数作为参数,一类是以函数作为返回值
函数的类型
什么是函数的类型:
跟def关键字无关
跟函数名无关
跟函数实现的功能无关
跟函数的参数名无关
函数的类型由 参数的类型(类型、个数、顺序)以及返回值的类型共同决定
/**
* 函数类型
* @param str
* @return
*/
//fun1是一个有一个参数,参数类型为string,返回值类型为int类型的函数
def fun1(str: String): Int = {
str.toInt + 100
}
//fun2是一个有一个参数,参数类型为string,返回值类型为int类型的函数
def fun2(str: String): Int = {
str.toInt + 100
}
//fun3是一个有一个参数,参数类型为int,返回值类型为int类型的函数
def fun3(i: Int): Int = {
i + 3
}
//这里fun1和fun2为同类型函数,fun3不属于
lambda表达式用以简化
/**
*f:String=>Int
*f:是funX函数所需要的参数的参数名
*String=>Int:是funX所需要的参数的类型
*=> 左边的部分 表示 所传进来的函数 的 参数类型
*=> 右边的部分 表示 所传进来的函数 的 返回值类型
*/
//这里定义了一个函数,它可以接收一个函数
def funX(f:String=>Int) = {
val i:Int = f("200")
println(i)
}
/**
* lambda表达式 匿名函数 用以简化函数
*/
//定义了一个有两个参数 类型分别是string 和 int,返回值类型为int这样的匿名函数
(str:String,int:Int) => {
str.toInt + int
}
//使用lambda简化fun1
val i :String => Int =(str:String)=>str.toInt + 100
def main(args: Array[String]): Unit = {
println(fun1("200"))
println(fun2("200"))
funX(fun1)
funX(fun2)
//lambda简化
funX((str1:String)=>{
str1.toInt + 1
})
//lambda的简化
//1.如果代码只有一行 花括号可以省略
//2.参数的类型可以省略 括号也可以顺便省略
//3.如果参数只被调用了一次,则可以使用_下划线替代
funX((str1: String) => str1.toInt + 1)
funX(str1 => str1.toInt + 1)
funX(_.toInt + 1)
funX(i)
println(i("100"))
}
函数作为参数
这里面函数作为map函数的参数
object Demo13Func3 {
//函数作为参数的应用
def main(args: Array[String]): Unit = {
val array: Array[Int] = Array[Int](1,2,3,4,5,6,7,8)
println(array) //打印出来一个地址
//指定一个分隔符,将数组中的元素依次拼接,最后得到一个string
//同split相反,split是将一个string分割,最后得到一个数组
println(array.mkString(","))
//对array中的每个元素加1
//以函数式编程的思想来做,需要用到map函数,map函数可以对里面的元素做变化
def add(i:Int):Int = {
i+1
}
array.map(add).foreach(println)
// array.map(_ + 1).foreach(println)
}
}
函数作为返回值
/**
* 以函数作为返回值,也有类型的限制
*/
//在以函数作为返回值时,需要手动给定类型 自动推断会有问题
//这里定义了一个以函数作为返回值的函数
def fun1(str1: String):String=>Int={
def fun2(str2:String):Int={
str1.toInt + str2.toInt
}
fun2
}
函数柯里化
//这里定义一个函数,可以传入两个参数
def fun3(str1:String,str2:String): Int ={
str1.toInt + str2.toInt
}
//函数的柯里化:将一个有N个参数的函数 变成 N个只有一个参数的函数;也就是把括号拆开来罢了
def fun4(str1:String)(str2:String):Int={
str1.toInt + str2.toInt
}
偏函数
//偏函数:将一个含有N个参数的函数,变成含有N-X个参数的函数 X表示固定的参数;也就是把其中一个变量固定罢了
//计算a的b次方
def fun5(a:Int,b:Int = 3):Double = {
Math.pow(a,b)
}
感谢阅读,我是啊帅和和,一位大数据专业大四学生,祝你快乐。