Scala开发问题汇总

一、在scala的2.10.*时代，case class只支持22参数

但是在scala2.11.*时代则没有这个问题。。。

https://blog.csdn.net/feloxx/article/details/76605232

二、Nil的含义

Nil是一个空的List，定义为List[Nothing]，根据List的定义List[+A]，所有Nil是所有List[T]的子类。

https://www.jianshu.com/p/2a61366355a7

三、split的使用

问题的出现：当在实时计算平台上获取字符串进行分割时，出现以下错误

问题排查后，发现当字符串中出现 \ 等转义字符时，应该将其再转换成\，如下图所示

http://blog.sina.com.cn/s/blog_b6487d470101g0hp.html
https://www.cnblogs.com/davidhaslanda/p/4050471.html

四、scala中集合求交集和差集

交集：

scala> Set(1,2,3) & Set(2,4)   // &方法等同于interset方法
scala> Set(1,2,3) intersect Set(2,4)

差集：

scala> Set(1,2,3) -- Set(2,4) //得到 Set(1,3)
scala> Set(1,2,3) &~ Set(2,4) 
scala> Set(1,2,3) diff Set(2,4)

scala中集合的交集、并集、差集

五、scala中可变的map

 var a:scala.collection.mutable.Map[String,Int]=scala.collection.mutable.Map("k1"->1,"k2"->2)//初始化构造函数
  a += ("k3"->3)//添加元素
  a += ("k4"->4)//添加元素
  a += ("k1"->100)//已经存在添加元素会覆盖
  a += ("k1"->100,"k9"->9)//添加多个元素
  a -= ("k2","k1")//删除元素
  a ++= List("CA" -> 23, "CO" -> 25)//追加集合
  a --= List("AL", "AZ")//删除集合

Scala中的Map使用例子
scala 基础七 scala Map和元组的操作

六、scala中value foreach is not a member of java.util.Set[String]，如何使用import scala.collection.JavaConverters._

在使用fastjson解析json’字符串时，可能需要遍历keys，此时如果直接遍历会报错，例如：

for (key <- reducedList.keySet) {}
for (entry <- dataJson.entrySet) {
      val dataValue = entry.getValue.toString
      }
//Error:(24, 29) value foreach is not a member of java.util.Set[String]

 for (wc: Word <- dataList) {}
//Error:(21, 22) value filter is not a member of java.util.ArrayList[myakka.messages.Word]

原因：因为reducedList是java.util.HashMap, 没有foreach方法, 所以需要将其转换为Scala的集合类型,
因此需要在代码中加入如下内容(Scala支持与Java的隐式转换),
import scala.collection.JavaConversions._

参考链接1
补充：
使用 scala.collection.JavaConverters 与Java集合交互。它有一系列的隐式转换，添加了asJava和asScala的转换方法。使用它们这些方法确保转换是显式的，有助于阅读：

import scala.collection.JavaConverters._
 
 val list: java.util.List[Int] = Seq(1,2,3,4).asJava
 val buffer: scala.collection.mutable.Buffer[Int] = list.asScala

参考链接2
https://blog.csdn.net/dymkkj/article/details/77921573
https://blog.csdn.net/u013013024/article/details/80452019
https://blog.csdn.net/javanetc001/article/details/88701874

七、scala中可变的List

import scala.collection.mutable.ListBuffer
scala.collection.mutable.ListBuffer.fill(5个)(0.0)

八、scala.Some cannot be cast to java.lang.String

获取map里面的值时，可以将getOrElse替换成get，因为get得到的数据是Option[double]
此时可以get(目标值).get

1. https://stackoverflow.com/questions/40637696/casting-error-from-optiondouble-to-double-in-scala/40637803
2. https://stackoverflow.com/questions/17620554/scala-some-cannot-be-cast-to-java-lang-string/17620765
3. http://www.cnblogs.com/lixiaolun/p/6380952.html

八、scala中时间和时间戳互换

时间戳是秒数，需要乘以1000l转化成毫秒

def DateFormat(time:String):String={
    var sdf:SimpleDateFormat = new SimpleDateFormat("yyyy-MM-dd")
    var date:String = sdf.format(new Date((time.toLong*1000l)))
    date
  }

