（一）Scala语言——入门

最新推荐文章于 2023-09-17 11:33:10 发布
最新推荐文章于 2023-09-17 11:33:10 发布
阅读量4.2k 收藏 60
点赞数 7
分类专栏： Scala 文章标签： Scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fseast/article/details/100511272
版权

目录

一、Scala 入门

1. 概述

1.1 为什么学习Scala
  1. Spark——新一代内存级大数据 计算框架，是大数据的重要内容。
  2. Spark就是使用Scala编写的。因此为了更好的学习Spark, 需要掌握Scala这门语言。
    总而言之，我是为了学习Spark而学习Scala的。
1.2 Scala 发展历史

  联邦理工学院的马丁·奥德斯基（Martin Odersky）于2001年开始设计Scala。

1.3 Scala 和 Java 关系

  一般来说，学Scala的人，都会Java，而Scala是基于Java的，因此我们需要将Scala和Java以及JVM 之间的关系搞清楚，否则学习Scala你会蒙圈。

1.4 Scala 语言特点

  Scala 是一门 以Java虚拟机（JVM）为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言。
  1）Scala是一门多范式的编程语言，Scala支持面向对象和函数式编程。
  2）Scala源代码（.scala）会被编译成Java字节码（.class），然后运行于JVM之上，并可以调用现有的Java类库，实现两种语言的无缝对接。
  3）Scala单作为一门语言来看，非常的简洁高效。
  4）Scala在设计时，马丁·奥德斯基是参考了Java的设计思想，可以说Scala是源于Java，同时马丁·奥德斯基也加入了自己的思想，将函数式编程语言的特点融合到JAVA中, 因此，对于学习过Java的同学，只要在学习Scala的过程中，搞清楚Scala和Java相同点和不同点，就可以快速的掌握Scala这门语言。

2. Scala 环境搭建

  1. 安装步骤
    （1）首先确保jdk1.8安装成功
    （2）下载对应的Scala安装文件scala-2.11.8.zip
    （3）解压scala-2.11.8.zip，我这里解压到E:\02_software
    （4）配置Scala的环境变量

  2. 测试

3. Scala 插件安装

默认情况下IDEA 不支持 Scala 的开发，需要安装 Scala 插件。

3.1 插件在线安装

先找到安装插件位置点击file->setting

3.2 离线安装

除了可以在线安装还可以选择离线安装，当然还是推荐在线安装的好一点。


然后选择在官网下载好的插件即可。

4. HelloWorld 案例

4.1 IDEA环境创建

1）步骤1：file->new project -> 选择Maven

2）步骤2：添加包名和项目名称
在这里插入图片描述
3）步骤3：指定项目工作目录空间

4）为了方便管理，创建项目的源文件目录。点击Directory，写一个名字（比如scala），新建一个写Scala的目录。然后点击该目录右键——>Mark Directory as ——> Sorce Root


说明：右键main目录->创建一个diretory -> 写个名字（比如scala）->右键scala目录->mark directory ->选择source root即可。

5）步骤5：默认下，maven不支持Scala的开发，需要引入Scala框架。
右键项目点击-> add framework support… ，在下图选择Scala，然后点击create…选择你的安装目录。
在这里插入图片描述
6）步骤6：在scala包下，创建包com.fseast.scala001包名，然后右键，new -> Scala Class，命名为HelloWorld，并创建Object。

在这里插入图片描述
7）步骤7：编写输出Hello scala案例
在类中中输入main，然后回车可以快速生成main方法。

package com.fseast.scala001

object HelloWorld {
  def main(args: Array[String]): Unit = {
    System.out.println("hello world")
    println("hello")
  }

}

运行后，就可以看到输出。

8）Scala程序基本结构

class Hello {

  /*
  定义变量：
  val/var 变量名:变量类型 = 变量值
  */
  val a: Int = 1

  /*
  定义方法：
  def 函数名(参数名:参数类型):返回值类型={方法体}
  */
  def hello(arg: String): Unit = {
    println(arg)
  }
}
4.2 Scala程序反编译

1）object在底层会生成两个类 Hello , Hello$
2）Hello中有个main函数，调用 Hello$ 类的一个静态对象 MODULES$
3）Hello$.MODULE$. 对象时静态的，通过该对象调用Hello$的main函数
4）可以理解我们在main中写的代码在放在Hello$的main，在底层执行Scala编译器做了一个包装
下面我们说明一下Scala程序的执行流程：
1. hello 源代码

object Hello {
def main(args: Array[String]): Unit = {
		  //4. 可以理解我们在main中写的代码在放在Hello$的main,在底层执行scala编译器做了一个包装
        println("hello,scala")
    }
}

2. Hello.class类

//package com.atguigu.chapter01

//1. object在底层会生成两个类 Hello , Hello$
//2. Hello中有个main函数，调用 Hello$ 类的一个静态对象 MODULES$
public final class Hello
{
    public static void main(String[] paramArrayOfString)
    {
        Hello$.MODULE$.main(paramArrayOfString);
    }
}

2. Hello$.class类

public final class Hello$
{
    public static final  MODULE$;

    static
    {
    	  new ();
    }

    public void main(String[] args)
    {
		  //3. Hello$.MODULE$. 对象是静态的，通过该对象调用Hello$的main函数
    	  Predef..MODULE$.println("hello,scala");
    }

    private Hello$()
    {
    	  MODULE$ = this;
    }
}

说明：
（1）Scala中如果使用object关键字声明类，在编译时，会同时生成两个类：当前类，当前类$
（2）使用当前类$的目的在于模拟静态语法，可以通过类名直接访问方法。
（3）Scala将当前类$这个对象称之为“伴生对象”，伴随着类所产生的对象，这个对象中的方法可以直接使用。

4.3 开发注意事项

1）Scala源文件以“.scala" 为扩展名。
2）Scala程序的执行入口是object 中的main()函数。
3）Scala语言严格区分大小写。
4）Scala方法由一条条语句构成，每个语句后不需要分号（Scala语言会在每行后自动加分号）。（至简原则）
5）如果在同一行有多条语句，除了最后一条语句不需要分号，其它语句需要分号。

