讲解了Scala的集合操作，如筛选、转换、集合运算等，并介绍了如何在Scala中读取数据源和进行隐式转换。
Scala的设计理念是，特定领域的应用程序开发往往需要特定于该领域的语言扩展。
Scala提供了许多独特的语言机制，可以以库的形式轻易无缝添加新的语言结构。
表达式
在Scala中，一切皆为表达式。Scala非常推崇表达式语法，因为表达式语法对函数式编程非常友好。对于开发者来说，表达式语法使得代码非常简洁易读。
例如，我们在定义方法时，会和声明变量一样，使用等号(=)连接。等号左侧是函数名、参数列表和返回值类型（可以省略），而等号右边则是一个由大括号({})包裹的多行表达式。
在Scala中，每个表达式都会有返回值。在Java中，我们使用void来声明无返回值的方法，但在Scala里，这种情况也会有返回值，会返回一个Unit，这是一个特定的值，表示忽略方法的返回值。
方法与函数
对于Scala初学者来说，方法和函数的概念可能会有些模糊，在使用中可能会搞不清楚到底该使用方法还是函数。那么，如何区分呢？关键在于看这个函数是否在类中定义。如果在类中定义，那么它就是方法，因此Scala的方法是类的一部分。而Scala中的函数则是一个完整的对象，可以赋给一个变量。不过，在Scala中，方法和函数是可以相互转化的。下面我们重点介绍如何把方法转为函数。
方法转函数
上文中提到，任何方法都是在声明一个表达式，所以将方法转为函数就非常简单了，相当于是把方法指向的表达式，又重新赋给了一个函数变量，这就是显式转化。还有另外一种写法，是通过偏应用函数的方式，将方法转化为一个新的函数，称作隐式转化。
1）隐式转化
val f2 = f1 _
2）显式转化
val f2: (Int) => Int = f1
模式匹配
模式匹配是检查某个值是否匹配某一个模式的机制。它是Java中的switch语句的升级版，同样可以用于替代一系列的 if/else 语句。以下介绍几种常用的模式匹配：常量模式、变量模式、通配符模式。
常量模式
常量模式匹配，就是在模式匹配中匹配常量。
object ConstantPattern{
def main(args:Array[String]) :Unit = {
//模式匹配结果作为函数返回值
def patternShow(x : Any) = x match {
//常量模式
case 5 => "五"
case true => "真"
case "test" => "字符串"
case null => "null值"
case Nil => "空列表"
//变量模式
case x => "变量"
//通配符模式
case _ => "通配符"
}
}
}变量模式和通配符模式，都可以匹配任意值，他们之间的区别是，变量模式匹配成功后，该变量中会存储匹配成功的值，在后续的代码中还可以引用，而通配符模式匹配成功后，不能再引用匹配到的值。另外要注意的是，由于模式匹配是按顺序匹配的，因此变量模式和通配符模式要写在表达式的最后面。
类型匹配模式
可以匹配输入变量的类型。
object TypePattern{
def main(args:Array[String]) :Unit = {
//类型匹配模式
def typePattern(t : Any) = t match {
case t : String => "String"
case t : Int => "Intger"
case t : Double => "Double"
case _ => "Other Type"
}
}
}case class模式
构造器模式指的是，直接在case语句后面接类构造器，匹配的内容放置在构造器参数中。
object CaseClassPattern{
def main(args:Array[String]) :Unit = {
//定义一个Person实例
val p = new Person(“nyz”,27)
//case class 模式
def constructorPattern(p : Person) = p match {
case Person(name,age) => “name =” + name + “,age =” + age
case _ => “Other”
}
}
}模式守卫
为了让匹配更加具体，可以使用模式守卫，也就是在模式后面加上if判断语句。
object ConstantPattern{
def main(args:Array[String]) :Unit = {
//模式匹配结果作为函数返回值
def patternShow(x : Any) = x match {
//模式守卫
case x if(x == 5) => “守卫”
//通配符模式
case _ => “通配符”
}
}
}Option匹配
在Scala中Option类型样例类用来表示可能存在或也可能不存在的值(Option的子类有Some和None)。Some包装了某个值，None表示没有值。
class OptionDemo {
val map = Map ((“a”,18),(“b”,81))
//get方法返回的类型就是Option[Int]
map.get(“b”) match {
case some(x) => println(x)
case None => println(“不存在”)
}
}Scala Trait(特质)
Scala Trait(特质) 相当于 Java 的接口，但实际上它比接口的功能强大。与接口不同的是，它还可以定义属性和方法的实现。
一般情况下Scala的类只能够继承单一父类，但可以使用with关键字混入多个 Trait(特质) 。不过，如果一个scala类没有父类，那么它混入的第一个特质需要使用extends关键字，之后混入的特质使用with关键字。
Trait(特质) 定义的方式与类相似，但它使用的关键字是 trait，如下所示：
trait Equal {
def isEqual(x: Any): Boolean
def isNotEqual(x: Any): Boolean = !isEqual(x)
}以上特质（Equal）由两个方法组成：isEqual 和 isNotEqual。isEqual 方法没有定义方法的实现，isNotEqual定义了方法的实现。子类继承特质可以实现未被实现的方法。
以下演示了特质的完整实例：
trait Equal {
def isEqual(x: Any): Boolean
def isNotEqual(x: Any): Boolean = !isEqual(x)
}
class Point(xc: Int, yc: Int) extends Equal {
val x: Int = xc
val y: Int = yc
def isEqual(obj: Any) = obj.isInstanceOf[Point] && obj.asInstanceOf[Point].x == x
}
object Test {
def main(args: Array[String]) {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotEqual(p2))
println(p1.isNotEqual(p3))
println(p1.isNotEqual(2))
}
}执行以上代码，输出结果为：
$ scalac Test.scala $ scala -cp . Test``false``true``true
集合操作
常用集合
以下代码演示了常用集合的创建方式：
// 定义整型 List，其元素以线性方式存储，可以存放重复对象。
val x = List(1,2,3,4)
// 定义 Set，其对象不按特定的方式排序，并且没有重复对象。
val x = Set(1,3,5,7)
// 定义 Map，把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象。
val x = Map("one" -> 1, "two" -> 2, "three" -> 3)
// 创建两个不同类型元素的元组，元组是不同类型的值的集合
val x = (10, "Bigdata")
// 定义 Option，表示有可能包含值的容器，也可能不包含值。
val x:Option[Int] = Some(5)集合函数
在操作 Scala 集合时，一般会进行两类操作：转换操作（transformation）和行动操作（action）。第一种操作类型将集合转换为另一个集合，第二种操作类型返回某些类型的值。
1. 最大值和最小值
在序列中查找最大或最小值是一个极常见的需求。以下是一个简单的例子：
val numbers = Seq(11, 2, 5, 1, 6, 3, 9) numbers.max //11 numbers.min //1
对于这种简单数据集合，Scala的函数式特性显露无疑，如此简单的取到了最大值和最小值。再来看一个数据集合复杂的例子：
case class Book(title: String, pages: Int)
val books = Seq(
Book("Future of Scala developers", 85),
Book("Parallel algorithms", 240),
Book("Object Oriented Programming", 130),
Book("Mobile Development", 495)
)
// 下面代码返回Book(Mobile Development,495)
books.maxBy(book => book.pages)
// 下面代码返回Book(Future of Scala developers,85)
books.minBy(book => book.pages)minBy & maxBy方法解决了复杂数据的问题。
2. 筛选-Filter
对集合进行过滤，返回满足条件的元素的新集合，比如过滤一组数据中的偶数。
val numbers = Seq(1,2,3,4,5,6,7,8,9,10) numbers.filter(n => n % 2 == 0) //上面返回Seq(2,4,6,8,10)
获取页数大于300页的书。
val books = Seq(
Book("Future of Scala developers", 85),
Book("Parallel algorithms", 240),
Book("Object Oriented Programming", 130),
Book("Mobile Development", 495)
)
books.filter(book => book.pages >= 300) //上面返回Seq(Book("Mobile Development", 495))还有一个与 filter类似的方法是 filterNot，也就是筛选出不满足条件的对象。
3. Flatten
Flatten的作用是将多个集合展开，组成一个新的集合，举例说明。
val abcd = Seq('a', 'b', 'c', 'd')
val efgj = Seq('e', 'f', 'g', 'h')
val ijkl = Seq('i', 'j', 'k', 'l')
val mnop = Seq('m', 'n', 'o', 'p')
val qrst = Seq('q', 'r', 's', 't')
val uvwx = Seq('u', 'v', 'w', 'x')
val yz = Seq('y', 'z')
val alphabet = Seq(abcd, efgj, ijkl, mnop, qrst, uvwx, yz)
alphabet.flatten执行后返回下面的集合：
List('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z')4. 集合运算函数
集合运算即差集、交集和并集操作。
val num1 = Seq(1, 2, 3, 4, 5, 6) val num2 = Seq(4, 5, 6, 7, 8, 9) // 返回List(1, 2, 3) num1.diff(num2) // 返回List(4, 5, 6) num1.intersect(num2) // 返回List(1, 2, 3, 4, 5, 6, 4, 5, 6, 7, 8, 9) num1.union(num2) // 合并后再去重，返回List(1, 2, 3, 4, 5, 6, 7, 8, 9) num1.union(num2).distinct
5. map函数
map 函数的逻辑是遍历集合并对每个元素调用传入的函数进行处理。
val numbers = Seq(1,2,3,4,5,6)
// 返回List(2, 4, 6, 8, 10, 12)
numbers.map(n => n * 2)
val chars = Seq('a', 'b', 'c', 'd')
// 返回List(A, B, C, D)
chars.map(ch => ch.toUpper)6. flatMap
flatMap将map & flatten组合起来，以下是一个操作示例：
val abcd = Seq('a', 'b', 'c', 'd')
// 返回List(A, a, B, b, C, c, D, d)
abcd.flatMap(ch => List(ch.toUpper, ch))从结果可以看出来是先做的map，然后做的flatten。
7. forall & exists
forall是对整个集合做判断，当集合中的所有元素都满足条件时，返回true。而exists则是只要有一个元素满足条件就返回true。
val numbers = Seq(3, 7, 2, 9, 6, 5, 1, 4, 2) // 返回true numbers.forall(n => n < 10) // 返回false numbers.forall(n => n > 5) // 返回true numbers.exists(n => n > 5)
读取数据源
读取外部数据源是开发中很常见的需求，如在程序中读取外部配置文件并解析，获取相应的执行参数。
以下是Scala通过Source类读取数据源的简单介绍：
import scala.io.Source
object ReadFile {
// 读取ClassPath下的配置文件
val file = Source.fromInputStream(this.getClass.getClassLoader.getResourceAsStream("app.conf"))
// 一行一行读取文件,getLines()表示读取文件所有行
def readLine: Unit ={
for(line <- file.getLines()){
println(line)
}
}
// 读取网络上的内容
def readNetwork: Unit ={
val file = Source.fromURL("http://www.baidu.com")
for(line <- file.getLines()){
println(line)
}
}
// 读取给定的字符串-多用于调试
val source = Source.fromString("test")
}隐式转换
隐式转换是Scala中一种非常有特色的功能，它可以实现将某种类型的对象转换为另一种类型的对象。在数据分析工作中，最常使用到的就是java和scala集合之间的互相转换，转换以后就可以调用另一种类型的方法。scala提供了scala.collection.JavaConversions类，只要引入此类中相应的隐式转化方法，在程序中就可以用相应的类型来代替要求的类型。
例如，通过以下转换，scala.collection.mutable.Buffer自动转换成了java.util.List。
import scala.collection.JavaConversions.bufferAsJavaList // scala.collection.mutable.Buffer => java.util.List
同样，java.util.List也可以转换成scala.collection.mutable.Buffer。
import scala.collection.JavaConversions.asScalaBuffer // java.util.List => scala.collection.mutable.Buffer
所有可能的转换汇总如下，双向箭头表示可互相转换，单箭头则表示只有左边可转换到右边。
import scala.collection.JavaConversions._
// scala.collection.Iterable <=> java.lang.Iterable
// scala.collection.Iterable <=> java.util.Collection
// scala.collection.Iterator <=> java.util.{ Iterator, Enumeration }
// scala.collection.mutable.Buffer <=> java.util.List
// scala.collection.mutable.Set <=> java.util.Set
// scala.collection.mutable.Map <=> java.util.{ Map, Dictionary }
// scala.collection.concurrent.Map <=> java.util.concurrent.ConcurrentMap
// scala.collection.Seq => java.util.List
// scala.collection.mutable.Seq => java.util.List
// scala.collection.Set => java.util.Set
// scala.collection.Map => java.util.Map
// java.util.Properties => scala.collection.mutable.Map[String, String]隐式参数
所谓隐式参数，指的是在函数或者方法中，定义使用implicit修饰的参数。当调用该函数或方法时，scala会尝试在变量作用域中找到一个与指定类型相匹配的使用implicit修饰的对象，即隐式值，注入到函数参数中函数体使用。以下是一个示例：文章来源：https://www.toymoban.com/news/detail-850758.html
class SayHello{
def write(content:String) = println(content)
}
implicit val sayHello=new SayHello
def saySomething(name:String)(implicit sayHello:SayHello){
sayHello.write("Hello," + name)
}
saySomething("Scala")
// 打印 Hello,Scala
文章来源地址https://www.toymoban.com/news/detail-850758.html
到了这里，关于Scala编程基础：表达式、函数、模式匹配与集合操作的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