https://blog.csdn.net/silentwolfyh/article/details/51792039
https://blog.csdn.net/weixin_40163498/article/details/80759726

九、scala immutable.Map 和 mutable.Map 相互转化

immutable.Map to mutable.Map

val m = collection.immutable.Map(1->"one",2->"Two") 
val n = collection.mutable.Map(m.toSeq: _*) 

mutable.Map to immutable.Map

val m = collection.mutable.Map(1->"one",2->"Two") 
val n = m.toMap

https://my.oschina.net/u/2000675/blog/1818699/

十、scala中利用org.json4s将Map转成json

https://blog.csdn.net/qq_36722360/article/details/77249424
https://blog.csdn.net/leehbing/article/details/74391308

##You can find available versions here:
##http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.json4s%22
<dependency>
  <groupId>org.json4s</groupId>
  <artifactId>json4s-native_${scala.version}</artifactId>
  <version>{latestVersion}</version>
</dependency>

<dependency>
  <groupId>org.json4s</groupId>
  <artifactId>json4s-jackson_${scala.version}</artifactId>
  <version>{latestVersion}</version>
</dependency>

import org.json4s._
import org.json4s.JsonDSL._
import org.json4s.jackson.JsonMethods._

var maplevel1:Map[String,String] = Map()
maplevel1 += ("apple"-> "苹果");
val jsons2 = compact(render(maplevel1))
println(jsons2)

十一、scala中求笛卡尔积集合

def cross(a:IndexedSeq[Tree], b:IndexedSeq[Tree]) = {
        a.map (p => b.map( o => (p,o))).flatten
    }

https://stackoverflow.com/questions/8217764/cartesian-product-of-two-lists

十二、scala中获取类中的所有属性和方法，以及获取属性的默认值

 val allFiles = Consts.getClass.getDeclaredFields
 for (curFile <- allHistogramFiles) {
      curFile.setAccessible(true)
      val curHdfsFile = curFile.get(Consts).toString

//      val normalFile = curFile.getName
      println(s"=================================================")
      println(curHdfsFile)
 }

即通过反射获取类的方法和变量、默认值
https://blog.csdn.net/qqllife/article/details/77237969
https://blog.csdn.net/qq779446849/article/details/50373102

十三、scala中压缩数据

选用snappy算法，

<dependency>
      <groupId>org.xerial.snappy</groupId>
      <artifactId>snappy-java</artifactId>
      <version>1.1.7.3</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>

package flink.util

import org.xerial.snappy.Snappy
import java.io.IOException


/**
  * created by test 
  */
object SnappyModel {
  def main(args: Array[String]): Unit = {
    //    val input = "Hello snappy-java! SnappyModel-java is a JNI-based wrapper of " + "SnappyModel, a fast compresser/decompresser."
    //    val compressed = Snappy.compress(input.getBytes("UTF-8"))
    //    val uncompressed = Snappy.uncompress(compressed)
    //    val result = new String(uncompressed, "UTF-8")
    //    val comress = compressString(input)
    //    val uncompress = decompressString(comress)
    //    println(uncompress)

    val a = List(List("123", "456"), List("789", "abc"))
    val b = a.map(x => x.map(y => compressString(y)))
    val result =b.flatMap(x => x).map(x => decompressString(x))
      println(result)

  }

  def cross(a: List[String], b: List[String]) = {
    a.map(p => b.map(o => (p, o))).flatten
  }


  def compressString(string: String): Array[Byte] = try
    Snappy.compress(string.getBytes("UTF-8"))
  catch {
    case e: IOException =>
      e.printStackTrace()
      null
  }


  def decompressString(bytes: Array[Byte]): String = try
    new String(Snappy.uncompress(bytes))
  catch {
    case e: IOException =>
      e.printStackTrace()
      null
  }

}

http://www.findsrc.com/columnist/detail/8638
https://blog.csdn.net/c446984928/article/details/50816016/
https://github.com/xerial/snappy-java

十四、scala中字符串插入变量

