Scala基本语法(1)

Scala介绍及其基本语法

目录

• Scala介绍及其基本语法
  • 1、Scala概述
  • 2、scala与java的区别
  • 3、scala的基本语法
    • (1)Scala类和main方法的介绍
    • (2)变量和常量
    • (3)java 和scala 类可以相互兼容(但语法不兼容)
    • (4)scala中的循环
    • (5)字符串拼接
    • (6)Scala的JDBC

1、Scala概述

(1)Scala 是 Scalable Language 的简写，是一门多范式的编程语言
(2)Scala是把函数式编程思想和面向对象编程思想结合的一种编程语言。
(3)大数据计算引擎Spark又Scala编写

2、scala与java的区别

Test.java---(javac编译)--->Test.class---->JVM运行
Test.scala---(scalac编译)--->Test.class---->JVM运行

scala与java都是基于JVM运行的语言

(1)java的输出语句在scala中可以使用(scala的println底层和java是一样的)
	println()<=>System.out.println()
(2)Java中的类在scala中可以直接使用，两者只是语法不一样
(3)在scala中，语句末尾的分号可以省略(通常不写)
(4)在scala中，返回值可以省略不写(通常写上)

3、scala的基本语法

(1)Scala类和main方法的介绍

/**
  * class：是一个类，调用方法的时候需要先new这个类的对象，然后才能调用
  * object：本身是一个对象，object中定义的所有的方法可以直接调用,object相当于静态
  */

object Demo1 {
  //Scala的main方法(输入main直接回车)
  def main(args: Array[String]): Unit = {
    //scala的输出语句
    println("李玉伟")
    //java的输出语句在scala中可以使用
    System.out.println("lyw")
  }
}

/**
    * main 需要放在object内才能运行
    * def： 定义方法的关键字
    * main : 方法名
    * (args: Array[String]) 方法的参数
    * args：参数名，Array[String]：参数类型（字符串数组）
    * []：scala中的泛型
    * Unit： 返回值，相当于void
    */

//执行结果
李玉伟
lyw

Process finished with exit code 0

(2)变量和常量

var----定义变量
val----定义常量
尽量使用val，因为性能更好
scala中的变量类型可以自动推断(通过等号右边推断等号左边的类型)，定义的时候不需要我们指定

package com.shujia.scala

import java.io.{BufferedReader, FileReader}
import java.util

object Demo2 {
  def main(args: Array[String]): Unit = {
    /**
     * var 定义变量
     * val 定义常量
     */
    var str:String = "lyw" //定义变量
    //或者  var str = "lyw" 数据类型可以省略不写
    //变量可以重新赋值(val定义的常量不能重新赋值)
    str = "java"
    println(str)//java

    /**
     * java中的所有的方法在scala中同样适用
     */
    //调取split()方法对字符串进行切分，得到的是一个数组
    //快捷键：str.split("")按住Ctrl+Alt+v
    val sp: Array[String] = str.split("")

    /**
     * scala对java中的类做了很多的扩展，增加了很多好用的方法（隐式转换）
     */
    //调取head()方法,获取字符串第一个字符
    val head: Char = str.head
    println(head) //y
    /*
      或者使用切分的变量名调取,然后输出
            val head: String = sp.head
            printIn(head)
      或者直接输出
            printIn(str.head)
     */

    println("=" * 10)  //分隔行

    //获取不包含头的所有字符
    println(str.tail) //uwei
    //获取字符串中最后一个字符
    println(str.last) //i

    println("=" * 10)  //分隔行
    /**
     * java中集合在scala中的使用
     *
     */
    //创建一个集合对象，并指定泛型
    val list = new util.ArrayList[Int]()
    //向集合中添加元素
    list.add(11)
    list.add(22)
    list.add(33)
    //打印集合
    println(list) //[11, 22,33]
    //获取集合中的第二个元素
    println(list.get(1))  //get()中输入索引值

    println("=" * 10)  //分隔行
    /**
     * 遍历集合，需要使用while循环
     */
    var i = 0
    while(i<list.size()){
      println(list.get(i))
      i += 1
    }

    /**
     * 在scala中使用java的io流
     */
    //new一个FileReader类，读取students.txt文件
    val fr = new FileReader("data/students.txt")
    //new一个BufferedReader类，创建字符缓冲输入流，读取数据
    val bfr = new BufferedReader(fr)

    //读取第一行
    var line1: String = bfr.readLine()

    while (line1 != null){
      println(line1)
      //第一行不是Null，读取下一行
      line1 = bfr.readLine()
    }

  }
}