5. 关联Scala源码

在使用Scala过程中，为了搞清楚Scala底层的机制，需要查看源码，下面看看如何关联和查看Scala的源码包。
1）查看源码，选择要查看的方法或者类，输入ctrl + b
当我们没关联源码时，看到如下图像：
在这里插入图片描述

2）关联源码
步骤1：将源码包拷贝到C:\software\scala-2.11.8文件夹下scala-sources-2.12.4
步骤2：关联即可，选中这个文件夹，进行关联，最后，可以看到源码
在这里插入图片描述

6. 官方编程指南

查看scala-docs-2.11.8文档，可以获得Scala的API操作。
官方地址：https://docs.scala-lang.org/#

二、变量和数据类型

1. 注释

用于注解说明解释程序的文字就是注释，注释提高了代码的阅读性。
注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。
1）基本语法

（1）单行注释：//
（2）多行注释：/* */
（3）文档注释：/**
	*
    */

2）代码规范
（1）使用一次tab操作，实现缩进，默认整体向右边移动，用shift+tab整体向左移
（2）或者使用ctrl + alt + L来进行格式化
（3）运算符两边习惯性各加一个空格。比如：2 + 4 * 5。
（4）一行最长不超过80个字符，超过的请使用换行展示，尽量保持格式优雅

  1. 标识符的命名规范
    Scala对各种变量、方法、函数等命名时使用的字符序列称为标识符。即：凡是自己可以起名字的地方都叫标识符。
    1）命名规则
    Scala中的标识符声明，基本和Java是一致的，但是细节上会有所变化，有以下四种规则：
    （1）以字母或者下划线开头，后接字母、数字、下划线
    （2）以操作符开头，且只包含操作符（+ - * / # !等）
    （3）第一种和第二种拼接，第一种在前，二者以下划线分隔
    （4）用反引号`…`包括的任意字符串，即使是关键字（39个）也可以

2）Scala 关键字（39个）
• package, import, class, object, trait, extends, with, type, for
• private, protected, abstract, sealed, final, implicit, lazy, override
• try, catch, finally, throw
• if, else, match, case, do, while, for, return, yield
• def, val, var
• this, super
• new
• true, false, null

3. 变量和常量

var 变量
val 常量
1）基本语法
var | val 变量名 [: 变量类型] = 变量值

var  a:Int = 19		//变量
val   b:Int = 20		//常量

说明：在Scala中声明一个变量时，可以不指定类型，编译器根据值确定
大部分情况下用的都是常量。能用常量的地方不用变量。

2）案例实操
（1）声明变量时，类型可以省略（编译器自动推导，即类型推导）
（2）类型确定后，就不能修改，说明Scala是强数据类型语言。
（3）变量声明时，需要初始值

package com.fseast.scala001

object TestVar {
  def main(args: Array[String]): Unit = {
    //（1）声明变量时，类型可以省略（编译器自动推导，即类型推导）
    var age = 18
    age = 30

    //（2）类型确定后，就不能修改，说明Scala是强数据类型语言。
    //    age = "tom" // 错误

    //（3）变量声明时，需要初始值
    //    var name //错误
  }
}

（4）在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改。

object TestVar {

    def main(args: Array[String]): Unit = {

        var num1 = 10   // 可变
        val num2 = 20   // 不可变

        num1 = 30  // 正确
        //num2 = 100  //错误，因为num2是val修饰的
    }
}

（5）val修饰的变量在编译后，等同于加上final通过反编译看下底层代码

object TestVar {
    var num1 = 10   // 可变
    val num2 = 20   // 不可变

    def main(args: Array[String]): Unit = {
        num1 = 30  // 正确
        //num2 = 100  //错误，因为num2是val修饰的
    }
}

（6）var修饰的对象引用可以改变，val修饰的则不可改变，但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）

object TestVar {

    def main(args: Array[String]): Unit = {

        // p1是var修饰的，p1的属性可以变，而且p1本身也可以变
        var p1 = new Person()
        p1.name = "dalian"
        p1 = null

        // p2是val修饰的，则p2的属性可以变，但是p2本身不可变（即p2的内存地址不能变）
        val p2 = new Person()
        p2.name="xiaolian"
//        p2 = null // 错误的，因为p2是val修饰的
    }
}

class Person{
    var name : String = "jinlian"
}

4. 字符串输出

1）基本语法
（1）字符串，通过+号连接
（2）printf用法：字符串，通过%传值。
（3）字符串，通过$引用

package com.fseast.scala001

object TestCharType {
  def main(args: Array[String]): Unit = {
    var name:String = "fseast"
    var age:Int = 22
    
    //（1）字符串，通过+号连接
    println(name + " " + age)

    //（2）printf用法字符串，通过%传值。
    printf("name=%s age=%d\n",name,age)

    //（3）字符串，通过$引用
    println(s"name=$name age=$age")
    
    println(
      s"""
        |name=${name}
        |age=${age}
      """.stripMargin
    )
  }
}

5. 键盘输入

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。
1）基本语法
StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()
2）案例实操
需求：可以从控制台接收用户信息【姓名，年龄，薪水】。

package com.fseast.scala001

import scala.io.StdIn

object TestInput {
  def main(args: Array[String]): Unit = {
    
    //1. 输入姓名
    val name = StdIn.readLine("input name:")

    //2. 输入年龄
    val age = StdIn.readLine("input age:")

    //3. 输入薪水
    val sal = StdIn.readLine("input sal")
    
    //把输入内容打印出来
    println("name:" + name)
    println("age:" + age)
    println("sal:" + sal)
  }
}

6. 数据类型关系

在这里插入图片描述
Scala数据类型关系总结
 1）Scala中一切数据都是对象，都是Any的子类。
 2）Scala中数据类型分为两大类：数值类型（AnyVal）、引用类型（AnyRef），不管是值类型还是引用类型都是对象。
 3）Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）
 4） Scala特殊的类型之Null，它只有一个实例就是Null，它是所有引用类型（AnyRef）的子类。
 5）Scala特殊类型之Nothing，是所有数据类型的子类，主要在一个函数没有正常返回值使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。

