大数据——Scala入门_scala输出等腰三角形

Scala简介

Scala源自Java

• Scala构建在JVM之上
• Scala与Java兼容、互通
  

Scala的优势

• 多范式编程：面向对象编程、函数式编程
• 表达能力强，代码精简
  

大数据与Scala

• Spark采用Scala语言设计

   提供的API更加优雅
   基于JVM的语言更融入Hadoop生态圈
  1
  2

安装Scala编译器和开发环境

Scala编译器安装和开发环境安装

Scala交互式编程（REPL）

Scala初体验

• 编写HelloWorld

object HelloWorld {
  def main(args: Array[String]): Unit = {
  var a = "HelloWorld"
    println(a)
  }
}
//def：定义一个方法
//Unit：代表没有返回值
1
2
3
4
5
6
7
8

• 结果展示：
  

Scala概述

面向对象特性

• 每个值都是对象
• 对象的数据类型和行为由类（Class）和特征（Trait，类似于interface）描述
• 利用特征实现混入式多重继承

函数式编程

• 每个函数都是一个值
• 支持高阶函数、柯里化（currying）、样例化（case class）及模式匹配…

Scala是静态类型语言

扩展性：隐式类、字符串插值

Scala变量与常量

变量

• 赋值后可以改变，生命周期中可以被多次赋值

var 变量名称:类型=xxx
//一般无需显示指定类型，Scala编译器会自动推断出类型
1
2

常量

• 赋值后不可变，类似于Java中的final变量

val 常量名称:类型=xxx
1

