精华内容
下载资源
问答
  • arr match{  case Array(0) = > "0"  case Array(x,y) => x+" "+y  case Array(0,_*) => "0 ..."  case _=> "something else" }


    arr match{

        case Array(0) = > "0"

        case Array(x,y) => x+" "+y

        case Array(0,_*) => "0 ..."

        case _=> "something else"

    }

    展开全文
  • scala 集合数组处理

    2019-01-10 10:02:58
    在使用spark的时候,选择scala会让代码感觉行云流水,小结一下scala中的集合,数组处理的方法 1 元组数据获取 val pair = Array(("hadoop"->90),("flume"->100)) 2 list 元素添加 3 函数式处理 map ...

     在使用spark的时候,选择scala会让代码感觉行云流水,小结一下scala中的集合,数组处理的方法

    1 元组数据获取

    val pair = Array(("hadoop"->90),("flume"->100))

    2 list 元素添加

     

    3 函数式处理 map ,groupby

    4 处理

     list.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).mapValues(_._.reduce(_+_._2))   // 错误方法

    foldLeft(0).(_+_)

     1 error: value sortBy is not a member of scala.collection.immutable.Map[String,Int]

         转成 toList

    2  转成并行化 数据---》充分利用 多核cpu 性能

    对象的构造方法

     

    主构造器的表达式都会被执行,但是定义的方法不会

     

    匹配  case class

    展开全文
  • 数组 / 映射 / 元组 一、数组 1、定长数组 ...声明数组的两种形式: ...声明指定长度的数组 val 数组名= new Array[类型](数组长度) ...提供数组初始值的数组,无需new...在JVM中,Scala的Array以Java数组的方式
    • 数组  /  映射  /  元组

      一、数组

      1、定长数组

      声明数组的两种形式:

      声明指定长度的数组 val 数组名= new Array[类型](数组长度)

        \

      提供数组初始值的数组,无需new关键字

        \

      Scala声明数组时,需要带有Array类名,且使用 () 来指明长度或提供初始值序列。

      在JVM中,Scala的Array以Java数组的方式实现。如arr在JVM中的类型对应java.lang.String[],charArr对应char[]。

      2、变长数组

        \

      ArrayBuffer,全称scala.collection.mutable.ArrayBuffer,类似于Java中的ArrayList和C++中的vector,是长度可变数组类型的结构,称为数组缓冲。

      通过:val 名 = ArrayBuffer[类型]() 来声明,声明ArrayBuffer时需要指明类型。

      通过 += 操作符来添加元素或序列,++= 操作符来拼接数组。

      【在ArrayBuffer的尾端添加或删除元素是一个高效的操作。】 ArrayBuffer还支持在指定位置插入、删除元素。

      ArrayBuffer到数组的转换: toArray方法

        \

      3、数组遍历

      通过for循环来遍历数组

        \

      指定遍历数组的步长——通过until(上界, 步长)

        \

        \

      通过reverse函数逆序遍历数组:

        \

      4、可以通过 for循环+yield 来获得新的数组或ArrayBuffer

        \

        \

      通过for+yield操作数组或ArrayBuffer之后将得到新的数组或ArrayBuffer。

      5、操作数组/数组缓冲常用函数

        \

      求和、求最大最小值、数组排序。通过sorted函数对数组或ArrayBuffer排序时,返回的是一个新的数组或ArrayBuffer,原有的不变。

      可以直接对数组调用排序算法,但是不能对ArrayBuffer排序。

        \

      quickSort是直接修改原数组,而sorted方法是返回新数组

      6、多维数组

      Scala中的多维数组同Java中一样,多维数组都是数组的数组。

      通过 Array.ofDim[类型](维度1, 维度2, 维度3,....)来声明多维数组,如声明二维数组;

        \

        从二维数组的初始化中,我们可以看到,多维数组在Scala中也是数组的数组。

      通过 Array[ Array[Int]](维度1) 来声明数组,可以声明不规则数组;

        \

        多维数组是数组的数组,按照这种性质来声明多维数组,如例子中的二维数组,声明时,需要指定最外围的数组大小。

      【注:可以通过scala.collection.JavaConversions包中隐式转换方法来实现Scala容器类与Java中类的转换。】

      二、映射

      1、映射构造

      对偶,即名值对。可以通过 -> 操作符来定义对偶, 名->值 运算的结果是( 名, 值 ); 

        \

      也可以声明对偶形式的变量

        \

      映射是由对偶构成的,映射是对偶的集合。

      声明不可变映射,直接使用Map来声明时,默认是不可变映射类型。

        \

        【注: 不可变映射维持元素插入顺序。】

      声明可变映射(scala.collection.mutable.Map)

        \

        【注:放入可变映射中的值并未按照放入顺序来排序的。】

        通过for循环来修改可变Map中的值;

        \

        【注:映射可变、不可变指的是整个映射是否可变,包括元素值、映射中元素个数、元素次序等。】

      声明空映射

        直接通过 new Map[类型1, 类型2]() 来定义映射会报错,因为Map是抽象的,无法实例化。

        定义空映射时,需要指定映射的实现类,通过new来定义;

        \

        分别定义不可变映射与可变映射。注,直接使用 new HashMap定义时会报错。

      2、映射常用操作

      判断映射中是否含有某个键: map.contains(键值)

        \

      使用 += 向可变映射中添加元素或拼接映射

        \

      使用 -= 移除可变映射中的键及对应元素

        \

      不可变映射可通过 + 操作符返回一个新的不可变映射;不可变映射可通过 - 操作符返回一个新的不可变映射;

        \

      映射遍历

        \

      获取映射的键集合keySet和值集合

        \

        通过映射的 keySet 方法可以获得映射的由键值构成的集合;通过 values 方法可以获得映射的值集合的Interable对象,应用于循环中。

        Scala的keySet / values 方法类似于Java中的映射方法。

      3、Scala中映射的底层实现要么基于哈希表,要么基于平衡树,其中基于平衡树的映射内部是有序的。

        \

        Scala目前基于平衡树的映射只提供了不可变版本。

        【注:构建可变有序映射可借助Java的TreeMap。】

      4、可变映射中,若穴ky"http://www.it165.net/qq/" target="_blank" class="keylink">qq5ub2ozqyz1tSqy9iy5cjry7PQ8rXE07PJ5L/Jzai5/UxpbmtlZEhhc2hNYXChozwvcD4KPHA+NaGizai5/XNjYWxhLmNvbGxlY3Rpb24uSmF2YUNvbnZlcnNpb25zLm1hcEFzU2NhbGFNYXC/yb2rSmF2YbXETWFw16q7u86qU2NhbGHA4NDNtcRNYXCju82ouf1zY2FsYS5jb2xsZWN0aW9uLkphdmFDb252ZXJzaW9ucy5tYXBBc0phdmFNYXC/yb2rU2NhbGG1xNOzyeTXqru7zqpKYXZhwODQzbXE07PJ5KGjPC9wPgo8cD42oaJ0b01hcLe9t6g8L3A+CjxwPqGhoaHKudPDdG9NYXC3vbeov8m9q7bUxbzX6bPJtcS8r7rP16q7r86q07PJ5KGjPC9wPgo8cD6hoaGhPGltZyBzcmM9"http://www.it165.net/uploadfile/files/2014/0920/20140920190600125.png" alt="\" />

      三、元组

      1、元组是不同类型的值的聚集;对偶是最简单的元组。

      2、元组表示

        通过将不同的值用小括号括起来,即表示元组。

        \

        上例中元组的类型就是 (Int, Double, Char, String) ;元组中可以存放不同类型的值。

      3、元组访问

      元组中的元素称为组元。可以通过 _1、 _2 、_3 的形式来访问对应下标的组元。

        \

        【注:元组中组元下标从1开始。】

      通过模式匹配来访问元组中的值

        \

        忽略不需穴ky"http://www.it165.net/qq/" target="_blank" class="keylink">qq1xNa1PC9zdHJvbmc+oaPU2sSjyr3GpcXkyrGjrM2ouf0gXyCjqM3yxNzGpcXkt/ujqcC0zqqyu9Do0qq78cih1rW1xNfp1KrVvM67o6zDv7j2IF8gvfa/ydLUzqrSu7j21+nUqtW8zruhozwvcD4KPHA+oaGhoTxpbWcgc3JjPQ=="http://www.it165.net/uploadfile/files/2014/0920/20140920190600129.png" alt="\" />

      4、元组可用于函数返回多个值的情形

        

        上例中,函数定义返回值类型为元组 (Int, String);

        

    展开全文
  • 数组 scala> val a = new Array[String](5) a: Array[String] = Array(null, null, null, null, null) scala> a.length res2: Int = 5 scala> a(1) = "hello" scala> val b ...

    随手记内容比较乱,看书看视频随手写的内容

     

    数组

    scala> val a = new Array[String](5)
    a: Array[String] = Array(null, null, null, null, null)

    scala> a.length
    res2: Int = 5

    scala> a(1) = "hello"

    scala> val b = new Array(5)
    b: Array[Nothing] = Array(null, null, null, null, null)

     

    声明数组,不指定类型返回的是Nothing类型,Nothing是Throwable,定义时候没问题,用的时候回抛错

    以上都是用new 声明的

    但是声明数组也可以

    scala> val a = Array("a","b","c")
    a: Array[String] = Array(a, b, c)

    这里面的Array就是通过 object下的apply方法完成实例化class

     

    不可变长度scala

    import scala.collection.mutable.ArrayBuffer

     

    scala> import scala.collection.mutable.ArrayBuffer
    import scala.collection.mutable.ArrayBuffer

    scala> val c = ArrayBuffer[Int]()
    c: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

    scala> c += 1
    res0: c.type = ArrayBuffer(1)

    scala> c += 2
    res1: c.type = ArrayBuffer(1, 2)

    scala> c += 3
    res2: c.type = ArrayBuffer(1, 2, 3)

    scala> c += (4,5,6)
    res3: c.type = ArrayBuffer(1, 2, 3, 4, 5, 6)

    scala> c ++=Array(7,8,9)
    res4: c.type = ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9)

    scala> c.insert(0,0)

    scala> c
    res7: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

    remove

    insert

    trimEnd

    变长数组变定长数组

    scala> c.toArray
    res13: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

     

    scala>     val a = Array(1,2,3,4,5)
    a: Array[Int] = Array(1, 2, 3, 4, 5)

    scala>     a.reduce(_ + _)
    res20: Int = 15

    scala>

    scala>     a.reduceLeft(_ + _)
    res21: Int = 15

    scala>     a.reduceRight(_ + _)
    res22: Int = 15

    scala>

    scala>     a.reduceLeft((a,b)=>{
         |       println(a)
         |       println(b)
         |       println("---------")
         |       a + b
         |     })
    1
    2
    ---------
    3
    3
    ---------
    6
    4
    ---------
    10
    5
    ---------
    res23: Int = 15

    scala>

    scala>     a.reduceRight((a,b)=>{
         |       println(a)
         |       println(b)
         |       println("---------")
         |       a + b
         |     })
    4
    5
    ---------
    3
    9
    ---------
    2
    12
    ---------
    1
    14
    ---------
    res24: Int = 15

     

    ZIP函数

    zip函数把相同位置的组成tuple,没有对不上的位置不合并

    scala> val a = List(1,2,3,4)
    a: List[Int] = List(1, 2, 3, 4)

    scala> val b = List("A","B","C","D")
    b: List[String] = List(A, B, C, D)

    scala> a.zip(b)
    res25: List[(Int, String)] = List((1,A), (2,B), (3,C), (4,D))

    scala> val c = List("A","B","C","D","E")
    c: List[String] = List(A, B, C, D, E)

    scala> a.zip
    zip   zipAll   zipWithIndex

    scala> a.zip(c)
    res26: List[(Int, String)] = List((1,A), (2,B), (3,C), (4,D))

    flatten和 flatMap

    flatMap等同于 flatten + map

    flatten将数据拍平,map操作不会对数据结构有变化,

    flatMap将数据进行map操作并大瓶

    scala> val f = Array(Array(1,2),Array(3,4),Array(5,6))
    f: Array[Array[Int]] = Array(Array(1, 2), Array(3, 4), Array(5, 6))

    scala>     f.flatten
    res30: Array[Int] = Array(1, 2, 3, 4, 5, 6)

    scala>     f.flatMap(_.map(_*2))
    res31: Array[Int] = Array(2, 4, 6, 8, 10, 12)

    scala>     f.map(_.map(_*2))
    res32: Array[Array[Int]] = Array(Array(2, 4), Array(6, 8), Array(10, 12))

     

    scala> val d = Array("hadoop,spark","bigdata,study")
    d: Array[String] = Array(hadoop,spark, bigdata,study)

    scala>

    scala>     d.map(x=>x.split(",")).flatten
    res33: Array[String] = Array(hadoop, spark, bigdata, study)

    scala> d.flatMap(x => x.split(","))
    res34: Array[String] = Array(hadoop, spark, bigdata, study)

    find

    find查找的,满足条件的元素里的第一个元素

    scala> val array = Array(1,2,3,4,5,6)
    array: Array[Int] = Array(1, 2, 3, 4, 5, 6)

    scala>     array.find( _ > 3)
    res35: Option[Int] = Some(4)

    Some继承了Option,

    Optin有两个,一个是Some,另一个是None

    获取东西获取到了是some,获取不到是None

    sorted

    按照字典序升序进行排序

    scala> val aaa = Array("c","b","a")
    aaa: Array[String] = Array(c, b, a)

    scala>     aaa.sorted
    res40: Array[String] = Array(a, b, c)

    降序排

    scala> val bbb = Array(3,1,2)
    bbb: Array[Int] = Array(3, 1, 2)
    
    scala> bbb.sortBy(x=> -x)
    res41: Array[Int] = Array(3, 2, 1)

    group by

    自定义分组

    scala> val arrs = Array(("a",5),("c",5),("a",20),("e",30))
    arrs: Array[(String, Int)] = Array((a,5), (c,5), (a,20), (e,30))

    scala>     arrs.groupBy(x => x._1)
    res38: scala.collection.immutable.Map[String,Array[(String, Int)]] = Map(e -> Array((e,30)), a -> Array((a,5), (a,20)), c -> Array((c,5)))

    scala>     arrs.groupBy(x => x._2)
    res39: scala.collection.immutable.Map[Int,Array[(String, Int)]] = Map(20 -> Array((a,20)), 5 -> Array((a,5), (c,5)), 30 -> Array((e,30)))

    mapValues

    scala> val data = Array("hello,world,hello","hello,world")
    data: Array[String] = Array(hello,world,hello, hello,world)

    scala> val words = data.flatMap(_.split(","))
    words: Array[String] = Array(hello, world, hello, hello, world)

    scala> val wordWithOne = words.map((_,1))
    wordWithOne: Array[(String, Int)] = Array((hello,1), (world,1), (hello,1), (hello,1), (world,1))

    scala> val groupByData = wordWithOne.groupBy(_._1)
    groupByData: scala.collection.immutable.Map[String,Array[(String, Int)]] = Map(world -> Array((world,1), (world,1)), hello -> Array((hello,1), (hello,1), (hello,1)))

    scala> val result = groupByData.mapValues(x => x.map(t=>t._2).sum)
    result: scala.collection.immutable.Map[String,Int] = Map(world -> 2, hello -> 3)

    scala> result.toList.sortBy(-_._2)
    res44: List[(String, Int)] = List((hello,3), (world,2))

     

    为什么要去分析Option的源码

    在scal的命令行工具,定义一个 名称为map的 Map类型的变量

    scala>     val map = scala.collection.mutable.Map("hadoop" -> 123, "spark" -> 345, "scala" -> 678)
    map: scala.collection.mutable.Map[String,Int] = Map(spark -> 345, hadoop -> 123, scala -> 678)
    scala> map.get("hadoop")

    scala> map.get("hadoop")
    res4: Option[Int] = Some(123)

    scala> map.get("flink")
    res5: Option[Int] = None

    scala> map.get("hadoop").get
    res6: Int = 123

    scala> map.get("flink").get
    java.util.NoSuchElementException: None.get
      at scala.None$.get(Option.scala:347)
      at scala.None$.get(Option.scala:345)
      ... 32 elided

    scala> map.get("flink").getOrElse("tmp_flink")
    res2: Any = tmp_flink

    源码分析

    在源码中我们可以看到Opetion是一个抽象的类,抽象类是不能直接使用的,需要通过其他方式复写这个类来实现底层的功能

    sealed abstract class Option[+A] extends Product with Serializable 
    

    Option的实现类有两个,一个是None,另一个是Some

    None类的源码

    case object None extends Option[Nothing] {
      def isEmpty = true
      def get = throw new NoSuchElementException("None.get")
    }

    Some类的源码

    final case class Some[+A](x: A) extends Option[A] {
      def isEmpty = false
      def get = x
    }

    case class 和 class的区别

    scala> class Person(val name:String,val age:Int)
    defined class Person

    scala> val p1 = new Person("scala",10)
    p1: Person = Person@65ae6ba4

    scala> val p2 = new Person("scala",10)
    p2: Person = Person@4f47d241

    scala> p1 == p2
    res0: Boolean = false

     

     

    scala> case class Person(name:String,age:Int)
    defined class Person

    scala> val p3 = Person("scala",10)
    p3: Person = Person(scala,10)

    scala> val p4 = Person("scala",10)
    p4: Person = Person(scala,10)

    scala> p3 == p4
    res1: Boolean = true

     

    scala> case class T1
    <console>:1: error: case classes without a parameter list are not allowed;
    use either case objects or case classes with an explicit `()' as a parameter list.
    case class T1
                 ^

    scala> case Object T1
    <console>:1: error: illegal start of definition
    case Object T1
    ^

    case class 样例类 必须要有参数列表

    case object 样例对象 必须不能加参数列表

     

    1.case class 不用实例化,class调用过程需要实例化

    2.什么场景相等会返回:

    为什么case class的类能相等,class不相等

    case class 一定是重写了 toString,hashCode,equals的方法

    3.case class默认就实现了序列化的方法

     

    Trait

    Trait 类(特质)似于理解java里的接口Interface

    如果要用多个接口,在scala

    不管抽象类还是Trait,第一个要用extend,后续的都要用with

     

    object MatchApp {
    
      /**
       * 模式匹配
       * @param args
       */
      def main(args: Array[String]): Unit = {
        def matchList(list:List[String]): Unit = {
          list match {
            case "bigdata"::Nil => println("Hello: bigdata") // 只能匹配只有bigdata一个元素
            case x::y::Nil => println(s"Hi: $x , $y") // 能匹配集合中有两个元素的
            case "java"::tail => println("HI:jepson and others") // 匹配java开头的
            case _ => println("......")
          }
        }
    
        matchList(List("bigdata"))
        matchList(List("hadoop","spark"))
        matchList(List("java","spark","scala","hadoop"))
        matchList(List("spark","scala","hadoop","java"))
      }
    }
    

     

    scala 柯里化

     

    偏函数

        /**
          * 偏函数  PartialFunction
          * A: 输入参数类型
          * B:输出参数类型
          *
          * 包在花括号内没有match的一组case语句
          */
        val values = Array("hadoop", "spark", "scala")
        val name = values(Random.nextInt(values.length))


        def say:PartialFunction[String,String] = {
          case "hdfs" => "存储框架"
          case "spark" => "计算框架"
          case "scala" => "语言"
          case _ => "真不知道是啥"
        }

        println(say(name))

    scala 文件操作

     

    def main(args: Array[String]): Unit = {
      val content = Source.fromFile("data/file.txt")
    
      def read(): Unit ={
        for(line <- content.getLines()){
          println(line)
        }
      }
      read()
    }
    展开全文
  • scala数组、序列)方法大全

    千次阅读 2020-04-29 00:46:35
    Scala超详细方法的使用 1、addString ...-【将数组中元素逐个添加到可变字符串序列b中】 scala> val a = Array(1,2,3,4,5) a: Array[Int] = Array(1, 2, 3, 4, 5) scala> val b = new Strin...
  • Scala模式匹配,case 字符串,case 匹配类型,case 匹配数组,case 匹配List,case 匹配元组,case匹配case class和case object.pdf
  • scala数组、集合、序列函数总结 Array ++ ++: +: :+ /: :\ addString addString addString map apply array addThen applyOrElse charAt clone collect collectFirst combinations contains containsSlice canEqual ...
  • Scala 数组

    2019-11-11 22:54:57
    Scala 教程Scala 简介Scala 安装及环境配置Scala 基础语法Scala 数据类型Scala 变量Scala 访问修饰符Scala 运算符Scala IF...ELSE 语句Scala 循环Scala 方法与函数Scala 闭包Scala 字符串Scala 数组Scala Collection...
  • scala 数组匹配相同元素

    千次阅读 2018-06-29 17:24:07
    快速匹配的函数:  def matchCells(a:Array[String] , y:Array[String]) = {  var sum = 0  for(x ){  if(a.exists({ y: String => y == x })){  sum += 1  }  }  sum  }    def matchCells2(a:Array...
  • Scala 数组集合

    2020-02-16 02:29:28
    Scala 常用数组集合简单总结 数组 Array-数组 //伴⽣对象创建数组 var a1=Array(1,2,3,5,4) //创建⻓度为5的数组,所有值都是0 var a2=new Array[Int](5) //获取⻓度 a1.length a2.size //修改 a1(1) = -1 a1.update...
  • scala数组

    2019-05-09 15:44:50
    声明数组 语法格式 var ArrayName : Array[DataType] = new Array[DataType](length) 或 var ArrayName = new Array[DataType](length) 或 var ArrayName = Array("data1", "data2", "data2") 数组赋值 //...
  • Scala数组 数组是一种可变的、可索引的数据集合。在Scala中用Array[T]的形式来表示java中的数组形式T[ ]。 //声明一个数组对象 方法一:var numbers:[String]=new Array[String](3) 方法二:val numbers = Array(1,...
  • scala数组函数

    2020-07-29 19:26:18
    scala数组函数 val a = Array(1,2,3,4) val b = Array(5,6,7,8) def ++ 合并集合,并返回一个新的数组,新数组包含左右两个集合对象内容 val c=a++b def ++: 合并成一个新的数组,右边操纵数的类型决定着返回...
  • Scala数组函数总结

    2020-09-14 23:43:56
    Scala 数组函数 数组是一种可变的、可索引的数据集合。在Scala中用Array[T]的形式来表示Java中的数组形式 T[]。 ##变量:赋值后可以改变,生命周期中可以被多次赋值 ##常量:赋值后不变,类似Java中的final变量 ##...
  • Scala数组函数

    2020-09-18 23:32:16
    Scala数组函数 1、++ 说明:合并集合,并且返回一个新数组 注:因为数组中包含数字也包含字符串,所以会用Any顶级类型接收,如果数组中有重复内容,不会去重 2、++: 说明:合并集合,冒号右边的类型决定返回结果...
  • 一、scala数组 数组:用来存储固定大小的同类型元素,通过索引来访问指定元素,索引index从0开始 声明数组 定义数组--语法格式: var z:Array[String] = new Array[String](3) 或 var z = new Array[String](3) ...
  • scala 数组函数大全

    2020-09-10 14:40:47
    Scala 语言中提供的数组是用来存储固定大小的同类型元素,跟Java中的数组很类似。 声明数组 //方式一 var arr:Array[String] = new Array[String](1,2,3,4) //方式二 var arr = new Array[String](3) 处理...
  • Scala 数组和元组

    2020-10-20 15:29:34
    1、定义数组 数组创建方式一: var a1:Array[String] = new Array[String](3) a1(0)="Jason" a1(1)="Marie" a1(2)="Jimmy" 注意:1、泛型使用方括号;2、数组元素访问使用圆括号。 数组创建方式二: var a2=Array(...
  • Scala数组/集合

    2020-02-13 17:28:18
    数组 Array-数组 //伴生对象创建数组 var a1=Array(1,2,3,4,5) //创建长度为5的数组,所有值都是0 var a2=new Array[Int](5) //获取长度 a1.length a2.size //修改 a1(0) = -1 a1.update(1,-2) //遍历...
  • 数组、集合函数 ++ 说明: 把两个数组或集合,合并成一个大集合,谁在左边合成大集合的时候,元素放在前面。 返回值: 返回值是一个数组或者集合,也可以是数组和集合合并,返回值谁在左边,返回值就是谁的类型。 ...
  • scala数组、集合函数大全

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,517
精华内容 2,606
关键字:

scala的匹配数组