10.SCALA编程思想笔记 组合表达式

Scala 至简原则一、什么是 Scala 至简原则？Scala 至简原则是指使用 Scala 进行编程时，遵循简单、清晰、易读的原则，以提高代码的可维护性和可复用性。

Scala 至简原则强调代码的简洁性，避免过度使用复杂的语法和功能，让代码更易于理解和调试。

二、为什么要遵循 Scala 至简原则？1.提高代码的可读性：简单的代码更容易被其他开发人员理解，从而提高协作效率。

2.提高代码的可维护性：简洁的代码结构清晰，降低了维护代码的难度。

3.提高代码的可复用性：简单的代码更容易抽象和重用，减少了重复编写代码的工作量。

4.减少 Bug 的产生：复杂的代码容易出现逻辑错误，而简单的代码更易于调试和修复。

三、遵循 Scala 至简原则的关键点1. 使用一致的命名规范对于变量、函数、类等的命名，应遵循统一的命名规范，使命名清晰易懂。

避免使用过于简单或过于复杂的命名，选择能准确描述其用途的名称。

2. 减少代码的重复重复的代码不仅增加了代码量，还增加了维护成本。

要尽量避免代码的重复，可以通过抽象和封装公共逻辑来实现代码的复用。

3. 使用简洁的语法Scala 提供了许多强大的语法特性，但并不意味着在每个地方都要使用这些特性。

合理选择使用简洁的语法，以提高代码的可读性。

4. 合理使用注释注释是对代码进行解释和说明的重要工具，但过多或过少的注释都会影响代码的可读性。

合理使用注释，对代码的关键部分进行解释和说明，能更好地帮助他人理解你的代码。

5. 尽量避免嵌套和复杂的控制流程过多的嵌套和复杂的控制流程会使代码难以理解和调试。

尽量避免长时间的嵌套和复杂的 if-else、for 循环等控制流程，可以通过提取方法、使用模式匹配等方式简化代码的结构。

四、如何应用 Scala 至简原则？1. 使用合适的数据结构和算法选择合适的数据结构和算法可以简化代码的逻辑和实现。

例如，使用集合类和高阶函数可以减少循环的使用，使代码更简洁。

快速入门Scala编程语言Scala编程语言是一种多范式编程语言，结合了面向对象编程和函数式编程的特点。

它的语法简洁优雅，适合用于大规模的软件开发项目。

本文将带你快速了解Scala编程语言。

一、Scala的基本语法1. 变量和常量：在Scala中，使用关键字`var`来声明一个可变的变量，使用关键字`val`来声明一个不可变的常量。

例如，`var x = 10`声明一个可变变量x，`val y = 5`声明一个不可变常量y。

2. 数据类型：Scala拥有丰富的数据类型，包括整数类型、浮点数类型、布尔类型、字符类型等。

例如，`Int`表示整数类型，`Double`表示浮点数类型，`Boolean`表示布尔类型，`Char`表示字符类型。

3. 控制流语句：Scala支持常见的控制流语句，如条件判断和循环。

例如，`if-else`语句用于条件判断，`for`循环用于迭代执行操作。

4. 函数：在Scala中，函数是一等公民，可以作为值进行传递和操作。

函数的定义使用关键字`def`，例如`def add(x: Int, y: Int): Int = x + y`定义了一个接受两个整数参数并返回它们的和的函数。

5. 类和对象：Scala是一种面向对象的语言，每个值都是一个对象。

类用于定义对象的蓝图，对象是类的实例。

通过使用`class`关键字定义类，使用`new`关键字来创建对象。

二、函数式编程特性Scala内置了许多函数式编程特性，使得函数的组合和操作更加简洁和灵活。

1. 高阶函数：Scala中的函数可以作为值进行传递和操作，因此可以使用函数作为参数或返回值。

这种函数接受其他函数作为参数或将函数作为返回值的函数称为高阶函数。

高阶函数可以极大地简化代码的编写和理解。

2. 不可变性：Scala鼓励使用不可变的数据结构和变量，在处理数据时避免副作用和数据竞争的发生。

不可变性使得代码更加安全和易于调试。

3. 模式匹配：模式匹配是一种强大的功能，用于根据数据的结构和属性进行分支处理。

Scala入门本文源自Michel Schinz和Philipp Haller所写的A Scala Tutorial for Java programmers，由Bearice成中文，dongfengyee(东风雨)整理。

1 简介本文仅在对Scala语言和其编译器进行简要介绍。

本文的目的读者是那些已经具有一定编程经验，而想尝试一下Scala语言的人们。

要阅读本文，你应当具有基础的面向对象编程的概念，尤其是Java语言的。

2 第一个Scala例子作为学习Scala的第一步，我们将首先写一个标准的HelloWorld，这个虽然不是很有趣，但是它可以让你对Scala有一个最直观的认识而不需要太多关于这个语言的知识。

我们的Hello world看起来像这样：object HelloWorld{def main(args:Array[String]){println("Hello, world!")}}程序的结构对Java程序员来说可能很令人怀念：它由一个main函数来接受命令行参数，也就是一个String数组。