字符串中的变量替换，Scala中基础的字符串插值就是在字符串前加字幕‘s’，然后在字符串中放入变量，每个变量都应以‘$’开头。字符串前加字母‘s’时，其实是在创建一个处理字符串字面量

https://my.oschina.net/u/2000675/blog/1592140
https://www.cnblogs.com/pursue339/p/10619581.html

十五、scala中求数组排序后每两个元素的差值

例如数组 1,5,8,10,2求得结果为 1,3,3,2一般什么样的场景会有这种需求呢?比如 计算一堆数据在一定时间内的计算时延, 或者得到这段时间内数据的平均计算时延,最大最小之类

https://www.cnblogs.com/chendapao/p/9170588.html

十六、Scala中的String.split函数，提取ip三段

例如114.220.192.248
求得：114.220.192

s.reverse.split("\\.",2).toList(1).reverse

split(StrToSplit, 0)。因此，我将主要介绍第二种参数形式。第二种参数形式中每个参数的意义如下：

arg0: String 是一个正则表达式，代表分割的边界。这个正则表达式成功匹配一次，split的结果中就会加入一个新的子串。子串包含上次匹配后（如果没有上次匹配就是被分割字符串的起始位置）到这次匹配前的所有字符。最后，split函数会将最后一次匹配后剩余的字串作为最后一个子串加入到结果中。

arg1: Int 是对分割后子串的个数的限定。理解这个参数才能正确的运用split函数。

当arg1大于0时，它限制arg0最多成功匹配arg1-1次，也就是说字符串最多被分成arg1个子串。此时split会保留分割出的空字符串（当两个arg0连续匹配活着arg0在头尾匹配，会产生空字符串），直到达到匹配上限。

https://www.cnblogs.com/davidhaslanda/p/4050471.html

十七、scala中ambiguous reference to overloaded definition（使用JSON.toJSONString时）

出于某种原因，Scala重载逻辑与Java逻辑不匹配，必须像这样称呼它：

JSON.toJSONString(map, SerializerFeature.PrettyFormat)

https://blog.csdn.net/qq_21383435/article/details/81133461
https://stackoverflow.com/questions/40519743/ambiguous-reference-to-overloaded-definition-when-call-method-in-java-library

十八、com.alibaba.fastjson.JSONException: default constructor not found. class ***

异常出现原因是 因为 实体类中没有空的构造方法，加上空的构造方法，问题解决

https://www.cnblogs.com/xbq8080/p/6489954.htmlhttps://blog.csdn.net/hellojoy/article/details/81183490 构造函数

十九、scala中match的使用

//通过模式匹配进行条件判断，可自定义条件
    val test2: Int = 1;
    val result2 = test2 match {
      case i if i + 1 == 2 => "one"
      case i if i + 1 == 3 => "tow"
      case _ => "error"
    }
    println(result2)
    
   
    //注意下面和上面的不同比对方式
    def ClassMatch(classTest: Any): Unit = {
    classTest match {
      case Class1(param1, param2) => {
        println("Class1:" + param1 + "_" + param2)
      }
      case Class2(param1) => {
        println("Class2:" + param1)
      }
      case _ => println("error")
    }
  }
    

https://www.cnblogs.com/hark0623/p/4196261.html

二十、Scala Json 转化

//json 与 class 互相转化

case class Student( name:String , no: String )
 
    val gson = new Gson
    val student = Student("张三", "100")
    val str = gson.toJson(student, classOf[Student])
    println(str)
    val student2 = gson.fromJson(str, classOf[Student])
    println(student2)

尤其注意：使用 classOf ，不能使用 getclass

https://blog.csdn.net/shuaidan19920412/article/details/79356440

二十、Fastjson1.2.58中key使用Integer类型问题

升级fastjson的jar包由1.2.29到1.2.58后，对Int类型的解析在1.2.29会被解析为String，在1.2.58会被解析为Integer

//1.2.58版本，key使用Integer类型问题，两种方法：

1、序列化之前加上这句话，JSON.DEFAULT_PARSER_FEATURE = Feature.config(JSON.DEFAULT_PARSER_FEATURE, Feature.NonStringKeyAsString, true);

