Spark学习--------Scala循环控制语句、元祖、数组、集合

最新推荐文章于 2023-03-20 08:59:17 发布

原创最新推荐文章于 2023-03-20 08:59:17 发布 · 2.1k 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#scale循环控制

spark 专栏收录该内容

7 篇文章

订阅专栏

本文详细介绍了Scala中的值类型隐式转换、强制类型转换、值类型与字符串的转换，重点讲解了判断语句、循环语句（while、do-while、for）及其特殊形式，元组的创建与操作，数组的创建、访问和遍历，以及集合List、Set、Map和Vector的基本用法。通过实例解析，帮助读者深入理解Scala编程中的这些关键概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

0.值类型隐式转换

        (高阶隐式转换和隐式函数,这里我们先不讲)
        当scala程序在进行赋值或者运算的时候,精度小的类型
        自动转换为精度大的类型,这个就是自动类型转换(隐式转换)
    //char -> Int
    var a: Int = ‘a’
    //int -> double
    var d: Double=100
细节注意:
    1)有多种类型进行混合运算时,系统首先将所有的类型,转换成精度最大
的那种数据类型,然后再进行计算
     例子

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

     2)当我们把精度大的类型赋值给精度小的类型时,就会出现错误,反之就是
自动类型转换.
     3)(byte,short)和char之间是不会进行类型转换的
val a: Byte = 10
val b: Char = a
     4)byte ,short ,char 三者是可以计算,计算的时候首先转换成Int类型

			val a: Byte = 10
			val b: Char = 90
			val c:Short =a+b	
			val d:Short = 10+90 
			val e:Short =100

1.强制类型装换

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

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

细节注意:
1)当进行数据的从大–>小的转换的时候,我们需要使用强制转换
2)强制转换至针对最近的操作数有效,往往需要使用小括弧,提升其优先级

		   		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类型来处理

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

当我们测试,或者是写小项目的时候,需要用到从控制台输入信息
版本问题:

<dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>2.12.2</version>
        </dependency>

//1.新版本
val name = StdIn.readInt()
//2.老版本
var name =console.readLine()

3.判断语句

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

	if(布尔表达式)
			{
		  // 如果布尔表达式为 true 则执行该语句块
			}

例子:

object Test {
			   def main(args: Array[String]) {
				  var x = 10;

				  if( x < 20 ){
					 println("x < 20");
				  }
			   }
			}

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

if(布尔表达式){
		   // 如果布尔表达式为 true 则执行该语句块
		}else{
		   // 如果布尔表达式为 false 则执行该语句块
		}

例子:

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 执行该语句块
			}

例子:

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(){
	}
}

案例：

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

4.循环语句

scala的循环语句给我们提供了三类
1)while
2)do while
3)for
1)while
1.语法格式如下：

while(条件)
		{
			  方法体
			}

2.案例

// 局部变量
			var a = 10
			// while 循环执行
			while (a>3){
			  a-=1
			  println(a)
			}

2)do while
a.语法格式如下：

do {
				  方法体
				} while( 条件 );
				注意：他是先执行一次方法题

b.案例

 // 局部变量
					var a = 10
					// while 循环执行
				   do {
					  println("Value of a: " + a)
					  a = a + 1
					}while (a < 10)
				  }

3)for
a.基本语法

 for (循环条件) {
				  方法体
				}

b.案例

 for (i <- 0 to 10) {
				  println(i)
				}

c.for 循环保护式，也成条件判断式
基本案例：

	//if i!=2  相当于我们的continue,它不是退出，而是跳过
   for(i<-0 to 3 if i!=2){  //注意这里，没有关键字的时候，一定要有分号
    				  println(i)
    				}

d.for 循环返回值
1.基本语法
yield :可有把for循环的内容放到一个Vector集合里面,并返回
//Vector 是一个容器，可以保存其他数据对象，也称为集合,后续内容会讲到
2.案例1

val list=for(i<- 0 to 10) yield i
		println(list)

3.案例2

val vec = for (i <- 0 to 10) yield {
				  if (i % 2 == 0) {
					i
				  } else {
					"不是偶数"
				  }
				}
			println(vec)

5.循环跳出语句

循环控制语句(scala 中不支持break continue)

	   // 创建 Breaks 对象
		val loop = new Breaks
		// 在 breakable 中循环
		loop.breakable {
		  // 循环
		  while (true) 
			println("这里只循环一次-------")
			loop.break;
		  }
		}

6.元祖的介绍和使用

1)概念
元祖是scala中一个非常有用的容器对象,用于存放不同类型的数据元素,当然他是不可变的
关键字:不同类型长度不可变
2)元组的创建
val tuple=(1,“abc”,false)
val tuple1 = new Tuple2(1,2)
3)元组的操作
元组是通过下划线+下标索引进行访问的,并且是从1开始

	 val tuple = (1, 2, 3, 4)
	// println()
	val a = tuple._1 + tuple._2 + tuple._3 + tuple._4
	println(s"元祖中所有元祖的和是: $a")

7.数组的介绍和使用

