scala数组 map 元组

数组

 def  one (): Unit ={
    //创建数组
    val array = new Array[Int](5)
    val ints = Array(1, 2, 3, 4, 5, 6)
    //获取数组中的元素
    val num = array(2)
    println(num)
    //数组遍历
    for(a <- ints){
      println(a)
    }
    //判断是否包含
    println(array.contains(2))
    //数组元素的拼接输出
    println("数组元素："+array.mkString("[",",","]"))
  }

  /**
   * 可变数组
   */
  def tow (): Unit ={
    //可变数组
    //定义一个数组
  //  val arrayBuffer1 = new ArrayBuffer[Int]()
 //   val arrayBuffer2 = ArrayBuffer[String]()
    //val arrayBuffer3 = ArrayBuffer[String](16)
   // val arrayBuffer = ArrayBuffer[String](16)
    //crud
    val arr = ArrayBuffer(1,2,3,4,5,6)
    arr.append(1)
    arr.append(2,3,4)
    println(arr)
    //制定位置插入
    arr.insert(0,-3,-2)
    println(arr)
    //改
    arr(1)=1
    println(arr)
    //删 remove元数组
    arr.remove(1)
    //制定位置删除
    arr.remove(0,2)
    println(arr)
    //drop 删除 形成一个新数组
    val ints = arr.drop(1)
    println(ints)
    //遍历和长度
    for(ele <- arr){
      println(ele)
    }
    println(arr.length)
    //拼接输出
    val str = arr.mkString("[", "+", "-")
    //判断元素是否包含
    println(arr.contains(2))
    //数组求和
    println(arr.sum)
    //最大最小值
    println(arr.min+" "+arr.max)
    //array和arraybuffer之间互相转换
    println(arr.toArray)
    println(arr.toBuffer)
    println(Array(1,2,3))//array数组输出是一个地址
    println(ArrayBuffer(1,2,3))//buffer数组输出是值
  }
  //累加
  def add(arr:Int*): Unit ={
    var sum = 0
    for(i<-arr){
      sum+=i
    }
    println(sum)
  }

map

  /**
   * map不可变
   */
  //map的实现是根据trait接口实现的，无法直接new对象出来，所以使用他的伴生对象创建
  def mapB (): Unit ={
    //结构
    val map = Map[Int,String]()
    //创建不可变map。必须实例化的时候添加值
    val captial = Map[String,String](
      "china" -> "Bj",
      "japan" -> "tokyo",
      "south korea" -> "han"
    )
    //crud 增
    //不可变的map不能增加 错误演示
   // captial +=("us"->"sda")
   // captial("wds") = "wc"
    //删除 drop
    val ret = captial.drop(1) //创建一个新的map，原理来的map不会变化
   //改 不可map变无法改
    //captial("china") = "wc"
    //查 返回值为some[T]和none
    //some是有值，none是没有值
    //都是option【T】类的子类，使用这个类是因为value可能幼稚也可能没有值

    //key获取value
    println(captial.get("japan"))
    //获取元素的第二种方式

    //	java.util.NoSuchElementException: key not found: uk
    //	key不存在会报错

    //推荐使用
    val str = captial.getOrElse("china",44)是否存在值，不存在返回参数二
    println("---"+str)
    //判断
    if(captial.contains("uk")){
      println(captial("uk"))
    }
    //长度
    println(captial.size)


    /**
     * 可变map
     * 包：import scala.collection.mutable.Map
     */
     //定义并初始化
     val pc = mutable.Map[String, String]()
    //crud 添加
    pc +=("广东"->"粤")
    pc +=("湖南"->"湘")
    pc += ("湖北" -> "鄂")
    pc += ("广东" -> "粤")
    pc("广西") = "桂"
    println(pc)
    //修改
    pc("广西") = "桂林"
    println(pc)
    println(pc.getOrElse("江西", "兰州")) //是否存在值，不存在返回参数二
    println(pc.remove("广东"))
    println(pc)

    /**
     * map的通用操作
     */
    //集合大小
    println(map.size)
    //map的遍历
    /**
     * java版本
     * for(Map.Entry<K, V> me : map.entrySet) {
     *     me.getKey
     *     me.getValue
     * }
     * for(K key : map.keySet()) {
     * V v = map.get(key);
     * }
     */
    for((k,v) <- pc){
      println("key" + k + " value" + v)
    }
    for (kv <- pc){
      println(kv)
    }
    //函数式编程的遍历
    pc.foreach(kv =>{
      println(kv)
    })
  }

元组

 /**
   * Tuple元组
   * 定义：将多个值包含在圆括号中构成 eg：（1,1.34，“yes”）是一个元组
   *    类型为：tuple3[Int,Double,java.lang.string]
   *  创建并初始化
   *  注意：元组Tuple是List<Object>，但是长度是有限的最多22个元素，即Tuple22
   *  Tuple1可以简写为Tuple
   */
  def Tuple (): Unit ={
    //元组只能在创建的时候进行初始化
    val tuple1 = new Tuple1[Int](1)
    val tuple2 = new Tuple2[Int, Double](1, 1.23)
    //操作
    //获取元组的第一元素
    println(tuple2._1)
    //获取第二个
    println(tuple2._2)
    //获取第N（1 <= N <= 22）个
    //tuple2._N
    //遍历
    for (value<- tuple2.productIterator){
      println(value)
    }
    //比较常见的定义元组的方式
    val season = ("spring", "summer", "autumn", "winter")
    println(season)
    val (spring, summer, autumn, winter) = ("springsad", "summerasd", "autumn", "winter")
    println(spring)
    println(summer)
  }

  /**
   * 拉链操作
   * zip：多对一，将两个单列的集合组成双列的集合
   */
    def ziptest(): Unit ={
      val province = Array("山东", "河南", "陕西", "福建")
      val capital = Array("济南", "郑州", "西安", "福州", "桂林")
      //拉链操作
      val tuples = province.zip(capital)
      //拉链实现map形式，输出k
      val map = tuples.toMap
      for((k,v)<-map){
        println(k)
      }
    }
  /**
   * zip:长度不等的集合多余的部分会被丢弃
   * zipAll：实现不等长集合的拉链,在参数后面手动添加，
   */
  def zipAll(): Unit ={
    val province = Array("山东", "河南", "陕西", "福建")
    val capital = Array("济南", "郑州", "西安", "福州", "桂林")
    println(province.zipAll(capital, "桂林", "手动添加").foreach(println))
    //手动添加只有一个值不会被输出
  }
}