scala基础

时间:2024-07-09 20:02:02

scala基础:

hello world:

  • 写scala可运行文件的注意事项
  • 1、如果一个scala文件要运行,class要改成object
  • 2、如果是class,就仅单纯代表一个类,如果是object代表的是单例对象
  • 3、scala语法中,一句话结束不需要加分号
  • 4、scala文件中,可以无缝使用java中的类和方法
object HelloWorld {
  def main(args: Array[String]): Unit = {
    // 输出一句hello world
    println("hello world")

    // java语言的输出一句话
    System.out.println("hello world")
  }
}

变量、常量

/**
 * 变量:在程序的运行过程中,其值可以发生改变的量
 * 在scala中定义一个变量,需要使用一个关键词:var
 *常量: 定义一个常数,使用关键字:var
 * 注意:
 * 1、变量一旦定义,它的类型就确定,可以不用手动指定类型,根据赋的值自动推断出类型
 * 2、也可以手动的指定变量的数据类型,完整的写法:var 变量名:数据类型 = 值
 *
 * scala中的数据类型和java的数据类型对应关系(Byte->Double 按所占字节数的大小,从小到大进行排序):
 * java:              scala:
 * byte                Byte
 * short               Short
 * int                 Int
 * long                Long
 * float               Float
 * double              Double
 * boolean             Boolean
 * char                Char
 */
// var定义一个变量
    var a1 = 100
    println(a1)
    //获取变量的类型
    println(a1.getClass)
    // 更改a1的值
    a1 = 200
    println(a1)
    
    var a2: Int = 10
    println(a2.getClass)
    
    val a3: Int = 100
    println(a3)
    // val 定义常量,若是修改其值会报错
//    a3 = 200
    // * : 为一个函数,底层通过StringBuilder来实现字符的链接
    println("=" * 50)

字符串

/**
 * scala中字符串、及其函数的使用
 * 字符串:由若该字符串组成的序列
 */
// 可以使用双引号构建字符串
var s1: String = "这是一个字符串"
println(s1)

// 使用""" """" 构建一个长字符串
var sql: String =
  """
    |这是一个长字符串
    |真的很长
    |注意了!!!
    |""".stripMargin
println(sql)

// String类和Java是一个共同的字符串类,String类中的功能在scala中正常使用

var s3 = "hello,world,java,hadoop,scala"
val arr1: Array[String] = s3.split(",")
// scala中的数组下标也是从0开始的,不过取的时候要使用arr1(0)
println(arr1(0))
println(arr1(1))
println(arr1(2))

/**
 * scala中字符串的拼接:
 * 1、使用 + 进行拼接,不过这种方式很消耗性能
 * 2、使用StringBuilder
 * 3、使用scala的特有函数mkString,前提条件是:有一组可拼接的序列
 * 4、使用scala特有的字符串传递方式 s"{变量}” (类似于python语言) 底层就是使用StringBuilder方式拼接的
 */
var q1: String = "hello"
var q2: String = "hello"
var q3: String = "hello"
var res1: String = q1 + "," + q2 + "," + q3
println(res1)

var res2: StringBuilder = new StringBuilder()
res2.append(q1).append(",").append(q2).append(",").append(q3)
println(res2)

var res3: String = arr1.mkString(",")
println(res3)

// 使用s"${}", 功能强大可以在括号中调用函数
var res4: String = s"${q1.toUpperCase},${q2},${q3}"
println(res4)

运算符

/**
 * 运算符
 */
var x: Int = 3
var y: Int = 4

println(x + y)
println(x - y)
println(x * y)
//此处的 / 为整除,若想让其取小数,可以让两个数中的其中一个变成一个浮点数
println(x / y)
println(x * 1.0 / y)
println(x % y)

循环语句

/**
 * 循环语句:
 * 注:
 * 1、在scala语言中,没有++或--, 如 i++ 、 i--
 * 2、在scala语言中,不存在和java一样的普通for循环
 * 3、scala中的循环的写法不太一样
 */

var i: Int = 0
while (i < arr2.length){
  println(arr2(i))
}

