spark之scala快速入门

scala和java都是在jvm之上的语言，相对来讲，scala热度比较低，其实并不是一个特别好的语言选择。

原因倒不是因为scala本身的缺点，而是使用人群不够多，论坛和社区不够活跃。这就跟社交软件一样，大家都用微信，短信就没人用了。

但是scala是写分布式程序的一门非常方便的语言，因为scala几乎每个对象都有map,reduce,filter等方法，这跟spark的用法简直如出一辙。

多范式

scala是一种多范式的语言，这也没啥特别的，就是既能面向过程又能面向对象，比如C++就是多范式。

安装

装scala要先装java，再装scala。

交互式编程

scala支持像javascript那种交互式编程，在命令行输入scala，进入交互式编程控制台。

编译

scalac 约等于 javac

打包和引包

打包有两种，第一种和java一样，在首行用package关键字。先掌握这种就行了。

引包也是用import但功能比java要强大,可以在代码任意位置引。

import java.awt.{Color, Font}// 重命名成员
import java.util.{HashMap => JavaHashMap}// 隐藏成员
import java.util.{HashMap => _, _} // 引入了util包的所有成员，但是HashMap被隐藏了

默认情况下，Scala 总会引入 java.lang._ 、 scala._ 和 Predef._，这里也能解释，为什么以scala开头的包，在使用时都是省去scala.的。

数据类型

scala多了几种比较傻又还是有点用的数据类型:

Unit 类似于void

Null 等于null

Nothing 是所有类的子类

Any 约等于 Object

常量和变量声明

常量: val x:String ="a";

变量 var x:String ="a";

访问修饰符

private ,protect,public default是public。有一些些区别，比如可灵活指定范围 private[ClassA]表示ClassA能访问。

运算符

基本运算符完全一致，不用特地去看。

针对集合或者是特殊对象有一些运算符，如List中(::,:::),Set中(&,++)等，运算符也可以作为方法使用。

if...else

完全一致，不用特地去看。

循环

终止循环。scala不支持break和continue关键字，scala2.8之后加入了 Breaks类，使用如下写法：

// 导入以下包
import scala.util.control._// 创建 Breaks 对象
val loop = new Breaks;// 在 breakable 中循环
loop.breakable{// 循环for(...){....// 循环中断loop.break;}
}

for循环比较好用，java感觉也是借鉴了该思想:

//1到10
for( var x <-  1 to 10 ){statement(s);
}//1到9
for( var x <-  1 until 10 ){statement(s);
}//双循环，java里面需要两个for
for( a <- 1 to 3; b <- 1 to 3){println( "Value of a: " + a );println( "Value of b: " + b );}//集合
for(x<- List)
{
}//循环过滤 感觉不需要掌握，放在循环体内也可以。for( a <- numListif a != 3; if a < 8 ){println( "Value of a: " + a );}//yield  注意for后面是大括号 用于返回满足条件的所有a集合里面的值，生成新集合var retVal = for{ a <- numList if a != 3; if a < 8}yield a

方法声明

在java中是先声明出参再声明入参，scala正好相反。只是思维方式不一样。

object add{def addInt( a:Int, b:Int ) : Int = { var sum:Int = 0 sum = a + b return sum } }

函数声明

函数是scala函数式编程的重点，会在下一篇文章中重点介绍。

字符串

scala字符串是不能更新的所以对字符串变量的修改会在内存区域创建一个新的字符串对象，如果需要更新，可以用StringBuilder这个对象。

集合：

scala集合包括java中常见的那些集合(List,Set,Map)，以及元组，与java不同的是，scala中的集合一般是不可变集合，修改集合的实现是创建一个新的集合。

链表（List）

列表的元素类型 T 可以写成 List[T]。

构造列表的两个基本单位是 Nil 和 :: 。 Nil 也可以表示为一个空列表。

scala的类java构造数组办法。

// 字符串列表
val site: List[String] = List("Runoob", "Google", "Baidu")// 整型列表
val nums: List[Int] = List(1, 2, 3, 4)// 空列表
val empty: List[Nothing] = List()// 二维列表
val dim: List[List[Int]] =List(List(1, 0, 0),List(0, 1, 0),List(0, 0, 1))

