Scala练习题
目录
-
- 题目
- 第一题
- 第二题
- 第三题
- 第四题
- 第五题
- 第六题
- 第七题
- 第八题
- 第九题
- 第十题
- 第十一题
- 第十二题
- 第十三题
- 第十四题
- 第十五题
- 第十六题
- 第十七题
- 第十八题
- 第十九题
- 第二十题
- 第二十一题
- 第二十二题
- 第二十三题
- 第二十四题
题目
1、创建一个demo1的单例，在demo1中创建一个样例类名字为student1，成员变量为name:String, age:Int
创建主方法实例化student，并传参数（“xiaoming”,20）,打印输出student1对象到控制台
2、创建一个demo2的单例，在demo2中创建一个样例类名字为student2，成员变量为name:String, age:Int
创建主方法实例化student2，并传参数（“xiaoming”,20）,修改student2对象的age=25,打印输出student2对象到控制台
3、创建一个demo3的单例，在demo3中创建一个样例类名字为student3，成员变量为name:String, age:Int
创建主方法，使用apply方法实例化student3，并传参数（“xiaoming”,18），使用toString输出对象到控制台
4、创建一个demo4的单例，在demo4中创建一个样例类名字为student4，成员变量为name:String, age:Int
创建主方法，并创建a和b两个样例对象，参数都是（“xiaoming”,18）,分别使用==和equals两种方式判断a和b对象是否相等
5、创建一个demo5的单例，在demo5中创建一个样例类名字为student5，成员变量为name:String, age:Int
创建主方法，创建三个样例对象a(“xiaoming”,18),b(“xiaoming”,19),c(“xiaoming”,20),分别输出a,b,c的哈希值到控制台
6、创建一个demo6的单例，在demo6中创建一个样例类名字为student6，成员变量为name:String, age:Int
创建主方法， 创建一个实例对象a(“xiaoming”,18)，使用copy方法创建另一个对象b（“xiaoli”,20），并输出对象b到控制台
7、创建一个demo7的单例，在demo7中定义一个性别Sex特质,定义两个样例对象并继承了Sex特质，分别为Male 和Female
创建一个样例类名字为student7,成员变量为name:String, sex:Sex,创建主方法， 创建一个实例对象a(“xiaoming”,Male),打印输出对象a
8、创建一个demo8的单例，在demo8中创建一个样例类名字为student8，成员变量为name:String, age:Int
创建主方法，并创建a,b,c三个对象,参数分别为("zhangsan",10)("lisi",20)("wangwu",30),把这三个对象添加到List列表中
循环遍历列表，使用match case进行匹配，匹配到的对象如果是student8("zhangsan",10),打印输出“zhangsan”,
匹配到的对象如果是student8("lisi", 20),打印输出“lisi”,匹配到的对象如果是其他的,打印输出“没有匹配上”
9、创建一个demo9的单例，在demo9中请使用 StdIn.readLine()方法，在控制台输入数据，使用match case进行匹配，
输入1，输出为孙悟空
输入2，输出为猪八戒
输入3，输出为沙和尚
输入0，输出为唐僧
输入其他的，输出为未匹配
10、创建一个demo10的单例，在demo10中使用模式匹配数组
Array(10,x,y,z) ，输出为以10开头，后续的三个元素不固定
Array(6) 输出为 只匹配一个6元素的元素
Array(scala, ...) 输出为可以任意数量，但是以0开头的数组
其他的，输出为没有匹配上
11、创建一个demo11的单例，在demo11中使用模式匹配列表
定义一个列表为List(1,2,3),分别匹配输出为只有1的列表，1开头的列表,只有两个元素${
x}, ${
y}的列表，未匹配到
12、创建一个demo12的单例，在demo12中
12.1、定义一个值为5的Option实例a
val a : Option[Int] = Some(5)
12.2、定义一个无值的Option实例b
val b : Option[Int] = None
12.3、对有值的Option实例调用getOrElse不能替换值
a.getOrElse(0)
12.4、getOrElse只能替换None值
b.getOrElse(0)
13、创建一个demo13的单例，在demo13中
13.1、定义一个两个数相除的方法，使用Option类型来封装结果
13.2、然后使用模式匹配来打印结果
13.3、o不是除零，打印结果
13.4、o除零打印异常错误
14、创建一个demo14的单例，在demo14中使用findAllMatchIn进行匹配
定义一个正则表达式，来匹配邮箱是否合法
定义一个合法邮箱测试：666888@163.com
定义一个不合法的邮箱测试：666888@.com
15、创建一个demo15的单例，在demo15中使用try..catch来捕获除零异常
定义一个变量为 a= 100/0,使用try catch进行捕获异常，并打印输出异常信息
16、创建一个demo16的单例，在demo16中
定义一个List(("xiaoming1","男",18),("xiaohua1","女",20),("xiaomeng","男",18),
("xiaoli1","女",19),("xiaoming2","男",22),("xiaoli2","女",17),("xiaoming4","男",28))
16.1、把每个人的年龄改成之前的3倍
16.2、把每个人的年龄改成之前的2倍，之后再这个基础上进行减一
16.3、年龄小于20的过滤掉
16.4、性别是女的过滤掉
16.5、计算一下所有人的总年龄
16.7、请按照年龄从小到大排序
16.8、请按照年龄从大到小排序
16.9、把每个人的姓名性别年龄合成一个输出
16.10、把年龄为奇数和偶数的人分开
17、创建一个demo17的单例，在demo17中
创建List("hello world", "alibaba hello", "hello hello hello")
请把每个元素按照空格进行切分，并打印输出
18、创建一个demo18的单例，在demo18中
创建一个List中含有（1，2，3，4，5，6，7，8，9，10）
将list0中的每一个元素乘以10后生成一个新的集合
将list0中的偶数取出来生成一个新的集合list1
将list0中的奇数取出来生成一个新的集合list2
reduce 计算list1所有数的和
reduce 计算list2所有数数组的乘积
将list1的数据降序排列
将list2中的数据进行翻转
创建一个list中包含多个list多个list压平, 也就是抽取出来
19、创建一个demo19的单例，在demo19中
var A0 = Array(1, 4, 10, 3, 6)
var A1 = Array(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1, 2, 3, 4, 5)
var A2 = Array("zhangsan*lisi*wnagwu", "hadoop*hive*hbase", "biejing*hanghai*nanjing")
将A1中的数据进行升序排序
遍历A0中的数据,将返回的结果每个都*2
找出A1中除余3等于1的数返回
将A2中的数据拆分之后重新返回一个新的Array
将A1中的数字累加计算结果
20、创建一个demo20的单例，在demo20中
var arr0=array(11,5,7,2,1,2,3,4,5,6)
var arr1=array("1,2,3,4","6,7,8,9","1,2,3,4")
1.现有一个数组arr0，请将每个元素乘以10，只保留大于40的数并打印。
2.求出arr0中每个元素10倍的乘积
3.将arr1中每个字符串用","切分,组成一个新的集合，并且求出数组的长度
4.将arr0进行奇数偶数分区，基数分区进行正序排序，偶数部分倒序排序
21、创建一个demo21的单例，在demo21中
var A1 = Array(6, 7, 8, 9, 10, 1, 2, 3, 4, 5)
var A2 = Array("11,22,33", "44,55,66", "77,88,99")
1.遍历输出A1,并将每个数*2且输出
2.A1升序
3.A1降序
4.A1奇数偶数分开
5.将A2中每个字符串用","切分,组成一个新的集合，并且求出数组的长度
6.将A2中每个字符串用","切分,组成一个新的集合，并且将每个数除11把大于5的数输出
22、创建一个demo22的单例，在demo22中
创建一个val lst0 = List(1,7,9,8,0,3,5,4,6,2)
将lst0倒序排序
将lst0中的偶数取出来生成一个新的集合lst1
将lst1反转
求lst1的和
var A1 = Array("1,2,3", "4,5,6", "7,8,9")
将A1中字符串用“，”切分，生成新的集合，并将奇数偶数分开打印
23、创建一个demo23的单例，在demo23中
1．创建一个名为list的List(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1, 2, 3, 4, 5)列表
2．使用map方法和foreache方法list遍历
3．将集合内数据*10产生一个新的列表L2
4．将L2中的所有偶数取出来产生一个新的列表L3
5．计算L3数据的总和
6．将L3倒序排序
7．将L3反转
8．创建新list1数据为 List(Array(11,22,33), Array(44,55,66))
9．使用flatten将list列表合并成一个新的列表
10．将list奇数偶数分开打印
24、创建一个demo24的单例，在demo24中
var a0 = Array(1, 2, 3, 4, 5)
var a1 = Array(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1, 2, 3, 4, 5)
1.现有一个数组a0，请将每个元素*10，只保留小于10的数并打印。
2.求出a0中每个元素10倍的乘积并降序输出
3.求a1中大于10的数据的总和
4.将a0进行奇数偶数分区，基数分区进行正序排序，偶数部分倒序排序
第一题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 20:59
*
* 1、创建一个demo1的单例，在demo1中创建一个样例类名字为student1，成员变量为name:String, age:Int
* 创建主方法实例化student，并传参数（“xiaoming”,20）,打印输出student1对象到控制台
*/
object Demo01 {
case class student1(name:String,age:Int)
def main(args: Array[String]): Unit = {
var stu1=new student1("xiaoming",20)
println(stu1)
}
}
第二题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 21:03
*
* 2、创建一个demo2的单例，在demo2中创建一个样例类名字为student2，成员变量为name:String, age:Int
* 创建主方法实例化student2，并传参数（“xiaoming”,20）,修改student2对象的age=25,打印输出student2对象到控制台
*/
object Demo02 {
case class student2(name:String,var age:Int)
def main(args: Array[String]): Unit = {
var stu2=new student2("xiaoming",20)
stu2.age=25
println(stu2)
}
}
第三题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 21:07
*
* 3、创建一个demo3的单例，在demo3中创建一个样例类名字为student3，成员变量为name:String, age:Int
* 创建主方法，使用apply方法实例化student3，并传参数（“xiaoming”,18），使用toString输出对象到控制台
*/
object Demo03 {
case class student3(name: String, age: Int)
def main(args: Array[String]): Unit = {
var stu3=student3("xiaoming",18)
println(stu3.toString)
println(student3("xiaoming", 18).toString)
}
}
第四题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 21:15
*
* 4、创建一个demo4的单例，在demo4中创建一个样例类名字为student4，成员变量为name:String, age:Int
* 创建主方法，并创建a和b两个样例对象，参数都是（“xiaoming”,18）,分别使用==和equals两种方式判断a和b对象是否相等
*/
object Demo04 {
case class student4(name:String,age:Int)
def main(args: Array[String]): Unit = {
val a=student4("xiaoming",18)
val b=student4("xiaoming",18)
println(a==b)
println("使用equals比较："+a.equals(b))
}
}
第五题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 21:20
*
* 5、创建一个demo5的单例，在demo5中创建一个样例类名字为student5，成员变量为name:String, age:Int
* 创建主方法，创建三个样例对象a(“xiaoming”,18),b(“xiaoming”,19),c(“xiaoming”,20),分别输出a,b,c的哈希值到控制台
*/
object Demo05 {
case class student5(name: String, age: Int)
def main(args: Array[String]): Unit = {
val a = student5("xiaoming", 18)
val b = student5("xiaoming", 19)
val c = student5("xiaoming", 20)
println("a的哈希值："+a.hashCode())
println("b的哈希值："+b.hashCode())
println("c的哈希值："+c.hashCode())
}
}
第六题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 21:24
*
* 6、创建一个demo6的单例，在demo6中创建一个样例类名字为student6，成员变量为name:String, age:Int
* 创建主方法， 创建一个实例对象a(“xiaoming”,18)，使用copy方法创建另一个对象b（“xiaoli”,20），并输出对象b到控制台
*/
object Demo06 {
case class student6(name:String,age:Int)
def main(args: Array[String]): Unit = {
val a=student6("xiaoming",18)
val b=a.copy("xiaoli",20)
println(b)
}
}
第七题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 21:25
*
* 7、创建一个demo7的单例，在demo7中定义一个性别Sex特质,定义两个样例对象并继承了Sex特质，分别为Male 和Female
* 创建一个样例类名字为student7,成员变量为name:String, sex:Sex,创建主方法， 创建一个实例对象a(“xiaoming”,Male),打印输出对象a
*/
object Demo07 {
trait Sex
case object Male extends Sex
case object Female extends Sex
case class student7(name:String,sex:Sex)
def main(args: Array[String]): Unit = {
val a=student7("xiaoming",Male)
println(a)
}
}
第八题
package Day04_0331.Subject
import scala.io.StdIn
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 21:28
*
* 8、创建一个demo8的单例，在demo8中创建一个样例类名字为student8，成员变量为name:String, age:Int
* 创建主方法，并创建a,b,c三个对象,参数分别为("zhangsan",10)("lisi",20)("wangwu",30),把这三个对象添加到List列表中
* 循环遍历列表，使用match case进行匹配，匹配到的对象如果是student8("zhangsan",10),打印输出“zhangsan”,
* 匹配到的对象如果是student8("lisi", 20),打印输出“lisi”,匹配到的对象如果是其他的,打印输出“没有匹配上”
*/
object Demo08 {
case class student8(name: String, age: Int)
def main(args: Array[String]): Unit = {
val a = student8("zhangsan", 10)
val b = student8("lisi", 20)
val c = student8("wangwu", 30)
val list = List(a, b, c)
for (i <- list) {
i match {
case student8("zhangsan", 10) => println("zhangsan")
case student8("lisi", 20) => println("lisi")
case _ => println("没有匹配上")
}
}
}
}
第九题
package Day04_0331.Subject
import scala.io.StdIn
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 21:40
*
* 9、创建一个demo9的单例，在demo9中请使用 StdIn.readLine()方法，在控制台输入数据，使用match case进行匹配，
* 输入1，输出为孙悟空
* 输入2，输出为猪八戒
* 输入3，输出为沙和尚
* 输入0，输出为唐僧
* 输入其他的，输出为未匹配
*/
object Demo09 {
def main(args: Array[String]): Unit = {
while (true){
println("请输入数据：")
var datas=StdIn.readInt()
datas match {
case 1=>println("孙悟空")
case 2=>println("猪八戒")
case 3=>println("沙和尚")
case 4=>println("唐僧")
case _=>println("输出未匹配")
}
}
}
}
第十题
package Day04_0331.Subject
import scala.io.StdIn
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 21:44
*
* 10、创建一个demo10的单例，在demo10中使用模式匹配数组
* Array(10,x,y,z) ，输出为以10开头，后续的三个元素不固定
* Array(6) 输出为 只匹配一个6元素的元素
* Array(scala, ...) 输出为可以任意数量，但是以0开头的数组
* 其他的，输出为没有匹配上
*/
object Demo10 {
def main(args: Array[String]): Unit = {
var arr=Array(10,2,3,4)
arr match {
case Array(10,x,y,z)=>println("以10开头，后续的三个元素不固定")
case Array(6)=>println("只匹配一个6元素的元素")
case Array(0,_*)=>println("可以任意数量，但是以0开头的数组")
case _=>println("没有匹配上")
}
}
}
第十一题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 21:52
*
* 11、创建一个demo11的单例，在demo11中使用模式匹配列表
* 定义一个列表为List(1,2,3),分别匹配输出为只有1的列表，1开头的列表,只有两个元素${x}, ${y}的列表，未匹配到
*/
object Demo11 {
def main(args: Array[String]): Unit = {
val list = List(1, 2, 3)
list match {
case 1 :: Nil => println("只有1的列表")
case 1 :: tail => println("1开头的列表")
case x :: y :: Nil => println(s"只有两个元素${x},${y}的列表")
case _ => println("未匹配到")
}
}
}
第十二题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 21:56
*
* 12、创建一个demo12的单例，在demo12中
* 12.1、定义一个值为5的Option实例a
* val a : Option[Int] = Some(5)
* 12.2、定义一个无值的Option实例b
* val b : Option[Int] = None
* 12.3、对有值的Option实例调用getOrElse不能替换值
* a.getOrElse(0)
* 12.4、getOrElse只能替换None值
* b.getOrElse(0)
*/
object Demo12 {
def main(args: Array[String]): Unit = {
val a: Option[Int] = Some(5)
val b: Option[Int] = None
println(a.getOrElse(0))
println(b.getOrElse(0))
}
}
第十三题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 22:02
*
* 13、创建一个demo13的单例，在demo13中
* 13.1、定义一个两个数相除的方法，使用Option类型来封装结果
* 13.2、然后使用模式匹配来打印结果
* 13.3、o不是除零，打印结果
* 13.4、o除零打印异常错误
*/
object Demo13 {
def dvi(a:Double,b:Double):Option[Double]={
if (b!=0){
Some(a/b)
}else{
None
}
}
def main(args: Array[String]): Unit = {
// val result=dvi(1.0,5)
val result=dvi(1.0,0)
result match{
case Some(x)=>println(x)
case None=>println("除零异常")
}
}
}
第十四题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 21:00
*
* 14、创建一个demo14的单例，在demo14中使用findAllMatchIn进行匹配
* 定义一个正则表达式，来匹配邮箱是否合法
* 定义一个合法邮箱测试：[email protected]
* 定义一个不合法的邮箱测试：[email protected]
*/
object Demo14 {
def main(args: Array[String]): Unit = {
val r=""".+@+\..+""".r
val HeFa="[email protected]"
val NotHeFa="[email protected]"
if (r.findAllMatchIn(HeFa).size>0){
println(HeFa+" 邮箱合法")
}else{
println(HeFa+" 邮箱不合法")
}
if (r.findAllMatchIn(NotHeFa).size>0){
println(NotHeFa+" 邮箱合法")
}else{
println(NotHeFa+" 邮箱不合法")
}
}
}
第十五题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 22:11
*
* 15、创建一个demo15的单例，在demo15中使用try..catch来捕获除零异常
* 定义一个变量为 a= 100/0,使用try catch进行捕获异常，并打印输出异常信息
*/
object Demo15 {
def main(args: Array[String]): Unit = {
try {
val a=100/0
println("正常输出")
}catch {
case ex:Exception=>println(ex.getMessage)
}
}
}
第十六题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 22:15
*
* 16、创建一个demo16的单例，在demo16中
* 定义一个List(("xiaoming1","男",18),("xiaohua1","女",20),("xiaomeng","男",18),
* ("xiaoli1","女",19),("xiaoming2","男",22),("xiaoli2","女",17),("xiaoming4","男",28))
* 16.1、把每个人的年龄改成之前的3倍
* 16.2、把每个人的年龄改成之前的2倍，之后再这个基础上进行减一
* 16.3、年龄小于20的过滤掉
* 16.4、性别是女的过滤掉
* 16.5、计算一下所有人的总年龄
* 16.7、请按照年龄从小到大排序
* 16.8、请按照年龄从大到小排序
* 16.9、把每个人的姓名性别年龄合成一个输出
* 16.10、把年龄为奇数和偶数的人分开
*/
object Demo16 {
def main(args: Array[String]): Unit = {
val list = List(
("xiaoming1", "男", 18),
("xiaohua1", "女", 20),
("xiaomeng", "男", 18),
("xiaoli1", "女", 19),
("xiaoming2", "男", 22),
("xiaoli2", "女", 17),
("xiaoming4", "男", 28))
//16.1、把每个人的年龄改成之前的3倍
//list.map(a =>a._3*3).map(println)
//16.2、把每个人的年龄改成之前的2倍，之后再这个基础上进行减一
//list.map(a =>a._3*2-1).map(println)
//16.3、年龄小于20的过滤掉
//list.filterNot(x => if (x._3 < 20) true else false).map(println)
//16.4、性别是女的过滤掉
//list.filterNot(x=>if (x._2.equals("女"))true else false).map(println)
//16.5、计算一下所有人的总年龄
//var sum=list.map(a=>a._3).sum
//println(sum)
//16.7、请按照年龄从小到大排序
//list.sortBy(x=>x._3).map(println)
//16.8、请按照年龄从大到小排序
//list.sortBy(x => -x._3).foreach(println)
//16.9、把每个人的姓名性别年龄合成一个输出
//list.flatMap(x=>x._1+x._2+x._3).map(print)
//16.10、把年龄为奇数和偶数的人分开
val aa: (List[(String,String,Int)],List[(String,String,Int)]) = list.partition({
x => x._3 % 2 == 0 })
println(aa._1.mkString(","))
println(aa._2.mkString(","))
}
}
第十七题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 22:18
*
* 17、创建一个demo17的单例，在demo17中
* 创建List("hello world", "alibaba hello", "hello hello hello")
* 请把每个元素按照空格进行切分，并打印输出
*/
object Demo17 {
def main(args: Array[String]): Unit = {
val list=List("hello world", "alibaba hello", "hello hello hello")
list.flatMap(x=>x.split(" ")).foreach(println)
}
}
第十八题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 22:56
*
* 18、创建一个demo18的单例，在demo18中
* 创建一个List中含有（1，2，3，4，5，6，7，8，9，10）
* 将list0中的每一个元素乘以10后生成一个新的集合
* 将list0中的偶数取出来生成一个新的集合list1
* 将list0中的奇数取出来生成一个新的集合list2
* reduce 计算list1所有数的和
* reduce 计算list2所有数数组的乘积
* 将list1的数据降序排列
* 将list2中的数据进行翻转
* 创建一个list中包含多个list多个list压平, 也就是抽取出来
*/
object Demo18 {
def main(args: Array[String]): Unit = {
//创建一个List中含有（1，2，3，4，5，6，7，8，9，10）
var list0 = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
//将list0中的每一个元素乘以10后生成一个新的集合
var Cheng = list0.map(a => a * 10)
println("乘10后的集合数据")
Cheng.map(println)
println("========")
//将list0中的偶数取出来生成一个新的集合list1
var list1 = list0.filter(a => if (a % 2 == 0) true else false)
println("list1集合")
list1.map(println)
println("========")
//将list0中的奇数取出来生成一个新的集合list2
println("list2集合")
var list2 = list0.filter(a => if (a % 2 == 1) true else false)
list2.map(println)
println("========")
//reduce 计算list1所有数的和
var sum = list1.reduce((a, b) => a + b)
println("list1所有数的和："+sum)
println("========")
//reduce 计算list2所有数数组的乘积
var ChengJi = list2.reduce((a, b) => a * b)
println("list2所有数的乘积："+ChengJi)
println("========")
//将list1的数据降序排列
var JiangXu=list1.sortBy(a=> -a)
println("list1降序排列："+JiangXu+" ")
println("========")
//将list2中的数据进行翻转
var FanZhuan=list2.reverse
println("list2数据翻转")
FanZhuan.map(println)
println("========")
//创建一个list中包含多个list多个list压平, 也就是抽取出来
val listAll=List(list0,Cheng,list1,list2)
println("包含多个List的ListAll")
listAll.map(println)
println("========")
println("将多个listAll集合扁平化")
var all=listAll.flatMap(a=>a)
print(all)
}
}
第十九题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 23:27
*
* 19、创建一个demo19的单例，在demo19中
* var A0 = Array(1, 4, 10, 3, 6)
* var A1 = Array(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1, 2, 3, 4, 5)
* var A2 = Array("zhangsan*lisi*wnagwu", "hadoop*hive*hbase", "biejing*hanghai*nanjing")
* 将A1中的数据进行升序排序
* 遍历A0中的数据,将返回的结果每个都*2
* 找出A1中除余3等于1的数返回
* 将A2中的数据拆分之后重新返回一个新的Array
* 将A1中的数字累加计算结果
*/
object Demo19 {
def main(args: Array[String]): Unit = {
var A0 = Array(1, 4, 10, 3, 6)
var A1 = Array(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1, 2, 3, 4, 5)
var A2 = Array("zhangsan*lisi*wnagwu", "hadoop*hive*hbase", "biejing*hanghai*nanjing")
//将A1中的数据进行升序排序
//A1.sortBy(x=>x).foreach(println)
//遍历A0中的数据,将返回的结果每个都*2
//var a=A0.map(x=>x*2)
//a.map(x=>println(x))
//找出A1中除余3等于1的数返回
//A1.filter(x=>if (x % 3==1) true else false).map(println)
//将A2中的数据拆分之后重新返回一个新的Array
//val arr: Array[String] = A2.flatMap(x => x.split("\\*"))
//arr.foreach(println)
//将A1中的数字累加计算结果
println(A1.reduce(_+_))
}
}
第二十题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 23:39
*
* 20、创建一个demo20的单例，在demo20中
* var arr0=Array(11,5,7,2,1,2,3,4,5,6)
* var arr1=Array("1,2,3,4","6,7,8,9","1,2,3,4")
* 1.现有一个数组arr0，请将每个元素乘以10，只保留大于40的数并打印。
* 2.求出arr0中每个元素10倍的乘积
* 3.将arr1中每个字符串用","切分,组成一个新的集合，并且求出数组的长度
* 4.将arr0进行奇数偶数分区，基数分区进行正序排序，偶数部分倒序排序
*/
object Demo20 {
def main(args: Array[String]): Unit = {
var arr0 = Array(11, 5, 7, 2, 1, 2, 3, 4, 5, 6)
var arr1 = Array("1,2,3,4", "6,7,8,9", "1,2,3,4")
//1.现有一个数组arr0，请将每个元素乘以10，只保留大于40的数并打印。
//arr0.map(x => x * 10).filter(y => if (y > 40) true else false).map(println)
//2.求出arr0中每个元素10倍的乘积
//println(arr0.map(x => x * 10).reduce((a, b) => a * b))
//3.将arr1中每个字符串用","切分,组成一个新的集合，并且求出数组的长度
//var a1:Array[String]=arr1.flatMap(x=>x.split(","))
//println(a1.length)
//4.将arr0进行奇数偶数分区，基数分区进行正序排序，偶数部分倒序排序
var pt: (Array[Int], Array[Int]) = arr0.partition({
x => x % 2 == 0 })
println("偶数正序：")
var pt1 = pt._1.sortBy(x => x)
println(pt1.mkString(","))
println("===============")
println("奇数倒序：")
var pt2 = pt._2.sortBy(x => -x)
println(pt2.mkString(","))
}
}
第二十一题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/3/31 23:56
*
* 21、创建一个demo21的单例，在demo21中
* var A1 = Array(6, 7, 8, 9, 10, 1, 2, 3, 4, 5)
* var A2 = Array("11,22,33", "44,55,66", "77,88,99")
* 1.遍历输出A1,并将每个数*2且输出
* 2.A1升序
* 3.A1降序
* 4.A1奇数偶数分开
* 5.将A2中每个字符串用","切分,组成一个新的集合，并且求出数组的长度
* 6.将A2中每个字符串用","切分,组成一个新的集合，并且将每个数除11把大于5的数输出
*/
object Demo21 {
def main(args: Array[String]): Unit = {
var A1 = Array(6, 7, 8, 9, 10, 1, 2, 3, 4, 5)
var A2 = Array("11,22,33", "44,55,66", "77,88,99")
//1.遍历输出A1,并将每个数*2且输出
//A1.map(x=>x*2).map(println)
//2.A1升序
//A1.sortBy(x=>x).foreach(println)
//3.A1jiangxu
//A1.sortBy(x => -x).map(println)
//4.A1奇数偶数分开
//val pt: (Array[Int], Array[Int]) = A1.partition({ x => x % 2 == 0 })
//println(pt._1.mkString(","))
//println(pt._2.mkString(","))
//5.将A2中每个字符串用","切分,组成一个新的集合，并且求出数组的长度
//var aa:Array[String]=A2.flatMap(x=>x.split(","))
//aa.map(println)
//println("=========")
//println("数组长度："+aa.length)
//6.将A2中每个字符串用","切分,组成一个新的集合，并且将每个数除11把大于5的数输出
var aa: Array[String] = A2.flatMap(x => x.split(","))
aa.map(println)
println("=========")
var bb = aa.filter(x => if (Integer.parseInt(x) / 11 > 5) true else false)
bb.foreach(println)
}
}
第二十二题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/4/1 0:15
*
* 22、创建一个demo22的单例，在demo22中
* 创建一个val list0 = List(1,7,9,8,0,3,5,4,6,2)
* 将lst0倒序排序
* 将lst0中的偶数取出来生成一个新的集合lst1
* 将lst1反转
* 求lst1的和
* var A1 = Array("1,2,3", "4,5,6", "7,8,9")
* 将A1中字符串用“，”切分，生成新的集合，并将奇数偶数分开打印
*/
object Demo22 {
def main(args: Array[String]): Unit = {
val lst0 = List(1, 7, 9, 8, 0, 3, 5, 4, 6, 2)
//将lst0倒序排序
//lst0.sortBy(x=> -x).foreach(println)
//将lst0中的偶数取出来生成一个新的集合lst1
val lst1 = lst0.filter(x => if (x % 2 == 0) true else false)
// lst1.foreach(println)
//将lst1反转
// println(lst1.reverse)
//求lst1的和
// println(lst1.reduce(_+_))
var A1 = Array("1,2,3", "4,5,6", "7,8,9")
//将A1中字符串用“，”切分，生成新的集合，并将奇数偶数分开打印
var aa: (Array[String], Array[String]) = A1.flatMap({
x => x.split(",") }).partition({
y => Integer.parseInt(y) % 2 == 0 })
println(aa._1.mkString(","))
println(aa._2.mkString(","))
}
}
第二十三题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/4/1 0:30
*
* 23、创建一个demo23的单例，在demo23中
* 1．创建一个名为list的List(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1, 2, 3, 4, 5)列表
* 2．使用map方法和foreache方法list遍历
* 3．将集合内数据*10产生一个新的列表L2
* 4．将L2中的所有偶数取出来产生一个新的列表L3
* 5．计算L3数据的总和
* 6．将L3倒序排序
* 7．将L3反转
* 8．创建新list1数据为 List(Array(11,22,33), Array(44,55,66))
* 9．使用flatten将list列表合并成一个新的列表
* 10．将list奇数偶数分开打印
*/
object Demo23 {
def main(args: Array[String]): Unit = {
//1．创建一个名为list的List(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1, 2, 3, 4, 5)列表
val list = List(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1, 2, 3, 4, 5)
//2．使用map方法和foreache方法list遍历
// list.map(println)
// println("======")
// list.foreach(println(_))
//3．将集合内数据*10产生一个新的列表L2
val L2 = list.map(x => x * 2)
// L2.map(println)
//4．将L2中的所有偶数取出来产生一个新的列表L3
val L3 = L2.filter(x => if (x % 2 == 0) true else false)
// L3.map(println)
//5．计算L3数据的总和
var sum = L3.reduce(_ + _)
// println(sum)
//6．将L3倒序排序
// L3.sortBy(x=> -x).foreach(println)
//7．将L3反转
// println(L3.reverse)
//8．创建新list1数据为 List(Array(11,22,33), Array(44,55,66))
val list1 = List(Array(11, 22, 33), Array(44, 55, 66))
//9．使用flatten将list列表合并成一个新的列表
val list2 = list1.flatten(x => x)
//list2.map(println)
//10．将list2奇数偶数分开打印
val aa: (List[Int], List[Int]) = list2.partition({
x => x % 2 == 0 })
println(aa._1.mkString(","))
println(aa._2.mkString(","))
}
}
第二十四题
package Day04_0331.Subject
/**
* @Author 王作程
* @Version v 1.0
* @Date 2020/4/1 0:45
*
* 24、创建一个demo24的单例，在demo24中
* var a0 = Array(1, 2, 3, 4, 5)
* var a1 = Array(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1, 2, 3, 4, 5)
* 1.现有一个数组a0，请将每个元素*10，只保留小于10的数并打印。
* 2.求出a0中每个元素10倍的乘积并降序输出
* 3.求a1中大于10的数据的总和
* 4.将a0进行奇数偶数分区，基数分区进行正序排序，偶数部分倒序排序
*/
object Demo24 {
def main(args: Array[String]): Unit = {
var a0 = Array(1, 2, 3, 4, 5)
var a1 = Array(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1, 2, 3, 4, 5)
//1.现有一个数组a0，请将每个元素*10，只保留小于10的数并打印。
// a0.map(x=>x*10).filter(y=>if (y < 20) true else false).foreach(println)
//2.求出a0中每个元素10倍的乘积并降序输出
// println(a0.map(x => x * 10).reduce((a,b)=>a*b))
// a0.map(x=>x*10).sortBy(y=> -y).foreach(println)
//3.求a1中大于10的数据的总和
// println(a1.filter(x=>if (x > 10) true else false) .reduce(_+_))
//4.将a0进行奇数偶数分区，基数分区进行正序排序，偶数部分倒序排序
val aa: (Array[Int], Array[Int]) = a0.partition({
x => x % 2 == 0 })
println(aa._1.sortBy(x=> -x).mkString(","))
println(aa._2.sortBy(x=>x).mkString(","))
}
}