list scala 当前位置遍历_scala 字符串（string）数组(array),映射(Map),元组常用操作...

最新推荐文章于 2023-06-08 09:19:55 发布

黑龙桑丶

最新推荐文章于 2023-06-08 09:19:55 发布

阅读量1.3k

点赞数

文章标签： list scala 当前位置遍历

本文链接：https://blog.csdn.net/weixin_30451613/article/details/111911209

版权

本文介绍了Scala中字符串、数组和映射的基本操作，包括去除空格、替换、正则表达式、遍历、转换、拼接、创建、遍历、排序、比较、查找元素、转换为映射、多维数组和元组的使用等。重点讨论了如何在字符串中使用trim、replaceAll、stripPrefix和stripSuffix，数组的遍历、插入、删除、转换和合并，以及映射的创建、更新和迭代。

摘要由CSDN通过智能技术生成

字符串

去除收尾空格

val aaaaa = " 546 "

aaaaa.length = 5

aaaaa.trim().length = 3

去除前缀后缀

val aaaaa = "xxxxx546546yyyyy"

aaaaa.stripPrefix("xxxxx").stripSuffix("yyyyy")

结果：

res1: String = 546546

替换字符串

val aaaaa = "xxxxx546546yyyyy"

aaaaa.replaceAll("xxxxx","yyyyy")

结果：

res2: String = yyyyy546546yyyyy

正则提取

import scala.util.matching.Regex

val pattern = new Regex("[a-zA-Z]+")

pattern.findAllIn(aaaaa).toArray

正则替换

使用字符串自带的replaceALL替换

val a = "aaaaa11111"

a.replaceALL("0","11111")

如果要替换括号"()"，需要注意如果只有半个括号，会报错。

如果想只替换半个扩号，那么括号需要用方括号框起来"[]"就能正常运行。

val a = "aaaaa(11111)"

a.replaceALL("aaaaa[(]","")

使用正则表达式中的replaceAllIn

val b = "aaaaa11111"

val regex = "= [A-Za-z]+".r

val newString = regex.replaceAllIn(b, "a")

拼接字符串

val str3 = str1.concat(str2)

数组

部分转载自：【快学scala】

常用

若长度固定则使用Array，若长度可能有变化则使用ArrayBuffer

提供初始值时不要使用new

用()来访问元素