// 1 to 10 : 相当于闭区间的1到10
for (e <- 1to 10){
  println(e)
}

for(e <- 1 until 10){
  println(e)
}

控制语句

/**
   * 控制语句
   * 注:在scala中没有break、continue关键字
   * 要想使用break得导包:import scala.util.control.Breaks.break
   */
  //TODO 在break后,程序的执行结束,如若想继续执行,那么需要再加上一个breakable
  breakable{
    for (e <- 1 to 10) {
      if (e == 5) {
        //TODO:底层为一个异常抛出, def break(): Nothing = { throw breakException }
        break;
      }
      println(e)
    }
  }
  println("太牛了!")
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

IO流

def main(args: Array[String]): Unit = {
  //读取一个文件内容
  //使用java的方式读取文件, 使用带缓冲区的字符输入流
      val br: BufferedReader = new BufferedReader(new FileReader("scala/data/words.txt"))
      var line:String = br.readLine()
      while (line!=null){
        println(line)
        line = br.readLine()
      }

  //scala中的读取文件的方式
  //Source.fromFil 底层是使用了字节输入流读取数据FileInputStream
  val bs: BufferedSource = Source.fromFile("scala/data/words.txt")
  // getLines();返回的是一个迭代器对象, 使用迭代器的hasNext()、next() 方法进行数据的输出
  val lineIterator: Iterator[String] = bs.getLines()
      while (lineIterator.hasNext){
        val s: String = lineIterator.next()
        println(s)
      }

  // 既然返回的是一个迭代器,那么就可以使用for循环来进行输出
  for (e <- bs.getLines()) {
    println(e)
  }

  //java写文件
  /**
   * FileWriter对象被用作参数来创建一个BufferedWriter对象。
   * 这样,就可以通过BufferedWriter来写入字符,而实际的写入操作(包括可能的缓冲)将由BufferedWriter处理。
   */
  val bw = new BufferedWriter(new FileWriter("scala/data/words2.txt"))
  bw.write("写入数据!")
  // newLine()方法用于写入一个行分隔符
  bw.newLine()
  bw.write("太棒了!")
  //flush()方法用于将缓冲区中的数据强制写入到底层输出流(如FileWriter)中,并清空缓冲区。

  bw.flush()

  //TODO 纯scala中没有写文件的方式!!

}

异常抛出(与java中很像)

手动抛出异常:

val sc = new Scanner(System.in)
print("输入除数:")
val cs: Int = sc.nextInt()
if(cs!=0){
  println(10/cs)
}else{
  throw new ArithmeticException("您输入的除数是0")
}

使用try、catch捕获异常

def main(args: Array[String]): Unit = {
  /**
   *  scala中的异常和java的很像
   */
  try {
    println(10/2)
    val arr1: Array[Int] = Array(1, 2, 3, 4, 5)
    println(arr1(2))

    val br: BufferedReader = new BufferedReader(new FileReader("scala/data/words888.txt"))
        
    val sc = new Scanner(System.in)
    print("输入除数:")
    val cs: Int = sc.nextInt()
    
      println(10/cs)

    // 异常被捕获后,后续代码都可以运行
  }catch{
    //类似于sql语句中case when
    // 使用case来选择抛出的异常
    case e:ArithmeticException=>
      println("除0异常")
        e.printStackTrace()
    case e:ArrayIndexOutOfBoundsException=>
      println("数组越界异常")
    // TODO _ : 表示所有的异常都可以抛出,相当于Exception
    case _ =>
      println("出现异常")
  }finally {
    //TODO 用于确保无论是否发生异常,都会执行一段代码。
    //  今后finally中的处理大部分情况下都与释放资源有关
    println("这是finally代码块")
  }

  println("hello world")
}

scala中的函数

/**
 * def: 定义函数或者方法的关键字
 * main: 是函数或者方法的名字,符合标识符的命名规则
 * args: 函数形参的名字
 * Array[String]: 参数的数据类型是一个元素为字符串的数组
 * =: 后面跟着函数体(与Java中不同之处)
 * Unit: 等同于java中的void 表示无返回值的意思
 *
 *形式:
 * def main(args: Array[String]): Unit = {
 *
 * }
 *
 * 在不同的地方定义,称呼不一样
 * 函数:在object中定义的叫做函数
 * 方法:在class中定义的叫做方法
 */

