一 数据类型

1

在 中，定制小程序开发费用字符串的类型实际上就是 Java中的 String类，定制小程序开发费用它本身是没有 String 类的。

在 Scala 中，String 定制小程序开发费用是一个不可变定制小程序开发费用的字符串对象，定制小程序开发费用所以该对象不可被修改。定制小程序开发费用这就意味着你如果修改定制小程序开发费用字符串就会产生一个新的字符串对象。

Scala中String定义如下：

type String        = java.lang.String
1

（1）定制小程序开发费用定制小程序开发费用字符串拼接

def main(args: Array[String]): Unit = {    //TODO 字符串拼接    //sql语句中不可以拼接 如select 'name' num from user    val name = "zhangsan"    println("Hello" + name)  }
1
2
3
4
5
6

在某些情况下，字符串的拼接不好用，比如JSON格式（JavaScript Object Notation），特殊标记的JavaScript对象。

定义一个JSON对象

var obj = {"username“:”zhangsan","age":30}var objs = [obj,obj.obj]alert(obj.username + obj.age)
1
2
3

JSON字符串：符合JSON格式的字符串。网络中传递的数据是JSON对象

（2）传值字符串

    val name = "zhangsan"    val password = "123321"    printf("username : %s\",name)    printf("password : %s",password)
1
2
3
4

使用的时候换行需要使用，不方便。

（3）插值字符串（推荐）

    val name = "zhangsan"    val password = "123321"    println(s"name : $name")    println(s"password : $password")
1
2
3
4

使用插值字符串定义一个JSON格式字符串

    val json = s"{\"username\":\"${name}\",\"password\":\"${password}\"}"    println(json)
1
2

以上两条语句出错误（官方无法使用插值字符串封装JSON），为了解决这个问题，有了（4）

（4）多行字符串

// 竖线表示顶格符号val s ="""  |Hello Scala  |""".stripMargin
1
2
3
4
5

改变顶格符号

    val s =  """  |Hello Scala  |""".stripMargin('@')    println(s)
1
2
3
4
5

使用多行字符串封装JSON字符串

    val json =      s"""        |{"username":"${name}","password":"${password}"}        |""".stripMargin    println(json)
1
2
3
4
5

使用多行字符串封装sql语句

val sql =      """        |select        |  id        |from        |  (        |  select * from t_user        |  where id = 1        |  order by id desc        |  ) a         |group by id         |""".stripMargin
1
2
3
4
5
6
7
8
9
10
11
12

2 输入输出

（1）输入

• 场景一：从控制台获得输入

      val line = StdIn.readLine()    println(line)
  1
  2

• 场景二：从文件中获取输入

  	// 数据源source    // 文件路径：    //    绝对路径（不可以改变的路径）    //        本地路径：file:///c:/test/test.txt    //        网络路径：http:///www.xxx.com    //    相对路径（可以改变的路径，一定存在一个基准路径），IDEA中的基准路径为项目的根路径（project）    //        ./  当前路径（基准路径的位置，而非当前文件所在的路径）可以省略    //        .// 当前路径的上一级路径（基准路径的上一级）    val source: BufferedSource = Source.fromFile("C:\\Users\\ASUS\\Desktop\\新建文本文档.txt")    val strings: Iterator[String] = source.getLines()    while(strings.hasNext){      println(strings.next())    }    source.close()
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

（2）输出

Scala进行文件写操作，用的都是 java中的I/O类

	//TODO IO    val writer = new PrintWriter(new File("C:\\Users\\ASUS\\Desktop\\test.txt" ))    writer.write("Hello Scala")    writer.close()
1
2
3
4

（3）网络

分布式计算中基本的架构方式：主从。

分布式计算中一定要切分数据。

分布式计算中计算方式不能固定。

（i）自定义客户端和服务器，传送简单的字节码。

client：

package com.hike.bigdata.scala.chapter02import java.io.OutputStreamimport java.net.Socketobject Scala05_Master {  def main(args: Array[String]): Unit = {    //TODO 连接服务器    val client = new Socket("localhost",9999)    val out: OutputStream = client.getOutputStream    out.write(1)    out.flush()    out.close()    println("客户端向服务器发送数据：1")    client.close()  }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

server：

package com.hike.bigdata.scala.chapter02import java.io.InputStreamimport java.net.ServerSocketobject Scala06_Slaver {  def main(args: Array[String]): Unit = {    //TODO 启动服务器    //端口号：唯一标识同一台机器上不同的服务    val server = new ServerSocket(9999)    println("服务器已经启动，等待客户端的连接...")    val client = server.accept()    val in: InputStream = client.getInputStream    val i: Int = in.read()    println("从客户端接受的数据为：" + i)    in.close()    client.close()    server.close()  }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

（ii）自定义客户端和服务器，传送一个类

user类

package com.hike.bigdata.scala.test;import java.io.Serializable;public class User implements Serializable {    public static int age;    static {        age = 30;        System.out.println("user static init...");    }    @Override    public String toString() {        return "User["+ age + "]";    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

client：

package com.hike.bigdata.scala.chapter02import java.io.{ObjectOutputStream, OutputStream}import java.net.Socketimport com.hike.bigdata.scala.test.Userobject Scala05_Master_Object {  def main(args: Array[String]): Unit = {    //TODO 连接服务器    val client = new Socket("localhost",9999)    val user = new User()    //对象输出流    val objOut = new ObjectOutputStream(client.getOutputStream)    objOut.writeObject(user)    objOut.flush()    objOut.close()    println("客户端向服务器发送数据：1")    client.close()  }}
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

server：

package com.hike.bigdata.scala.chapter02import java.io.{InputStream, ObjectInputStream}import java.net.ServerSocketobject Scala06_Slaver_Object {  def main(args: Array[String]): Unit = {    //TODO 启动服务器    //端口号：唯一标识同一台机器上不同的服务    val server = new ServerSocket(9999)    println("服务器已经启动，等待客户端的连接...")    val client = server.accept()    val objIn = new ObjectInputStream(client.getInputStream)    val user = objIn.readObject()    println("从客户端接受的数据为：" + user)    objIn.close()    client.close()    server.close()  }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

java中的序列化：

java将内存中的对象存储到磁盘文件中，要求对象必须实现可序列化接口

在网络中想要传递对象，这个对象需要序列化。

3 数据类型

类型约束外部的数据，泛型约束的是内部的数据。

（1）java数据类型

Java的数据类型包含基本类型和引用类型

• 基本类型：byte,short,char,int,long,float,double,boolean
• 引用类型：Object，数组，字符串，包装类，集合，POJO对象等

（2）scala数据类型

Scala是完全面向对象的语言，所以不存在基本数据类型的概念，有的只是任意值对象类型（AnyVal）和任意引用对象类型(AnyRef)，下图十分重要，建议背下来。

（a）AnyVal示例

object Scala07_DataType {  def main(args: Array[String]): Unit = {    //TODO 数据类型    //任意值类型    val b : Byte = 20    val s : Short = 20    val c : Char = 'a'    val i : Int = 20;    val l : Long = 20    val f : Float = 20F    val d : Double = 20    val flg : Boolean = true    val u : Unit = test() //Unit是一个类型，这个类型只有一个对象，打印结果为一个小括号  }  def test(): Unit = {  }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

（b）AnyRef示例

object Scala07_DataType_1 {  def main(args: Array[String]): Unit = {    //TODO 数据类型    val list : AnyRef = List(1,2,3,4)    val list1 = List(1,2,3,4)    val obj : AnyRef = new User()    val obj1 : AnyRef = Scala07_DataType_1    println(list)    println(obj)    println(obj1)  }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

（c）scala中的null

object Scala07_DataType_2 {  def main(args: Array[String]): Unit = {    //TODO 数据类型        // User user = new User()    // User user = null    // val i : Int = null    // Null在scala中是一个类型，只有一个对象，就是null    val n = null    val user : User = null    // val i : Int = null 是错误的  }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

（d）scala中的

object Scala07_DataType_3 {  def main(args: Array[String]): Unit = {    //TODO 数据类型        // Object obj = new User()    // obj = new Emp()    // 将字符串转换成整形    var i : Any = "123"    i = 1  }}
1
2
3
4
5
6
7
8
9
10
11
12

（e）Nothing

java中方法的出口有两个，一个是正常返回，一个是异常，nothing是一个特殊的处理方案，将方法正常的返回和异常的返回做了统一。

object Scala07_DataType_4 {  def main(args: Array[String]): Unit = {    //TODO 数据类型    // java中方法的出口有两个，一个是正常返回，一个是异常  }  def test() : Nothing = {    throw new Exception()  }}
1
2
3
4
5
6
7
8
9
10
11

4 类型转换

（1）隐式转换

java中的基本数据类型没有类型的概念，但是有精度的概念。当没有找到使用byte类型的方法输出，可以扩大精度。扩大精度的条件：精度小的类型的所有取值精度大的类型都能满足，如char类型（0-65535）不能满足byte中的负数。

	     	1byte     0000 0001	short	 0000 0000 0000 0001	int		 0000 0000 0000 0000 0000 0000 0000 0001
1
2
3
4

在scala中没有基本数据类型，所见皆对象，所以不能从精度的角度去理解。

object Scala07_DataType_4 {  def main(args: Array[String]): Unit = {    //TODO 数据类型    val b : Byte = 20    val i : Int = b    //b = i //错误，与精度无关，两者能转换的条件：有子父类关系或者有实现类和接口的关系  }
1
2
3
4
5
6
7
8
9
10

Byte和Int本不可以进行转换，因为它们属于不同的类，但scala的编译器进行了隐式转换，所以可以编译通过，隐式转换开发人员看不到。如上图所示，所有的虚线连接都可以进行隐式转换，并不是真的可以转换，只是编译器进行了微操。

val c : Char = 'A' + 1val c : Char = (b + 1) //错误println(c)
1
2
3

以上代码是正确的，常量（字符串，Boolean，数字，字符）的计算是在编译时完成的。‘A’ + 1 在编译时会计算成66，没有超过char的范围，所以输出为B。

（2）强制类型转换

java语言：截取精度（32位—8位）

int a = 10;byte b = (byte)a;byte b = 127;//b++; //一元运算符（只有一个元素参与运算的符号）：不会提升数据类型，等于下一条语句byte b1 = (byte)(b + 1);	//输出-128
1
2
3
4
5
6

为什么为-128？

	1270111 1111 + 1 =0000 0000 0000 0000 0000 0000 1000 0000  （int）再次强制转换成byte							  1000 0000 = -128第一位为符号位，1为负，0为正1 + 1111111	== 8位数据中负数的最大值 == -11 + 1111111 == 8位数据中负数的最小值 == -1281000 0001 == -127
1
2
3
4
5
6
7
8

scala语言：

var a : Int = 10Var b : Byte = a.toByte// 基本上Scala的AnyVal类型之间都提供了相应转换的方法。
1
2
3

（3）字符串类型转换

scala是完全面向对象的语言，所有的类型都提供了toString方法，可以直接转换为字符串，字符串也可以转换成数值

object Scala07_DataType_6 {  def main(args: Array[String]): Unit = {    //TODO 数据类型    val b : Byte = 20    val string = b.toString    println(string)    val s : String = "123"    val i = s.toInt    println(i)  }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

任意类型都提供了和字符串进行拼接的方法

val i = 10val s = "hello " + i
1
2