Scala---字符串、集合

一、字符串

String
StringBuilder 可变
string操作方法举例

比较:equals
比较忽略大小写:equalsIgnoreCase
indexOf：如果字符串中有传入的assci码对应的值，返回下标

1./**
2.* String && StringBuilder
3./
4.val str = "abcd"
5.val str1 = "ABCD"
6.
7.println(str.indexOf(97))
8.println(str.indexOf("b"))
9.
10.println(str==str1)
11./**
12. compareToIgnoreCase
13.*
14.* 如果参数字符串等于此字符串，则返回值 0；
15.* 如果此字符串小于字符串参数，则返回一个小于 0 的值；
16.* 如果此字符串大于字符串参数，则返回一个大于 0 的值。
17.*
18.*/
19.println(str.compareToIgnoreCase(str1))
20.
21.val strBuilder = new StringBuilder
22.strBuilder.append("abc")
23.// strBuilder.+('d')
24.strBuilder+ 'd'
25.// strBuilder.++=("efg")
26.strBuilder++= "efg"
27.// strBuilder.+=('h')
28.strBuilder+= 'h'
29.strBuilder.append(1.0)
30.strBuilder.append(18f)
31.println(strBuilder)

二、集合

数组

1、创建数组

new Array[Int](10)

赋值：arr(0) = xxx

Array[String]("s1","s2","s3")

2、数组遍历

for
foreach

3、创建一维数组和二维数组

4、数组中方法举例

Array.concate：合并数组
Array.fill(5)("zhangsan")：创建初始值的定长数组

创建两种方式:

1./**
2.* 创建数组两种方式：
3.* 1.new Array[String](3)
4.* 2.直接Array
5.*/
6.
7.//创建类型为Int 长度为3的数组
8.val arr1 = new Array[Int](3)
9.//创建String 类型的数组，直接赋值
10.val arr2 = Array[String]("s100","s200","s300")
11.//赋值
12.arr1(0) = 100
13.arr1(1) = 200
14.arr1(2) = 300

遍历两种方式：

1./**
2.* 遍历两种方式
3.*/
4.for(i <- arr1){
5.  println(i)
6.}
7.arr1.foreach(i => {
8.  println(i)
9.})
10.
11.for(s <- arr2){
12.  println(s)
13.}
14.arr2.foreach { 
15.  x => println(x) 
16.}

创建二维数组:

1./**
2.* 创建二维数组和遍历
3.*/
4.val arr3 = new Array[Array[String]](3)
5.arr3(0)=Array("1","2","3")
6.arr3(1)=Array("4","5","6")
7.arr3(2)=Array("7","8","9")
8.for(i <- 0 until arr3.length){
9.  for(j <- 0 until arr3(i).length){
10.    print(arr3(i)(j)+" ")
11.  }
12.  println()
13.}
14.
15.var count = 0
16.for(arr <- arr3 ;i <- arr){
17.  if(count%3 == 0){
18.     println()
19.  }
20.  print(i+" ")
21.  count +=1 
22.}
23.
24.arr3.foreach { arr => {
25.  arr.foreach { println }
26.}}
27.
28.
29.val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))
30.arr4.foreach { arr => {
31.  arr.foreach(i => {
32.    println(i)
33.  })
34.}}
35.println("-------")
36.for(arr <- arr4;i <- arr){
37.  println(i)
38.}

5、可变长数组

/**
* 可变长度数组的定义
*/

val arr = ArrayBuffer[String]('a','b','c')
arr.append("hello","scala")//添加多个元素
arr.+=("end")//在最后追加元素
arr.+=:("start")//在开头添加元素
arr.foreach(println)

list

1、创建list

val list = List(1,2,3,4)

Nil长度为0的list

2、list遍历

foreach ，for

3、list方法举例

filter:过滤元素
count:计算符合条件的元素个数
map：对元素操作
flatmap ：压扁扁平,先map再flat

1.//创建
2.val list = List(1,2,3,4,5)
3.
4.//遍历
5.list.foreach { x => println(x)}
6.// list.foreach { println}
7.//filter
8.val list1 = list.filter { x => x>3 }
9.list1.foreach { println}
10.
11.//count
12.val value = list1.count { x => x>3 }
13.println(value)
14.
15.//map
16.val nameList = List(
17. "hello zhangsan",
18. "hello xasxt",
19. "hello shsxt"
20.)
21.val mapResult:List[Array[String]] = nameList.map{ x => x.split(" ") }
22.mapResult.foreach{println}
23.
24.//flatmap
25.val flatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") }
26.flatMapResult.foreach { println }