这个函数的唯一一行代码把我 们的问候语传递给了一个叫println的预定义函数。

main函数不返回值（所以它是一个procedure method）。

所以，也不需要声明返回类型。

对于Java程序员比较陌生的是包含了main函数的object语句。

这样的语句定义了一个单例对象：一个有且仅有一个实例的类。

object语 句在定义了一个叫HelloWorld的类的同时还定义了一个叫HelloWorld的实例。

这个实例在第一次使用的时候会进行实例化。

聪明的读者可能会发现main函数并没有使用static修饰符，这是由于静态成员（方法或者变量）在Scala中并不存在。

Scala从不定义静态成员，而通过定义单例object取而代之。

2.1 编译实例我们使用Scala编译器“scalac”来编译Scala代码。

scala的运算符Scala是一门功能强大的编程语言，它提供了丰富的运算符用于实现各种计算和操作。

本文将介绍Scala的一些常用运算符，并且分别对它们进行详细的说明和使用示例。

一、算术运算符1. 加法运算符（+）：用于执行两个值的相加操作。

示例：val a = 10 + 5 // a的值为152. 减法运算符（-）：用于执行两个值的相减操作。

示例：val b = 10 - 5 // b的值为53. 乘法运算符（*）：用于执行两个值的相乘操作。

示例：val c = 10 * 5 // c的值为504. 除法运算符（/）：用于执行两个值的相除操作。

示例：val d = 10 / 5 // d的值为25. 取余运算符（%）：用于返回两个值相除后的余数。

示例：val e = 10 % 3 // e的值为1二、关系运算符1. 相等运算符（==）：用于判断两个值是否相等。

示例：val a = 10; val b = 5; val c = 10val result = a == b // result的值为false2. 不等运算符（!=）：用于判断两个值是否不相等。

示例：val a = 10; val b = 5; val c = 10val result = a != b // result的值为trueval result2 = a != c // result2的值为false3. 大于运算符（>）：用于判断一个值是否大于另一个值。

示例：val a = 10; val b = 5val result = a > b // result的值为true4. 小于运算符（<）：用于判断一个值是否小于另一个值。

示例：val a = 10; val b = 5val result = a < b // result的值为false5. 大于等于运算符（>=）：用于判断一个值是否大于或等于另一个值。

scala编程思想—学习笔记⽅法⽅法是打包在某个名字下的⼩程序。

在使⽤⽅法时，也就是调⽤⽅法时就会执⾏这个⼩程序。

⽅法将⼀组活动组合起来并赋予⼀个名字，这就是组织程序的最基本⽅式。

scala 中⽅法的基本形式为def methodName(arg1:Type1, arg2:Type2, ...):returnType = {lines of coderesult}类和对象scala 不仅仅是⾯向对象语⾔，还是函数式语⾔。

在函数式语⾔中，我们会考虑动词，即希望执⾏的动作，并且通常会将这些动作描述成数学上的等式。

对象包含存储数据⽤的 val 和 var 也就是域，并且使⽤⽅法来执⾏操作。

类定义了域和⽅法，它们使类在本质上就是⽤户定义的新数据类型。

构建某个类型的 val 或 var 称为创建对象或创建实例。

我们甚⾄将注⼊ Double 和 String 这样的内建类型的实例也称为对象在 scala 中，使⽤ RPEL 可以很容易的对类进⾏探究，这使得他具有补全代码的好功能。

Scala Doc在线 Scala Doc 地址 https:///api/current/index.html创建类对象是针对待解决问题的解决⽅案的有机组成部分。

我们先将对象当做表达概念的⽅式，如果你发现了待解决问题的某样“事物”，那么就将其看作解决⽅案中的对象。

创建类需要以 class 开头，后⾯跟着为⼼类起的名字。

类名必须以⼤写英⽂字母开头。

类中的⽅法在类中可以定义属于这个类的⽅法。

在⽅法中创建的⽅法并未出现在类的定义内部，但是事实证明，在 Scala 中所有的事物都是对象。

当我们使⽤ RPEL或运⾏脚本时， Scala 会将所有不在类的内部的⽅法以不可视的⽅式打包到⼀个对象的内部。

导⼊和包使⽤ import 的⼀种⽅式是指定类名。

import packagename.classname可以在单个 import 语句中将多个类组合起来。

scala 除法Scala是一种面向对象的编程语言，它也支持函数式编程。

在Scala中，除法是一种基本的算术运算，用于计算两个数的商。

本文将介绍Scala 中除法的主要内容，包括除法的基本语法、除法的运算规则、除法的类型转换、除法的异常处理等。

一、除法的基本语法Scala中的除法运算符是“/”，它可以用于计算两个数的商。

除法运算符可以用于整数、浮点数和其他数字类型。

下面是一个简单的例子，演示如何使用除法运算符计算两个整数的商：val a = 10val b = 2val c = a / bprintln(c)输出结果为5，这是因为10除以2等于5。