定义多行字符串用三个双引号来表示分隔符，格式为：""" … “”"

var a ="""
我爱学习，
我爱Java，
我爱Scala
"""
1
2
3
4
5

使用类型别名定义变量

type关键字

type 类型别名=类型
var 变量名称:类型别名=xxx
val 常量名称:类型别名=xxx
1
2
3

Scala关键字列表

Scala数据类型

Scala与Java有着相同的原始数据类型

Scala数据类型层次结构

• Any：所有类型的超类（顶级类型）
• AnyVal：表示值类型的超类
• AnyRef：表示引用类型的超类，对应java.lang.Object
• Unit：表示无值，类似Java中void
• Nothing：所有类型的子类
• Null：表示null或空引用
  
  null是Null类型的唯一实例；nothing没有实例

字符串插值

s插值器：允许将变量引用、表达式直接插入字面字符中

val nam="James"
println(s"Hello,Sname")
//Hello,James
println(s"1+1=${1+1}")
//1+1=2
1
2
3
4
5

f值插值器

val height=1.9d
val name="James"
println(f"$name%s is $height%2.2f meters tall")
//%s：后面连接的字符串可以不加空格
//%2.2f：第一个2代表数值>=2不做变化，数值<2用空格补足,相差几就补足几个空格；第二个2代表保留两位小数
1
2
3
4
5

raw插值器

s"a\nb"			//将输出换行符
raw"a\nb"		//输出原始字符
1
2

Scala条件控制

if语句

val x=10
if(x>0){
	print("x大于0")
}
1
2
3
4

Scala中换行等同于分号，所以分号可以省略

示例

object test {
  def main(args: Array[String]): Unit = {
    val x=10
    if(x>0){
      print("x大于0")
    }
  }
}
1
2
3
4
5
6
7
8

输出结果：

if…else语句

val x=10
if(x>10){
	print("x大于10")	
}else{
	print("x小于等于10")
}
1
2
3
4
5
6

示例

object test {
  def main(args: Array[String]): Unit = {
    val x=10
    if(x>10){
      print("x大于10")
    }else{
      print("x小于等于10")
    }
  }
}
1
2
3
4
5
6
7
8
9
10

结果展示：

if…else if…else语句

val x=10
if(x>10){
    print("x大于10")
}else if(x==10){
    print("x等于10")
}else{print("x小于10")
}
1
2
3
4
5
6
7

示例

object test {
  def main(args: Array[String]): Unit = {
    val x=10
    if(x>10){
      print("x大于10")
    }else if(x==10){
      print("x等于10")
    }else{print("x小于10")
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11

结果展示：

条件语句返回值

Scala任何表达式都有返回值

val x=10
val y=if(x==10) x+1 else x	//单行表达式可以省略{}
//y=?
1
2
3

示例

object test {
  def main(args: Array[String]): Unit = {
    val x=10
    val y=if(x==10) x+1 else x	//单行表达式可以省略{}
    println(y)
  }
}
1
2
3
4
5
6
7

结果展示：

代码块“{…}”也是表达式，返回值为最后一个表达式结果

val x=10
val y={
   print("我是代码块")
   x+1
}
//y=11
1
2
3
4
5
6

val x=10
val y={
    x+1;print("我是代码块")
}
//多个表达式使用“;”分隔
//y=?
1
2
3
4
5
6

Scala循环控制

while循环

var num: Int = 0;
while ( num < 100 ) {
    println( num );
    num = num + 1;
}
1
2
3
4
5

示例

object test {
  def main(args: Array[String]): Unit = {
    var num: Int = 0;
    while ( num < 100 ) {
      println( num );
      num = num + 1;
    }
  }
}
1
2
3
4
5
6
7
8
9

输出结果：

do…while

var num: Int = 0;
do {
    println( num ); 
     num = num + 5;
} while ( num < 200 )
1
2
3
4
5

示例

object test {
  def main(args: Array[String]): Unit = {
    var num: Int = 0;
    do {
      println( num );
      num = num + 5;
    } while ( num < 200 )
  }
}
1
2
3
4
5
6
7
8
9

结果展示：

for循环

val num:Int = 10;
for ( i: Int <- 1 to num ) 
{     
    println( i * 100 );
}
1
2
3
4
5

for { i: Int <- 1 until 100 }
{
    val y = 2*i;
    println( y );
}
1
2
3
4
5

"i to j"或者"i until j"均表示创建一个区间Range
区别：to表示=这个数字；until表示<这个数字

示例

object test {
  def main(args: Array[String]): Unit = {
    val num:Int = 10;
    for ( i: Int <- 1 to num )
    {
      println( i * 100 );
    }
  }
}
1
2
3
4
5
6
7
8
9

结果展示：

object test {
  def main(args: Array[String]): Unit = {
    for { i: Int <- 1 until 100 }
    {
      val y = 2*i;
      println( y );
    }
  }
}
1
2
3
4
5
6
7
8
9

结果展示：

打印直角在左下的直角三角形

object test {
  def main(args: Array[String]): Unit = {
    //打印直角在左下的直角三角形
    for(i<-1 to 5) {
      for(j<-1 to i) {
        print("*")
      }
      println()
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11

结果展示：

打印直角在左上的直角三角形

object test {
  def main(args: Array[String]): Unit = {
    //打印直角在左上的直角三角形
    for(i<-5 to 1 by -1) {
      for(j<-i to 1 by -1) {
        print("*")
      }
      println()
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11

结果展示：

打印直角在右下的直角三角形

object test {
  def main(args: Array[String]): Unit = {
    //打印直角在右下的直角三角形
    for(i<-1 to 5 ) {
      for(j<-1 to 5-i ) {
        print(" ")
      }
      for(j<-1 to i){
      print("*")
      }
      println()
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

结果展示：

打印直角在右上的直角三角形

object test {
  def main(args: Array[String]): Unit = {
    //打印直角在右下的直角三角形
    for(i<-1 to 5  ) {
      for(j<-1 to i-1 ) {
        print(" ")
      }
      for(j<-1 to 6-i){
      print("*")
      }
      println()
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

结果展示：

打印等腰三角形

object test {
  def main(args: Array[String]): Unit = {
    //打印等腰三角形
    for(i<-1 to 5){
      for (j<-1 to 5-i) {
        print(" ")
      }
     for(j<-1 to 2*i-1){
print("*")
     }
      println()
    }

  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

结果展示：

打印空心等腰三角形

object test {
  def main(args: Array[String]): Unit = {
  //外循环决定行，内循环决定列 共5行 固 i为1-5
    for(i<-1 to 5) {
    //空格数从 4-0 固 5-i
      for(j<-1 to 5-i) {
        print(" ")
      }
      //*的数量 为 1 3 5 7 固 2*i-1
      for(j<-1 to 2*i-1) {
      //空心 顾名思义 只留最边的*号
        if(j==1 || j==2*i-1 ||i==5){
          print("*")
        }else{
          print(" ")
        }
      }
      //后续空白 有无无所谓 同第一个内循环
      for(1<-1 to 5-i){
        print(" ")
      }
      println()
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

结果展示：

九九乘法表

object test {
  def main(args: Array[String]): Unit = {
    for(i<-1 until 10) {
      for(j<-1 to i) {
        print(i+"*"+j+"="+(i*j)+"\t")
      }
      println()
    }
  }
}
1
2
3
4
5
6
7
8
9
10

结果展示：

中断

import.scala.util.control.Breaks._
val num:Int = 10;
for ( i: Int <- 1 to num by 2 ) {
    if(i>=5) break; 
    println( i * 100 );
}
1
2
3
4
5
6

by表示步长

import scala.util.control.Breaks
    var num=10
    val loop=new Breaks
    loop.breakable(
      for(x<-num to 1 by -1) {
        if(x<3)loop.break
        println(x)
      }
    )
1
2
3
4
5
6
7
8
9

示例

object test {
  def main(args: Array[String]): Unit = {
    import scala.util.control.Breaks._
    var num=10
    breakable{
      for(x<-num to 1 by -1) {
        if(x<3)break
        println(x)
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12

结果展示：

for循环过滤

val num:Int = 10;
for ( i: Int <- 1 to num; if i%2==0;if i>5 ) //多个条件时使用分号(;)
{     
    println( i * 100 );
}
1
2
3
4
5

for循环返回值

for循环中的yield会把元素记下来，保存在集合中，循环结束后将返回该集合。也称for推导式

val num:Int = 10;
var retVal=for ( i: Int <- 1 to num; if i%2==0;if i>5 ) yield i;	//for循环使用yield将具有返回值
for(a<-retVal){
    println(a);
}
//输出6 8 10
1
2
3
4
5
6

示例

var i=100
    val resValue = for (x <- 1 to i; if x % 2 == 0; if x % 5 == 0) yield x
    println(resValue)
    for(i<-resValue) {
      println(i)
    }
1
2
3
4
5
6

结果展示：

使用Scala编程输出如图所示加法表

object test {
  def main(args: Array[String]): Unit = {
    for(i<-0 to 6 by 1) {
      println(s"$i+${6-i}=6")
    }
  }
}
1
2
3
4
5
6
7

结果展示：

Scala数组

存储固定大小的元素
数组索引从0开始

//数组创建方式一
var a1:Array[String] = new Array[String](3)	//泛型使用方括号
a1(0)="Jason"	//数组元素访问使用圆括号
a1(1)="Marie"
a1(2)="Jimmy"

//数组创建方式二
var a2=Array("Jason","Marie","Jimmy")	//调用Array的伴生对象中的apple()返回Array实例

//数据创建方式三：区间数组
var a3=Array.range(1,10,2)
1
2
3
4
5
6
7
8
9
10
11

Scala元组

可以包含不同类型的元素
最多支持22个元素（Tuple1~Tuple22）
使用下划线“_”访问元素，“_1”表示第一个元素

//元组声明方式一
var tp1 = ("Mike", "123 ABC street", 58)
println(tp1._1)
println(tp1._2)
println(tp1._3)

//迭代元组
tp1.productIterator.foreach{ i =>println("Value = " + i )}

//元组声明方式二
var tp2 = new Tuple3("Mike", "123 ABC street", 58)

//元组声明方式三
def mike = "Mike" -> 5

//输出scala.Tuple2
mike.getClass

//将元组元素依次赋给三个变量
val(name, address, age) = tp1
println(name)
println(address)
println(age)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

输出结果：

Scala集合（一）

Seq

• 序列，元素按顺序排序

Set

• 集合，元素不重复

Map

• 映射，键值对集合
  

Scala集合（二）

不可变集合

• scala.collection.immutable，默认Scala选择不可变集合

可变结合：可以修改、添加或移除一个集合的元素

• scala.collection.mutable

var a=scala.collection.mutable.ListBuffer(1,2,3)
a(1)=1
a
var b=List(1,2,3)
b.getClass
b.drop(1)
a
b
1
2
3
4
5
6
7
8

Scala集合（三）

Scala.collection.immutable

Set：ListSet、HashSet、TreeSet
Map：ListMap、HashMap、TreeMap
Seq：Vector、String、Range、List、Stack、Stream、Queue
1
2
3

Scala集合（四）

scala.collection.mutable

Scala集合（五）

常用集合

Scala List常用操作

var c = List[Char]('a', 'b', 'c')
var x = 'x' +: c    // (x, a, b, c)
var y = c :+ 'x'   // (a, b, c, x)
import scala.collection.mutable._
var lb = ListBuffer[Int](1, 2, 3, 4)
lb += 100    //1, 2, 3, 4, 100
lb += (21, 33)//    
88 +=: lb   //88, 1, 2, 3, 4, 100, 21, 33
List(77, 66) ++=: lb     
1
2
3
4
5
6
7
8
9

var l = List[Int](2, 3, 4, 6, 8, 9, 11, 20)
var x = l grouped 3   //等价l.grouped(3)
x.next()    //(2, 3, 4)
x.next()   //(6, 8, 9) 
var y = l sliding 2
y.next()  // (2, 3)
y.next()  // (3, 4)
1
2
3
4
5
6
7

var a1 = Array[Int](1, 2, 3, 4)
var a2 = Array[Int](100, 200, 300, 400)
var a = List.concat(a1, a2)//Array->List
a3=a1++a2  //Arrays->Array
a(3) = 333    //Error
a3(3)=333    //OK
var b = Array(333, "333", '3', false )
var c = List.concat(a, b)  
val x = a.filter( _ %2 != 0 )
val y = a.reverse 
var m = a.groupBy(t => t%2 == 0)
var n = a.slice(2, 4)
a.sorted   //1, 2, 3, 4, 100, 200, 300, 400
a.sorted( Ordering.Int.reverse )
a.sortWith( _ > _ )
a.sortBy( x => x )   //升序
a.sortBy( x => x*(-1) )   //降序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Scala Set常用操作

var s = Set("ab", "yz")
s += "mn"    //mn, ab, yz
s += "mn"    //??
s -= "yz"       //mn, ab
var t = Set("ab", "gh", "mn", "st", "yz" )
t -- s       //gh, st, yz   
t ++ s    //ab, gh, mn, st, ya

var os = SortedSet(1, 99, 66, 54, 77 )
os  //1, 54, 66, 77, 99
os += 33
os  //1, 33, 54, 66, 7
1
2
3
4
5
6
7
8
9
10
11
12

var s = Set("ab", "yz")
var t = Set("ab", "gh", "mn", "st", "yz" )
//求交集
t & s       
t intersect s
//求并集
t | s
t union s
//求差集
t &~ s
t diff s
1
2
3
4
5
6
7
8
9
10
11

Scala Map常用操作

var m = Map[String, Int]("a"->1, "b"->2, "c"->3, "d"->4, "e"->5, "f"->6, "g"->7, "h"->8, "i"->9)
m("a")        //1
m += ("j"->0)
m += ("j"->0)   //??
m += ("j"->11)   //??
var n = m ++ Map[String, Int]("a"->3, "j"->99)    //??
n -= ("g", "e")
1
2
3
4
5
6
7

Scala Stream & Vector

Stream是List惰性版（需要的时候再去调用）

val stream = (1 to 1000).toStream
stream     // Stream(1, ?)
stream.head // 1
stream.tail  // Stream(2, ?)
stream(3)
stream.tail  // Stream(2,3,4,?)
1
2
3
4
5
6

Vector拥有连续的内存空间，利于随机存取（直接访问）

val v = Vector.empty :+ 2 :+ 2
val v1 = v ++ Vector[Int](3)
v.length
v1.length
1
2
3
4