Scala知识使用

1.String
2.StringBuilder 可变
3.string操作方法举例
比较: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)

集合
数组
1.创建数组
new ArrayInt
赋值：arr(0) = xxx
ArrayString
2.数组遍历
for
foreach
3.创建一维数组和二维数组
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)
    }
    

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

 //创建
    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(
    		"hello bjsxt",
    		"hello xasxt",
    		"hello shsxt"
        )
    val mapResult:List[Array[String]] = nameList.map{ x => x.split(" ") }
    mapResult.foreach{println}    
    
    //flatmap
    val flatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") }
    flatMapResult.foreach { println }

5.可变长List

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

set
1.创建set
注意：set集合会自动去重
2.set遍历
foreach，for
3.set方法举例
交集：intersect ,&
差集: diff ,&~
子集:subsetOf
最大:max
最小:min
转成数组，toList
转成字符串：mkString(“~”)
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("\t"))

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

map
1.map创建
Map（1 –>”bjsxt’）
Map((1,”bjsxt”))
注意：创建map时，相同的key被后面的相同的key顶替掉，只保留一个

    val map = Map(
      "1" -> "bjsxt",
      2 -> "shsxt",
      (3,"xasxt")
    )

2.获取map的值
map.get(“1”).get
map.get(100).getOrElse(“no value”)：如果map中没有对应项，赋值为getOrElse传的值。

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

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)
    })

4.遍历key
map.keys

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

5.遍历value
map.values

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

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)

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")
      
    }))

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