7. 整数类型（Byte、Short、Int、Long）

Scala的整数类型就是用于存放整数值的，比如12，30，3456等等。
1）整型分类

数据类型描述
Byte [1]8位有符号补码整数。数值区间为 -128 到 127
Short [2]16位有符号补码整数。数值区间为 -32768 到 32767
Int [4]32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long [8]64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807 = 2的(64-1)次方-1
  1. Scala各整数类型有固定的表数范围和字段长度，不受具体操作的影响，以保证Scala程序的可移植性。
object TestDataType {

    def main(args: Array[String]): Unit = {

        // 正确
        var n1:Byte = 127
        var n2:Byte = -128

        // 错误
        // var n3:Byte = 128
        // var n4:Byte = -129
    }
}
  1. Scala的整型，默认为Int型，声明Long型，须后加‘l’或‘L’
object TestDataType {

    def main(args: Array[String]): Unit = {

        var n5 = 10
        println(n5)

        var n6 = 9223372036854775807L
        println(n6)
    }
}
  1. Scala程序中变量常声明为Int型，除非不足以表示大数，才使用Long

8. 浮点类型（Float、Double）

Scala的浮点类型可以表示一个小数，比如123.4f，7.8，0.12等等。

  1. 浮点型分类
数据类型描述
Float [4]32 位, IEEE 754标准的单精度浮点数
Double [8]64 位 IEEE 754标准的双精度浮点数
  1. Scala的浮点型常量默认为Double型，声明Float型常量，须后加‘f’或‘F’。
object TestDataType {

    def main(args: Array[String]): Unit = {

        // 建议，在开发中需要高精度小数时，请选择Double
        var n7 = 2.2345678912f
        var n8 = 2.2345678912

        println("n7=" + n7)
        println("n8=" + n8)
    }
}

运行结果：

n7=2.2345679
n8=2.2345678912

9. 字符类型（Char）

1) 基本说明
  字符类型可以表示单个字符，字符类型是Char，16位无符号Unicode字符（2个字节），区间值为U+0000到U+FFFF。

2） 案例实操
（1）字符常量是用单引号 ’ ’ 括起来的单个字符。
（2）可以直接给Char赋一个整数，然后输出时，会按照对应的unicode字符输出

object TestCharType {

    def main(args: Array[String]): Unit = {

        //（1）字符常量是用单引号 ' ' 括起来的单个字符。
        var c1: Char = 'a'

        println("c1=" + c1)

        //（2）可以直接给Char赋一个整数，然后输出时，会按照对应的unicode字符输出
        println("c1码值=" + c1.toInt)
    }
}

（3）Char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码。

object TestCharType {

    def main(args: Array[String]): Unit = {

        var c2: Char = 98 // 正确，因为直接将一个数值给char，编译器只判断是否越界
        var c3: Char = 'a' + 1 // 错误，Int高->char低，编译器判断类型

        var c4: Char = ('a' + 1).toChar
    }
}

（4）\t ：一个制表位，实现对齐的功能
（5）\n ：换行符
（6）\ ：表示
（7）" ：表示"

object TestCharType {

    def main(args: Array[String]): Unit = {
        //（4）\t ：一个制表位，实现对齐的功能
        println("姓名\t年龄")
        
        //（5）\n ：换行符
        println("西门庆\n潘金莲")
        
        //（6）\\ ：表示\
        println("c:\\岛国\\avi")
        
        //（7）\" ：表示"
        println("同学们都说：\"大海哥最帅\"")
    }
}

10. 布尔类型：Boolean

1）基本说明
（1）布尔类型也叫Boolean类型，Booolean类型数据只允许取值true和false
（2）boolean类型占1个字节。

2）案例实操

object TestBooleanType {

    def main(args: Array[String]): Unit = {
        
        var isResult : Boolean = false
        var isResult2 : Boolean = true
    }
}

11. Unit 类型、Null类型和 Noting类型

1）基本说明

数据类型描述
Unit表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Nullnull , Null 类型只有一个实例值null
NothingNothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。当一个函数，我们确定没有正常的返回值，可以用Nothing来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性）

2）实操案例
（1）Null类只有一个实例对象，Null类似于Java中的null引用。Null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）

object TestDataType {

    def main(args: Array[String]): Unit = {

        //null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）
        var n1: Int = null // 错误
        println("n1:" + n1)

        var cat = new Cat();
        cat = null	// 正确
    }
}

class Cat {

}

（2）Unit类型用来标识过程，也就是没有明确返回值的函数。
  由此可见，Unit类似于Java里的void。Unit只有一个实例——( )，这个实例也没有实质意义

object TestSpecialType {

    def main(args: Array[String]): Unit = {

        def sayOk : Unit = {// unit表示没有返回值，即void
            println("say ok")
        }
        sayOk
    }
}

（3）Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于Nothing是其他任意类型的子类，他还能跟要求返回值的方法兼容。

object TestSpecialType {

    def main(args: Array[String]): Unit = {

        def test() : Nothing={
            throw new Exception()
        }
        test
    }
}

12. 数值类型转换

12.1 数值类型自动转换

  当Scala程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换（隐式转换）。数据类型按精度（容量）大小排序为：
在这里插入图片描述

1）基本说明
（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。
（2）当我们把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
（3）（byte，short）和char之间不会相互自动转换。
（4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。

2）案例实操

object TestValueTransfer {

    def main(args: Array[String]): Unit = {

        //（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数值类型，然后再进行计算。
        var n = 1 + 2.0
        println(n)  // n 就是Double

        //（2）当我们把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
        var n2 : Long = 1L
        //var n3 : Int = n2 //错误，原因不能把高精度的数据直接赋值和低精度。

        //（3）（byte，short）和char之间不会相互自动转换。
        var n4 : Byte = 1
        //var c1 : Char = n4  //错误

        //（4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。
        var n5 : Byte = 1
        var c2 : Char = 1
        // var n : Short = n5 + c2 //当n5 + c2 结果类型就是int
        // var n6 : Short = 10 + 90 //错误
        var n7 : Short = 100 //正确
    }
}
12.2 强制类型转换

