李林超博客
首页
归档
留言
友链
动态
关于
归档
留言
友链
动态
关于
首页
大数据
正文
Scala总结(三)
Leefs
2021-03-10 PM
2394℃
2条
# 15.Scala总结(三) ### 一、字符串操作 ```scala object Scala_String_Test { def main(args: Array[String]): Unit = { val s1 = "Hello" val s2 = "Scala" //拼接、合并字符串 println(s1 + " "+s2) println(s1.concat(" "+s2)) //访问、截取字符串 println(s1(0)) val s3 = s1.substring(0,2) println(s3) //分割字符串 val s4 = s1.split("ll") s4.foreach(println) //字符串格式化 val name = "zhangsan" val age = 20 val s5 = "%s is %d years old".format(name,age) println(s5) //处理字符串中的字符(map,filter,flatmap,for,foreach) val upper = s1.map(upper=>upper.toUpper) val upper2 = s1.map(_.toUpper) println(upper,upper2) val filter = s1.filter(i=>i !='o') println(filter) //for循环遍历单个字母 s1.foreach(println) for( i <- s1 if i != 'l'){ println("i= "+i) } /** * 字符串中的查找模式 * 在一个string上调用.r方法可以创建一个Regex对象,之后在查找是否含有一个匹配时就可以用findFirstIn, * 此方法返回option类型,当需要查找是否完全匹配时可以用findAllIn,此方法返回一个迭代器 */ val pattern = "[0-9]+".r val address = "101 main street 123" val match1 = pattern.findFirstIn(address) val match2 = pattern.findAllIn(address) match1.foreach(println) match2.foreach(println) //字符串中的替换模式(replaceAll replaceAllIn replaceFirst replaceFirstIn) val address1 = address.replaceAll("[0-9]","x") println(address1) //抽取String中模式匹配的部分 val pattern1 = "([0-9]+) ([A-Za-z]+)".r val pattern1(count,fruit) = "100 bananas" println(count,fruit) } } ``` ### 二、数组 **2.1 性质** > - 若长度固定,则使用`Array`,若长度可能 有变化则使用`ArrayBuffer` > - 提供初始值时不要使用`new` > - 用`()`来访问元素 > - 用`for(elem <- arr)`来遍历元素 > - 用`for(elem <- arr if ...)...yeild...`来将原数组转型为新数组 > - Scala数据和Java数组可以互操作,用`ArrayBuffer`,使用`scala.collection.JavaConversions`中的转换函数 **2.2 定长数组** ```scala val nums = new Array[Int](10) // 10个整数型的数组,所有元素初始化为0 val s = new Array[String](10) // 10个字符串类型数组,初始化为null val s = Array("Hello", "World") // 提供初始值时不要用new s(0) = "Goodbye"// Array("Goodbye", "World"), 使用()非[]访问元素 ``` **2.3 变长数组** ```scala import scala.collection.mutable.ArrayBuffer val b = new ArrayBuffer[Int]() // 因为没有初始化,所以new和()可以只要一个 // val b = ArrayBuffer[Int]() or val b = new ArrayBuffer[Int] // 用+=给b尾端添加元素 b += 1 // ArrayBuffer(1) b += (1, 2, 3, 5) // ArrayBuffer(1, 1, 2, 3, 5) // 用++=追加任何集合 b ++= Array(8, 13, 21) // ArrayBuffer(1, 1, 2, 3, 5, 8, 13, 21) // 用.trimEnd(N) 移除最后N个元素, .trimStart(N)移除开始N个元素 b.trimEnd(5) // ArrayBuffer(1, 1, 2) ``` 在数组缓冲的尾端添加或移除元素是一个高效的操作,你也可以在任意位置添加或移除元素,但这样的操作并不那么高效,因为所有在哪个位置之后的元素都必须被平移。 ```scala // b.insert(pos, nums), 在pos位置之前插入nums b.insert(2, 6, 7, 8) // ArrayBuffer(1, 1, 6, 7, 8, 2) // b.remove(pos, lens = 1), 从pos位置开始,移除lens个元素 b.remove(2) // ArrayBuffer(1, 1, 7, 8, 2) b.remove(2, 3) // ArrayBuffer(1, 1) ``` 有时需要构建一个Array, 但不知道最终要装多少个元素。在这种情况下,先构建一个数组缓冲,然后调用: `b.toArray`。然后过来,调用`a.toBuffer`可以将一个数组`a`转换成一个数组缓冲。 **2.4 数组遍历** > + 数组的长度:`a.length` > > + 遍历数据index:`0 until a.length // 0 until 3, Range(0, 1, 2)` > > + 遍历偶数index:`0 until (a.length, 2)` > > + 从尾端开始遍历:`(0 until a.length).reverse` **2.5 数组转换** > 使用`for(x <- arr)yield func(x)` 可以把arr数组做map函数转换 ```scala val a = Array(1, 2, 3, 4) val result = for(elem <- a) yield 2 * elem // result = Array(2, 4, 6, 8) // 效果等同:val result = a.map(2 * _) // _是a中元素的迭代器 ``` **2.6 多维数组** ```scala //二维数组 val secArray = new Array[Array[String]](10) for(index <- 0 until secArray.length){ secArray(index) = new Array[String](10) } //往二维数组中填充数据 /* for(i <- 0 until secArray.length){ for(j <- 0 until secArray(i).length){ secArray(i)(j) = i*j + "" } }*/ for(i <- 0 until secArray.length;j <- 0 until secArray(i).length){ secArray(i)(j) = i*j + "" } ``` **2.7 与Java的互操作** > Scala的数组是用Java数组实现的,所以可以在Scala和Java中来回传递。引入`scala.collection.JavaConversions`的隐式转换方法,这样在使用Scala缓冲,调用Java方法时,这些对象会被自动包装成Java列表。 在`java.lang.ProcessBuilder`类中有一个以`List
`为参数的构造器。在Scala中调用它的例子: ```scala import scala.collection.JavaConversions.bufferAsJavaList import scala.collection.mutable.ArrayBuffer val command = ArrayBuffer("ls", "-al", "/home/cay") val pb = new ProcessBuilder(command) // Scala到Java的转换 ``` Scala缓冲被包装成了一个实现了`java.util.List`接口的Java类对象。反过来,当Java方法返回`java.util.List`时,我们可以让它自动转换成一个`Buffer`: ```scala import scala.collection.JavaConversions.asScalaBuffer import scala.collection.mutable.Buffer val cmd: Buffer[String] = pd.command() // Java到Scala的转换 // 不能使用ArrayBuffer, 因为包装起来的对象仅能保证是个Buffer ``` ### 三、List集合 ```scala object Scala_List_Test { def main(args: Array[String]): Unit = { val a = List(1,2,3,4) //for(i <- a) println(i) //将0添加到a中 val b = 0::a //for( i <- b) println(i) val c = List("x","y","z") //两个List合并 val d = a ::: c //for( i <- d) println(i) println(a.head) //返回第一个元素 println(a.tail) //返回除第一个元素的List println(a.isEmpty) //判断List是否为空 // 取出List中的偶数; // filrter高阶函数:他的参数就是一个匿名函数,匿名参数输入参数x就代表的是列表中的一个元素, // filter会遍历列表中的每个元素,每个元素就去套用传进来的匿名函数的判断条件,如果判断为true就保留这个元素 val e =a.filter(x => x % 2 ==0) //println(e) //filter简写 val e1 = a.filter(_ % 2 == 0) //println(e1) //过滤字符串中的数字 val str = "123 hello scala 168" val f = str.toList.filter(x => Character.isDigit(x)) //println(f) //取到某个字符之前的所有字符 val g = str.toList.takeWhile(x => x != 's') //println(g) //map高阶函数:将每个元素进行转换映射 val h = c.map(x => x.toUpperCase()) //println(h) //map简写 val h1 = c.map(_.toUpperCase()) //print(h1) //取出列表中的偶数,并且为每个元素加上100 val k = a.filter(_ % 2 == 0).map(_ + 100) //println(k) //两层List val q = List(a,List(4,5,6)) // 取出q中的所有偶数;第一步:map获取每个list,第二步:filter过滤每个list中的偶数元素 val r = q.map(x => x.filter(y => y % 2 ==0)) //println(r) //简写 val r1 = q.map(_.filter(_ % 2 ==0)) //println(r1) // flatMap高阶函数:是将List中的结果扁平 val p = q.flatMap(_.filter(_ % 2 == 0)) //println(p) /** * 总结map与flatMap区别: * map:返回的结果和原List结构一致,如果是两层,返回的就是两层;r: List[List[Int]] = List(List(2,4), List(4, 6)) * flatMap:返回的结果只有一层List结构; p: List[Int] = List(2, 4, 4, 6) */ // 规约操作:reduceLeft(op:(T,T) => T) // 求List中元素的和 val m = a.reduceLeft((x,y) => x + y) println(m) //reduceLeft简写 val m1 = a.reduceLeft(_ + _) println(m1) // 规约操作:foldLeft(z:U)(op:(U,T)) => U //求List中元素的和 val n = a.foldLeft(0)((x,y) => x+y) println(n) // 简写 val n1 = a.foldLeft(0)(_ + _) println(n1) } } ``` ### 四、Set ```scala object Scala_Set_Test { def main(args: Array[String]): Unit = { //创建 val set1 = Set(1,2,3,4,4) val set2 = Set(1,2,5) //遍历 //注意:set会自动去重 set1.foreach{println} for( s <- set1){ println(s) } println("**************") /** * 方法举例 */ //交集 val set3 = set1.intersect(set2) set3.foreach{println} val set4 = set1.&(set2) set4.foreach{println} println("*******") //差集 set1.diff(set2).foreach { println } set1.&~(set2).foreach { println } //子集 set1.subsetOf(set2) //最大值 println(set1.max) //最小值 println(set1.min) println("****") //转成数组,list set1.toArray.foreach{println} println("****") set1.toList.foreach{println} //mkString println(set1.mkString) println(set1.mkString("\t")) } } ``` ### 五、Map ```scala object Scala_Map_Test { def main(args: Array[String]): Unit = { val map = Map( "1" -> "bj", 2 -> "sh", 3 -> "gz" ) val keys = map.keys val keyIterator = keys.iterator while(keyIterator.hasNext){ val key = keyIterator.next() /** * map集合的get方法返回值是一个Option类型的对象 * Option类型有两个子类型 分别为some None */ /* Map中的方法 : 1. filter:过滤,留下符合条件的记录 2. count:统计符合条件的记录数 3. contains:map中是否包含某个key 4. exist:符合条件的记录存在不存在 * */ println(key + "\t" + map.get(key).get) } /** * getOrElse 原理: * 去集合中去取数据,若不存在返回默认值 */ println(map.get(4).getOrElse("default")) for(k <- map) println(k._1 + "\t" + k._2) //分别取第一个位置的数据和第二个位置的数据,即Key-Value map.foreach(x=>println(x._1 + "\t" + x._2)) map.filter(x=>{ Integer.parseInt(x._1 + "") >= 2 }).foreach(println) val count = map.count(x=>{ Integer.parseInt(x._1 + "") >= 2 }) println(count) /** 合并Map的操作: 1.++ 例:map1.++(map2) --map1中加入map2 2.++: 例:map1.++:(map2) –map2中加入map1 注意:合并map会将map中的相同key的value替换 **/ } } ``` ### 六、元组 与列表一样,元组也是不可变的,但与列表不同的是元组可以包含不同类型的元素。 元组的值是通过将单个的值包含在圆括号中构成的。例如: ```scala val t = (1, 3.14, "Fred") ``` 以上实例在元组中定义了三个元素,对应的类型分别为`[Int, Double, java.lang.String]`。 其他定义元祖方式 ```scala val t = new Tuple3(1, 3.14, "Fred") ``` 访问元祖 使用 `t._1` 访问第一个元素, `t._2` 访问第二个元素 ```scala object Test { def main(args: Array[String]) { val t = (4,3,2,1) val sum = t._1 + t._2 + t._3 + t._4 println( "元素之和为: " + sum ) } } ``` 示例 ```scala object Scala_YZ_Test { def main(args: Array[String]): Unit = { val t1 = (4,3,2,1) //迭代输出元组的所有元素 t1.productIterator.foreach{ i =>println("Value = " + i )} val t2 = new Tuple3(1, "hello", Console) //使用 Tuple.toString() 方法将元组的所有元素组合成一个字符串 println("连接后的字符串为: " +t2.toString() ) //使用 Tuple.swap 方法来交换元组的元素 val t3 = new Tuple2("www.google.com", "www.lilinchao.com") println("交换后的元组: " + t3.swap ) } } ``` *附:* *[参考文章链接1](https://www.jianshu.com/p/218c74bca686?from=singlemessage)*、*[参考文章链接2](https://www.runoob.com/scala/scala-tuples.html)*、*[参考文章链接3](https://blog.csdn.net/hjy1821/article/details/83751384)*
标签:
Hadoop
,
Spark
,
Scala
非特殊说明,本博所有文章均为博主原创。
如若转载,请注明出处:
https://lilinchao.com/archives/1223.html
上一篇
Scala总结(一)
下一篇
SpringBoot2.x整合百度UidGenerator
取消回复
评论啦~
提交评论
已有 2 条评论
范明明
完全看不懂系列!
回复
2021-03-19 17:29
Leefs
博主
@范明明
哈哈,大佬研究的领域比我的难度要大
回复
2021-03-22 09:27
栏目分类
随笔
2
Java
326
大数据
229
工具
31
其它
25
GO
47
标签云
设计模式
gorm
人工智能
排序
正则表达式
Shiro
Hbase
随笔
数据结构和算法
MyBatisX
链表
nginx
Typora
Spark Streaming
数据结构
持有对象
SpringCloud
Spark SQL
Java
二叉树
Hive
Flume
Eclipse
JavaSE
并发编程
Jenkins
DataX
锁
DataWarehouse
微服务
友情链接
申请
范明明
庄严博客
Mx
陶小桃Blog
虫洞
完全看不懂系列!
哈哈,大佬研究的领域比我的难度要大