1字符串
1.1String
1.2StringBuilder 可变
1.3string操作方法举例
- 比较:equals
- 比较忽略大小写:equalsIgnoreCase
- indexOf：如果字符串中有传入的assci码对应的值，返回下标
/** * String && StringBuilder */ val str = "abcd" val str1 = "ABCD" println(str.indexOf(97)) println(str.indexOf("b")) println(str==str1) /** * compareToIgnoreCase * * 如果参数字符串等于此字符串，则返回值 0； * 如果此字符串小于字符串参数，则返回一个小于 0 的值； * 如果此字符串大于字符串参数，则返回一个大于 0 的值。 * */ println(str.compareToIgnoreCase(str1)) val strBuilder = new StringBuilder strBuilder.append("abc") // strBuilder.+('d') strBuilder+ 'd' // strBuilder.++=("efg") strBuilder++= "efg" // strBuilder.+=('h') strBuilder+= 'h' strBuilder.append(1.0) strBuilder.append(18f) println(strBuilder)
2.集合
2.1数组
2.1.1创建数组
- new Array[Int](10)
赋值：arr(0) = xxx
- Array[String](“s1”,”s2”,”s3”)
2.1.2数组遍历
- for
- foreach
2.1.3创建一维数组和二维数组
2.1.4数组中方法举例
- Array.concate：合并数组
- Array.fill(5)(“bjsxt”)：创建初始值的定长数组
创建两种方式::
/** * 创建数组两种方式： * 1.new Array[String](3) * 2.直接Array */ //创建类型为Int 长度为3的数组 val arr1 = new Array[Int](3) //创建String 类型的数组，直接赋值 val arr2 = Array[String]("s100","s200","s300") //赋值 arr1(0) = 100 arr1(1) = 200 arr1(2) = 300
遍历两种方式：
/** * 遍历两种方式 */ for(i <- arr1){ println(i) } arr1.foreach(i => { println(i) }) for(s <- arr2){ println(s) } arr2.foreach { x => println(x) }
创建二维数组:
/** * 创建二维数组和遍历 */ val arr3 = new Array[Array[String]](3) arr3(0)=Array("1","2","3") arr3(1)=Array("4","5","6") arr3(2)=Array("7","8","9") for(i <- 0 until arr3.length){ for(j <- 0 until arr3(i).length){ print(arr3(i)(j)+" ") } println() } var count = 0 for(arr <- arr3 ;i <- arr){ if(count%3 == 0){ println() } print(i+" ") count +=1 } arr3.foreach { arr => { arr.foreach { println } }} val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6)) arr4.foreach { arr => { arr.foreach(i => { println(i) }) }} println("-------") for(arr <- arr4;i <- arr){ println(i) }
2.2 List
2.2.1创建list
val list = List(1,2,3,4)
- Nil长度为0的list
2.2.2 list遍历
foreach ，for
2.2.3 list方法举例
- filter:过滤元素
- count:计算符合条件的元素个数
- map：对元素操作
- flatmap ：压扁扁平,先map再flat
//创建 val list = List(1,2,3,4,5) //遍历 list.foreach { x => println(x)} // list.foreach { println} //filter val list1 = list.filter { x => x>3 } list1.foreach { println} //count val value = list1.count { x => x>3 } println(value) //map val nameList = List( "ni hao a", "hello scala" ) val mapResult:List[Array[String]] = nameList.map{ x => x.split(" ") } mapResult.foreach{x =>{ x.foreach(println) }} //flatmap val flatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") } flatMapResult.foreach {x =>{ x.foreach(println) }}
2.3 Set
2.3.1创建set
注意：set集合会自动去重
2.3.2set遍历
foreach，for
2.3.3set方法举例
- 交集：intersect ,&
- 差集: diff ,&~
- 子集:subsetOf
- 最大:max
- 最小:min
- 转成数组，toList
- 转成字符串：mkString(“~”)
2.3.4 set方法总结
//创建 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(" "))
2.4 Map
2.4.1map创建
- Map（1 –>”bjsxt’）
- Map((1,”bjsxt”))
注意：创建map时，相同的key被后面的相同的key顶替掉，只保留一个
val map = Map( "1" -> 11, 2 -> 11, (3,"dsasd") )
2.4.2 获取map的值
- map.get(“1”).get
- map.get(100).getOrElse(“no value”)：如果map中没有对应项，赋值为getOrElse传的值。
println(map.get("1").get) println(map.get(6).getOrElse("no this key"))
2.4.3遍历map
- for,foreach
//map遍历 for(x <- map){ println("====key:"+x._1+",value:"+x._2) } map.foreach(f => { println("key:"+ f._1+" ,value:"+f._2) })
2.4.4遍历key
- map.keys
//遍历key val keyIterable = map.keys keyIterable.foreach { key => { println("key:"+key+", value:"+map.get(key).get) } }
2.4.5遍历value
- map.values
//遍历value val valueIterable = map.values valueIterable.foreach { value => { println("value: "+ value) } }
2.4.6合并map
- ++ 例：map1.++(map2) --map1中加入map2
- ++: 例：map1.++:(map2) –map2中加入map1
注意：合并map会将map中的相同key的value替换
//合并map val map1 = Map( (1,"a"), (2,"b"), (3,"c") ) val map2 = Map( (1,"aa"), (2,"bb"), (2,90), (4,22), (4,"dd") ) map1.++:(map2).foreach(println)
2.4.7 map中的方法举例
- filter:过滤，留下符合条件的记录
- count:统计符合条件的记录数
- contains：map中是否包含某个key
- exist：符合条件的记录存在不存在
/** * map方法 */ //count val countResult = map.count(p => { p._2.equals("shsxt") }) println(countResult) //filter map.filter(_._2.equals("shsxt")).foreach(println) //contains println(map.contains(2)) //exist println(map.exists(f =>{ f._2.equals("xasxt") }))
2.5元组
2.5.1元组定义
与列表一样，与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。
2.5.2创建元组与取值
- val tuple = new Tuple（1） 可以使用new
- val tuple2 = Tuple（1,2） 可以不使用new，也可以直接写成val tuple3 =（1,2,3）
- 取值用”._XX” 可以获取元组中的值
注意：tuple最多支持22个参数
//创建，最多支持22个 val tuple = new Tuple1(1) val tuple2 = Tuple2("zhangsan",2) val tuple3 = Tuple3(1,2,3) val tuple4 = (1,2,3,4) val tuple18 = Tuple18(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18) val tuple22 = new Tuple22(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22) //使用 println(tuple2._1 + " "+tuple2._2) val t = Tuple2((1,2),("zhangsan","lisi")) println(t._1._2)
2.5.3元组的遍历
tuple.productIterator得到迭代器，进而遍历
//遍历 val tupleIterator = tuple22.productIterator while(tupleIterator.hasNext){ println(tupleIterator.next()) }
2.5.4 swap,toString方法
注意：swap元素翻转，只针对二元组
/** * 方法 */ //翻转，只针对二元组 println(tuple2.swap) //toString println(tuple3.toString())