二、除法的运算规则在Scala中，除法运算符的运算规则与其他编程语言类似。

如果除数和被除数都是整数，则结果也是整数。

如果其中一个是浮点数，则结果也是浮点数。

下面是一个例子，演示了整数除法和浮点数除法的区别：val a = 10val b = 3val c = a / bprintln(c)val d = 10.0val e = 3.0val f = d / eprintln(f)输出结果为3和3.3333333333333335，这是因为10除以3等于3，而10.0除以3.0等于3.3333333333333335。

三、除法的类型转换在Scala中，如果除数和被除数的类型不同，则需要进行类型转换。

如果其中一个是浮点数，则结果也是浮点数。

如果两个数都是整数，则结果也是整数。

下面是一个例子，演示了类型转换的过程：val a = 10val b = 3.0val c = a / bprintln(c)输出结果为3.3333333333333335，这是因为10除以3.0等于3.3333333333333335。

四、除法的异常处理在Scala中，除数不能为0，否则会抛出异常。

如果除数为0，则会抛出ArithmeticException异常。

下面是一个例子，演示了除数为0时的异常处理：val a = 10val b = 0try {val c = a / bprintln(c)} catch {case e: ArithmeticException => println("除数不能为0")}输出结果为“除数不能为0”，这是因为除数为0时会抛出ArithmeticException异常。

scala编程函数，⽅法与数组（其⼆）scala 函数与⽅法！1,在实际中，⽅法存在于对象中，⽤来处理对象的数据。

2,scala 之中的所有的算术运算实际上是专门的⽅法，只是绑定到类型之中。

