scala集合day03

集合

1.Array

/**
     * 创建数组的两种方式：
     * 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
   /**
     * 创建二维数组 
     */
    val secArray = new Array[Array[String]](10)
    for(index <- 0 until secArray.length){
      secArray(index) = new Array[String](10)
    }
    
   /**
     * 遍历数组的两种方式
     */
    for(i <- arr1){
    	  println(i)
    }
    arr1.foreach(i => {
      println(i)
    })
    
    for(s <- arr2){
      println(s)
    }
    arr2.foreach { 
      x => println(x) 
    }

2.List

//创建List 不可变List
    val list = List(1,2,3,4,5)
    
    //遍历List
    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 先map再flat
    val flatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") }
    flatMapResult.foreach { println }

   /**
     * 可变的list集合
     */
    val listBuffer = new ListBuffer[String]
    listBuffer.+=("hello")
    listBuffer.+=("bj")
    listBuffer.foreach { println }
    
    listBuffer.-=("hello")

3.Set

//创建Set
    val set1 = Set(1,2,3,4,4)
    val set2 = Set(1,2,5)
    //遍历Set集合
    //注意：set会自动去重
    set1.foreach { println}
   for(s <- set1){
      println(s)
    }

4.Map

val map = Map(
                 "1" -> "bj",
                  2 -> "sh",
                  3 -> "gz"
                )
    val keys = map.keys
    val keyIterator = keys.iterator
    while(keyIterator.hasNext){
    val key = keyIterator.next()
    /**
      * map集合的get方法返回值是一个Option类型的对象
      * Option类型有两个子类型  分别为some None
      */
      println(key + "\t" + map.get(key).get)
    }
     
     /**
      * getOrElse原理：去集合中去取数据，若不存在返回默认值
      */
     println(map.get(4).getOrElse("default"))
    
     // Map遍历
     for(k <- map)
     println(k._1 + "\t" + k._2)
       
     map.foreach(x=>println(x._1 + "\t" + x._2))        
   
     // filter:过滤，留下符合条件的记录
     map.filter(x=>{
       Integer.parseInt(x._1 + "") >= 2
     }).foreach(println)
     
     // count:统计符合条件的记录数
     val count = map.count(x=>{
       Integer.parseInt(x._1 + "") >= 2
     })
     println(count)

5.Tuple

/**
      * 元组 vs list
      * list创建的时候指定了泛型，那么集合中必须是这个泛型的对象
      * 元祖中可以包含任意类型的元素，这些元素使用一对小括号来封装
      * 元组的创建：最多支持22个
      */
     val t2 = Tuple2(1,"hello")
     val tt2 = (1,"hello")
     
     val t3 = Tuple3(1,true,"hello")
     val tt3 = (1,true,"hello")
     
     val moreTuple = (1,2,3)   
     
     // 元组的遍历
     val tupleIterator = tt3.productIterator
     while(tupleIterator.hasNext){
     println(tupleIterator.next())
     }
     
     // toString方法
     println(tt3.toString())
     
     //swap交换 注意只有二元组对象才会有这个方法
     val swapt2 = tt2.swap
     println(swapt2._1 + "\t" + swapt2._2)

8、字符串

 // String不可变
    val str1 = "hello bi"
    val str2 = "hello sh"
    val flag = str1.equalsIgnoreCase(str2)    
    println(flag)
    
    str1.split(" ")
    
    // StringBuffer可变
    val strBuilder = new StringBuilder
    strBuilder.append("hello\t")
    strBuilder.append("bj")
    println(strBuilder)