4、可变长List

1./**
2.* 可变长list
3.*/
4.val listBuffer: ListBuffer[Int] = ListBuffer[Int](1,2,3,4,5)
5.listBuffer.append(6,7,8,9)//追加元素
6.listBuffer.+=(10)//在后面追加元素
7.listBuffer.+=:(100)//在开头加入元素
8.listBuffer.foreach(println)

set

1、创建set

注意：set集合会自动去重

2、set遍历

foreach，for

3、set方法举例

交集：intersect ,&
差集: diff ,&~
子集:subsetOf
最大:max
最小:min
转成数组，toList
转成字符串：mkString("~")

4、set方法总结

1.//创建 
2.val set1 = Set(1,2,3,4,4)
3.val set2 = Set(1,2,5)
4.//遍历
5.//注意：set会自动去重
6.set1.foreach { println}
7.for(s <- set1){
8.  println(s)
9.}
10.println("*******")
11./**
12.* 方法举例
13.*/
14.
15.//交集
16.val set3 = set1.intersect(set2)
17.set3.foreach{println}
18.val set4 = set1.&(set2)
19.set4.foreach{println}
20.println("*******")
21.//差集
22.set1.diff(set2).foreach { println }
23.set1.&~(set2).foreach { println }
24.//子集
25.set1.subsetOf(set2)
26.
27.//最大值
28.println(set1.max)
29.//最小值
30.println(set1.min)
31.println("****")
32.
33.//转成数组，list
34.set1.toArray.foreach{println}
35.println("****")
36.set1.toList.foreach{println}
37.
38.//mkString
39.println(set1.mkString)
40.println(set1.mkString("\t"))

5、可变长set

1./**
2.* 可变长Set
3.*/
4.import scala.collection.mutable.Set
5.val set = Set[Int](1,2,3,4,5)
6.set.add(100)
7.set.+=(200)
8.set.+=(1,210,300)
9.set.foreach(println)

map

1、map创建

Map（1 -->"zhangsan'）
Map((1,"zhangsan"))

注意：创建map时，相同的key被后面的相同的key顶替掉，只保留一个。

2、获取map的值

map.get("1").get
map.get(100).getOrElse("no value")：如果map中没有对应项，赋值为getOrElse传的值。

1.//获取值
2.println(map.get("1").get)
3.val result = map.get(8).getOrElse("no value")
4.println(result)

3、遍历map

for,foreach

1.//map遍历
2.for(x <- map){
3. println("====key:"+x._1+",value:"+x._2)
4.}
5.map.foreach(f => {
6. println("key:"+ f._1+" ,value:"+f._2)
7.})

4、遍历key

map.keys

1.//遍历key
2.val keyIterable = map.keys
3.keyIterable.foreach { key => {
4.println("key:"+key+", value:"+map.get(key).get)
5.} }
6.println("---------")

5、遍历value

map.values

1.//遍历value
2.val valueIterable = map.values
3.valueIterable.foreach { value => {
4. println("value: "+ value)
5.} }

6、合并map

++ 例：map1.++(map2) --map1中加入map2
++: 例：map1.++:(map2) --map2中加入map1

注意：合并map会将map中的相同key的value替换

1.//合并map
2.val map1 = Map(
3.(1,"a"), 
4.(2,"b"), 
5.(3,"c") 
6.)
7.val map2 = Map(
8.(1,"aa"),
9.(2,"bb"),
10.(2,90),
11.(4,22),
12.(4,"dd")
13.)
14.map1.++:(map2).foreach(println)

7、map中的方法举例

filter:过滤，留下符合条件的记录
count:统计符合条件的记录数
contains：map中是否包含某个key
exist：符合条件的记录存在不存在

1./**
2.* map方法
3.*/
4.//count
5.val countResult = map.count(p => {
6. p.2.equals("shsxt")
7.})
8.println(countResult)
9.
10.//filter
11.map.filter(._2.equals("shsxt")).foreach(println)
12.
13.//contains
14.println(map.contains(2))
15.
16.//exist
17.println(map.exists(f =>{
18. f._2.equals("xasxt")
19.
20.}))

8、可变长map

**
  * 可变长Map
  */
import scala.collection.mutable.Map
val map = Map[String,Int]()
map.put("hello",100)
map.put("world",200)
map.foreach(println)