Scala总结（三)

Leefs 2021-03-10 PM 3376℃ 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<String>`为参数的构造器。在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

Scala总结（三)

评论已关闭

栏目分类

标签云

友情链接申请

Scala总结（三)

评论已关闭

 栏目分类

标签云

友情链接申请

栏目分类

标签云

友情链接申请