博客

一 数据类型

1 字符串

在 Scala 中，字符串的类型实际上就是 Java中的 String类，它本身是没有 String 类的。

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

Scala中String定义如下：

type String        = java.lang.String

（1）字符串拼接

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

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

定义一个JSON对象

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

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

（2）传值字符串

    val name = "zhangsan"
    val password = "123321"
    printf("username : %s\n",name)
    printf("password : %s",password)

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

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

    val name = "zhangsan"
    val password = "123321"
    println(s"name : $name")
    println(s"password : $password")

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

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

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

（4）多行字符串

// 竖线表示顶格符号
val s =
"""
  |Hello Scala
  |""".stripMargin

改变顶格符号

    val s =
  """
  |Hello Scala
  |""".stripMargin('@')
    println(s)

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

    val json =
      s"""
        |{"username":"${name}","password":"${password}"}
        |""".stripMargin
    println(json)

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

val sql =
      """
        |select
        |  id
        |from
        |  (
        |  select * from t_user
        |  where id = 1
        |  order by id desc
        |  ) a 
        |group by id 
        |""".stripMargin

2 输入输出

（1）输入

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

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

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

  	// 数据源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()
  

（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()

（3）网络

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

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

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

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

client：

package com.hike.bigdata.scala.chapter02

import java.io.OutputStream
import java.net.Socket

object 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()
  }
}

server：

package com.hike.bigdata.scala.chapter02

import java.io.InputStream
import java.net.ServerSocket

object 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()
  }
}

（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 + "]";
    }
}

client：

package com.hike.bigdata.scala.chapter02

import java.io.{ObjectOutputStream, OutputStream}
import java.net.Socket

import com.hike.bigdata.scala.test.User

object 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()
  }
}

server：

package com.hike.bigdata.scala.chapter02

import java.io.{InputStream, ObjectInputStream}
import java.net.ServerSocket

object 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()
  }
}

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 = {

  }
}

（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)
  }
}

（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 是错误的
  }
}

（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
  }
}

（e）Nothing

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

object Scala07_DataType_4 {

  def main(args: Array[String]): Unit = {
    //TODO 数据类型

    // java中方法的出口有两个，一个是正常返回，一个是异常
  }
  def test() : Nothing = {
    throw new Exception()
  }
}

4 类型转换

（1）隐式转换

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

	     	1
byte     0000 0001	
short	 0000 0000 0000 0001	
int		 0000 0000 0000 0000 0000 0000 0000 0001

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

object Scala07_DataType_4 {

  def main(args: Array[String]): Unit = {
    //TODO 数据类型

    val b : Byte = 20
    val i : Int = b
    //b = i //错误，与精度无关，两者能转换的条件：有子父类关系或者有实现类和接口的关系
  }

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

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

以上代码是正确的，常量（字符串，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

为什么为-128？

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

scala语言：

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

（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)
  }
}

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

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