2、JSONObject jsonObject =JSON.parseObject(ss, Feature.NonStringKeyAsString);

 JSON.DEFAULT_PARSER_FEATURE = Feature.config(JSON.DEFAULT_PARSER_FEATURE, Feature.NonStringKeyAsString, true);
 

二十一、scala中String 日期 转成 Date, 月份减1

     val lastDateKey = ”20191005“
      val dateFormat = new SimpleDateFormat("yyyyMMdd")
      val parseddate = dateFormat.parse(lastDateKey)
      val g = Calendar.getInstance
      g.setTime(parseddate)
      g.add(Calendar.DAY_OF_MONTH, -1)
      preLastDateKey = dateFormat.format(g.getTimeInMillis)

https://www.iteye.com/blog/zgqhyh-127897

二十二、Scala Array [String]到Java Collection [String]

val names:Array[String] = something.map(...)
//java方法
java.util.Arrays.asList(names: _*)
//scala方法
import collection.JavaConversions._
val namesColl: java.util.Collection[String] = names.toSeq

http://www.voidcn.com/article/p-ufvggent-buz.html

二十三、NoClassDefFoundError: scala/collection/Seq

报这个错时要先看看是不是pom文件配错了，比如为了打包把scala-library配成了provided，去掉即可

<dependency>  
      <groupId>org.scala-lang</groupId>  
      <artifactId>scala-library</artifactId>  
      <version>${scala.version}</version>  
      <scope>provided</scope>  
    </dependency>  

二十四、{“traversableAgain”:true,“empty”:false}

这个是在进行JSON.toJSONString时，对应的key里面内容出现了这个异常，本来该key内容是Array(String)，但是误传入了List[java.lang.String]

二十五、Breeze操作矩阵向量

1. https://www.jianshu.com/p/95fe9878fb37
2. https://blog.csdn.net/HANLIPENGHANLIPENG/article/details/70139010?utm_source=copy
3. https://cloud.tencent.com/developer/article/1392268
4. https://www.cnblogs.com/itboys/p/10594039.html

二十五、Scala中sliding与grouped的区别

scala> val xs = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
xs: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> xs.sliding(4,2).foreach(println)
List(1, 2, 3, 4)
List(3, 4, 5, 6)
List(5, 6, 7, 8)
List(7, 8, 9)

scala> val xs = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
xs: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> xs.sliding(4,4).foreach(println)
List(1, 2, 3, 4)
List(5, 6, 7, 8)
List(9)

scala> xs.grouped(4).foreach(println)
List(1, 2, 3, 4)
List(5, 6, 7, 8)
List(9)

可见，sliding第一个参数的含义是几个元素组成一个List，本例中第一个参数是4，所以是每4个元素组成一个List，剩余元素不够的组成一个List。

第二个参数的含义可以理解为，每次List第一个元素相对上一个List的第一个元素移动的步数。例如本例第二个参数是2，那么第一个List的第一个元素是1；第二个List的第一个元素向后移动2位，就是3；第三个List相对第二个List的第一个元素3，再向后移动2位，就是5；以此类推。

def sliding(size: Int): Iterator[Iterabl)[A]] 的含义是，如果不指定step，默认step是1。

当size和step相等的时候，可以简化使用grouped方法

二十六、Scala 函数柯里化(Currying)

柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。
https://www.runoob.com/scala/currying-functions.html

二十七、Scala 中Map转json字符串和json字符串转map

Map转Json字符串

import org.json4s._
import org.json4s.native.Serialization._
import org.json4s.native.Serialization

implicit val formats = Serialization.formats(NoTypeHints)

 val m = Map(
  "name" -> "john doe",
  "age" -> 18,
  "hasChild" -> true,
  "childs" -> List(
    Map("name" -> "dorothy", "age" -> 5, "hasChild" -> false),
    Map("name" -> "bill", "age" -> 8, "hasChild" -> false)))

 write(m)
//注意key不能是null， 可以是“null”

json字符串转换成map：

import scala.util.parsing.json.JSON
 
