package Test.E1
import scala.collection.mutable.Set
import scala.collection.mutable.Map
import scala.collection.immutable.List
import scala.io.StdIn
import scala.util.control.Breaks
import scala.collection.mutable.ArrayBuffer
import scala.util.Random
/**
* @author ChinaManor
* #Description T2
* #Date: 4/8/2021 18:03
*/
object T2 {
// set集合(1-10)
// 1、定义一个不可变set集合a，保存以下元素：10,20,30,10,50,40
def t1()={
val set =Set(10,20,30,10,50,40)
println(set)
}
// 2、获取a集合的大小
def t2(): Unit = {
val set =Set(10,20,30,40,50)
println(set.size)
}
// 3、遍历a集合
def t3(): Unit = {
val set =Set(10,20,30,40,50)
for (i <- set) println(i)
}
// 4、a集合删除元素50
def t4(): Unit = {
val set =Set(10,20,30,40,50)
set -= 50
for (i <- set) println(i)
}
// 5、a集合拼接set集合Set(60,80,90)
def t5(): Unit = {
val set =Set(10,20,30,40,50)
val a =Set(60,80,90)
set ++a
for (i<- set) println(i)
}
// 6、a集合拼接列表List(100,300,200)
def t6(): Unit = {
var set =Set(10,20,30,40,50)
var a =List(100,300,200)
set ++a
for (i<- set) println(i)
}
// 7、定义一个可变set集合b,初始元素为：5,6,7,8
def t7(): Unit = {
var set =Set(5,6,7,8)
println(set.mkString)
}
// 8、b集合中使用+=添加元素9
def t8(): Unit = {
var b =Set(5,6,7,8)
b+=9
println(b)
}
// 9、b集合中删除元素5
def t9(): Unit = {
var b =Set(5,6,7,8)
b -=5
println(b)
}
// 10、b集合使用add添加元素10
def t10(): Unit = {
var b =Set(5,6,7,8)
b.add(9)
println(b)
}
// Map映射(11-20)
// 11、构建一个映射map1，内容为"zhangsan" -> 20, "lisi" -> 18, "wangwu" -> "22"
def t11(): Unit = {
val map1 =Map("zhangsan"->20,"lisi"->18,"wangwu"->22)
println(map1)
}
// 12、构建一个映射map2，内容为"zhangsan" -> 20, "lisi" -> 18, "wangwu" -> "22"
def t12(): Unit = {
val map2 =Map("zhangsan"->20,"lisi"->18,"wangwu"->22)
// println(map2)
// 14、获取map2中的lisi的年龄
// println(map2("lisi"))
// 15、获取所有的map2中的key值
// println(map2.keys)
// map2.keys.foreach(i =>
// println("Key ="+ i)
// )
// 16、获取所有的map2中的value值
// println(map2.values)
// 17、map2中新增一组数据：zhaoliu,25
map2 +=("zhaoliu" ->25)
// 18、map2中获取zhaoliu的年龄，如果zhaoliu不存在，则返回-1
println( map2.getOrElse("zhaoliu","-1")
)
// 19、map2中遍历打印所有的key和value
for(x <- map2)println(x)
for((key,value) <- map2)println(key+"\t"+value)
// 20、在map2中添加map1集合
}
// 13、构建一个空的映射map3，参数类型为Map[String, Int]
def t13(): Unit = {
val map3 =Map[String, Int]()
println(map3)
}
// 方法（21-30）
// 以下10道题目需要倒入两个包
// 21. 编写一个方法method1，输入分数之后能够打印出不及格（小于60分）、及格（60-80）、良好（80-90）、优秀（大于90）\
def method1(int: Int): Unit = {
if (int <60){
println (s" = 不及格：${int}")
}else if (60 >=int&&int <80 ){
println (s" = 及格：${int}")
}else if (80 <=int&& int<90 ){
println (s" = 良好：${int}")
}else if (int >=90){
println (s" = 优秀：${int}")
}
}
// 22. 编写一个方法method2，输入名字，判断该名字是否为laowang，如果是返回true，如果不是返回false（不使用return）
def method2(string: String): Unit ={
if (string.equals("laowang")){
println("true")
}else {
println("false")
}
}
// 23. 编写一个方法method3，要求能够输入一个大于0的数字参数，能够打印1到该数字范围内的所有数。（2种方式）
def method3(int: Int): Unit ={
// if (int>0){
// val i = Random.nextInt(int)+1
// for (i<-1 to i)println(i)
// }
val i = Random.nextInt(int)+1
for (i<-1 to i if (int>0))println(i)
}
// 24. 编写一个方法method4，要求能够输入一个大于0的数字参数，能够打印1到该数字范围内的所有偶数。
def method4(int: Int): Unit ={
if (int>0){
val i = Random.nextInt(int)+1
for (i<-1 to i if i%2==0)println(i)
}
}
// 25. 编写一个方法method5，要求能够输入一个大于0的数字参数，能够打印1到该数字范围内的所有奇数，并且该奇数不能被5整除。
def method5(int: Int): Unit ={
if (int>0){
val i = Random.nextInt(int)+1
for (i<-1 to i if i%2==1&& i%5 !=0)println(i)
}
}
// 26. 编写一个方法method6，要求可以输入任意多个参数(数字类型)，将每个参数乘以100后放入数组并返回该数组。
// 如：2, 4, 6 返回 Array(200, 400, 600)。
def method6(num:Int*): Unit ={
// num:Int*
var arr = new ArrayBuffer[Int]()
for(i<- num ){
arr+=i*100
}
println(arr)
}
//27. 编写一个方法method7，要求输入一个数字，如果数字大于150则抛出异常，并捕获该异常，捕获异常后打印The number is greater than 150。
//提示：throw new Exception("The number is greater than 150")
def method7(num:Int): Unit = {
if (num>150)throw new Exception("The number is greater than 150")
// try {
// num
// } catch {
// case num>150 =>println("The number is greater than 150")
// }
}
// println(method7(151))
//28. 编写一个方法method8，要求传入两个参数，默认值分别为10,15，返回两个参数的乘积。
def method8(a:Int=10,b:Int=15): Int=a*b
// println(method8())
//29. 定义一个名为method9的方法，有三个参数，前两个为数字类型，最后一个参数为f1函数（该函数类型参数接受两个数字类型参数，返回值也是数字类型），该method9方法返回值为数字类型。定义一个函数f1两个参数分别为x,y都为数字类型，执行返回结果是两个参数的和
var function = (a:Int,b: Int) => a+b
def method9(x:Int,y:Int,f1:(Int,Int)=>Int): Int={
f1(x,y)
}
// println(method9(10,20,function))
//30. 编写一个方法method10，要求有两个参数，两个参数都为大于0的数字，要求能够打印1到第一个参数数字范围内的所有数，在打印过程中遇到与第二个参数相乘大于200就停止。
def method10(a:Int,b:Int): Unit = {
for (i<- 1 to a if a>0 if b>0 if i*b<=200){
println(i)
}
}
// method10(10,40)
// 28. 编写一个方法method8，要求传入两个参数，默认值分别为10,15，返回两个参数的乘积。
// 29. 定义一个名为method9的方法，有三个参数，前两个为数字类型，最后一个参数为f1函数（该函数类型参数接受两个数字类型参数，返回值也是数字类型），该method9方法返回值为数字类型。定义一个函数f1两个参数分别为x,y都为数字类型，执行返回结果是两个参数的和
// 30. 编写一个方法method10，要求有两个参数，两个参数都为大于0的数字，要求能够打印1到第一个参数数字范围内的所有数，在打印过程中遇到与第二个参数相乘大于200就停止。
// 数组（31-40）
// 31、定义一个数组arr1内容为1-10
def a1(): Unit ={
val arr =Array(1,2,3,4,5,6,7,8,9,10)
arr.foreach(println)
}
// 32、使用filter过滤器,过滤出来偶数
def a2(): Unit ={
val arr =ArrayBuffer(1,2,3,4,5,6,7,8,9,10)
// println(arr.filter(_%2 ==0).mkString)
// 33、使用map把arr1数组中每一个元素都取出arr(i)-=arr(i)来放到一个全新数组
val ints = arr.map(x=>x)
// println(ints.mkString)
// 34、使用foreach打印出arr1数组中的元素
// arr.foreach(println)
// 35、翻转数组arr1
// println(arr.sorted.reverse.mkString)
// 36、修改数组arr1中下标为0的数据为100
// arr(0)=100
// println(arr)
// 37、删除arr1数组下标为0的数据
// arr -= arr(0)
// println(arr)
// 38、arr1数组从下标2开始,删除3个元素
for(i<-0 to arr.length-1 ){
if (i>=2&&i<5){
arr.remove(i)
}
println(arr(i))
}
// 39、插入数据到arr1数组, 第一个参数是开始的位置,插入50,66,77
// 茴香豆有四种写法
// arr.insert(0,50)
// arr.insert(0,66)
// arr.insert(0,77)
var arrY = ArrayBuffer[Int]()
arrY += 50
arrY ++= arr
arrY+=66
arrY+=77
arr ++= arrY
// var arr1 =ArrayBuffer(50,66,77)
// val value = arr1++arr
// arr1++=arr
// println(arr)
// 40、对arr1数组进行降序排列
arr.sorted.reverse
}
// List列表（41-70）
// 41、定义一个列表list1，内容为("a", "b" ,"c","d","e")
def l1(): Unit ={
var list1 = List("a", "b", "c", "d", "e")
// 42、在list1列表开头添加元素t
// val value = "t":: list1
val value = List("m","n")
// 43、在列表开头添加指定列表List("m","n")的元素
// val v2 = value.mkString::list1
// println(v2)
// 44、在列表list1后添加元素1
// list1 +="1"
// 45、将列表的所有元素添加到 StringBuilder
// val builder = new StringBuilder
// list1.addString(builder)
// 46、将列表的所有元素添加到 StringBuilder并指定分隔符为","
// list1.addString(builder,",")
builder.append(list1)
// // 47、获取列表索引为0的元素
// list1.addString(builder,",")
// // 48、检测列表中是否包含指定的元素a
// list1.contains("a")
// // 49、向list1列表中追加数据"a"
// list1+="a"
// // 50、去除list1列表的重复元素,并返回新列表
// list1.distinct
// // 51、list1丢弃前3个元素，并返回新列表
// list1.drop(3)
// // 52、list1丢弃最后2个元素，并返回新列表
// list1.dropRight(2)
// 53、检测列表list1是否以指定a结尾
// val bool = list1.last.equals("a")
// println(bool)
// 54、判断是否是以指定a开始的列表list1
// val bool = list1.head.equals("a")
val bool = list1.startsWith("a")
println(bool)
// 55、获取list1列表的第一个元素
println(list1.head)
// 56、在list1中从指定位置 0 开始查找元素d第一次出现的位置
println(list1.indexOf("d",0))
// 57、list1返回所有元素，除了最后一个
// 58、检测列表list1是否为空
println(list1.isEmpty)
// 59、返回list1列表最后一个元素
println(list1.last)
// 60、返回list1所有元素，除了第一个
println(list1.tail)
// 61、提取列表list1的前2个元素
println(list1.take(2))
// 62、提取列表list1的后2个元素
println(list1.takeRight(2))
// 63、列表list1转换为数组
val array = list1.toArray
// 64、list1转换为 Seq
val seq = list1.toSeq
// 65、list1转换为 Set
val set = list1.toSet
// 66、list1列表转换为字符串
val str = list1.toString()
// 67、list1列表反转
list1.sorted.reverse
// 68、list1列表排序
list1.sorted
// 69、检测list1列表在指定位置1处是否包含指定元素a
list1.head.equals("a")
list1.take(0).equals("a")
// 70、列表list1转换为数组
list1.toArray
}
// 元组（71-76）
// 71 创建一个元组Y1，内部含有zhangsan biejing 20 true 四个数据
def t71(): Unit ={
val tuple =("zhangsan","beijing",20,true)
println(tuple.toString())
// 72 获取元组Y1内的第二个元素（biejing）
println(tuple._2)
}
// 现有数据如下图
// 姓名 zhangsan lisi wangwu zhaoliu
// 年龄 20 30 40 50
// 性别 1 0 1 0
// 73 创建一个元组Y2，内部含有(zhangsan ,lisi,wangwu,zhaoliu),(20,30,40,50),(1,0,1,0) 3个数据(每个内部依然是元组)。
def t72()={
val tuple =(("zhangsan" ,"lisi","wangwu","zhaoliu"),(20,30,40,50),(1,0,1,0))
// println(tuple.toString())
// 74 获取zhangsan,并输出
println(tuple._1._1)
// 75 获取lisi 的年龄,并输出
println(tuple._2._2)
// 76 获取wangwu的性别,并输出
println(if (tuple._3._3.equals(1)){"男"})
}
// Iterator迭代器(77-86)
// 77、 定义一个迭代器iter1，数据为"Hadoop","Spark","Java"
def t77() ={
val iter1 =Iterator("Hadoop","Spark","Java");
while (iter1.hasNext)println(iter1.next())
}
// 78、遍历iter1，使用while循环并打印输出
def t78() ={
val iter1 =Iterator("Hadoop","Spark","Java");
while (iter1.hasNext)println(iter1.next())
}
// 79、定义一个迭代器iter2，数据为10,20,20,30,34,50,60
def t79() ={
val iter2 =Iterator(10,20,20,30,34,50,60);
// 80、打印出iter2中的最大值
// 81、打印出iter2中的最小值
// 82、打印出iter2的长度
// println( iter2.max)
// println( iter2.min)
// println( iter2.length)
// 83、合并iter2和iter1两个迭代器
// val value = iter2++iter2
// val value = iter2.drop(2)
// 84、iter2丢弃前2个元素
// 85、检查iter2是否为空
val value = iter2.isEmpty
println(if(value.equals(false)){"空值"}else if(value.equals(true)){"不空"})
// 86、iter2返回前 2个元素的新迭代器
val iter1 = iter2.take(2)
while (iter1.hasNext)println(iter1.next())
}
// 87.变长数组的特点是什么？
// 变长数组指的是数组的长度是可变的，可以往数组中添加、删除元素
// 88.创建没有初始元素的ArrayBuffer变长数组，语法结构是什么？
// var/val a =ArrayBuffer[元素类型]()
// 89.创建带有初始元素的ArrayBuffer的语法结构是什么？
// var/val a =ArrayBuffer(元素1,元素2,元素3......)
// 90.在定义变长数组的时候需要导入哪个包？
// import scala.collection.mutable.ArrayBuffer
// 91.定义变长数组的时候需要注意的点？
// 要导包
// 92.定义一个变长数组 a,数组类型为string，长度为0
def t92(): Unit ={
val a =ArrayBuffer[String]()
// 93.向变长数组中添加元素spark
a+="spark"
// 94.定义一个包含以下元素的变长数据，10,20,30,40,50
val b =ArrayBuffer(10,20,30,40,50)
// 95.b数组删除元素50
b-=50
// 96.在b数组后面追加一个数组Array(70)
val c =Array(70)
b++c
// 97.使用for循环遍历b数组的内容并输出
for(i<-b){println(i)}
// 98.使用for循环遍历b数组的索引下标，并打印元素
for(i<-0 to b.length -1){println(b(i))}
for(i<-0 until b.length -1){println(b(i))}
}
// 99.在scala中数组常用方法有哪些？
// - 求和——sum方法
// - 求最大值——max方法
// - 求最小值——min方法
// - 排序——sorted方法
// 100.定义一个数组，包含以下几个元素（10,20,30,40)，请计算该数组的和
def t100(): Unit ={
val t100 =Array(10,20,30,40)
println(t100.sum)
// 101.定义一个数组，包含以下几个元素（130,120,310,140)，请计算该数组的最大值
val t101 =Array(130,120,310,140)
println(t101.max)
// 102.定义一个数组，包含以下几个元素（130,120,310,140)，请计算该数组的最小值
println(t101.min)
// 103.定义一个数组，包含以下几个元素（130,120,310,140)，请计算该数组的和
println(t101.sum)
// 104.定义一个数组，包含以下几个元素（130,120,310,140)，请实现降序排序
println(t101.sorted.reverse.mkString)
}
def main(args: Array[String]): Unit = {
// t1()
// t2()
// t3()
// t4()
// t5()
// t6()
// t7()
// t8()
// t9()
// t10()
// t11()
// t12()
// t13()
// t14()
// method1(90)
// method2("laowang")
// method3(9)
// method4(9)
// method5(999)
// method5(999)
// method5(999)
// method6(2,4,6)
// method7(151)
// a1();
a2()
// a3()
// l1()
// t71()
// t72()
// t77()
// t77()
// t79()
// t92()
// t100()
}
//
}
扫一扫
01-03
1660
1660
06-10
493
493
11-13
125
125
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
