scala case（Scala class和case class的区别）

本文目录

• Scala class和case class的区别
• Scala的case class究竟默认实现了哪些方法
• Scala 中的case关键字在这里是什么意思
• scala ide是干什么用的
• Scala这个有知道的吗，怎么样啊
• scala case class 这时候该怎么用

Scala class和case class的区别

Scala的case class使得对对象进行模式匹配变得非常方便，简单的来说，Scala的case class就是在普通的类定义前加case这个关键字，然后你可以对这些类来模式匹配。在我们详细介绍Scala的Case class和模式匹配之前，我们可以通过一个简单的例子来说明一些基本概念。我们设计一个函数库，这个函数库可以用来计算算术表达式，为简单起见，我们设计的算术表达式只侧重于变量，数字，单操作符，和双操作符。我们可以采用如下的Scala类定义：abstract class Exprcase class Var(name:String) extends Exprcase class Number(num:Double) extends Exprcase class UnOp(operator:String, arg:Expr) extends Exprcase class BinOp(operator:String,left:Expr,right:Expr) extends Expr这里我们定义了一个抽象类Expr和四个子类（分别代表变量，数值，单操作符，双操作符），Scala允许我们不定义类的实现，实际我们是class C 和 class C {}是等价的。

Scala的case class究竟默认实现了哪些方法

首先写一个样例类Demo 运行后，使用反编译打开，会发现一个样例类 Dollar会生成Dollar$.class和Dollar.class文件 首先来看Dollar$.class 然后Dollar.class 1、样例类默认实现了序列化，实现了scala的Product 2、构造器中的value当成了属性，且默认都是val(对应Java的final) 3、默认实现了apply和unapply，这就是为何样例类不用new可以直接使用的原 4、默认实现了常用的toString/equals/hashCode/copy方法

Scala 中的case关键字在这里是什么意思

(1 to 10) map { case x =》 2*x }中的{ case x =》 2*x } 得到的是一个PartialFunction 。然而，事实并非如此。简单说，凡是Scala中出现如下表达式时：{ case p1 =》 e1; case p2 =》 e2; ...; case pn =》 en }其结果为Scala中的匿名函数(Anonymous Function) ,但是其具体类型是根据其所处位置而定，可能是一个FunctionN，也可能是一个PartialFunction （这里的FunctionN指的是非PartialFunction的Function）。下面用一段小代码证明之：scala》 def needfunc forSome { type ?0 》: ?0; type ?0 《: Int =》 Int } = class scala.runtime.AbstractFunction1$mcII$sp上面的结果表明，当我需要一个Function(非PartialFunction)时，我得到的就是一个非PartialFunction的Function；当我需要一个PartialFunction时，得到就是PartialFunction。当然，我不是仅有上面的例子就下结论。实际上，《Scala语言规范》(Scala Language Specification)对此有具体规定，引用如下：Pattern MatchingPattern Matching Anonymous FunctionsBlockExpr ::= `{’ CaseClauses `}’An anonymous function can be defined by a sequence of cases{ case p1 =》 b1; …… case pn =》 bn }which appear as an expression without a prior match. The expected type of such an expression must in part be defined. It must be either scala.Functionkk, where the argument type(s) S1,…,Sk must be fully determined, but the result type R may be undetermined.为啥需要搞清什么时候是PartialFunction而什么时候是FunctionN呢，这里涉及另一个问题：PartialFunction在某些时候相对FunctionN会存在性能问题！这是另一个有趣的问题了。

scala ide是干什么用的