object Demo5Function {
  def main(args: Array[String]): Unit = {
    //调用函数
    val res1: Int = add(3, 4)
    println(res1)


    // scala中的函数可以嵌套定义,函数中可以再定义函数
    def plus(x: Int, y: Int): Int = {
      return x + y
    }

    //调用必须在定义之后
    val res2: Int = plus(10, 20)
    println(res2)

    // 函数无法成功调用
//    val res3: Int = add2(11, 22)
//    println(res3)

    val d1: Demo1 = new Demo1()
    val res4: Int = d1.add2(11, 22)
    println(res4)

    //调用形式1:object中的函数可以使用类名调用,类似于静态一样
    val res5: Int = Demo5Function.add(100, 200)
    println(res5)

    //调用形式2:object中的函数调用时,可以省略类名
    val res6: Int = add(200, 300)
    println(res6)

    val res7: Int = fun1("1000")
    println(res7)

    //TODO 如果方法调用的函数只有一个参数的时候,可以将.和小括号用空格代替调用
    val res9: Int = Demo5Function.fun1("1000")
    val res8: Int = Demo5Function fun1 "1000"   //  "=" * 50 -> "=".*(50)
    println(res8)

    //TODO 如果定义的时候,没有小括号,调用的时候,就不需要加小括号(无需传入参数)
    show

  }

  //定义格式1:如果函数有返回值,且最后一句话作为返回值的话,return关键字可以不写
  def add3(a1: Int, b1: Int): Int = {
    a1 + b1
  }
  //定义格式2:如果函数体中只有一句实现,那么大括号也可以不写
  def add4(a1: Int, b1: Int): Int = a1 + b1

  //定义格式3:如果函数没有参数的时候,小括号省略不写
  def show= println("好好学习,天天向上!")



  //需求1:定义一个求两个数之和的函数,返回结果
  def add(a1: Int, b1: Int): Int = {
    return a1 + b1
  }

  def fun1(s:String): Int = {
    return s.toInt
  }


}


//TODO 函数或者方法必须定义在class或者object中,否则将会报错,无法进行编译
//def add2(a1: Int, b1: Int): Int = {
//  return a1 + b1
//}

class Demo1{
  //这里叫方法,将来调用时需要创建该类的对象才可以调用
  def add2(a1: Int, b1: Int): Int = {
    return a1 + b1
  }
}

递归调用

/**
 * scala中的函数也可以递归
 * 方法定义时,自身调用自身的现象
 *
 * 条件:要有出口(停止递归调用条件),不然就是死递归
 */
object Demo6Function {
  def main(args: Array[String]): Unit = {
    //求阶乘 5!
    val res1: Int = factorial(5)
    println(s"5的阶乘是$res1")

    println(s"5的阶乘是${Demo6Function factorial 5}")

  }

  def factorial(number: Int): Int = {
    if (number == 1) {
      1
    } else {
      number * factorial(number - 1)
    }
  }


}

scala中定义class类

object Demo7Class {
  def main(args: Array[String]): Unit = {
    //    val s1: Student = new Student()

    //    val s1: Student = new Student("张三",18)
    val s2: Student = new Student("张三", 18, "男")

    println(s2)

    //如果调用的是一个类的无参构造方法,new的时候小括号可以不用写
    val s3: Student2 = new Student2
    s3.fun1()

    //也可以使用多态的方式创建对象
    val s4:Object = new Student("张三111", 19, "男")
//    s4.fun1()
    println(s4.toString)
  }
}

/**
 * 可以在scala程序定义类
 * 类:构造方法 成员方法 成员变量
 *
 * 构造方法:
 * 1、在scala中构造方法的编写和在java中不太一样,类所拥有的大括号中都是构造代码块的内容
 * 2、默认情况下,每一个类都应该提供一个无参的构造方法
 * 3、构造方法可以有许多
 */