2+3 实际上是调⽤了值为2的⼀个Int 的加法⽅法，并提供参数3，返回值为5 object Hello{def main(args: Array[String]): Unit = {moth(8, 4)println(function0(1, 2))println(m(f1))println(powwer(2, 8)) // 递归函数println(greet(name = "hello world! "))println(fn(12, 12, 12))println(fn1(1)(2)) //两个输⼊参数分解到参数组之中去！println(add())// 调⽤匿名函数a()println(funinfun(3))}// 定义⽅法 "=" 可以省略, 省略之后,⽆论⽅法体最后⼀⾏计算结果是什么都会丢弃,返回Unitdef add(){println("⽆返回值")}// Unit 表⽰⽆返回数值// 定义⼀个⽅法需要 def 指定// ⽅法的返回值可以不写，但是递归必须指定返回值def moth(a :Int,b :Int) ={println("Unit 表⽰⽆返回数值! ")}// 函数可以像数据类型⼀样传递和操作！val function0 = (x:Int,y:Int) => x+y// 函数作为形参传递⽅法！在⽅法之中调⽤函数(来⾃形参)def m(f:(Int,Int)=>Int) =f(2,6)val f1 = (x:Int,y:Int)=> x+y// 将⽅法转换成函数！def f2 = m _// k 的 w次幂def powwer(k:Int,w:Int):Long ={if (w>=1) k *powwer(k,w-1)else 1}// 有默认的参数⼀般重要参数在前其他参数在后def greet(prefix :String ="H",name:String)=s"$prefix$name"// 可变参数求和计算（items 是 WrappedArry）def fn(items:Int*):Int ={var total = 0 // var 才能达到可变的效果！for (i <- items) total += itotal}//参数组def fn1(x:Int)(y:Int) = if(x>y) x else y// 定义匿名函数val a = (name:String) =>{println("hello world!" + name)}// 函数之间的嵌套def funinfun(num:Int)={def fun(num:Int): Int ={if(num==1) 1 else num*fun(num-1)}fun(num)}// 原始函数def showlog(d:Date,log:String): Unit ={println("date is "+d+", log is "+log)}val data = new Date()showlog(data,"a")showlog(data,"b")showlog(data,"c")showlog(data,"d")// 使⽤偏应⽤函数达到省略部分传参的效果val fun1 = showlog(data:Date,_:String)fun1("a")fun1("b")fun1("c")fun1("d")// ⾼阶函数传⼊的函数作为逻辑运算def fun_in(a:Int,b:Int): Int ={a+b}def fun_out(f:(Int,Int)=>Int,s:String)={val result = f(100,244)result + "~" + s}println(fun_out(fun_in, "hello"))// ⾼阶函数函数的返回是函数// (String,String) =>String 指的是 fun_retu 的返回类型def fun_retu(a:Int,b:Int): (String,String) =>String={val resu = a*bdef fun2(s:String,s1:String): String ={s +"@" +s1+"$"+resu}fun2}println(fun_retu(10, 20)("hello", "world"))// ⾼阶函数函数的传⼊与返回都是函数def fun_in_resu(f:(Int,Int)=>Int): (String,String) =>String ={val results = f(8,9)def fun4(s1:String,s2:String): String={s1+"@"+s2+"!"+results}fun4}fun_in_resu((a:Int,b:Int)=>{a+b})}关于数组的说明:1，Arry 类型是 scala 封装的⼀个 java 数组类2，scala 数组是通过 ()来访问的每次遍历有时候是调⽤的类型的 toString()⽅法,但是只是打印数组例外 3,可变数组是⼀种静态类4,数组，元组，映射等默认都是不可变的，需要引⼊可变的包！package day01object Test2{def main(args: Array[String]): Unit = {// 不需要调⽤类默认是定长数组val arr = new Array[Int](8) //默认 0填充// println(arr) // 是⼀个引⽤// println(arr.toBuffer) //转换成数组缓冲！也可以for循环遍历val arrstr = new Array[String](8) //默认是 null填充// println(arrstr) // 打印的是⼀个引⽤！// println(arrstr.toBuffer) //转换成数组缓冲val arr2 =Array("python","scala","java")//在此处可以看出调⽤的是静态类不需要 new// println(arr2.toBuffer)// println(arr2(2)) //使⽤的 () 不是[]//scala ⽣成⼀个动态类需要引⽤包import scala.collection.mutable.ArrayBufferval arr3 = ArrayBuffer[Int]()arr3 += 1 //数组追加 1arr3+=(2,3,4) //追加多个元素使⽤元组或者数组arr3++=Array(5,6)arr3++=ArrayBuffer(7,8,9)arr3.insert(0,-1,0) // 在下标 0前处加⼊ -1 和 0arr3.remove(2,3) // 2(包括)下标开始删除删除三个for(i<-arr3) println(i) //使⽤ for 打印每⼀个值for (i <- (0 until arr3.length).reverse) println(arr3(i)) //反转取值val yie = for (i <- arr3) yield i //此时是⽣成⼀个新的数组val arr4 = Array(arr3.max,arr3.sum,arr3.sorted) //求和与最⼤值,排序升序⽣成的数组println(arr4.toBuffer)// println(yie)// println(arr3.toBuffer)}}。

Scala学习之路（三）Scala的基本使⽤⼀、Scala概述scala是⼀门多范式编程语⾔，集成了⾯向对象编程和函数式编程等多种特性。

scala运⾏在虚拟机上，并兼容现有的Java程序。

Scala源代码被编译成java字节码，所以运⾏在JVM上，并可以调⽤现有的Java类库。

⼆、第⼀个Scala程序Scala语句末尾的分号可写可不写HelloSpark.scalaobject HelloSpark{def main(args:Array[String]):Unit = {println("Hello Spark!")}}运⾏过程需要先进⾏编译编译之后⽣成2个⽂件运⾏HelloSpark.class输出结果Hello Spark三、Scala的基本语法1、概述/*** Scala基本语法:* 区分⼤⼩写* 类名⾸字母⼤写（MyFirstScalaClass）* ⽅法名称第⼀个字母⼩写（myMethodName()）* 程序⽂件名应该与对象名称完全匹配* def main(args:Array[String]):scala程序从main⽅法开始处理，程序的⼊⼝。

** Scala注释：分为多⾏/**/和单⾏//** 换⾏符：Scala是⾯向⾏的语⾔，语句可以⽤分号（；）结束或换⾏符（println()）** 定义包有两种⽅法：* 1、package com.ahu* class HelloScala* 2、package com.ahu{* class HelloScala* }** 引⽤：import java.awt.Color* 如果想要引⼊包中的⼏个成员，可以⽤selector（选取器）:* import java.awt.{Color,Font}* // 重命名成员* import java.util.{HashMap => JavaHashMap}* // 隐藏成员默认情况下，Scala 总会引⼊ ng._ 、 scala._ 和 Predef._，所以在使⽤时都是省去scala.的* import java.util.{HashMap => _, _} //引⼊了util包所有成员，但HashMap被隐藏了*/2、Scala的数据类型Scala 与 Java有着相同的数据类型，下表列出了 Scala ⽀持的数据类型：数据类型描述Byte8位有符号补码整数。

Scala运算符[toc]## Scala运算符> 运算符是⼀种特殊的符号，⽤以表⽰数据的运算、赋值和⽐较等。

>> 1. 算术运算符> 2. 赋值运算符> 3. ⽐较运算符(关系运算符)> 4. 逻辑运算符> 5. `位运算符`### 1. 算术运算符> 1. 算术运算符(arithmetic)是对`数值类型的变量`进⾏运算的，在Scala程序中使⽤的⾮常多。

>> 2. 算术运算符⼀览图：>> >> 3. 案例演⽰算术运算符的使⽤`(Operator.scala)`：>> 1. `+, - , * , / , % 重点讲解 /、%`> 2. `+、-、* 是⼀个道理，完全可以类推。

`> 3. ==算数运算符的运算规则和Java⼀样。

==>> 4. 细节说明：>> 1. 对于除号“/”，它的整数除和⼩数除是有区别的：整数之间做除法时，只保留整数部分⽽舍弃⼩数部分。

`例如：var x : Int = 10/3 ,结果是3`> 2. 当对⼀个数取模时，可以等价 `a%b=a-a/b*b` ，这样我们可以看到取模的⼀个本质运算(==和java 的取模规则⼀样==)。

> 3. ==Scala中没有++、--操作符，需要通过+=、-=来实现同样的效果==。

~~~~scala/*** @Date 2021/3/22 20:05* @Version 10.21* @Author DuanChaojie*/object ArithoperDemo01 {def main(args: Array[String]): Unit = {/** / 号的使⽤* r1 = 3* r2 = 3.0* r3 = 3.3333333333333335* r3 = 3.33*/var r1: Int = 10 / 3println("r1 = " + r1)var r2: Double = 10 / 3println("r2 = " + r2)var r3: Double = 10.0 / 3println("r3 = " + r3)println("r3 = " + r3.formatted("%.2f"))/** %的使⽤* 1* -1* -1* 1*/println(10 % 3)println(-10 % 3)println(-10 % -3)println(10 % -3)/** ++ 和 --* 在scala中没有 ++ 和 --，⽽使⽤ +=1 和 -=1*/var num1 = 10// num1++ 错误num1 += 1num1 -= 1println(num1) //10}}~~~~#### 课堂练习> 1. 假如还有97天放假，问：xx个星期零xx天> 2. 定义⼀个变量保存华⽒温度，华⽒温度转换摄⽒温度的公式为：5/9*(华⽒温度-100),请求出华⽒温度对应的摄⽒温度。

Scala语法笔记JAVA中，举例你S是⼀个字符串，那么s(i)就是该字符串的第i个字符(s.charAt(i)).Scala中使⽤apply的⽅法JAVA与C++的?:操作符等同于Scala的if ( x > 0) 1 else -1x>0 ? 1: -1 //JAVA或C++在Scala中，每个表达式都有⼀个类型，如下:if ( x > 0) "positive" else -1其中⼀个分⽀是ng.String ⽽另⼀个分⽀是Int,他们的公共超类型是Any使⽤如下会报错:if(x > 0) 1 else if( x == 0) 0 else -1改为if(x > 0){ 1 }else if (x== 0) 0 else -1⾼级for 循环可以使⽤变量<- 表达式的形式提供多个⽣成器，⽤分号将其隔开如果for循环的循环体以yield开始，则循环会构造出⼀个结合，每次迭代⽣成集合中的⼀值:每个⽣成器都⾃带⼀个守卫，以if开头的Boolean表达式可以任意多的定义，引⼊可以在循环中使⽤变量定义函数：Scala⼀般不需要声明返回值类型，会⾃⼰推断,但使⽤递归的时候必须指定返回类型:默认参数和带名参数(什么⿁，Java的思想被颠覆)过程，Scala对于不返回值的函数有特殊的表⽰语法，如果函数体包含在花括号中但没有前⾯的=号，那么返回类型就是Unit 或def box(s : String) : Unit = { ...} 显⽰声明Unit返回类型数组:声明⼀个空的数组缓冲，⽤+=在尾端添加元素，⽤()⽽不是⽤{} 移除⽤trimEnd也可在任意位置插⼊或移除元素其中remove⽅法第⼆个参数为要删除多少个遍历数组使⽤的是until ，它属于RichInt类的⽅法，返回所有⼩于（但不包括）上限的数字。

常⽤算法使⽤sum⽅法，元素类型必须是数值类型，要么是整型，要么是浮点型或者integer,decimalsorted⽅法将数组或数组缓冲排序并返回经过排序的数组或数组缓冲val b = ArrayBuffer(1, 7, 2, 9)val bSorted = b.sorted(_ < _)如果要显⽰数组或数组缓冲的内容，可以⽤mkString⽅法，它允许你指定元素之间的分隔符。

scala定义集合的方法Scala是一种基于Java虚拟机的多范式编程语言，拥有函数式编程、面向对象编程等多种编程范式。

在Scala中，集合是一项重要的特性，可以大大提高程序的灵活性和可读性。

本文将围绕Scala定义集合的方法展开，为读者提供详细的步骤和实例。

1. 什么是集合在Scala中，集合指的是一组相同类型的元素，这些元素可以通过一些特定的方法进行遍历、增删改查等操作。

Scala集合可以被分为两大类：可变集合和不可变集合。

其中，可变集合的内容可以被修改，而不可变集合的内容一旦确定就无法被修改。

2. 如何创建集合Scala中的集合可以通过以下方式进行创建：（1）使用Array创建使用Array创建集合时，需要指定元素类型和长度。

例如，下面的代码创建了一个长度为3，元素类型为Int的集合：val arr = Array(1, 2, 3)（2）使用List创建使用List创建集合时，可以使用::符号将元素添加到集合中。

例如，下面的代码创建了一个包含1、2、3三个元素的集合：val list = 1 :: 2 :: 3 :: Nil（3）使用Set创建使用Set创建集合时，集合中的元素不允许重复，可以使用+运算符将元素添加到集合中。

例如，下面的代码创建了一个包含1、2、3三个元素的集合：val set = Set(1, 2, 3)set + 4（4）使用Map创建使用Map创建集合时，需要指定键值对。

可以使用+运算符将键值对添加到集合中。

例如，下面的代码创建了一个包含三个键值对的Map集合：val map = Map("key1" -> "value1", "key2" -> "value2", "key3" -> "value3")map + ("key4" -> "value4")3. 如何操作集合Scala中，集合的操作方法非常丰富，可以满足不同需求的操作。

Scala进阶之路-Scala的基本语法 Scala进阶之路-Scala的基本语法 作者：尹正杰版权声明：原创作品，谢绝转载！否则将追究法律责任。

⼀.函数式编程初体验Spark-Shell之WordCountvar arr=Array("hello","yinzhengjie","hello","world","yinzhengjie","big","data") //声明⼀个数组arr.map((_,1)).groupBy(_._1).mapValues(_.length).toList.sortBy(-_._2) //使⽤Spark进⾏单词个数统计并进⾏降序 使⽤CMD窗⼝操作如下：⼆.变量定义以及条件表达式1>.数据类型介绍 答：Scala 和Java 相似，有7 种数值类型Byte、Char、Short、Int、Long、Float 和Double（⽆包装类型）和Boolean、Unit 类型.注意:Unit 表⽰⽆值，和其他语⾔中void 等同。

⽤作不返回任何结果的⽅法的结果类型。

Unit只有⼀个实例值，写成()。

下图展⽰了Scala中的整体类层级图，其中Any位于最顶端，Nothing位于最底端。

2>.变量定义1/*2@author :yinzhengjie3Blog:/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/4EMAIL:y1053419035@5*/6package .yinzhengjie.basicGrammar78 object DefiningVariable {9 def main(args: Array[String]): Unit = {10/**11 * 变量的定义可以⽤关键字var和val修饰12 * var修饰的变量值可以更改13 * val修饰的变量值不可⽤改变，相当于Java中final修饰的变量14 * 定义变量格式如下 :15 * ⽅式⼀ : var | val 变量名称 : 类型 = 值16 * ⽅式⼆ : var | val 变量名称 = 值17 *18*/19 val name:String = "尹正杰"20 var age:Int = 2621 val blog = "/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/"22// 输出我们上⾯定义的变量23 println ("姓名 :" + name , "年龄 :" + age , "博客地址 :" + blog )2425/**26 * Unit数据类型相当于Java中void关键字，但是在scala它的表⽰形式是⼀对括号，即"()"。

Scala是一门多范式的编程语言，设计初衷是为了实现可伸缩的语言，并集成面向
对象编程和函数式编程的各种特性。

它是一种纯粹的面向对象语言，因为每个值都是一个对象。

对象的类型和行为由类和特征描述。

类可以通过子类化和使用灵活的
基于mixin的组合机制作为多继承的干净替代来扩展。

Scala是Scalable Language的简写，由Martin Odersky于2001年基于Funnel的工作开始设计。

Funnel是把函数式编程思想和Petri网相结合的一种编程语言。

Odersky先前的工作是Generic Java和javac（Sun Java编译器）。

如需了解更多关于Scala的信息，建议查阅Scala的官网或咨询专业技术人员。

scala的多种集合的使⽤（2）之集合常⽤⽅法⼀、常⽤的集合⽅法1.可遍历集合的常⽤⽅法下表列出了Traverable在所有集合常⽤的⽅法。

接下来的符号：c代表⼀个集合f代表⼀个函数p代表⼀个谓词n代表⼀个数字op代表⼀个简单的操作(通常是⼀个简单的函数)2.可变的集合⽅法下表⾥的是可变集合常⽤的操作符：3.不可变的集合⽅法注意不可变集合不可被修改，所以在第⼀⾏的每个表达式的结果必须赋给⼀个新变量。

操作符描述c1 ++ c2把c2集合的元素附加到c1⾥创造⼀个新的集合scala> val c1 = Vector(1,2,3,4,5)c1: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5)scala> val c2 = Vector(6,7,8)c2: scala.collection.immutable.Vector[Int] = Vector(6, 7, 8)scala> c1 ++ c2res35: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5, 6, 7, 8)操作符描述c :+ e 返回把元素e附加到集合c的新集合scala> val v1 = Vector(1,2,3,4,5)c1: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5)scala> val e = 10e: Int = 10scala> v1 :+ eres38: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5, 10)操作符描述e +: c2返回⼀个把元素e前插到集合c的新集合scala> val v1 = Vector(1,2,3,4,5)c1: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5) scala> val e = 10e: Int = 10scala> e +: v1res39: scala.collection.immutable.Vector[Int] = Vector(10, 1, 2, 3, 4, 5)操作符描述e :: list返回⼀个把e前插到名为list列表的集合(::只在List集合上⽤) scala> val list = List(7,8,9)list: List[Int] = List(7, 8, 9)scala> val e = 10e: Int = 10scala> e :: listres75: List[Int] = List(10, 7, 8, 9)操作符描述c drop n把c2集合的元素附加到c1⾥创造⼀个新的集合scala> val v1 = Vector(1,2,3,4,5)v1: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5) scala> val n = 3n: Int = 3scala> v1 drop nres1: scala.collection.immutable.Vector[Int] = Vector(4, 5)操作符描述c1 take n把集合的前两个元素列出来scala> val c1 = Vector(1,2,3,4,5)c1: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5) scala> c1 take 2res82: scala.collection.immutable.Vector[Int] = Vector(1, 2)4.可变和不可变的map的常⽤⽅法m代表⼀个不可变mapmm代表⼀个可变的mapk代表⼀个键v代表⼀个值p代表⼀个谓词c代表⼀个集合如果是var修饰，引⽤可变，⽀持读写。