用for (elem

scala> var intArray=Array(1,2,3)

intArray: Array[Int] = Array(1, 2, 3)

// to length-1

scala> for(i

// until 小于length

scala> for(i

// 正确遍历数组的姿势

scala> for(i

//倒叙遍历

scala> for(i

用for (elem

// 生成新的数组原数组不变

scala> var intArray=Array(1,2,3)

intArray: Array[Int] = Array(1, 2, 3)

scala> for(i

res6: Array[Int] = Array(2, 4, 6)

scala> intArray

res7: Array[Int] = Array(1, 2, 3)

scala> var intArray2=for(i

intArray2: Array[Int] = Array(2, 4, 6)

// 加入过滤条件

scala> var intArray2=for(i2) yield i*2

intArray2: Array[Int] = Array(6)

//转换类型，把array中的字符串类型转化为Int

var StringArray=Array("1","2","3")

StringArray: Array[String] = Array(1, 2, 3)

scala> for(i

res8: Array[Int] = Array(1, 2, 3)

//也可以直接使用map

StringArray.map(_.toDouble)

//用map的时候要注意，比如遇见嵌套的Array就需要使用case来处理

//比如array(array("ID:1111","TEL:1233","NAME:ASDF"),array("ID:1221","TEL:1211","NAME:DFAS"))

//我们需要对array中的子数组做处理，比如只去ID项

array = array.map{case Array(x,y,z)=>Array(x)}

Scala数组和java数组可以互操作；用ArrayBuffer，使用scalacollection.JavaConversions中的转换函数

如果数组在rdd中，假设结构为(id,array)，若想要打印rdd内容并看到数组内容可以a.take(10).foreach(v => println(v._1, v._2.mkString(",")))

-def isEmpty: Boolean 判断当前数组是否为空。

val a = Array(1, 2, 3, 4, 5)

a.isEmpty // return false

-def intersect(that: collection.Seq[T]): Array[T] 取两个集合的交集

val a = Array(1, 2, 3, 4, 5)

val b = Array(3, 4, 6)

val c = a.intersect(b)//也可以这样 val c = c intersect b

println(c.mkString(",")) //return 3,4

10.其他

//求和

scala> intArray.sum

res8: Int = 6

//求最小值

scala> intArray.min

res9: Int = 1

//求最大值

scala> intArray.max

res10: Int = 3

// make String

scala> intArray.mkString(",")

res11: String = 1,2,3

scala> intArray.mkString("")

res12: String = <1,2,3>

val first = intArray(0) // 读取第一个元素

intArray(3) = 100 // 替换第四个元素为100

有时候会出现错误：scala.MatchError: [Ljava.lang.String;@51443799 (of class [Ljava.lang.String;)

这是Array中元素和调用时元素不匹配造成的，用case时常会遇见这种问题，几种方法可以预防。

问题重现：

scala> val Array(k, v) = "1,2".split(",")

k: String = 1

v: String = 2

scala> val Array(k, v) = "1,2,3".split(",")

scala.MatchError: [Ljava.lang.String;@508dec2b (of class [Ljava.lang.String;)

11.1. 可以加入if来判断数组是否为空，或者直接判断数组长度

11.2.可以使用_*来代替后续的元素

val Array(k, v, _*) = Array(1, 2, 3, 4, 5)

#k: Int = 1

#v: Int = 2

生成数组

1.Array.ofDim[Double](3,4) //生成3*4的二维数组,初始值为0.0

2.Array.ofDim[Double](3) //生成length=3的数组，初始值为0.0

3.Array.emptyDoubleArray() //生成一个泛型为double的空数组

用fill创建和填充数组

scala> val array1 = Array.fill(3)("0")

array1: Array[String] = Array("0","0", "0")

13.合并数组

用Array中的concat可以合并数组元素

import Array._

val array = Array.concat(array1,array2,array3)

14.比较数组

判断两个数组是否相等

Array("1","2")==Array("1","2") 是false。

Array("1","2").equal(Array("1","2")) 是false。

需要使用sameElements

Array("1","2") sameElements Array("1","2") 是true

scala中array比较特殊，转成序列或者列表会好一些。

例如：

List("1","2") == List("1","2") //true

List("1","2") sameElement List("1","2") //true

如果想知道两个数组(a,b)是否是b被a包含的关系，可以使用相交再相等的方式

val a = Array("1","2","3").

val b = Array("1","2")

val c = a.intersect(b) //a = Array("1","2")

c sameElement b //true

15.查找元素

使用find可以查找符合条件的第一个元素

比如嵌套的数组中array(array("x","y","z"),array("a","b","c"),array("a","w","e")……)

查找数组中子数组第一个元素等于"a"的第一个子数组

array.find({x:Array[String] => x(0) == "a"})

查找出来的结果是Option类型，Some(……)，这种类型里的数据不能直接拿出来用，需要用到get方法取值

array.find({x:Array[String] => x(0) == "a"}).get.mkString(",")

使用get，如果查找不到会报以下的错误，并返回一个空字符串。

Spark--java.util.NoSuchElementException: None.get at at

单条这种情况，最后也有返回值，影响不是很大，但是如果是在dataframe中遍历的时候，每条都报这个错误，最后程序就无法运行。所以通常不用get，使用getOrElse，查找不到就返回自己设定的一个值，后面如果不需要，可以手动过滤掉。

array.find({x:Array[String] => x(0) == "a"}).getOrElse(Array("error")).mkString(",")

1.定长数组

val nums = new Array[Int](10)//所有元素初始化为0

//nums: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

val a = new Array[String](10)

// 10个元素的字符串数组，所有元素初始化为null

//a: Array[String] = Array(null, null, null, null, null, null, null, null, null, null)

val s = Array("Hello","World")

// 长度为2的Array[String]——类型是推断出来的，已提供初始值就不需要new了

//s: Array[String] = Array(Hello, World)

s(0) = "Goodbye"

//Array("Goodbye","World")

//使用()而不是[]来访问元素

2.变长数组：数组缓冲

对于长度需要变化的数组，Java有ArrayList，C++有Vector，Scala中有ArrayBuffer

import scala.collection.mutable.ArrayBuffer

val b = ArrayBuffer[Int]()

//或者val b = new ArrayBuffer[Int]()

//一个空的数组缓冲，准备存放数组

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)

// 可以用 ++= 操作符追加任何集合

//但是不能 b++= 1 【错误】1不是集合类型

b.trimEnd(5)

//移除最后5个元素

//ArrayBuffer(1,1,2)

在ArrayBuffer的尾端添加或移除元素是一个高效的操作(”amortized constant time“，固定时间)。

在任意位置插入或移除元素时，效率较低——在那位置之后的元素都要被平移。如：

b.insert(2,6)//在第二个元素后插入6

//ArrayBuffer(1,1,6,2)

b.insert(2,7,8,9) //在第二个元素有插入7,8,9

//ArrayBuffer(1,1,7,8,9,6,2)

b.remove(2) //移除第二个元素后的一个元素

//ArrayBuffer(1,1,8,9,6,2)

b.remove(2,3) //移除第二个元素后的三个元素

//ArrayBuffer(1,1,2)

//第二个参数是要移除多少元素

3.Array和ArrayBuffer的转换

b.toArray

//Array(1,1,2)

b.toBuffer

//ArrayBuffer(1,1,2)

4.遍历Array和ArrayBuffer

在Java和C++中，数组和数组列表/向量有一些语法上的不同，Scala则更加统一。大多数时候，可以用相同的代码处理这两种数据结构。

for(i

println(i + ":" +a(i))

//until返回所有小于但不包括上限的数字。

0 until (a.length, 2)

//Range(0,2,4,...)

(0 until a.length).reverse

//Range(...,2,1,0)

for(elem

println(elem)

5.数组转换

从一个数组(或数组转换)出发，以某种方式对它进行转换，这些转换动作不会修改原始数组，而是产生一个全新的数组。

val a = Array(2,3,5,7,11)

val result = for(elem

//result是Array(4,6,10,14,22)

val result1 = for(elem

//scala.collection.immutable.IndexedSeq[Int] = Vector(0, 2, 4, 6, 8, 10, ……,198)

for(elem

//对每个偶数元素翻倍，并丢弃奇数元素

一种等价方法

a.filter(_ % 2 == 0).map(2 * _)

//或者

a.filter{_ % 2 == 0}map{ 2 * _}

高效数组操作

//给定一个整数的数组缓冲，移除第一个负数之外的所有负数。

var first=true

var n=a.length

var i=0

while ( i

if (a(i) >= 0)

i+=1

else{

if (first) {

first=false

i+=1

} else {

a.remove (i)

n-=1 }}}

//从数组缓冲中移除元素并不高效，把非负数值拷贝到前端比较好

var first = true

val indexes =

for(i= 0)

yield{

if (a(i) < 0) first = false;//遇到第一个负数时置first = false,以后再遇到负数，根据 first||a(i)>=0 就直接跳过了

i //i是下标

}

for (j

a.trimEnd(a.length - indexes.length)

这里的关键点是，拿到所有下标好过逐个处理，一次就能处理完。

数组转成映射(array转Map)

假设一个场景，一个array中全是字符串，我们需要拿出最长的那个字符串，那么我们可以把这个array转成Map，

映射表中为(str -> str.length)这种形式。

那么我们可以先用case转化array为元祖，再用toMap转化成映射。

val a = Array("1222","733232","2435345", "9568678")

val b = a.map{case x => (x,x.length) }

val c = b.toMap

val d = c.maxBy(_._2)

val e = d._1

6.常用算法

求和与排序

求和与排序，Scala有内建的函数来处理这些任务

Array(1,7,2, 9).sum // 19，对ArrayBuffer同样适用

要使用sum方法，元素类型必须是数值类型：要么是整型，要么是浮点数或者Biglnteger/BigDecimal。

同理，min和max输出数组或数组缓冲中最小和最大的元素。

ArraryBuffer("Mary", "had","a","little", "lamb").max // "little"

sorted方法将数组或数组缓冲排序并返回经过排序的数组或数组缓冲，这个过程并不会修改原始版本：

val b=ArrayBuffer(1,7,2, 9)

val bSorted=b.sorted(_ < _) // b没有被改变，bSorted是ArrayBuffer(1,2,7,9)

sortWith方法：

val bDescending = b.sortWith(_>_) //ArrayBuffeer(9,7,2,1)

可以直接对一个数组排序，但不能对数组缓冲排序：

val a=Array(1,7,2,9)

scala.util.Sorting.quickSortIa(a) // a现在是Array(1,2,7,9)

显示数组内容

最后，如果你想要显示数组或数组缓冲的内容，可以用mkString方法，它允许你指定元素之间的分隔符。该方法的另一个重载版本可以让你指定前缀和后缀。例如:

a.mkString("and") // "1 and 2 and 7 and 9"

a.mkString("") // "<1,2,7,9>"

和toString相比：

a.toString // " [I@85b8d"，这里被调用的是Java的毫无意义的toString方法

b.toString // "ArrayBuffer(l,7,2, 9)"，toString方法报告了类型，便于调试

7.多维数组

多维数组是通过数组的数组来实现的。举例来说，Double的二维数组类型为：

Array[Array[Double]]

要构造这样一个数组，可以用ofDim方法：

val matrix=Array.ofDim[Double](3,4) //三行，四列要访问其中的元素，使用两对圆括号：

matrix (row) (column) =42

你可以创建不规则的数组，每一行的长度各不相同：

val triangle=new ArraylArray [Int] (10)

for (i

triangle(i)=new Array[lnt] (i+1)

8.转化

scala中的容器大部分可以使用toList，toSet，toArray，toMap等相互转换

如果要转化成java容器，例如scala List转java List

import scala.collection.JavaConverters._

scalaList.asJava

映射

构造映射

映射是键/值对偶的集合。Scala有一个通用的叫法-元组-n个对象的聚集，并不一定要相同的类型。对偶不过是一个n=2的元组。我们可以通过以下方式构造映射，如

1.构造不可变映射

scala> val map = Map("a" -> 1, "b" -> 2)

map: scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2)

注：上述代码构造了一个不可变的Map[String, Int]-对偶类型Scala会自动推导，其值不能被改变。你可以通过 -> 操作符来创建对偶。你也可以通过Map(("a", 1), ("b", 2))来创建对偶。

2.构建可变映射

val res = scala.collection.mutable.Map("a" -> 1, "b" -> 2)

res: scala.collection.mutable.Map[String,Int] = Map(b -> 2, a -> 1)

注：上述代码构建了一个可变的Map[String, Int]，其值可以被改变。Scala可以推导出Map对偶的类型，但是如果为Map()，则会生成一个可变的Map[Nothing, Nothing]。

3.构建空映射

scala> val res = new scala.collection.mutable.HashMap[String, Int]

res: scala.collection.mutable.HashMap[String,Int] = Map()

注：上述代码构建了一个空映射。

获取映射中的值

在Scala中，你要使用()表示法来查找某个键对应的值。如，

scala> val map = scala.collection.mutable.Map("a" -> "b", "b" -> "a")

map: scala.collection.mutable.Map[String,String] = Map(b -> b, a -> a)

scala> map("a")

res0: String = b

注：如果映射并不包含请求中使用的键，则会抛出异常。如果你要检查映射中是否包含某个指定的键，可用contains方法。映射中有一个getOrElse方法，有则取对应key值，否则取默认值，如.getOrElse("c", "t")，调用返回字符串t。在Scala中，映射.get(键)这样的调用返回一个Option对象，要么是Some(键对应的值)，要么是None。

getOrElse()主要就是防范措施，如果有值，那就可以得到这个值，如果没有就会得到一个默认值，getOrElse()方法要比用get()方法安全得多。

object Test5 {

def main(args: Array[String]): Unit = {

var map=Map[Int,String]()

map+=(1->"one",2->"two")

println(map.getOrElse(1,"default"))

println(map.getOrElse(2,"default"))

println(map.getOrElse(3,"default"))

}

结果

one

two

default

更新映射中的值

在可变映射中，你可以更新某个映射的值，或者添加一个新的映射关系，

1.更新/新增一个键/值对,做法是在=号的左侧使用()

scala> val map = scala.collection.mutable.Map("a" -> "a", "b" -> "b")

map: scala.collection.mutable.Map[String,String] = Map(b -> b, a -> a)

scala> map("a") = "a1"

scala> map("c") = "c"

scala> print(map("a") + "-" + map("c"))

a1-c

2.添加多个键/值对，使用+=

scala> val map = scala.collection.mutable.Map("a" -> "a", "b" -> "b")

map: scala.collection.mutable.Map[String,String] = Map(b -> b, a -> a)

scala> map += ("c" -> "c", "d" -> "d")

res4: map.type = Map(b -> b, d -> d, a -> a, c -> c)

3.移除某个键和对应的值，使用-=

scala> val map = scala.collection.mutable.Map("a" -> "a", "b" -> "b")

map: scala.collection.mutable.Map[String,String] = Map(b -> b, a -> a)

scala> map -= "b"

res5: map.type = Map(a -> a)

在不可变映射中，你不可以更新其值。但你仍然可以对其进行操作，如

1.获取一个包含所需要的更新的映射，使用+

scala> val map = Map("a" -> "a", "b" -> "b")

map: scala.collection.immutable.Map[String,String] = Map(a -> a, b -> b)

scala> val newMap = map + ("b" -> "b1", "c" -> "c")

newMap: scala.collection.immutable.Map[String,String] = Map(a -> a, b -> b1, c -> c)

注：newMap映射包含了与map相同的映射关系，此外"c"被添加进来，"b"被更新。在不变映射中，老的和新的映射共享大部分数据结构。

2.移除不可变映射中某个键，使用-

scala> var map = Map("a" -> "a", "b" -> "b")

map: scala.collection.immutable.Map[String,String] = Map(a -> a, b -> b)

scala> map = map + ("b" -> "b1", "c" -> "c")

map: scala.collection.immutable.Map[String,String] = Map(a -> a, b -> b1, c -> c)

scala> map = map - "c"

map: scala.collection.immutable.Map[String,String] = Map(a -> a, b -> b1)

注：不变映射中，老的和新的映射共享大部分数据结构。

迭代映射

如果你想迭代映射，可使用如下结构，即for((k, v)

scala> var map = Map("a" -> "a", "b" -> "b")

map: scala.collection.immutable.Map[String,String] = Map(a -> a, b -> b)

scala> for((k, v)

key: a, value: a

key: b, value: b

注：如果你想迭代key，则可使用for(k

附：Map表的大部分操作

package test

/**

* map的操作;

object MapDemo {

def main(args: Array[String]): Unit = {

var map = Map[String,String]("name" -> "jason","age" -> "500","test_100" -> "test_100","test_101" -> "test_101") //引用可变,支持读写操作;

map += ("city" -> "北京") //新增

println(map) //打印结果为:Map(city -> 北京, name -> jason, test_100 -> test_100, test_101 -> test_101, age -> 500);

val map2 = Map[String,String]("sex" -> "男","brand" -> "apple") //引用不可变,只能第一次写入值,之后只能读取;

//map2 += ("test" -> "报错吗") //此时不能加,直接报错;

val map3 = scala.collection.mutable.Map[String,String]() //引用不可变,支持读写操作;

map3 += ("test" -> "能添加吗") //添加单个元素;

map3 += ("test" -> "改变了") //更新;

map3 += ("success" -> "添加成功了吗","anthor" -> "另外一个") //添加多个元素;

println(map3) //打印结果为:Map(success -> 添加成功了吗, anthor -> 另外一个, test -> 能添加吗);

println(map3.keys) //返回所有的key;

println(map3.values)//返回所有的value;

println(map3.isEmpty) //当map为空时,返回true;

var combine_map = map ++ map2 //合并两个map;

println(combine_map) //打印结果为:Map(city -> 北京, name -> jason, test_100 -> test_100, test_101 -> test_101, age -> 500, brand -> apple, sex -> 男);

combine_map -= ("city","name") //删除指定的key;

println(combine_map) //打印结果为:Map(test_100 -> test_100, test_101 -> test_101, age -> 500, brand -> apple, sex -> 男)

println(combine_map.get("age").get) //返回指定key的值;

println(combine_map.init) //返回所有元素，除了最后一个;

println(combine_map.last) //返回最后一个元素;

println(combine_map.max) //查找最大元素;

println(combine_map.min) //查找最小元素;

println(combine_map.mkString("")) //集合所有元素作为字符串显示;

//println(combine_map.product) //返回集合中数字元素的积;注意得是num型;

println(combine_map.size) //返回map的大小;

println(combine_map.toArray) //集合转数组;

println(combine_map.toBuffer) //返回缓冲区,包含了Map的所有元素;

println(combine_map.toList) //返回List,包含了Map的所有元素;

combine_map.get("test_101").getOrElse("不存在") //根据key取value值,如果不存在返回后面的值;

val keySet = combine_map.keys

val key_iter = keySet.iterator //遍历,迭代map;

while (key_iter.hasNext){

val key = key_iter.next

println(key + ":" + combine_map.get(key).get)

}

println(combine_map.apply("brand")) //返回指定键的值，如果不存在返回 Map 的默认方法;

println(combine_map.contains("test_key")) //如果map中存在指定 key,返回 true，否则返回 false;

val age_count = combine_map.count(x=>{ //计算满足指定条件的集合元素数量;

x._1.equals("age")

})

println(age_count) //打印结果为1;

val drop_map = combine_map.drop(1) //返回丢弃最后n个元素新集合;

println(drop_map) //打印结果为:Map(brand -> apple, sex -> 男);

println(combine_map.empty) //返回相同类型的空map;

println(map.equals(map2)) //如果两个 Map 相等(key/value 均相等)，返回true，否则返回false;

println(combine_map.exists(x => { //判断集合中指定条件的元素是否存在;

x._2.equals("男")

}))

println(combine_map.filter(x=>{ //返回满足指定条件的所有集合; 结果为:Map(brand -> apple);

x._1.length > 4

}))

println(combine_map.filterKeys(x=>{ //返回符合指定条件的不可变 Map;

x.equals("test_100")

}))

println(combine_map.find(x=>{ //查找集合中满足指定条件的第一个元素;

x._1.equals(x._2)

}))

combine_map.foreach(x=>{ //循环map里的所有元素;

println(x +"------------")

})

}

可变Map和不可变Map相互转换

1、mutable.Map to immutable.Map

val map = mutable.Map(1 -> "zhangsan", 2 -> "lisi")

val result = map.toMap

2、immutable.Map to mutable.Map

val map = immutable.Map(1 -> "zhangsan", 2 -> "lisi")

val result = mutable.Map(map.toSeq: _*)

collectAsMap

scala> val data = sc.parallelize(List((1, "www"), (1, "iteblog"), (1, "com"),

(2, "bbs"), (2, "iteblog"), (2, "com"), (3, "good")))

data: org.apache.spark.rdd.RDD[(Int, String)] =

ParallelCollectionRDD[26] at parallelize at :12

scala> data.collectAsMap

res28: scala.collection.Map[Int,String] = Map(2 -> com, 1 -> com, 3 -> good)

从结果我们可以看出，如果RDD中同一个Key中存在多个Value，那么后面的Value将会把前面的Value覆盖，最终得到的结果就是Key唯一，而且对应一个Value。

元组

映射是键/值对偶的集合。对偶是元组(tuple)的最简单形态--元组是不同类型值的聚集。元组的值是通过将单个的值包含在圆括号中构成的。如，(1, 2.66, "lm")是一个元组类型为Tuple3[Int, Double, java.lang.String]的三元数组，元组类型也可写为(Int, Double, java.lang.String)。

scala> val tuple = (1, 2.66, "lm")

tuple: (Int, Double, String) = (1,2.66,lm)

1.通过_下标获取元组的值

scala> val tuple = (1, 2.66, "lm")

tuple: (Int, Double, String) = (1,2.66,lm)

scala> print(tuple._1)

注：你可以使用变量._下标获取值，也可用变量 _下标获取值。十分注意的是，和数组或字符串中的位置不同，元组的各组元从1开始，而非0。

2.使用匹配模式获取元组的值

scala> val tuple = (1, 2.66, "lm")

tuple: (Int, Double, String) = (1,2.66,lm)

scala> val (first, second, thrid) = tuple

first: Int = 1