Scala是一门现代的多范式编程语言，志在以简练、优雅及类型安全的方式来表达常用编程模式。它平滑地集成了面向对象和函数语言的特性。Scala是面向对象的：Scala是一个纯面向对象语言，在某种意义上来讲所有数值都是对象。对象的类型和行为是由class和trait来描述的。Class的抽象可由子类化和一种灵活的基于mixin的组合机制（它可作为多重继承的简单替代方案）来扩展。Scala是函数式的： Scala还是一个函数式语言，在某种意义上来讲所有函数都是数值。Scala为定义匿名函数提供了一种轻量级的语法，它支持高阶（higher-order）函数、允许函数嵌套、支持局部套用（currying）。Scala的case类及其内置支持的模式匹配模型代数类型在许多函数式编程语言中都被使用。Scala是静态类型的：Scala配备了一套富有表现力的类型系统，该抽象概念以一种安全的和一致的方式被使用。Scala是可扩展的：Scala的设计承认了实践事实，领域特定应用开发通常需要领域特定语言扩展。Scala提供了一个独特的语言组合机制，这可以更加容易地以类库的形式增加新的语言结构：两者结合使用可方便地定义新语句，无需扩展语法，也无需使用类似宏的元编程工具。任何方式可以被用作中缀（infix）或后缀（postfix）操作符闭包按照所期望的类型（目标类型）自动地被构造Scala可与Java和.NET进行互操作：Scala设计时就考虑了与流行编程环境良好交互，如Java 2运行时环境（JRE）和 .NET框架（CLR）。特别是与主流面向对象语言，如Java和C#尽量无缝交互。Scala有像Java和C#一样的编译模型（独立编译，动态装载类），允许访问成千上万的高质量类库。对于某些开发者来说，这些刺激已足以引诱他们脱离Java进入Scala世界。但对另外一些开发者来说，它们并没有为Java世界里当前正在演绎的日复一日的编程活动提供更多好处。在一篇名为“Scala：集Ruby和Java之所长”的博文中，Ian讲述了或许不应在Java和Scala之间做出选择，相反，相对于选择其它语言如Ruby，选择使用Java和Scala的混合物是的另一种选择：许多开发者热爱Ruby，不过他们不能从中获取足够的东西。它可能是最具侵略性的语言之一，因为Java才是第一个到场的。人们总是引证Ruby的灵活而可扩展的语法、闭包等特性，以及其代码如何简明和具有表现力。例如，你可以用一个简单语法创建一个Map（Ruby称之为“hashes”，尽管hashtable只是map一种可能的实现方式），如：numberMap = {"one" =》 1, "two" =》 2, "three" =》 3}Java与之对等的语句显得颇为冗长：Map《String, Integer》 numberMap = new HashMap《String, Integer》(); numberMap.put("one", 1); numberMap.put("two", 2); numberMap.put("three", 3);那么Scala怎么样呢？让我们看看Scala中map的例子：var numberMap = Map("one" -》 1, "two" -》 2, "three" -》 3)你会注意到它看上去非常类似等价的Ruby代码，但是这儿有一些重要区别。特别是，就像Java，Scala编译器知道numberMap使用String作为键，Integer作为值。与Java不同的是，你无需告知，它本身就能领会这一点！这称为“类型推理（type inference）”。这意味着如果你试图给numberMap增加一个新的键值对，但是要使用Integer作为键，String作为值，Scala将在你试图编译它时立刻报错（或者你的IDE将立刻警告你）。使用Ruby，只有当你运行你的软件并试图从该Map中找回该键和值时，得到的分别是Integer和String而不是所期望的String和Integer，这时才会导致报错。过分强调编译时类型检查节省多少多少时间是困难的，但它消除了所有类在执行时将会产生的bug。Scala给你带来了这一好处，而且代码并不繁琐。为更进一步在一个小例子中展现代码量的缩减，Ted Neward研究了开发同一个类，用Java、C#、Virual Basic、Ruby和Scala的区别。请参考其博文Scala pt 2：简短。Ian继续指出：Scala还有一连串其它好的Ruby特性（Java所缺乏的），包括闭包，以及非常适合“领域特定语言”的可塑性语法。它拥有所有这些特性，而且结合了静态类型好处。David MacIver在其博文说正经的，为什么选择Scala？中分享了他对于面向对象编程、面向模块编程、静态类型、函数编程以及该语言中他所喜欢的未言明特性的观点。他补充道：Scala离完美还差得远。它有一些语法缺陷，一些由Java带来的问题，一个有适度问题的编译器以及一堆你记不住的琐碎特性和边界情况（edge case）。然而，我发现这些问题除了烦你之外并不真正产生什么后果。如果只是想坐下来书写好的代码，该语言的核心是强大的和非常有用的。为了提供一个均衡的观点，David在其博文中接着探讨了为什么不选Scala，文中他阐述了一些边界情况（edge case）。作为总结，David有如下评论：总而言之，我发现这些只是增加了一些烦心事。它仍是我最喜欢的JVM语言，但是你的看法将取决于你怎样搁置那些对你来说可能是更重要的需要优先考虑的事情。为了展现Scala是一门不断成熟的语言，Programming in Scala一书很快将会出版。如果等不及，Artima网站上有该书PDF格式的预印版。

Scala这个有知道的吗，怎么样啊

    Scala是一门多范式语言，一般常用的范式有：命令式 和 函数式，由于Scala是一门多范式语言，所以通俗来说我们可以说Scala是一门命令式编程语言同时也是函数式编程语言。

    命令式：命令式是植根于冯·诺依曼体系的，一个命令式程序就是一个冯·诺依曼机的指令序列，给机器提供一条又一条的命令序列让其原封不动的执行。通俗来说就是按照指令顺序一步一步执行。

    函数式：又称泛函编程，它将计算机的计算视为数据中的函数计算。函数式编程最重要的基础是λ（lambda）演算，λ演算对函数式编程语言有着巨大的影响。典型的函数式语言包括Erlang和Lisp等。

