一、字符串
- 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 {
8. println(i)
9.})
10.
11.for(s 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 {
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 5、可变长数组
/**
* 可变长度数组的定义
*/
val arr = ArrayBuffer[String]('a','b','c')
arr.appe服务器托管网nd("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
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 {
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)服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net
在Qt框架中，QString 是一个强大而灵活的字符串容器，专为处理 Unicode 字符而设计。它提供了许多方便的方法来操作和处理字符串，使得在跨平台开发中能够轻松地进行文本操作。QString 是 Qt 开发中不可或缺的一部分，它的灵活性和强大的功能使其成…