// 把json格式的字符串转换成map格式,(id:String,pos:Float,neg:Float,seg:Double)
  def str2map(vstr:String): collection.immutable.Map[String, Any] ={
    val vSome = JSON.parseFull(vstr)
//    println(vSome,manOf(vSome)) //(Map(id -> 1, pos -> 100.0, neg -> 100.0, seg -> 0.5),Any)
    // 转换类型
    var vmap = vSome match {
      case Some(map:collection.immutable.Map[String, Any]) => map
    }
//    println(vmap("id"),manOf(vmap)) //(1,scala.collection.immutable.Map[java.lang.String, Any])
    vmap
  }
//注意用可变集合collection.mutable.Map[String, Any] ，行不通
 
//查看数据类型方法-manOf(data)
  def manOf[T:Manifest](t:T):Manifest[T]=manifest[T]

https://blog.csdn.net/zsyoung/article/details/88844702
https://www.cnblogs.com/xl717/p/11636966.html

二十八、Scala 中解析时间，“27/Jul/2020:19:32:16 +0800”

val testimestamp = "27/Jul/2020:19:32:16 +0800"
val format = new SimpleDateFormat("dd/MMM/yyyy:HH:mm:ss z",Locale.ENGLISH)
val df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
val date = format.parse(testimestamp)
println(df.format(date))

https://blog.csdn.net/u012260238/article/details/94472723

二十九、json解析时保持字段有序

1、解析时增加参数不调整顺序(fastjson)

JSONObject respondeBodyJson = JSONObject.parseObject(jsonStr, Feature.OrderedField);

2、初始化json对象为有序对象：（fastjson）

JSONObject json= new JSONObject(true);

3、使用Gson解析

JsonObject returnData = new JsonParser().parse(replyString).getAsJsonObject();

三十、scala将double转换为long

https://stackoverflow.com/questions/19647525/how-to-convert-any-a-number-to-a-long

val x = 1.0
x.asInstanceOf[Number].longValue

三十一、scala统计字符串中汉字和其他字符个数

/**
    * 处理字符串中的各种字符
    * @param curResponse
    * @return
    */
  def countChar(curResponse: String): String = {
    var count_en = 0 //英文
    var count_dg = 0 //数字
    var count_sp = 0 //空格
    var count_zh = 0 //中文
    var count_pu = 0 //特殊
    var count_len = 0 // 总长度

    if (curResponse != null && curResponse.size > 0) {
      count_len = curResponse.size
      for (tmp <- curResponse) {
        if ((tmp >= 'A' && tmp <= 'Z') || (tmp >= 'a' && tmp <= 'z')) {
          count_en = count_en + 1
        } else if ((tmp >= '0') && (tmp <= '9')) {
          count_dg = count_dg + 1
        } else if (tmp == ' ') {
          count_sp = count_sp + 1
        } else if (isChinese(tmp)) {
          count_zh = count_zh + 1
        } else {
          count_pu = count_pu + 1
        }
      }
    }

    count_len + "###" + count_en + "###" + count_dg + "###" + count_sp + "###" + count_zh + "###" + count_pu
  }

  /**
    * 判断是否汉字
    * @param ch
    * @return
    */
  def isChinese(ch: Char): Boolean = {
    //获取此字符的UniCodeBlock
    val ub = Character.UnicodeBlock.of(ch)
    //  GENERAL_PUNCTUATION 判断中文的“号
    //  CJK_SYMBOLS_AND_PUNCTUATION 判断中文的。号
    //  HALFWIDTH_AND_FULLWIDTH_FORMS 判断中文的，号
    if ((ub eq Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS) || (ub eq Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS) || (ub eq Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A) || (ub eq Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B) || (ub eq Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION) || (ub eq Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS) || (ub eq Character.UnicodeBlock.GENERAL_PUNCTUATION)) {
//      System.out.println(ch + " 是中文")
      return true
    }
    false
  }

https://www.cnblogs.com/tianyaxue/p/3147471.html
https://www.cnblogs.com/flyinghome/p/12144630.html

三十二、scala中foldLeft和foldRight

https://blog.csdn.net/a_yyc1990/article/details/11606073
https://blog.csdn.net/dz77dz/article/details/87191470