2020-10-30-Scala-19(数组/集合的补充)

1.数组(注意变长数组添加元素的方法)

object Test1 {
  def main(args: Array[String]): Unit = {
    //定长数组的声明
    var array = Array(1, 2, 3)
    var array1 = Array[Any]("1", 1, true)
    var array2 = new Array[Double](10) //初始容量为10
    //定长数组的反转
    val reverse = array.reverse
    for (index <- reverse) {
      println(index)
    }
    //与java不同是访问数组的元素语法 array(index)

    //变长数组的声明与操作
    var arraybuffer = new ArrayBuffer[Any]()
    //添加add方法,在末端添加
    arraybuffer += 1 //添加元素1
    arraybuffer += (11, 22, 33) //添加多个
    arraybuffer ++= array //添加集合
    println(arraybuffer) //ArrayBuffer(1, 11, 22, 33, 1, 2, 3)
    //
    arraybuffer.insert(2, 222) //这里不能添加多个元素???  在索引2后添加元素
    println(arraybuffer) //ArrayBuffer(1, 11, 222, 22, 33, 1, 2, 3)

    //其他方法例如:trimend 数组之间的转换
    //多维数组的声明与遍历
    var array3 = Array.ofDim[Int](4, 4) //四行四列同java
    array3(1)(1) = 1
    var array4 = Array(Array(), Array()) //
    for (index <- array3) {
      for (inde <- index) {
        print(inde)
      }
      println()
    }
  }
}

2.List集合

注意 take drop splitat 方法...

  def main(args: Array[String]): Unit = {
    //List集合
    //说明:底层是链表
    //list集合有两大特性:同构,同一个list的元素必须是同一类型; 协变,如果S是T的子集 则 List[S] 是 List[T] 的子集
    //构建list,原来集合不发生变化
    var list = List("hello", "world")
    var list2 = "hadoop" :: "MapReduce" :: list :: Nil
    // println(list2)//List(hadoop, MapReduce, List(hello, world))
    var list3 = "java" :: "scala" :: list2 ::: Nil //把list1集合打散...注意:::两边必须都要是集合
    // println(list3)//List(java, scala, hadoop, MapReduce, List(hello, world))
    var list1 = "hhh" :: list
    //println(list1) //List(hhh, hello, world)
    list1 = list1 :+ "哈哈哈"
    // println(list1)
    var list4 = list1 +: "jjj" //发现直接赋值给list1竟然不行????
    // println(list4) //Vector(List(hhh, hello, world, 哈哈哈), j, j, j)
    list1 = "哈哈哈" +: list1
    // println(list1) //List(哈哈哈, hhh, hello, world, 哈哈哈)


    //常用操作 以list2为例子
    //println(list2.isEmpty)//判断是否为空
    //head tail init last 方法
    // println(list2.head)//返回第一个元素
    // println(list2.tail)//返回第一个元素之后的元素
    // println(list2.tail.head)//返回第二个元素
    // println(list2.init)//返回,和tail反向
    // println(list2.last)//返回最后一个元素
    //反转集合
    // println(list2.reverse)
    //返回下标
    println(list2.indices) //Range 0 until 3
    //take drop splitat
    println(list2 take (2)) //获取前2元素
    println(list2 splitAt (2)) //从第几个元素开始拆分...原来的集合不变
    // val tuple = list2.splitAt(2) (List(hadoop, MapReduce),List(List(hello, world))) 返回的是一个元组
    println(list2.drop(2)) //从第几个元素删除 ,原来集合不发生改变,重新生成一个集合
  }
}

注意mkString方法

object Test3 {
  def main(args: Array[String]): Unit = {
    //list集合操作二
    var list = List(List(1, 2), List(3, 4), List(5, 6))
    //flatten
   // println(list.flatten)//List(1, 2, 3, 4, 5, 6) 扁平化返回一个列表
    //zip和unzip方法  zip(拉链)
    var list1 = List[Int](1,2,3)
    var list2 =List[String]("hadoop","hive")
    val value = list1.zip(list2)//List((1,hadoop), (2,hive)) 组成对偶元组,如果不对称就会发生数据丢失
   // println(value)
    val unzip = value.unzip
   // println(unzip)//是zip的反向操作

    //mkString()方法 ,mkString三种重载方法改变字符串的形式
    var s1 = List("java","scala","JavaScript")
    println(s1)//List(java, scala, JavaScript)
    val str = s1.mkString(",")
    println(str)//java,scala,JavaScript
    val str1 = s1.mkString("{", ":", "}")
    println(str1)//{java:scala:JavaScript}  说明:前缀,分隔符,后缀
    val str2 = s1.mkString
    println(str2)//javascalaJavaScript

   //迭代器
   var s2 =List(List(1,2),List(3,4),List(5,6))
    val iterator = s2.iterator
    while (iterator.hasNext) {
         println(iterator.next())
    }
   //toarray 和 tolist  数组和集合之间的转换 
   //copytoarray方法 把list元素拷贝到array指定位置
  }
}