Spark记录-Scala基础语法如果您熟悉Java语⾔语法和编程，那么学习Scala将会很容易。

Scala和Java之间最⼤的句法差异在于⾏结束字符的分号(;) 是可选的。

当编写Scala程序时，它可以被定义为通过调⽤彼此的⽅法进⾏通信的对象的集合。

现在我们简单地看⼀下类，对象，⽅法和实例变量的含义。

对象 - 对象有状态和⾏为。

⼀个对象是类的⼀个实例。

例如 - 狗有状态：颜⾊，名称，品种，它⾏为有：摇摆，吠叫和吃东西。

类 - 可以将类定义为描述与该类相关的⾏为/状态的模板/蓝图。

⽅法 - ⼀个⽅法基本上是⼀种⾏为。

⼀个类可以包含很多⽅法。

将逻辑代码写⼊的⽅法中，数据在⽅法中操纵并且执⾏所有的动作。

字段 - 每个对象都有其唯⼀的⼀组实例变量，称为字段。

对象的状态是由分配给这些字段的值来创建的。

闭包 - 闭包是⼀个函数，其返回值取决于在此函数之外声明的⼀个或多个变量的值。

特征 - 特征(Traits)封装了⽅法和字段定义，然后可以通过将它们混合到类中来重⽤它们，特征(Traits)⽤于通过指定⽀持的⽅法的签名来定义对象类型。

