一、字符串
- 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)