1）基本说明
  自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。使用时要加上强制转函数，但可能造成精度降低或溢出，格外要注意。

java  :  int num = (int)2.5
scala :  var num : Int = 2.7.toInt

2）案例实操
（1）当进行数据的从大——>小，就需要使用到强制转换
（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

object TestForceTransfer {

    def main(args: Array[String]): Unit = {

        //（1）当进行数据的从大——>小，就需要使用到强制转换
        var n1: Int = 2.5.toInt // 这个存在精度损失
        
        //（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
        var r1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt  // 10 *3 + 6*1 = 36
        var r2: Int = (10 * 3.5 + 6 * 1.5).toInt  // 44.0.toInt = 44

        println("r1=" + r1 + " r2=" + r2)
    }
}

（3）Char类型可以保存Int的常量值，但不能保存Int的变量值，需要强转
（4）Byte和Short类型在进行运算时，当做Int类型处理。

object TestForceTransfer {

    def main(args: Array[String]): Unit = {

        //（3）Char类型可以保存Int的常量值，但不能保存Int的变量值，需要强转
        var c2: Char = 98 // 正确，因为直接将一个数值给char，编译器只判断是否越界
        var c3: Char = 'a' + 1 // 错误，Int高->char低，编译器判断类型
        var c4: Char = ('a' + 1).toChar


        //（4）Byte和Short类型在进行运算时，当做Int类型处理。
        var a : Short = 5
        // a = a-2 // 错误， Int->Short

        var b : Byte = 3
        // b = b + 4 // 错误，Int->Byte
    }
}

13. 数值类型和 String 类型间转换

1）基本说明
  在程序开发中，我们经常需要将基本数值类型转成String类型。或者将String类型转成基本数值类型。
2）案例实操
（1）基本类型转String类型（语法：将基本类型的值+"" 即可）
（2）String类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）

object TestStringTransfer {

    def main(args: Array[String]): Unit = {

        //（1）基本类型转String类型（语法：将基本类型的值+"" 即可）
        var str1 : String = true + ""
        var str2 : String = 4.5 + ""
        var str3 : String = 100 +""

        //（2）String类型转基本数值类型（语法：调用相关API）
        var s1 : String = "12"

        var n1 : Byte = s1.toByte
        var n2 : Short = s1.toShort
        var n3 : Int = s1.toInt
        var n4 : Long = s1.toLong
    }
}

（3）注意事项
  在将String类型转成基本数值类型时，要确保String类型能够转成有效的数据，比如我们可以把"123"，转成一个整数，但是不能把"hello"转成一个整数。

三、运算符

  运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

1. 算术运算符

1）基本语法

运算符运算范例结果
+正号+33
-负号b=4; -b-4
+加5+510
-减6-42
*乘3*412
/除5/51
%取模(取余)7%52
+字符串相加“He”+”llo”“Hello”

（1）对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
（2）对一个数取模a%b，和Java的取模规则一样。
2）案例实操

object TestArithmetic {

    def main(args: Array[String]): Unit = {

        //（1）对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
        var r1: Int = 10 / 3 // 3
        println("r1=" + r1)

        var r2: Double = 10 / 3 // 3.0
        println("r2=" + r2)

        var r3: Double = 10.0 / 3 // 3.3333
        println("r3=" + r3)
        println("r3=" + r3.formatted("%.2f")) // 含义：保留小数点2位，使用四舍五入

        //（2）对一个数取模a%b，和Java的取模规则一样。
        var r4 = 10 % 3 // 1
        println("r4=" + r4)
    }
}

2. 关系运算符（比较运算符）

1）基本语法

运算符运算范例结果
==相等于4==3false
!=不等于4！=3true
<小于4<3false
>大于4>3true
<=小于等于4<=3false
>=大于等于4>=3true

2）案例实操

object TestRelation {

    def main(args: Array[String]): Unit = {

        // 测试：>、>=、<=、<、==、!=
        var a: Int = 2
        var b: Int = 1

        println(a > b)      // true
        println(a >= b)     // true
        println(a <= b)     // false
        println(a < b)      // false
        println("a==b" + (a == b))    // false
        println(a != b)     // true
    }
}

3. 逻辑运算符

1）基本语法
  用于连接多个条件（一般来讲就是关系表达式），最终的结果也是一个Boolean值。

  假定：变量A为true，B为false

运算符描述实例
&&逻辑与(A && B) 运算结果为 false
||逻辑或(A || B) 运算结果为 true
!逻辑非!(A && B) 运算结果为 true

2）案例实操

object TestLogic {
    def main(args: Array[String]): Unit = {

        // 测试：&&、||、!
        var a = true
        var b = false

        println("a&&b=" + (a && b))     // a&&b=false
        println("a||b=" + (a || b))     // a||b=true
        println("!(a&&b)=" + (!(a && b))) // !(a&&b)=true
    }
}

4. 赋值运算符

1）基本语法
  赋值运算符就是将某个运算后的值，赋给指定的变量。

运算符描述实例
=简单的赋值运算符，将一个表达式的值赋给一个左值C = A + B 将 A + B 表达式结果赋值给 C
+=相加后再赋值C += A 等于 C = C + A
-=相减后再赋值C -= A 等于 C = C - A
*=相乘后再赋值C *= A 等于 C = C * A
/=相除后再赋值C /= A 等于 C = C / A
%=求余后再赋值C %= A 等于 C = C % A
<<=左移后赋值C <<= 2 等于 C = C << 2
>>=右移后赋值C >>= 2 等于 C = C >> 2
&=按位与后赋值C &= 2 等于 C = C & 2
^=按位异或后赋值C ^= 2 等于 C = C ^ 2
|=按位或后赋值C |= 2 等于 C = C | 2

注意：Scala中没有++、–操作符，需要通过+=、-=来实现同样的效果
2）案例实操