我们可以通过两种模式执⾏Scala程序：交互模式---命令⾏模式脚本模式---编程模式基础语法以下是Scala编程中的基本语法和编码约定。

区分⼤⼩写 - Scala是区分⼤⼩写的，⽐如标识符Hello和hello在Scala中表⽰不同的含义(对象)。

类名称 - 对于所有类名，第⼀个字母应为⼤写。

如果使⽤多个单词来形成类的名称，则每个内部单词的第⼀个字母应该是⼤写。

⽰例 - class MyFirstScalaClass，class Employee*类等。

⽅法名称 - 所有⽅法名称应以⼩写字母开头。

如果使⽤多个单词形成⽅法的名称，则每个内部单词的第⼀个字母应为⼤写。

⽰例 - def myMethodName()，def getName()等。

程序⽂件名 - 程序⽂件的名称应与对象名称完全匹配。

Scala语⾔Scala中函数是⼀等公民，可以不依赖对象直接创建函数，Scala将函数式编程和⾯向对象编程融合在⼀起。

Scala中将对象属性和对象⽅法与类属性和类⽅法进⾏了分离，Scala中的对象相关属性和⽅法通过 class 关键字定义在对象域中，⽽类相关的属性和⽅法通过 object 关键字定义在伴⽣对象中（Scala中没有 static 关键字，伴⽣对象编译后会⽣成原始对象的class⽂件（类名.class）和伴⽣对象的class⽂件（类名$.class）笔记语法中的”<xxx>“ 代表⽤户必填项，”[xxx]“ 代表选填项⼀、基本语法声明变量：var|val <变量名> [: 变量类型] = [变量值]Scala中分号可不写 val代表不可变量，编译后加上 final 修饰特殊类说明型Unit等同于 voidNull引⽤类型，但只有⼀个null实例Nothing在Scala继承链最底层，是任何类的⼦类，利⽤多态在我们确定⼀个函数不会正常返回的时候，可以将返回值（异常）返回给其他变量（因为是⼦类）Scala中值类型转换向下转型直接赋值向上转型在值上调⽤ toXxx（如：toDouble、toInt）强制转换函数Scala中不⽀持三⽬运算符（即：<布尔表达式>?<语句1>:<语句2>），全部使⽤ if-else ⽅式实现 Scala中也没有 switch 语句，⽽是使⽤match-case 匹配模式实现Scala中for循环控制// 打印1到3，闭区间for(i<- 1 to 3){print(i);}// 打印1到3，前闭后开for(i<- 1 unit 3){print(i)}// 直接遍历集合val list = List("h",1,2.2);for(item<-list){println(item)}// 循环守卫（也称条件判断式），判断为true进⼊循环，false则跳过循环for(i<- 1 to 3 if i!=2){println(i);}// 循环返回值，对循环中处理的结果返回到⼀个新的Vector集合中var res = for(i<- 1 to 3 )yield i// 控制步长，打印1到10 步长为2for(i <- Range(1,10,2)){println(i)}⼆、函数式编程基础在Scala中函数也被当做⼀种数据类型，可以作为⽅法的参数传递，Scala中将没有返回值的函数/⽅法也称为过程在类中定义⽅法：def <函数名> ([数名称:参数类型]....)[:返回值类型[=]]{ [语句...] [return 返回值] }直接定义函数：val func ([数名称:参数类型]....)[:返回值类型] =>{ [语句...] [return 返回值] }将对象的⽅法转换为独⽴的函数：val func = obj.func _;1. 形参为空可以省略()2. def <函数名> ([数名称:参数类型]....)={...} 表⽰返回值类型不确定（最后⼀条语句不能带 return 关键字），运⾏时类型推导完成，语句可以返回多种类型3. def <函数名> ([数名称:参数类型]....):<返回值类型>{...} 表⽰返回值类型在编译期就确定，语句中只能返回⼀种类型4. def <函数名> ([数名称:参数类型]....){...} 表⽰没有返回值（即等价于返回值Unit），即使语句中有return也不⽣效，这种函数也叫过程5. 如果没有return语句，默认语句的最后⼀⾏结果作为返回值6. 如果写了语句最后写了return关键字，则返回值类型就不能省略，函数返回不能⾃⾏推导7. 形参列表和返回值的数据类型可以是值类型和引⽤类型8. 在Scala中声明函数/⽅法形参列表时，可以指定默认值可变参数写法def <函数名> (){[语句...]}惰性函数在将函数返回值赋值给其他变量时候，将这个变量声明为lazy，则该函数不会⽴即执⾏，只会在取值的时候才会计算，这种函数叫惰性函数lazy可以修饰val变量，但不能修饰var变量。

