scala记录（3）字符串和集合

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