scala特有的构造办法如下：

// 字符串列表
val site = "Runoob" :: ("Google" :: ("Baidu" :: Nil))// 整型列表
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))// 空列表
val empty = Nil// 二维列表
val dim = (1 :: (0 :: (0 :: Nil))) ::(0 :: (1 :: (0 :: Nil))) ::(0 :: (0 :: (1 :: Nil))) :: Nil

连接列表的操作

你可以使用 ::: 运算符或 List.:::() 方法或 List.concat() 方法来连接两个或多个列表。实例如下:

object Test {def main(args: Array[String]) {val site1 = "Runoob" :: ("Google" :: ("Baidu" :: Nil))val site2 = "Facebook" :: ("Taobao" :: Nil)// 使用 ::: 运算符var fruit = site1 ::: site2println( "site1 ::: site2 : " + fruit )// 使用 List.:::() 方法fruit = site1.:::(site2)println( "site1.:::(site2) : " + fruit )// 使用 concat 方法fruit = List.concat(site1, site2)println( "List.concat(site1, site2) : " + fruit  )}
}

集合(Set)

可变集合和不可变集合。虽然可变Set和不可变Set都有添加或删除元素的操作，但是有一个非常大的差别。对不可变Set进行操作，会产生一个新的set，原来的set并没有改变，这与List一样。而对可变Set进行操作，改变的是该Set本身，与ListBuffer类似。

import scala.collection.mutable.Set // 可以在任何地方引入 可变集合

val mutableSet = Set(1,2,3)
println(mutableSet.getClass.getName) // scala.collection.mutable.HashSet

mutableSet.add(4)
mutableSet.remove(1)
mutableSet += 5
mutableSet -= 2println(mutableSet) // Set(5, 3, 4)

val another = mutableSet.toSet
println(another.getClass.getName) // scala.collection.immutable.Set

你可以使用 ++ 运算符或 Set.++() 方法来连接两个集合。如果元素有重复的就会移除重复的元素。实例如下：

object Test {def main(args: Array[String]) {val site1 = Set("Runoob", "Google", "Baidu")val site2 = Set("Faceboook", "Taobao")// ++ 作为运算符使用var site = site1 ++ site2println( "site1 ++ site2 : " + site )//  ++ 作为方法使用site = site1.++(site2)println( "site1.++(site2) : " + site )}
}

映射（Map）

默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合，你需要显式的引入 import scala.collection.mutable.Map 类

// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

注意，Map的get方法返回的对象是一个Option[String],Option表示可能为None，比如key值不存在的情况，如果不为None则是Some(value)。

Scala元组(Tuple)

元组是每个元素类型可以不一样的List，最大的size是22。

val t = (1, 3.14, "Fred")
val t = new Tuple3(1, 3.14, "Fred")//3是元组中元素的个数

我们可以使用 t._1 访问第一个元素， t._2 访问第二个元素，如下所示：

object Test {def main(args: Array[String]) {val t = (4,3,2,1)val sum = t._1 + t._2 + t._3 + t._4println( "元素之和为: "  + sum )}
}

类(class)

scala的类和对象与java的类和对象基本上一样。

类定义方法如下：

class Point(xc: Int, yc: Int) {var x: Int = xcvar y: Int = ycdef move(dx: Int, dy: Int) {x = x + dxy = y + dyprintln ("x 的坐标点: " + x);println ("y 的坐标点: " + y);}
}

对象的定义方法是用object关键字，和java以class名.java 命名文件不同，scala是以类名.scala命名文件。

接口(trait)

trait关键字很像java的interface，但是它能够定义某个方法的实现。

trait Equal {def isEqual(x: Any): Booleandef isNotEqual(x: Any): Boolean = !isEqual(x)
}

和java一样，scala只能继承一个父类，但如果是trait就可以继承多个，继承的关键字是extends

模式匹配

scala的 x match{case:...} 对应java中的switch(x){case:...}

捕获异常

scala的异常捕获和java大致一致，只是在catch的时候使用了模式匹配的思想。

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOExceptionobject Test {def main(args: Array[String]) {try {val f = new FileReader("input.txt")} catch {case ex: FileNotFoundException => {println("Missing file exception")}case ex: IOException => {println("IO Exception")}} finally {println("Exiting finally...")}}
}

提取器:apply和unapply

提取器是从传递给它的对象中提取出构造该对象的参数。感觉这个玩意很鸡肋。

object Test {def main(args: Array[String]) {//下面调用applyval x = Test(5)println(x)x match{//下面unapply 被调用case Test(num) => println(x + " 是 " + num + " 的两倍！")case _ => println("无法计算")}}def apply(x: Int) = x*2def unapply(z: Int): Option[Int] = if (z%2==0) Some(z/2) else None
}

文件IO

scala写文件操作直接用的是java的io，读操作有自己的，总体来讲比java简单。

import java.io._object Test {def main(args: Array[String]) {val writer = new PrintWriter(new File("test.txt" ))writer.write("菜鸟教程")writer.close()}
}

从屏幕读输入

import scala.io._
object Test {def main(args: Array[String]) {print("请输入菜鸟教程官网 : " )
//2.11版本后。Console.readLine已废弃val line = StdIn.readLine()println("谢谢，你输入的是: " + line)}
}

从文件中读内容

import scala.io.Sourceobject Test {def main(args: Array[String]) {println("文件内容为:" )Source.fromFile("test.txt" ).foreach{ print }}
}

转载于:https://www.cnblogs.com/arli/p/9335679.html

spark之scala快速入门相关推荐

scala快速入门系列【伴生对象】
本篇作为scala快速入门系列的第二十篇博客,为大家带来的是关于伴生对象的内容. 文章目录伴生对象定义伴生对象 private [this] 访问权限 apply 方法伴生对象在Java中,经 ...
scala快速入门系列【偏函数】
本篇作为scala快速入门系列的第三十一篇博客,为大家带来的是关于偏函数的内容. 文章目录偏函数定义示例一示例二偏函数偏函数提供了简洁的语法,可以简化函数的定义.配合集合的函数式编程,可以 ...
【Spark】scala基础入门
文章目录零.IDEA的scala环境配置 0.1 spark和scala之间的关系 0.2 编写项目 (0)创建项目 (1)配置pom.xml文件: (2)配置对应环境 (3)测试代码 (4)控制台 ...
2021-08-26 转载 Scala快速入门系列博客文章
作者:Huidoo_Yang 出处:http://www.cnblogs.com/yangp/ 本文版权归作者Huidoo_Yang和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面 ...
一二, Spark概述和快速入门
一, Spark概述 1.1 什么是Spark Spark是一种基于内存的快速,通用,可扩展的大数据分析计算引擎; "Apache Spark" is a unified anal ...
【Spark】介绍快速入门
目录介绍 Spark and Hadoop Spark or Hadoop 核心模块 Spark Core Spark SQL Spark Streaming Spark MLlib Spark G ...
scala case class 继承_数字硬件系统设计之一：Scala快速入门(2)
原想简单笼统介绍一下scala,后感觉这么做意思不大,网友看了和没看一样,还是应该稍微详细具体一点,故而把系列编号由(上)(中)(下),改为(上)(2)(3)(4)(5)....,(上)就是(1)吧, ...
spark之1：快速入门
spark之1:快速入门 @(SPARK)[spark, 大数据] spark可以通过交互式命令行及编程两种方式来进行调用: 前者支持scala与python 后者支持scala.python与jav ...
Spark快速入门指南 – Spark安装与基础使用
本文转载自Spark快速入门指南 – Spark安装与基础使用 Apache Spark 是一个新兴的大数据处理通用引擎,提供了分布式的内存抽象.Spark 正如其名,最大的特点就是快(Lightni ...

spark之scala快速入门

spark之scala快速入门相关推荐

最新文章

热门文章