Scala详解分号表⽰语句的结束；如果⼀⾏只有⼀条语句时，可以省略，多条时，需要分隔⼀般⼀⾏结束时，表⽰表达式结束，除⾮推断该表达式未结束：// 末尾的等号表明下⼀⾏还有未结束的代码.def equalsign(s: String)=println("equalsign: " + s)// 末尾的花括号表明下⼀⾏还有未结束的代码.def equalsign2(s: String) = {println("equalsign2: " + s)}//末尾的逗号、句号和操作符都可以表明，下⼀⾏还有未结束的代码.def commas(s1: String,s2: String) = Console.println("comma: " + s1 +", " + s2)多个表达式在同⼀⾏时，需要使⽤分号分隔常量定义的引⽤不可变，不能再指向别的对象，相当于Java中的finalScala中⼀切皆对象，所以，定义⼀切都是引⽤（包括定义的基本类型变量，实质上是对象）val定义的引⽤不可变，指不能再指向其他变量，但指向的内容是可以变的：val定义的常量必须要初始化val的特性能并发或分布式编程很有好处变量定义的引⽤可以再次改变（内容就更可以修改了），但定义时也需要初始化在Java中有原⽣类型（基础类型），即char、byte、short、int、long、float、double和boolean，这些都有相应的Scala类型（没有基本类型，但好⽐Java中相应的包装类型），Scala编译成字节码时将这些类型尽可能地转为Java中的原⽣类型，使你可以得到原⽣类型的运⾏效率⽤val和var声明变量时必须初始化，但这两个关键字均可以⽤在构造函数的参数中，这时变量是该类的⼀个属性，因此显然不必在声明时进⾏初始化。

