学习spark--(2)--scala(2)

1. 隐式转换

1)当scala程序在进行赋值或者运算的时候，精度小的类型。当自动转换为精度大的类型，这个就是自动类型转换(隐式转换)

//char  -> Int
var a: Int = 'a'
//int -> double
var d: Double=100

2)细节注意： 

-1-当有很多种类型混合运算时，系统先将所有的类型，转换成精度最大的那种数据类型，然后再进行计算

//4.5f+10 ==> float
val a = 12.12f
val b=10
val c=a+b

-2-当我们把精度大的类型赋值给精度小的类型时，就会出现错误，反之就是自动类型转换

-3-(byte,short)和char之间是不会进行类型转换的

demo:
val a: Byte = 10
val b: Char = a//error:编译报错，类型转换问题

-4-byte,short,char 三者是可以计算，计算的时候首先转换成Int类型

val a: Byte = 10
val b: Char = 90
val c:Short =a+b//error:类型转换
val d:Short = 10+90//error:类型转换
val e:Short =100

2. 强制类型装换

1)它是自动转换类型的逆过程,将容量大的数据类型转换成容量小的数据类型,使用的时候要加上强制转换函数,但可能造成精度的降低和溢出,使用的时候 要格外的注意

demo:
//java中的强制类型转换:int a=(int)12312.1231;
val a:Int=2.345.toInt
val b:Int=2.345f.toInt

 2)细节注意

-1-当进行数据的从大-->小的转换的时候,我们需要使用强制转换

 -2-强制转换至针对最近的操作数有效,往往需要使用小括弧,提升其优先级

demo:
val b=10*3.5.toInt+7*1.5.toInt
println(b)
val c=(10*3.5+7*1.5).toInt
println(c)

-3-Byte和Short类型,在运算的时候当做Int类型来处理

值类型和字符串类型的转换

1)基本数据类型转换为String

demo:
//double-->String
val d = 3.5
val c = d + ""  //看到灰色的下划线,说明编译类型做了转换
//boolean --> String
val a = true + ""
println(a)
println(true.getClass.getName)

2)String类型转换为基本数据类型

demo:
val s1="21"
val int = s1.toInt
val float = s1.toFloat
val double = s1.toDouble
val byte = s1.toByte
val long = s1.toLong
val short = s1.toShort

3)细节注意：

再将String转换为基本类型的时候，确保能够有效的转换

键盘输入语句

当我们测试，或者是写小项目的时候，需要用到从控制的太输入信息，版本问题的情况下有两种输入方式：

<dependency>
    <groupId>org.scala-lang</groupId>
    <artifactId>scala-library</artifactId>
    <version>2.12.2</version>
</dependency>
//1.新版本
val naem=StdIn.readInt()
//2.老版本
var name = Console.readLine()

3.语句

判断语句：

1) if 语句的语法格式如下

if(布尔表达式)
	{
		// 如果布尔表达式为 true 则执行该语句块
	}
demo:
	object Test {
		def main(args: Array[String]) {
			var x = 10;
			if( x < 20 ){
				println("x < 20");
			}
		}
	}

2)if...else 语句对应的语法如下:

if(布尔表达式){
	// 如果布尔表达式为 true 则执行该语句块
}else{
	// 如果布尔表达式为 false 则执行该语句块
}
demo:
	object Test {
		def main(args: Array[String]) {
			var x = 30;
            if( x < 20 ){
				println("x 小于 20");
			}else{
				println("x 大于 20");
			}
		}
	}

3)if...else if...else 语句

if...else if...else 语法格式如下：
    if(布尔表达式 1){
		// 如果布尔表达式 1 为 true 则执行该语句块
	}else if(布尔表达式 2){
		// 如果布尔表达式 2 为 true 则执行该语句块
	}else if(布尔表达式 3){
		// 如果布尔表达式 3 为 true 则执行该语句块
	}else {
		// 如果以上条件都为 false 执行该语句块
	}
demo:
	object Test {
		def main(args: Array[String]) {
			var x = 30;
			if( x == 10 ){
				println("X 的值为 10");
			}else if( x == 20 ){
				println("X 的值为 20");
			}else if( x == 30 ){
				println("X 的值为 30");
			}else{
				println("无法判断 X 的值");
			}
		}
	}

4)嵌套判断

if(){
	if(){
	}
}
demo：
	val a = 10
	val b = 15
	if (a > 4) {
	    if (b > 10) {
		    println("这是嵌套判断-------")
	    }
    }

循环语句

1)while

//1.语法格式如下：
    while(条件)
    {
	    //方法体
    }
//2.demo:	
    // 局部变量
    var a = 10
    // while 循环执行
    while (a>3){
        a-=1
	    println(a)
    }

2)do   while

//1.语法格式如下：
	do {
		//方法体
	} while( 条件 );
		//注意：他是先执行一次方法题
//2.demo
	// 局部变量
	var a = 10
	// while 循环执行
	do {
		println("Value of a: " + a)
		a = a + 1
		}while (a < 10)
	}

3)for

//1.基本语法
	for (循环条件) {
		//方法体
	}
//2.案例
	for (i <- 0 to 10) {
		println(i)
	}
//3.for 循环保护式，也成条件判断式
	demo：//if i!=2  相当于我们的continue,它不是退出，而是跳过
	for(i<-0 to 3 if i!=2){  //注意这里，没有关键字的时候，一定要有分号
		println(i)
	}

--1--for循环返回值

//1.基本语法
//yield :可有把for循环的内容放到一个Vector集合里面,并返回 
//Vector 是一个容器，可以保存其他数据对象，也称为集合,后续内容会讲到
//2.demo01
	val list=for(i<- 0 to 10) yield i
	println(list)
//3.demo02
val vec = for (i <- 0 to 10) yield {
	if (i % 2 == 0) {
		i
	} else {
		"不是偶数"
	}
}
println(vec)

--2--循环跳出语句

//循环控制语句(scala 中不支持break  continue)	
// 创建 Breaks 对象
	val loop = new Breaks
    //1.在 breakable 中循环，break功能
	loop.breakable {
	// 循环
	    while (true) 
	        println("这里只循环一次-------")
		    loop.break;
	    }
	}
    //2.在循环中,continue功能
    while(true){
       loop.breakable {
	        while (true)
               if(){
                  println("这里跳过本次-------")
		          loop.break;
               }
	        }
	    } 
    }