scala学习笔记

Array 数组

object Test1_array extends App {
  var a = Array("sj", 1, "lalala")
  for(i <- a){
    println(i)
  }
}

object Test4_array_3 extends App {
  // map
  val array = Array[Int]( 2,4,6,8,10 )
  var result = array.map( x => x*2 )
  result.foreach( println )

  result = array.map( _*2 )
  result.foreach( println )

  println("===============")
  val words = Array( "China is a big country", "USA is a big country too" )
  var splitwords = words.map( sentence => sentence.split(" ") )
  splitwords.foreach( println )

  for(i <- splitwords){
    for( j <- i ){
      println(j)
    }
    println("-----------")
  }

  println("========展平数组=========")
  val result2 = splitwords.flatten
  result2.foreach( println )

  println("========映射且展平数组=========")
//  words.flatMap( sentends => sentends.split(" ") )

}

apply（只要有apply方法，则可以将一个变量直接调用）

object Test2_apply extends App {
  val f = (x: Int) => x + 1 // 函数
  println(f) //scala.function对象
  println(f.apply(3))
  println(f(3)) //只要有apply方法，则可以将一个变量直接调用

  /**
   * Array(1,2,3)   ->   apply()
   * Array new Array()  ->  Array(1,2,3)
   */
}

List 列表

object Test5_list extends App {
  val names = List( "smith", "tom", "jack" )
  names.foreach( println )

  // 创建空列表
  val l = Nil
  println( l )

  // 容器的值为null
  val l2 = List()
  println(l2)
  println(l2.length)

  // 使用 :: 来创建列表
  val l3 = "smith"::"tom"::"jack"::List("abc")
  l3.foreach( println )

  println("=============")

  // 在列表中的元素以下标访问
  println( l3(1) )

  println("=============")

  // 计数 count
  println( "长度为3的名字有" + l3.count( s => s.length==3 ) + "个"  )

  // 删除头两个名字
  println(  l3.drop( 2 )  )
  println( l3.dropRight(1) )

  // 判断是否存在
  println( l3.exists( s => s=="tom" ) )

  // 过滤
  println( l3.filter( s => s.length==3 ) )

  // 判断是否以 xxx 开头
  println( l3.forall( s => s.startsWith("t") ) )
  println( l3.forall( s => s.endsWith("t") ) )

  // 取第一次、最后一个元素
  println( l3.head )
  println( l3.last )

  // 删除最后一个元素，生成新列表
  println( l3.init )

  // 删除第一个元素，生成新列表
  println( l3.tail )

  // 判断是否为空
  println( l3.isEmpty )

  // 长度
  println( l3.length )

  // 修改每个元素，再反转每个元素成一个新的列表
  println( l3.map( s=>{ val s1=s+"先生"; s1.reverse } ) )

  // 用逗号隔开每个字符串
  println( l3.mkString(",") )

  // 反序
  println( l3.reverse )

  // 排序
  println( l3.sortWith( (a, b)=>a.compareTo(b)<0 ) )
  println( l3.sortWith( _.compareTo(_)<0 ) )

  // tabulate() 通过给定的函数来创建列表
  val newList = List.tabulate(6)(n=>n*n)
  println( newList )

  // fill 创建一个指定重复数量
  val site = List.fill(3)("abc")
  println(site)

  val site2 = List.fill(3)(2)
  println(site2)

}

Set 集合

object Test6_set extends App {
  // 不可变集合
  val set = Set( 1,2,2,3,2,2 )  // scala.collection.immutable.Set$Set3
  println( set.getClass.getName )
  set.foreach( println )

  println( set.exists( i => i%2==0&&i%3==0 ) )
  println( set.exists( _%2==0 ) )

  println( set.drop(1) )

  import scala.collection.mutable.Set
  val set2 = Set( 1,2,3 )
  println( set2.getClass.getName )
  set2.add( 4 )
  set2.remove(1)
  set2.foreach(println)

  println("===========")

  set2+=5   // 与python一样，scala也重载运算符
  set2-=2
  set2.foreach( println )
}

object Test7_set extends App {
  val fruit = Set( "apple", "banana", "pears" )
  println( fruit.head )
  println( fruit.tail )

  // 集合运算   交，并，差
  val fruit2 = Set( "apple", "pears", "watermelon" )
  //并集
  val fruit3 = fruit2 ++ fruit
  println( fruit3 )
  val f4 = fruit2.++(fruit)
  println(f4)