此时如果⽤val声明，该属性是不可变的；如果⽤var声明，则该属性是可变的：class Person(val name: String, var age: Int)即姓名不可变，但年龄是变化的val p = new Person("Dean Wampler", 29)var和val关键字只标识引⽤本⾝是否可以指向另⼀个不同的对象，它们并未表明其所引⽤的对象内容是否可变定义时可以省略类型，会根据值来推导出类型scala> var str = "hello"str: String = helloscala> var int = 1int: Int = 1定义时也可明确指定类型：scala> var str2:String = "2"str2: String = 2以前传统Java都是指令式编程风格，如果代码根本就没有var，即仅含有val，那它或许是函数式编程风格，因此向函数式风格转变的⽅式之⼀，多使⽤val，尝试不⽤任何var编程指令式编程风格：def printArgs(args: Array[String]): Unit = {var i = 0while (i<args.length) {println(args(i))i += 1}}函数式编程风格：def printArgs(args: Array[String]): Unit = {for (arg <- args)println(arg)}或者：def printArgs(args: Array[String]): Unit = {//如果函数字⾯量只有⼀⾏语句并且只带⼀个参数，//则么甚⾄连指代参数都不需要args.foreach(println)}1.3Range数据范围、序列⽀持Range的类型包括Int、Long、Float、Double、Char、BigInt和BigDecimalRange可以包含区间上限，也可以不包含区间上限；步长默认为1，也可以指定⼀个⾮1的步长：函数是⼀种具有返回值（包括空Unit类型）的⽅法函数体中最后⼀条语句即为返回值。