class Student(name: String, age: Int) {
  /**
   * 定义成员变量
   */
  val _name: String = name
  val _age: Int = age
  // _: 这个下划线,就表示将来不传值时,会赋予其默认值。String的默认值是一个特殊的值,即null
  var _gender: String = _

  /**
   * 构造方法也可以写多个
   */
    // TODO def this () :为重载的构造器,有着不同的参数列表,
    //  在创建类的对象时,若传递三个参数,则会使用该构造方法进行初始化对象
  def this(name: String, age: Int, gender: String) {
      /**
       * this():
       * 用于在辅助构造器中调用主构造器或其他辅助构造器,
       * 以确保对象被正确初始化。需要注意的是,this(...)调用必须是构造器体中的第一条语句。
       */
      this(name: String, age: Int)
      _gender = gender
  }

  //  println("好好学习,天天向上!")


  /**
   * 也可以重写方法
   * 此处定义的类的父类都是Object,重写继承自父类的toString方法
   */
  override def toString: String = {
    // 使用s"${}"的形式会报错
    "姓名:" + _name + ", 年龄:" + _age + ", 性别:" + _gender
  }

  //  override def toString: String = super.toString
}

class Student2{
  def fun1()={
    println("666")
  }
}

样例类

/**
 *  scala提供了一个非常好用的功能:样例类
 *  较少用户创建类所编写代码量,只需要定义成员变量即可,自动扩充成员变量,构造方法,重写toString方法
 */
object Demo8CaseClass {
  def main(args: Array[String]): Unit = {
    val t1 = new Teacher("小虎", 16, "学习")
    println(t1)
    println(t1.name)
    println(t1.age)
    println(t1.like)

    t1.like = "敲代码"
    println(t1)
  }
}

/**
 * 样例类中的成员变量,编译后默认是被jvm添加了final关键字,用户是改变不了的
 * 对于scala来说,默认是被val修饰的
 * 如果将来想要被改变,定义的时候需要使用var进行修饰
 */
case class Teacher(name:String,age:Int,var like:String)

伴生对象(apply方法)

object Demo9Apply {
  def main(args: Array[String]): Unit = {
        val b: Book1 = new Book1()
        b.apply() // 定义在class中是一个普通的方法


    // TODO: 若定义在object中,那么可以直接用Book("中华上下五千年", 999)的形式来调用这个方法
    val b1: Book = Book("中华上下五千年", 999)

    println(b1)
  }
}

class Book1 {
  def apply(): Unit = {
    println("哈哈哈")
  }
}

// TODO object Book 为 class Book的伴生对象
object Book {
  def apply(name:String,price:Int): Book = {
    new Book(name,price)
  }
}

class Book(name: String, price: Int) {
  val _name: String = name
  val _price: Int = price

  override def toString: String = "书名:" + _name + ", 价格:" + _price
}

scala面向函数式编程

/**
 * scala中的函数式编程
 *
 * 面向对象编程:将对象当作参数一样传来传去
 * 1、对象可以当作方法参数传递
 * 2、对象也可以当作方法的返回值返回
 * 当看到类,抽象类,接口的时候,今后无论是参数类型还是返回值类型,都需要提供对应的实现类对象
 *
 * 面向函数式编程:将函数当作参数一样传来传去
 * 1、函数A当作函数B的参数进行传递
 * 2、函数A当作函数B的返回值返回
 *
 * 在scala中,将函数也当作一个对象,对象就有类型
 * 函数在scala也有类型的说法
 * 函数的类型的形式为:
 * 参数类型=>返回值类型
 *
 */
将函数当作对象,赋值给类型是函数类型的变量
//是一个参数为字符串类型,返回值是整数类型的函数
    def fun1(s: String): Int = {
      s.toInt + 1000
    }

    val res1: Int = fun1("1000")
    println(res1)

    //定义变量的方式,定义一个函数
    //将函数当作对象,赋值给类型是函数类型的变量,将来可以直接通过变量调用函数
    val fun2: String => Int = fun1

    val res2: Int = fun2("2000")
    println