object TestAssignment {
    
    def main(args: Array[String]): Unit = {
        
        var r1 = 10
        
        r1 += 1 // 没有++
        r1 -= 2 // 没有--
    }
}

5. 位运算符

1）基本语法

运算符描述实例
&按位与运算符(a & b) 输出结果 12 ，二进制解释： 0000 1100
|按位或运算符(a | b) 输出结果 61 ，二进制解释： 0011 1101
^按位异或运算符(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~按位取反运算符(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<左移动运算符a << 2 输出结果 240 ，二进制解释： 1111 0000
>>右移动运算符a >> 2 输出结果 15 ，二进制解释： 0000 1111
>>>无符号右移A >>>2 输出结果 15, 二进制解释: 0000 1111

2）案例实操

object TestPosition {

    def main(args: Array[String]): Unit = {

        // 测试：1000 << 1 =>10000
        var n1 :Int =8

        n1 = n1 << 1
        println(n1)
    }
}

四、流程控制

1. 分支控制if-else

让程序有选择的的执行，分支控制有三种：单分支、双分支、多分支

1.1 单分支

1）基本语法

if  (条件表达式)  {
	执行代码块
}

  说明：当条件表达式为ture时，就会执行{ }的代码。

2）案例实操
  需求：输入人的年龄，如果该同志的年龄大于18岁，则输出“age > 18”

object TestIfElse {
    def main(args: Array[String]): Unit = {
        
        println("input age:")
        var age = StdIn.readShort()

        if (age > 18){
            println("age>18")
        }
    }
}
1.2 双分支

1）基本语法

if (条件表达式) {
	执行代码块1
} else {
执行代码块2
}

2）案例实操
  需求：输入年龄，如果年龄大于18岁，则输出“age >18”。否则，输出“age <= 18”。

object TestIfElse {
    def main(args: Array[String]): Unit = {

        println("input age:")
        var age = StdIn.readShort()

        if (age > 18){
            println("age>18")
        }else{
            println("age<=18")
        }
    }
}
1.3 多分支

1）基本语法

if (条件表达式1) {
	执行代码块1
}
else if (条件表达式2) {
	执行代码块2
}
   ……
else {
	执行代码块n
}

2）案例实操
  （1）需求：岳小鹏参加Scala考试，他和父亲岳不群达成承诺：如果，成绩为100分时，奖励一辆BM；成绩为(80，99]时，奖励一台iphone；其它时，什么奖励也没有。

object TestIfElse {
    
    def main(args: Array[String]): Unit = {

        println("请输入成绩")
        val grade = StdIn.readInt()

        if (grade == 100){
            println("成绩为100分，奖励一辆BM")
        }else if (grade > 80 && grade <= 90){
            println("奖励一台iphone")
        }else{
            println("什么奖励也没有")
        }
    }
}

  （2）需求：Scala中if else表达式其实是有返回值的，具体返回值取决于满足条件的代码体的最后一行内容。

object TestIfElse {

    def main(args: Array[String]): Unit = {

        println("input your age")
        var age = StdIn.readInt()

        var res = if(age > 18){
            "您以成人"
        }else{
            "小孩子一个"
        }

        println(res)
    }
}

（3）注意：
如果大括号{}内的逻辑代码只有一行，大括号可以省略。
Scala中是没有三元运算符，因为可以这样简写

object TestIfElse {

    def main(args: Array[String]): Unit = {

        // Java
//        int result = flag?1:0

        // Scala
        var flag:Boolean = true
        var result = if(flag) 1 else 0
        println(result)
    }
}

2. 嵌套分支

  在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层。分支外面的分支结构称为外层分支。嵌套分支不要超过3层。
1）基本语法

if(){
        	if(){
       		}else{
        	}	
}

2）案例实操
  参加百米运动会，根据性别提示进入男子组或女子组。如果是女子组，用时8秒以内进入决赛，否则提示淘汰。

object TestIfElse {

    def main(args: Array[String]): Unit = {

        println("输入性别：")
        var gender = StdIn.readChar()

        if (gender == '男'){
            println("男子组")
        }else{
            println("女子组")
            
            println("输入成绩：")
            var grade = StdIn.readDouble()

            if (grade > 8.0){
                println("你被淘汰了")
            }else{
                println("成功晋级")
            }
        }
    }
}

3. For 循环控制

  Scala也为for循环这一常见的控制结构提供了非常多的特性，这些for循环的特性被称为for推导式或for表达式。

3.1 范围数据循环方式1

1）基本语法

for(i <- 1 to 3){
  print(i + " ")
}
println()

（1）i 表示循环的变量，<- 规定to
（2）i 将会从 1-3 循环，前后闭合
2）案例实操
需求：输出10句“Hello”

object TestFor {

    def main(args: Array[String]): Unit = {

        for(i <- 1 to 10){
            println("Hello"+i)
        }
    }
}
3.2 范围数据循环方式2

1）基本语法

for(i <- 1 until 3) {
  print(i + " ")
}
println()

（1）这种方式和前面的区别在于i是从1到3-1
（2）即使前闭合后开的范围

2）案例实操
需求：输出10句 “Hello”

object TestFor {

    def main(args: Array[String]): Unit = {

        for(i <- 1 until 10+1){
            println("Hello"+i)
        }
    }
}
3.3 循环守卫

1）基本语法

for(i <- 1 to 3 if i != 2) {
  print(i + " ")
}
println()

说明：
  （1）循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue。
  （2）上面的代码等价

for (i <- 1 to 3){
	if (i != 2) {
		print(i + "")
	}
}

2）案例实操
需求：输出1到10中，不等于5的值

object TestFor {

    def main(args: Array[String]): Unit = {

        for (i <- 1 to 10 if i != 5) {
            println(i + "")
        }
    }
}
3.4 循环步长

1）基本语法

for (i <- 1 to 10 by 2) {
      println("i=" + i)
    }

说明：by表示步长

2）案例实操
需求：输出1到10以内的所有奇数

for (i <- 1 to 10 by 2) {
println("i=" + i)
}

输出结果：

i=1
i=3
i=5
i=7
i=9
3.5 嵌套循环

1）基本语法

for(i <- 1 to 3; j <- 1 to 3) {
    println(" i =" + i + " j = " + j)
}

说明：没有关键字，所以范围后一定要加；来隔断逻辑

上面的代码等价于：

for (i <- 1 to 3) {
    for (j <- 1 to 3) {
        println("i =" + i + " j=" + j)
    }
}
3.6 引入变量

1）基本语法

for(i <- 1 to 3; j = 4 - i) {
    println("i=" + i + " j=" + j)
}

说明：
（1）for推导式一行中有多个表达式时，所以要加；来隔断逻辑
（2）for推导式有一个不成文的约定：当for推导式仅包含单一表达式时使用圆括号，当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号，如下

for {
    i <- 1 to 3
	j = 4 - i
} {
    println("i=" + i + " j=" + j)
}

2）案例实操
上面的代码等价于

for (i <- 1 to 3) {
    var j = 4 - i
    println("i=" + i + " j=" + j)
}
3.7 循环返回值

1）基本语法

val res = for(i <- 1 to 10) yield i
println(res)

说明：将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字
2）案例实操
  需求：将原数据中所有值乘以2，并把数据返回到一个新的集合中。

object TestFor {

    def main(args: Array[String]): Unit = {

        var res = for( i <-1 to 10 ) yield {
            i * 2
        }

        println(res)
    }
}

输出结果：
Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

5. While 循环控制

1）基本语法

循环变量初始化
while (循环条件) {
      循环体(语句)
      循环变量迭代
}

说明：
（1）循环条件是返回一个布尔值的表达式
（2）while循环是先判断再执行语句
（3）与if语句不同，while语句没有返回值，即整个while语句的结果是Unit类型()
（4）因为while中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，也就违背了函数式编程的重要思想（输入=>函数=>输出，不对外界造成影响），所以不推荐使用，而是推荐使用for循环。

2）案例实操
需求：输出10句 “Hello”

object TestWhile {
    
    def main(args: Array[String]): Unit = {

        var i = 0

        while (i < 10) {
            println("Hello" + i)
            i += 1
        }
    }
}

6. do…while循环控制

1）基本语法

  循环变量初始化;
   do{
       循环体(语句)
       循环变量迭代
   } while(循环条件)

说明：
（1）循环条件是返回一个布尔值的表达式
（2）do…while循环是先执行，再判断

2）案例实操
需求：输出10句 “Hello”

object TestWhile {

    def main(args: Array[String]): Unit = {

        var i = 0

        do {
            println("Hello" + i)
            i += 1
        } while (i < 10)
    }
}

7. 多重循环控制

1）基本说明
  （1）将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层】
  （2）实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
  （3）设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。
2）案例实操
需求：打印出九九乘法表

object TestWhile {

    def main(args: Array[String]): Unit = {

        var max = 9

        for (i <- 1 to max) {

            for (j <- 1 to i) {
                print(j + "*" + i + "=" + (i * j) + "\t")
            }

            println()
        }
    }
}

输出结果：
在这里插入图片描述

8. While 循环中断

1）基本说明
  Scala内置控制结构特地去掉了break和continue，是为了更好的适应函数式编程，推荐使用函数式的风格解决break和continue的功能，而不是一个关键字。scala中使用breakable控制结构来实现break和continue功能。
2）案例实操
  需求一：循环遍历10以内的所有数据，数值为5，结束循环（break）

import util.control.Breaks._

object TestBreak {

    def main(args: Array[String]): Unit = {

        var n = 1

        breakable {

            while (n < 10) {

                println("n=" + n)
                n += 1

                if (n == 5) {
                    break()
                }
            }
        }

        println("exit")
    }
}

需求二：循环遍历10以内的所有数据，奇数打印，偶数跳过（continue）

import util.control.Breaks._

object TestBreak {

    def main(args: Array[String]): Unit = {

        var n = 0

        while (n < 10) {

            breakable {

                n += 1

                if (n % 2 != 0) {
                    println(n)
                } else {
                    println("continue")
                    break()
                }
            }
        }
    }
}

3）注意事项
（1）break：breakable放在循环外
（2）continue：breakable放在循环内

下一篇：（二）Scala语言——函数式编程

fseast
关注
  • 7
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Scala编程语言从入门到精通
07-22
资源名称：Scala编程语言从入门到精通资源目录：【】DesignOfScala【】ExcitedScala_7(1)【】lift-lift_23_sbt-cf313e1【】ScalaTutorial-zh_CN【】Scala_2.7.6_API【】Scala向导(前13章)【】Scala向导（前15章）-p...
scala语言
浅谈
05-28 3434
Scala的特点、Scala数据类型、Scala类型转换、Scala运算符、Scala循环控制、Scala的函数式编程、Scala集合的相关操作、Scala面向对象的编程、Scala模式匹配、Scala隐式转换、Scala泛型、Scala正则匹配等等相关内容。基本涵盖了Scala的基本操作。
Scala语言入门
ks_1998的博客
03-21 3636
Scala语言入门
Scala编程语言
最新发布
IT小小白的博客
09-17 2203
Scala是一门多范式编程语法，所谓多范式指的就是多种编程风格的语法，Scala主要是一门面向对象编程语言和函数式编程语言。
scala语言介绍
程序员杂谈
02-20 9558
什么是Scala scala(Scalable Language)是一种多范式的编程语言，其设计的初衷是要集成面向对象编程和函数式编程的各种特性。 Scala运行于Java平台(java虚拟机上)，并兼容现有的Java程序。 面向对象(将对象当作参数传来传去) + 面向函数(方法，可以将函数当作参数传来传去) 为什么要学Scala 优雅：这是框架设计师第一要考虑的 速度快 Spark就是使用Scala编写的，因此为了更好的学习Spark，需要掌握Scala这门语言 =Spark的兴起，带动Scala语言的
大数据开发语言Scala（一）——scala入门
热门推荐
five小点心的博客
03-19 1万+
package： 包，等同于java中的packageobject：关键字，声明一个单例对象（伴生对象）main方法：从外部可以直接调用执行的方法def 方法名称( 参数名称 : 参数类型 ) : 返回值类型 = { 方法体 }Scala 完全面向对象，故scala去掉了Java中非面向对象的元素，如static关键字，void类型1) staticscala无static关键字,由object实现类似静态方法的功能(类名.方法名)
Scala—— 3.函数
01-07
可以这样理解：函数式编程把函数当作一等公民，充分利用函数、只是函数的多种使用方式，在Scala中，函数是一等公民，像变量一样，既可以作为函数的参数使用，也可以将函数赋值给一个变量，函数的创建不用依赖于类...
Scala—— 1.变量
01-07
Scala是一门以Java虚拟机...声明变量时，类型***可以省略(编译器自动推导， 即类型推导)， 类型确定后，就不能修改，说明Scala是强数据类型语言， 在声明/定义一个变量时，可以使用var或val来修饰，var修饰的变量可以
Scala—— 12.隐式转换
01-07
隐式转换函数是以implicit关键字声明的带有单个参数的函数，这种函数将会自动应用，将值从一种类型转换为另一种类型。 object boke_demo01 { def main(args: Array[String]): Unit = { //编写一个隐式函数转成 ...
Scala 语言
water drop的博客
02-16 2411
Scala 一、概述 ​ Scala用一种简洁的高级语言将 面向对象 和 函数式编程 结合在一起。 领域模型设计--------------面向对象开发设计的核心 数据集计算模型----------大数据开发的核心 ​ Scala是一门多范式的编程语言,同时支持面向对象和面向函数编程风格。它以一种优雅的方式解决现实问题。虽然它是强静态类型的编程语言，但是它强大的类型推断能力，使其看起来就像是...
大数据之Scala
大数据同盟会的博客
04-01 747
Scala是一种多范式的编程语言，具有面向对象和函数式特点，它运行在jvm平台上。 Scala的特点：优雅、开发速度快、能融合到Hadoop生态圈。
Scala语言基础
一米八多的瑞兹的博客
03-08 663
Scala语言基础 ✎ 学习目标 了解Scala的特点 掌握Scala和IDEA的下载安装 熟悉Scala面向对象的特性 掌握Scala的基础语法、数据结构、模式匹配与样例类 Spark是专为大规模数据处理而设计的快速通用的计算引擎，它是由Scala语言开发实现的，关于大数据技术，本身就是计算数据，而Scala既有面向对象组织项目工程的能力，又具备计算数据的功能，同时Spark和Scala的紧密集成，本书将采用Scala语言开发Spark程序，所以学好Scala将有助于我们更好的掌握Spark框架。 S
一文入门Scala(学习Spark必备)
MarcoLin
06-01 2207
本文主要介绍了Scala基本语法和Scala中函数式编程相关内容
Scala为什么是大数据第一高薪语言
qq_39581763的博客
05-07 3317
为什么是Scala 虽然在大数据领域Java的使用更普及，Python也有后来居上的势头，但Scala一直有着不可动摇的地位。我们熟悉的Spark，Kafka，Flink都是由Scala完成了其核心代码的开发。 所以掌握Scala不仅可以学习大数据组件的源码，而且会极大的提升大数据开发的效率。 这也是Scala的薪资水平一直遥遥领先的原因。 根据2019年全球编程语言薪资统计，排名前几...
Scala语言初入门
学习笔记
06-10 1万+
scala介绍 Scala语言来自于Scalable（可伸缩的）既可以写一些小的脚本，又可以写一写复杂的服务器端的程序。 Scala是一门纯正的面向对象语言，具有OO特征。 Scala是一门函数式语言，可以用函数式思想来编写代码 Scala是构建于JVM之上的，与java可以无缝互操作。 函数式编程思想函数式编程基本名词介绍纯函数来编写程序。 纯函数（Pure Function），或函数的纯粹性（P
一、Scala编程语言基础
Bananaaay的博客
11-17 902
Scala编程语言学习第一章，Scala基础
spark 读写hbase(scala)——2.批量操作
06-28
### 回答1： 批量操作是指一次性对多个数据进行操作，可以提高操作效率。在使用 Spark 读写 HBase 时，也可以使用批量操作来提高效率。具体实现方式如下： 1. 批量写入数据 使用 HBase 的 Put 类来创建要写入的数据，然后将 Put 对象添加到一个 List 中，最后使用 HBase 的 Table 类的 put 方法来批量写入数据。示例代码如下： ```scala val conf = HBaseConfiguration.create() val connection = ConnectionFactory.createConnection(conf) val table = connection.getTable(TableName.valueOf("table_name")) val puts = new ListBuffer[Put]() for (i <- 1 to 100) { val put = new Put(Bytes.toBytes(s"row_$i")) put.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("col"), Bytes.toBytes(s"value_$i")) puts += put } table.put(puts.toList.asJava) ``` 2. 批量读取数据 使用 HBase 的 Get 类来创建要读取的数据，然后将 Get 对象添加到一个 List 中，最后使用 HBase 的 Table 类的 get 方法来批量读取数据。示例代码如下： ```scala val conf = HBaseConfiguration.create() val connection = ConnectionFactory.createConnection(conf) val table = connection.getTable(TableName.valueOf("table_name")) val gets = new ListBuffer[Get]() for (i <- 1 to 100) { val get = new Get(Bytes.toBytes(s"row_$i")) get.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("col")) gets += get } val results = table.get(gets.toList.asJava) for (result <- results) { val row = Bytes.toString(result.getRow) val value = Bytes.toString(result.getValue(Bytes.toBytes("cf"), Bytes.toBytes("col"))) println(s"$row: $value") } ``` 以上就是使用 Scala 实现 Spark 读写 HBase 的批量操作的方法。 ### 回答2： 在实际的数据处理中，一次需要对多条数据进行读写操作，如果每次都进行单条的读写逐条操作会使程序效率非常低下。所以spark提供了批量操作API，可以对多条数据进行一次性的读写操作，极大地提高了程序的效率。 批量读操作： 批量读取数据的方式有两种：Get和Scan。 使用Get方式读取多条数据，需要将每条数据对应的Get对象添加到List集合当中，再将List集合转换为RDD对象进行操作。示例代码如下： ```scala val conf = HBaseConfiguration.create() conf.set(TableInputFormat.INPUT_TABLE, tableName) val gets = new util.ArrayList[Get]() gets.add(new Get(Bytes.toBytes("rowkey1"))) gets.add(new Get(Bytes.toBytes("rowkey2"))) gets.add(new Get(Bytes.toBytes("rowkey3"))) conf.set(TableInputFormat.SCAN, convertScanToString(new Scan())) val getRdd = sc.parallelize(gets) val hbaseRdd = getRdd.map((_, null)).hbaseBulkGet(conf, tableName, (result: Result) => { val kv: Array[Byte] = result.getValue(Bytes.toBytes(family), Bytes.toBytes(column)) Bytes.toString(kv) }) println(hbaseRdd.collect.toBuffer) ``` 使用Scan方式读取多条数据，需要将Scan对象作为参数传入，再将RDD对象转换为PairRDD并使用hbaseScan方法进行操作。示例代码如下： ```scala val conf = HBaseConfiguration.create() conf.set(TableInputFormat.INPUT_TABLE, tableName) val scan = new Scan(Bytes.toBytes("rowkey1"), Bytes.toBytes("rowkey3")) conf.set(TableInputFormat.SCAN, convertScanToString(scan)) val hbaseRdd = sc.hbaseScanRDD(conf).map((result: Result) => { val kv: Array[Byte] = result.getValue(Bytes.toBytes(family), Bytes.toBytes(column)) Bytes.toString(kv) }) println(hbaseRdd.collect.toBuffer) ``` 批量写操作： 批量写操作可以使用Put对象集合，将多条数据对应的Put对象添加到集合中，并将集合转换成RDD进行操作即可。示例代码如下： ```scala val conf = HBaseConfiguration.create() conf.set(TableOutputFormat.OUTPUT_TABLE, tableName) val puts = new util.ArrayList[Put]() puts.add(new Put(Bytes.toBytes("rowkey1")).addColumn(Bytes.toBytes(family), Bytes.toBytes(column), Bytes.toBytes("value1"))) puts.add(new Put(Bytes.toBytes("rowkey2")).addColumn(Bytes.toBytes(family), Bytes.toBytes(column), Bytes.toBytes("value2"))) puts.add(new Put(Bytes.toBytes("rowkey3")).addColumn(Bytes.toBytes(family), Bytes.toBytes(column), Bytes.toBytes("value3"))) val putRdd = sc.parallelize(puts) putRdd.hbaseBulkPut(conf, tableName) ``` 总结： 批量操作是Spark访问HBase的常见操作方式，在实际的实现过程中需要注意以下几点： 1、Get和Scan对象在HBase中读取数据的方式不一样，需要注意区分； 2、使用批量读操作可以大大提高程序效率，减少读写操作的时间消耗； 3、使用批量写操作需要合理规划写入的数据，避免出现数据冲突问题，影响程序的运行。 ### 回答3： 本篇文章将继续深入介绍如何使用Scala编码实现Spark读写操作HBase，具体涉及到HBase的批量操作。 一、Batch操作概述 在使用HBase进行数据处理的时候，我们常常需要对一个或多个表进行批量操作，批量操作即是针对 HBase的多行进行插入、删除等操作，以此来实现在HBase操作上的高效处理。HBase提供了很多批量操作API，比如 Put、Get、Delete、Scan，这些API都是可以批量操作的。 在Spark中，我们同样可以使用类似的API对HBase进行批量操作。本文将根据具体需求使用Spark实现HBase的批量操作。 二、批量操作的实现 Spark读写HBase时，使用RDD中的foreachPartition来对每个分区进行处理，在该函数内使用HBase API进行操作。关于批量操作，我们可以在每个分区中开启一个batch操作，将每个操作加入batch后，再提交即可。 例如，我们可以考虑实现一个批量put的功能，将RDD中的数据一批一批写入表中： ``` def insert(tableName: String, rdd: RDD[(String, String)]): Unit = { try{ rdd.foreachPartition({ iter => val conf = HBaseUtils.getHBaseConfiguration() conf.set(TableOutputFormat.OUTPUT_TABLE, tableName) val conn = ConnectionFactory.createConnection(conf) val table = conn.getTable(TableName.valueOf(tableName)) val puts = new java.util.ArrayList[Put]() iter.foreach { case (rowKey:String, value: String) => { // 构造put对象并append val put = new Put(Bytes.toBytes(rowKey)) put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(columnQualifier), Bytes.toBytes(value)) puts.add(put) if (puts.size() >= batchSize) { // 多条记录组成的put对象，使用put(List<Put>)一次性写入 table.put(puts) puts.clear() } } } // 如果puts还有内容，再写一次 if (puts.size() > 0) { table.put(puts) puts.clear() } table.close() conn.close() }) } catch { case e: Exception => e.printStackTrace() } } ``` 在该方法中，我们使用foreachPartition遍历RDD中的每个分区，然后通过Connection来获取HBase表实例。 之后定义了一个用于存放Put的List，当List的大小大于等于batchSize时，就将这个List中的所有put操作提交给HBase执行。 最后，释放资源，并为大家展示如何调用这个方法： ``` val rdd: RDD[(String, String)] = ... val tableName: String = ... insert(tableName, rdd) ``` 使用这种方式实现批量put，我们可以将一批数据提交到HBase执行，从而提升写入效率。当然，对于其他批量操作也可以应用类似的方式。 三、总结 本文根据实际需求，结合Spark和HBase的特点，实现了一些常用的批量操作，为大家提供了一个快速、高效的HBase操作方案。批量操作的好处是，可以将多条记录一次性操作，请求与写入等待时间都会得到缩短，获得更高的效率。感兴趣的同学可以试试，在实际开发中应该会受益匪浅！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值