  println("============")

  val f5 = fruit2.--(fruit)
  println(f5)
}

Map

object Test8_Map extends App {
  // 创建一个Map
  var A:Map[Char, Int] = Map()   // Map()  ->  apply()
  println(A)
  // 创建一个Map，存初始值
  val colors = Map( "red"->"#ff0000", "black"->"#000000" )
  println(colors)
  colors.foreach(println)

  // 添加
  A+=('1'->1000)
  A+=('2'->2000)
  A+=('3'->3000)
  A.foreach(println)

  // 取键、取值、取entry
  println( "键的集合:" + colors.keys )
  println( "值的集合:" + colors.values )
  println( "iterator:" + colors.iterator )
  val ite = colors.iterator
  val item = ite.next()
  println( item._1 + "  " + item._2 )

  // 判断是否为空，长度
  println( colors.isEmpty )
  println( colors.size )

  // 连接操作   .++  ++
  println("==========连接操作==========")
  val colors2 = Map( "red"->"#fffff00", "white"->"ffffffff" )
  var result = colors++colors2   //运算符重载
  result.foreach(println)
  result = colors.++( colors2 )   // 在这里， .++ 是一个函数，所以要加()
  println("----------------")
  result.foreach(println)

  // 迭代
  println("=========迭代===========")
  val web = Map( "baidu"->"www.baidu.com", "taobao"->"www.taobao.com" )
  // 键的循环
  web.keys.foreach(println)
  web.keys.foreach( key=>{ print("键:"+key); println(" 值:"+web(key)) } )
  web.keys.foreach{ key=>print("键:"+key); println(" 值:"+web(key)) }

  // 判断一个键是否存在
  println("========判断一个键是否存在========")
  println( web.contains("baidu") )

  // 删除
  println( web.removed("baidu") )
}

Tuple 元组

object Test9_tuple extends App {
  // 元组
  val t = (1,2,3,4)
  println( t.getClass )
  val sum = t._1 + t._2
  println("和为:" + sum)

  t.productIterator.foreach( println )

  val t2 = ( 1,"a", "xx" )
  t2.productIterator.foreach( println )
//  t2._1=100
  val l1 = List( 1, "a", "xx" )
  l1.foreach(println)

  // 定义元组时，指定类型
  val person:(Int, String) = (1,"张三")
  println( "编号:" + person._1 + "\t姓名:" + person._2 )
  println( s"编号:${person._1}\t姓名:${person._2}" )

  // 更复杂的元组
  val person2:(String, (String, String)) = ("张三", ("湖南省","衡阳市"))
  println(s"姓名:${person2._1}\t地址:${person2._2._1}\t${person2._2._2}")
}

Option

object Test10_option extends App {
  //Scala鼓励你在变量和函数返回值可能不会引用任何值的时候使用Option类型。在没有值的时候，使用None，这是Option的一个子类。
  // 如果有值可以引用，就使用Some来包含这个值。Some也是Option的子类。
  // option:选项
  def div2( a:Int, b:Int ):Option[Int] = {
    if(b!=0){
      Some( a/b )
    }else{
      None
    }
  }
  println( div2(10, 2) )
  println( div2(10, 0) )

  // getOrElse()
  val x1 = div2(10,5).getOrElse(0)
  println(x1)
  val x2 = div2(10,0).getOrElse(0)
  println(x2)
}

Option_match

object Test11_option_match extends App {
  val web = Map( "baidu"->"www.baidu.com", "taobao"->"www.taobao.com" )
//  println(web("baidu"))
  println( web.get("baidu") )
  println( web.get("abc") )

  println( show(web.get("baidu")) )
  println( show(web.get("abc")) )
  def show( x:Option[String] ):String = x match {
    case Some(s) => s
    case None => "查无结果"
  }

  // 事实上原生的Map已经实现了以上的操作
  println( web.getOrElse("baidu", "查无此网站") )
  println(web.getOrElse("abc", "查无此网站"))

}

Option_iterator

object Test_option_iterator extends App {
  val ite = Iterator( "baidu", "taobao", "jd" )
  println(ite)
  println( ite.hasNext )
  println( ite.next() )

  while( ite.hasNext ){
    println(ite.next())
  }

  ite.foreach( println )
  println( ite.size )
}```