为什么要用函数式：

    目前来说CPU的性能发展大体上是在同等面积上集成更多的晶体管等集成电路，随着纳米技术的不断提高，CPU能够集成的计算单元也越来越多，但终归是有上限的。所以在之后，单核的发展逐渐走向了多核的发展，以多核来达到性能的提升。

    目前计算机的CPU基本上都是多核CPU，在使用命令式编程的时候就设涉及到多线程之间的状态共享，需要锁机制实现并发的控制，而锁机制虽然保证了安全性，但是却对性能来说是一个阻碍。

    而函数式编程不会再多个线程之间共享状态，不需要用锁机制，可以更好的并行处理，充分利用多核CPU的并行处理能力。

    如，电信行业多数使用Erlang来进行开发，就是看中了函数式编程的并行处理能力。

Scala的特点

• Scala是面向对象的：Scala是一个纯面向对象语言，在某种意义上来讲所有数值都是对象。对象的类型和行为是由class和trait来描述的。Class的抽象可由子类化和一种灵活的基于mixin的组合机制（它可作为多重继承的简单替代方案）来扩展。

• Scala是函数式的： Scala还是一个函数式语言，在某种意义上来讲所有函数都是数值。Scala为定义匿名函数提供了一种轻量级的语法，它支持高阶（higher- order）函数、允许函数嵌套、支持局部套用（currying）。Scala的case类及其内置支持的模式匹配模型代数类型在许多函数式编程语言中 都被使用。

• Scala是静态类型的：Scala配备了一套富有表现力的类型系统，该抽象概念以一种安全的和一致的方式被使用。

• Scala是可扩展的：Scala的设计承认了实践事实，领域特定应用开发通常需要领域特定语言扩展。Scala提供了一个独特的语言组合机制，这可以更加容易地以类库的形式增加新的语言结构：两者结合使用可方便地定义新语句，无需扩展语法，也无需使用类似宏的元编程工具。

• 任何方式可以被用作中缀（infix）或后缀（postfix）操作符

• 闭包按照所期望的类型（目标类型）自动地被构造

• Scala可与Java和.NET进行互操作：Scala 设计时就考虑了与流行编程环境良好交互，如Java 2运行时环境（JRE）和 .NET框架（CLR）。特别是与主流面向对象语言，如Java和C#尽量无缝交互。Scala有像Java和C#一样的编译模型（独立编译，动态装载 类），允许访问成千上万的高质量类库。

scala case class 这时候该怎么用

OK，让我们一劳永逸的解决这个问题吧，让大家见识一下Scala的强大：给定一个字符串，自动转换为需要的case class

比如：

• 给定字符串"zhangsan,100,34"，定义了case class Person(name: String, id: Int, age: Int)，就能自动由字符串得到Person(zhangsan, 100, 34)

• 给定字符串"100,300,400"，定义了case class Vec(x: Int, y: Int, z: Int)，就能自动由字符串得到Vec(100, 300, 400)

• 首先给出最终的实现效果：
• @ case class Person(name: String, id: Int, age: Int)defined class Person@ Str2Class("100,200,300").getres5: Vec = Vec(100, 200, 300)
• 下面是具体的实现代码：
• object Str2Class {
•  import util.{ Failure, Success, Try }
•  trait Conveter }
•  object Conveter {
•    def apply = c
•    implicit object s2s extends Conveter {
•      def convert(text: String) = Try(text)
•    }
•    implicit object s2i extends Conveter {
•      def convert(text: String) = Try(text.toInt)
•    }
•  }
•  import shapeless._
•  trait Parser }
•  object Parser {    
•    def apply) = p
•    def fromFun {
•      def parse(xs: Seq) = f(xs)
•    }
•    implicit object HNilParser extends Parser {
•      def parse(xs: Seq = xs match {
•        case Seq() =》 Success(HNil)
•        case _   =》 Failure(new RuntimeException("More items than expected."))
•      }
•    }
•    implicit def hListParser = fromFun {
•      case x +: rs =》 for(xv 《- Conveter.parse(rs)) yield xv::rv
•      case Seq() =》 Failure(new RuntimeException("Less items than expected."))
•    }
•  }
•  trait LineParser {
•    def apply(text: String)
•                        (implicit gen: Generic.Aux =
•      p.parse(text.split(",")) map (gen.from)
•  }
•  def apply{}}

==================原回答===================

Here we go:

• @ import shapeless._@ import syntax.std.traversable._@ import syntax.std.tuple._@ case class data(a: Int, b: Int, c: Int, d: Int, e: Int)defined class data@ type DATA = Int :: Int :: Int :: Int :: Int :: HNildefined type DATA@ val arr = "1\t2\t3\t4\t5".split(’\t’).map(_.toInt)arr: Array = Array(1, 2, 3, 4, 5)
•                                               @ val myData = data.tupled(arr.toHList.get.tupled)myData: data = data(1, 2, 3, 4, 5)