Scala学习之（二）IO和数据类型

最新推荐文章于 2023-01-09 16:08:58 发布

goTsHgo

最新推荐文章于 2023-01-09 16:08:58 发布

阅读量510

点赞数

文章标签： scala 开发语言后端

本文链接：https://blog.csdn.net/goTsHgo/article/details/120880784

版权

本文详细介绍了Scala编程中的IO流操作，包括读取和写入文件的示例。此外，还深入探讨了Scala的数据类型，如整数、字符、浮点、布尔以及特殊类型Unit、Null和Nothing，并解析了数据类型转换的规则，包括自动转换和强制转换。同时，文章还讲解了数值类型与String之间的转换方法及其注意事项。

摘要由CSDN通过智能技术生成

一、IO流

二、数据类型

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

2.字符类型

3.浮点类型（Float、Double）

4.布尔类型

5.Unit类型、Null类型和Nothing类型

一、IO流

package Test

import java.io.{File, PrintWriter}
import org.junit.Test
import scala.io.Source

class Test_FileIO {

  @Test
  def test01():Unit ={

    /*
     * 路径的两种写法
     * src\\main\\resources\\
     * src/main/resources/
     */

    Source.fromFile("src\\main\\resources\\test.txt").foreach(print)
    //将数据写入文件
    val writer = new PrintWriter(new File("src/main/resources/output.txt"))
    writer.write("hello someone, how are you?")
    writer.close()
  }
}

二、数据类型

Java继承树

subtype实箭头：代表继承关系
implicit Conversion：代表隐式类型（精度）转换

Scala数据类型关系总结

1）Scala中一切数据都是对象，都是Any的子类。

2）Scala中数据类型分为两大类：数值类型（AnyVal）、引用类型（AnyRef），不管是值类型还是引用类型都是对象。

3）Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）

4) Scala中的StringOps是对Java中的String增强，但是确是值类型
5) Unit:对应Java中的void,用于方法返回值的位置，表示方法没有返回值。Unit是一个数据类型，只有一个对象就是（）。Void不是数据类型，只是一个关键字
6) Null是一个类型，只有一个对象就是null。它是所有引用类型(AnyRef) 的子类。

7) Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。

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

Scala的整数类型就是用于存放整数值的，比如12，300，4567等等。

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

2）案例实操

2.字符类型

//字符变量底层保存ASCII码
val i1:
Int=c1+1
println("i1:"+ i1)
val
i2: Int = c2
println ("i2: "+ i2)

3.浮点类型（Float、Double）

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

1）浮点型分类

数据类型	描述
Float [4]	32 位, IEEE 754标准的单精度浮点数
Double [8]	位 IEEE 754标准的双精度浮点数

2）案例实操

（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

4.布尔类型

1）基本说明

（1）布尔类型也叫Boolean类型，Booolean类型数据只允许取值true和false

（2）boolean类型占1个字节。

2）案例实操

// 4.布尔类型
val isTrue:
BooLean =
true
println(isTrue)|
I

5.Unit类型、Null类型和Nothing类型

1）基本说明

数据类型	描述
Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null	null , Null 类型只有一个实例值null
Nothing	Nothing类型在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 {


}

// 5.2空引用Null
//val n: Int = null //error
var student: Student = new Student( name = "alice",age=20)
student = null
println(student)

（2）Unit类型用来标识过程，也就是没有明确返回值的函数。

由此可见，Unit类似于Java里的void。Unit只有一个实例—— ( )，这个实例也没有实质意义

object TestSpecialType {

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

        def sayOk : Unit = {// unit表示没有返回值，即void

            println("say ok")

        }

        sayOk

    }

}


public final cLass BoxedUnit impLements java.io.Serializable {
    private static final Long serialVersionUID = 8405543498931817370L;
    public final static BoxedUnit UNIT = new BoxedUnit();
    public final static CLass<Void> TYPE 示java. lang. Void. TYPE;    
    private object readResolve() { return UNIT; }
    private BoxedUnit() { }
    public booLean equals (java.Lang.Object other) {   return this = other; }
    public int hashCode() { return 0;}
    pubLic String toString() {   return "()"; 
}

/**
通过源码可知：
我们在使用Unit的时候，返回的是一个BoxUnit类中的 static BoxedUnit（静态BoxedUnit对象） UNIT
*/

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

object TestSpecialType {
    def main(args: Array[String]): Unit = {
        def test() : Nothing={
            throw new Exception()
        }
        test
    }
}

三. 数据类型转换

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 //正确

    }

}

注意：Scala还提供了非常强大的隐式转换机制（隐式函数，隐式类等）

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

    }
}

四.数值类型和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"转成一个整数。