list的高级操作
map flatmap foreach 方法

object Test4 {
  def main(args: Array[String]): Unit = {
    //list集合
    //map flatmap  方法的比较

    var list = List(List(1, 2, 3), List(4, 5), List(6, 7))

    // println(list.map(_.toString() + 10)) //List(List(1, 2, 3)10, List(4, 5)10, List(6, 7)10)
    //发现使用下面的方法为空,怎么解决???
    // println(list.map(data=>data.map(data=>data+10)))//List(List(11, 12, 13), List(14, 15), List(16, 17))
    //两个例子用于比较map 和 flatMap 的区别
    //println(list.map(data => data.toList))//List(List(1, 2, 3), List(4, 5), List(6, 7))
    //println(list.flatMap(data => data.toList))//List(1, 2, 3, 4, 5, 6, 7)
    // foreach 方法
    var sum = 0
    //println(list.map(data => data.foreach(data => sum += data)))//求和
    // println(list.foreach(data => data.foreach(data => sum += data))) //求和
    println(sum) //求和
  }
  def fun(list: List[Int]): List[Int] = {
    var list1 = ListBuffer[Int]()
    for (index <- list) {

      list1 :+ (index + 10)
    }
    list1.toList
  }
}

Option()集合??

object Test5 {
  //过滤方法
  //Option(Int)
  def main(args: Array[String]): Unit = {
    var list = List(1, 2, 3, 4, 5, 6, 7)
    //filter方法 过滤判断
    //println(list.filter(data=>data%2==0))//List(2, 4, 6)
    //partition()按照筛选条件进行分组,返回的类型是元组
    // println(list.partition(_%2==1))//(List(1, 3, 5, 7),List(2, 4, 6))  返回的是一个元组,元组中是list集合
    //find方法,返回第一个满足条件的值,对于list集合可以使用getorelse()来给一个默认值
    val maybeInt = list.find(_ % 3 == 1) //Option(Int)
    // println((maybeInt.getOrElse(10, 0)))//1

    //三者的区别:takewhile遍历元素直到不符合条件,返回所有遍历的值,dropwhile相反返回未遍历的值,span方法综合两者生成一个元组
    println(list.takeWhile(_ < 5)) //List(1, 2, 3, 4)
    println(list.dropWhile(_ < 5)) //st(5, 6, 7) 
    println(list.span(_ < 5)) // (List(1, 2, 3, 4),List(5, 6, 7))
  }
}

注意比较方法

object Test6 {
  def main(args: Array[String]): Unit = {
    //列表 的检查:forall方法元素都满足条件者返回true exists方法只要有一个元素满足条件则返回true
    //list排序 sortwith方法 由于list是不可变的返回一个新的list
    var list = List(2, 3, 4, 66, 22, 11, 1)
    println(list.sortWith((s1, s2) => {
      s1>s2
    }))
    //反思java中自然排序和定制排序
    var list1 =List("11","111","1","999")
    println(list.sortWith((s1, s2) => {
      s1.toInt < s2.toInt
    }))
  }
}

3.set集合

略......

4.Map

object Test7 {
  def main(args: Array[String]): Unit = {
    //map
    //map的构建
    var map1 = Map((1, 2), (2, 3), (3, 4))
    var map2 = Map(1 -> 1, 2 -> 2, 3 -> 3)
    // var map3 =new Map[String,Int]..没有这种写法
    var map4 = new mutable.HashMap[String, String]
   // println(map1)
   // println(map2)
    // println(map3)
   // println(map4)
    //map的取值的四种方法
   // println(map1(1)) //直接传入key,如果没有这个key就会报错
    if (map1.contains(1)) {
     // println(map1(1))
    }
   // println(map1.get(1).get) //获取key1
   // println(map1.getOrElse(1, 0)) //第二个参数的默认值,如果不存在这个key,则使用默认值代替
    //同list一样map也有可变和不可变map
    //对map的增删改
    var map5 =mutable.Map("1"->"小明",1->"西华",'c'->Nil)
    println(map5)
    //存在则更新不存在则添加
    map5(1) = "火神盾"
    map5("1")="存储"
    map5(2)=Nil
    println(map5)
    //可以通过+= 和 -= 来添加可删除元素
    //map集合不可变 但是允许相同的操作生成一个新的map
    //遍历map的三种方法
    for(k<-map5.keys){println(map5(k))}
    for(v<-map5.values){println(v)}
    for ((k,v)<-map5){println(k + " " + v)}
  }
}

yield方法

object Test8 {
  def main(args: Array[String]): Unit = {
    //map  yield 方法从现有map生成一个新的map
    var map1 = Map(1 -> 1, 2 -> 2, 3 -> 3, 4 -> 4)
    val map2 = for ((k, v) <- map1) yield (k, v - 1)
    println(map2)
    var map3 = for ((k, v) <- map1) yield (v, k)
    println(map3)
  }
}