(3)java 和scala 类可以相互兼容(但语法不兼容)

java类和Scala类可以相互兼容：在Java类中可以调取Scala类中的方法

//定义一个scala中的类
class Demo3 {
  //类中定义一个print()方法
  def print(s:String):Unit ={
      println(s)
  }
}

//定义一个Java中的类
public class Demo4 {
    public static void main(String[] args) {
        //创建要调取的Scala类的对象
        Demo3 demo3 = new Demo3();
        //调取scala类中定义的方法
        demo3.print("lyw");	//lyw
    }
}

(4)scala中的循环

package com.shujia.scala

import scala.io.{BufferedSource, Source}

object Demo5 {
  def main(args: Array[String]): Unit = {
    //定义一个数组
    val array: Array[Int] = Array(1, 2, 3, 4, 5, 6)
    //如果数组中有多种类型，返回数组类型是Any
    val array1: Array[Any] = Array("lyw", 1, 2, 3, 4, 5, 6, 7, 8)

    /**
     * scala中的循环
     */
    //scala中的增强for循环
    for (i <- array) {
      println(i)
    }

    println("=" * 10) //分隔行

    //scala中的增强for循环while循环
    var i = 0
    while(i < array.length){
      println(array(i)) //通过下标获取元素，使用小括号
      i += 1
    }

    println("=" * 10) //分隔行

    /**
     * foreach方法
     * (i => println(i))  匿名函数
     */
    array.foreach(n=>println(n))

    println("=" * 10) //分隔行

    /**
     * io流: scala可以使用java中的io流
     * scala中读文件的类：Source
     */
    val source: BufferedSource = Source.fromFile("data/students.txt") //返回一个BufferedSource类型
    val lines: Iterator[String] = source.getLines() //返回一个迭代器
    //增强for循环遍历迭代器
    for (line <- lines) {
      println(line)
    }

  }
}

(5)字符串拼接

bject Demo5 {
  def main(args: Array[String]): Unit = {
    /**
     * 字符串拼接
     */
      //在Java中的方式
    val s:String = "lyw"
    val s1:String = "thy"
    val stringBuffer = new StringBuffer()//定义一个线程安全的StringBuffer类
    stringBuffer
      .append("lyw")
      .append("thy")
    println(stringBuffer.toString)  //lywthy

    //在Scala中的格式
    val s2 = "java"
    val s3 = "scala"
    val s4 = "hadoop"
    //利用s方法、$进行拼接
    val sp = s"$s2$s3$s4"
    println(sp) //javascalahadoop

    //如果直接在后面拼接，前一个变量要加上中括号
    val sp1 = s"$s2$s3${s4}shujia"
    println(sp1)  //javascalahadoopshujia
  }
}

(6)Scala的JDBC

前提：需要有mysql的依赖

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.40</version>
</dependency>

bject Demo5 {
  def main(args: Array[String]): Unit = {
    //1、加载驱动
    Class.forName("com.mysql.jdbc.Driver")

    //2、创建链接
    val con: Connection = DriverManager.getConnection("jdbc:mysql://rm-bp1h7v927zia3t8iwho.mysql.rds.aliyuncs.com:3306/students", "shujia012", "123456")

    //3、查询数据
    val stat: PreparedStatement = con.prepareStatement("select * from students")

    //4、执行查询
    val resultSet: ResultSet = stat.executeQuery()

    while (resultSet.next()) {
      val id: Long = resultSet.getLong("id")
      val age: Long = resultSet.getLong("age")
      val name: String = resultSet.getString("name")
      val clazz: String = resultSet.getString("clazz")
      val gender: String = resultSet.getString("gender")

      println(s"$id\t$name\t$age\t$gender\t$clazz")
    }
    //关闭链接
    con.close()
      
  }
}