1)概念
数组是一个存放相同类型元素的集合
分为可变数组和定长数组
2)数组创建方式
a.定长数组的创建

val array = new Array[String](3)
				val arr02 =  Array("a", "b", "c")

b.变长数组创建

val arrayBuffer = new ArrayBuffer[String]()
			  val arrayBuffer01 = ArrayBuffer()

2)数组的操作使用
a.定长数组的赋值和访问注意:数据的访问时通过下标索引,是从0开始的

		array(0) = "a"
		array(1) = "b"
		array(2) = "c"
		println(array(0))
		println(array(1))
		println(array(2))

b.变长数据的赋值和访问

		arrayBuffer.append(1)
		arrayBuffer.append(2)
		arrayBuffer.append(3)
		println(arrayBuffer(0))
		println(arrayBuffer(1))
		println(arrayBuffer(2))

c.定长数组遍历操作

 for (item <- array) {
					  println(item)
					}

d.变长数组遍历操作

 for (item<-arrayBuffer){
					  println(item)
					}

e.数组的常用函数

	  		//元素求和
			 println(arrayBuffer.sum)
			//最大值
			println(arrayBuffer.max)
			//最小值
			println(arrayBuffer.min)
			//排序(默认是升序)
			println(arrayBuffer.sorted)
			 //降序
			println(arrayBuffer.sortWith(_>_))

8.集合的介绍和使用

a.展示一张关系图

b.集合的分类
List(列表) :有序可重复
Set(集合) :无序不可重复
Map(映射) :键值对 (key 不可重复)
tuple(元祖):是不同类型值的集合
Vector(容器):是一个容器,可以保存不同数据对象

1)List(列表) :有序可重复
列表类似于元祖,他们所有的元素的类型都是一样
1.list的定义

//为什么不需要new:不适用new 关键字创建对象而是通过object apply :类似于构造器

			   //1.字符串列表
				 val strings = List("abc","d","e")
				//2.整数列表
				val ints = List(1,2,3,4)
				//3.二维列表
				val intses = List(List(1,2,3,4),List(1,2,3,4))

2.List的操作
for循环遍历打印列表中的元素

  //循环遍历集合
    for(i<- 0 until strings.length ){
    					 println( strings(i))
    					}
    				//
    					   for (item <- list) {
    					  println(item)
    					}

list.head:返回列表第一个元素
list.tail:返回一个列表处理第一元素以外的其他元素
list.isEmpty:列表如果为空的时候放回出
list.last :获取最后一个元素
//合并两个列表(两种方式)

 // val strss=strings:::strings01
					 val strss = List.concat(strings, strings01)

// 适应.fill创建一个重复次数为n次的列表

val site = List.fill(3)("gao") 
println( "site : " + site  )
println(site(0).getClass.getName)

3.scala中List 和listBuffer的区别

//可变的				
val buffer = ListBuffer[String]()
//向可变的buffer中添加元素,并打印查看
				    buffer.append("a")
					buffer.append("b")
					buffer.append("c")
					println(buffer)
				//元素移除
					buffer.remove(1)

2)Set(集合) :没有重复的对象集合,所有元素都是唯一
特点:无序 ,不重复
1.Set的定义
不能变集合定义
val set=Set(1,2,3)
可变集合的定义
val set = collection.mutable.SetString
2.Set的操作

增加元素
		 //1.赋值
		添加元素
		set.add("a")
		set.add("b")
		set.add("c")
		set+="d"
		减少元素
		set.drop(1)
		set-="b"
		//2.打印
		set.foreach(item => {
			println(item)
		})

3)Map(映射)
参考一下:https://www.runoob.com/scala/scala-maps.html
Map(映射)是一种可迭代的键值对（key/value）结构
key不可重复
分类:可变的不可变
1.Map的定义
//不可变

    var A:Map[Type,Type] = Map()
    val map = Map("key01" -> "value01", "key02" -> "value02")

//可变的

val map = collection.mutable.Map[String,String]()
		//添加
		map.put("", "")
		//去除
		map.remove("k1")
		//获取所有的keys
		println(map.keys)
		//获取所有的value
		println(map.values)
		//判断是否为空
		println(map.isEmpty)

4).Vector 是Scala标准包的一部分，我们可以直接使用，不需要导包
1)创建 Vector
无需使用new关键字就可以创建 Vector 容器实例。创建实例的同时我们可以放入元素
//创建Vector对象
val vec = Vector(1,2,3)
//Vector通过索引下标访问元素,Vector 的元素索引是从0开始的，使用圆括号将索引号括起来可以获得指定元素

   println(vec(0))
	 //Vector的遍历
			for (item <- vec) {
				 println(item)
			}
	//倒转 Vector
		 val vec = Vector(1, 2, 3)
		 println(vec)
		 println(vec.reverse)
	//Vector的排序
			val vec = Vector(1, 2, 3,1,4,7,1,3,9)
			println(vec)
			println(vec.sorted)
	//返回第一元素
			vec.head  
	//返回除了第一个元素的所有元素
			vec.tail