Scala语言的用法

目录

一、Scala与Java语言的关系

二、运行环境搭建

三、Scala语言具体用法

1、输出语法

2、变量使用和转换

3、方法（函数）

4、循环判断

5、IO流

6、异常，一般函数异常Scala已经抛出，不用在手动抛出。

7、连接数据库jdbc

8、字符串转换json格式

9、类的重载和重写

10、case类

11、apply（）方法

 12、字符串拼接

---

一、Scala与Java语言的关系

Java和Scala语言本质上是一样的，Scala就是在Java的基础上对Java语言进行简化操作而形成的。

二、运行环境搭建

     首先在idea中下载Scala插件然后重启idea，然后新建maven项目，在项目的prom.xml中导入下面的代码

<dependencies>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>2.11.12</version>
        </dependency>

        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-compiler</artifactId>
            <version>2.11.12</version>
        </dependency>

        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-reflect</artifactId>
            <version>2.11.12</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <!-- Java Compiler -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

            <!-- Scala Compiler -->
            <plugin>
                <groupId>org.scala-tools</groupId>
                <artifactId>maven-scala-plugin</artifactId>
                <version>2.15.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

        </plugins>
    </build>

三、Scala语言具体用法

1、输出语法

//Object:是Scala中的单例对象，object的方法可以直接调用。
object Demo1 {
  /*
    main 方法要放在object中才能运行
    def：定义方法的关键字
    main：方法名
    args:方法参数名
    Array[String]：参数类型（string类型的数组），[]在Scala中代表泛型
   */
  def main(args: Array[String]): Unit = {
    //java的输出语句，在Scala中也能使用
    System.out.println("HelloWorld")
    //简化了Java中输出语句，且可省略分号
    println("helloWorld")
    
    println("="*100)
  }
}

2、变量使用和转换

/*
      定义变量格式  val/var 变量名：类型 = 值
      val ：不可变的变量--常量
      var ：可变的变量  --变量
      用val表示该变量后面不会在修改

      在定义变量时类型可以不加，Scala会根据值自动判断数据类型
      一般需要加上，增强代码的可读性。
*/
    //定义一个常量
    val str: String = "helloWorld"

    //定义一个变量，类型可省略
    var str1 = 2
    str1 = 3
    //str1="d" 报错，因为Scala自动默认str1为int类型

//字符串的用法和Java中一致
    val str2: String = "java,hadoop,hbase"
    //java中方法在Scala中都能使用
    val arr: Array[String] = str2.split(",")

//类型转换
    var str4: String = "1000"
    //java中方法
    val i1: Int = Integer.parseInt(str4)
    //scala 的方法
    val i2: Int = str4.toInt
    val i3: Double = str4.toDouble
    println(i1,i2,i3)

3、方法（函数）

//函数
    def add1(x: Int, y: Int): Int = {
      return x + y
    }
    val s = add1(100, 300)
    println(s)
/*
    函数的简写
       1、return可以省略，最后一行会作为返回值
       2、如果函数只有一行代码，{}可以省略
       3、返回值类型可以自动推断， 根据返回值自动推断返回值类型
       4、如果参数列表为空，()可以省略
*/
    //省略了return，{}，返回值类型。
    def add2(x:Int,y:Int) = x+y
    val s2=add2(100,300)
    println(s2)

//函数参数使用默认值
    def add(x: Int = 100, y: Int): Int = {
      x + y
    }
    val s2: Int = add(200, 300) //有默认值也可改变
    val s3: Int = add(y = 300) 
    //val s2:Int = add(300) scala不能识别300赋给谁会报错
    
    def add1(x: Int, y: Int = 200): Int = {
      x + y
    }
    val s4:Int = add1(200) //y有默认值，200赋给了x

//不定数参数，Java为...,scala使用*
    def test(i: Int*): Unit = {
      for(a <- i){
        print(a)
      }
    }
    test(1,2,3,4,5)

4、循环判断

    val arr: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7)

//增强for循环，Scala中没有普通for循环
    for (i <- arr) {
      print(i)
    }

    println()

//while 循环
    var i = 0
    while (i < arr.length) {
      val j = arr(i) //数组使用(),[]在Scala中表示泛型
      print(j)
      i += 1
    }

    println()

arr.foreach(print) //Scala中独有的遍历数组的方式

//if判断和Java一致
    var age: Int = 20
    if (age >= 18) {
      println("已经成年")
    } else if (age < 19) {
      println("未成年")
    }

5、IO流

//java io流读取文件
    //字符流
    val fileReader: FileReader = new FileReader("data/students.txt")
    //字符缓存流
    val bufferedReader: BufferedReader = new BufferedReader(fileReader)

    var line: String = bufferedReader.readLine()

    while (line != null) {
      println(line)
      line = bufferedReader.readLine()
    }
    //关闭流
    bufferedReader.close()
    fileReader.close()
    
//Scala io流方法
    val bufferedSource:BufferedSource= Source.fromFile("data/students.txt")
    val lines: Iterator[String] = bufferedSource.getLines()
    
    for (lines <- lines){
      println(line)
    }
    bufferedSource.close()

6、异常，一般函数异常Scala已经抛出，不用在手动抛出。

try {
      val i: Int = 100 / 0
    } catch {
      case e: ArithmeticException =>
        println("除零异常")
      case e: RuntimeException =>
        println("代码异常")
    } finally {
      println("代码")
    }
    println("代码正常")

7、连接数据库jdbc

def main(args: Array[String]): Unit = {
    //加载驱动
    Class.forName("com.mysql.jdbc.Driver")
    //建立连接
    val conn: Connection = DriverManager.getConnection("jdbc:mysql://master:3306/shujia", "root", "123456")
    //写sql语句查询数据
    val stat: PreparedStatement = conn.prepareStatement("select * from student;")
    //执行查询
    val set: ResultSet = stat.executeQuery()
    //解析数据
    while(set.next()){
      val id: Long = set.getLong("id")
      val name: String = set.getString("name")
      val age: Long = set.getLong("age")
      val gender: String = set.getString("sex")
      val clazz: String = set.getString("clazz")

      println(id + "\t" + name + "\t" + age + "\t" + gender + "\t" + clazz)
    }
    //关闭连接
    stat.close()
    conn.close()
  }

8、字符串转换json格式

val str:String = "{\"id\":\"001\",\"name\":\"张三\",\"item\":[1,2,3,4]}"
    //解析json数据
    val nObject: JSONObject = JSON.parseObject(str)
    //使用key获取value
    val str1: String = nObject.getString("id")
    val str2: String = nObject.getString("name")
    val array: JSONArray = nObject.getJSONArray("item")
    println(str1+"\t"+str2+"\t"+array)

9、类的重载和重写

object Demo9 {
  def main(args: Array[String]): Unit = {
    //创建类的对象，默认调用类的构造函数
    val student = new Student("001", "张三")
    student.print()//调用对象的函数

    //调用的是类重载的构造函数，默认调用类其它构造函数
    val student1 = new Student("002", "李四", 24)
    println(student1)
/*结果
默认构造函数
student
默认构造函数
Student(002	李四	24)
*/
  }
/*
类:可以在类中定义方法，属性，构造函数，可以创建类的对象
在Scala中类的{}中都是默认构造函数
 */
class Student(id:String,name:String){
  println("默认构造函数")

  //定义属性, 定义及赋值
  var _id: String = id
  var _name: String = name

  //定义一个未赋值的变量，下划线的作用是占位符
  var _age: Int = _

  //重载构造函数，第一行需要先调用默认函数
  def this(id: String, name: String, age: Int) {
    //调用默认构造函数
    this(id, name)
    //给成员变量赋值
    this._age = age
  }

  //在类中定义普通的方法
  def print(): Unit = {
    println("student")
  }

  //重写父类toString的方法
  override def toString: String = {
    s"Student(" + _id + "\t" + _name + "\t" + _age + ")"
  }
  }
}

10、case类

  def main(args: Array[String]): Unit = {
    //创建类的对象
    val user = new User("001", "张三")
    println(user)//case修饰的类有额外的构造函数，可以直接输出
    
    // 样例类可以不通过new创建对象
    val user2 = User("003", "王五")
    println(user2)
    
    //修改属性的值，name前用var修饰了
    user.name = "李四"
    println(user)
  }
}
/**
 * 样例类：帮助我们简化写代码的类
 * scala在编译的过程中会自动的给样例类增加额外的属性，方法和构造函数
 * 样例类属性默认不支持修改，需要增加var才能修改
 */
case class User(id: String, var name: String, age: Int = 20)

11、apply（）方法

object Demo11 {
  def main(args: Array[String]): Unit = {
    Test.print()//不需要创建对象直接调用

    Test.apply()
    //调用对象的apply方法
    Test()
  }
}
/*
  object： 是一个特殊的类（类和对象绑定了，只一个一个对象）
  object中的方法可以直接调用，不需要创建对象
*/
object Test {
  def print(): Unit = {
    println("test")
  }
  //apply:是scala中一个特征的方法，可以直接使用object名调用
  def apply(): Unit = {
    println("apply")
  }
}

 12、字符串拼接

//java 的方式
    val builder = new StringBuilder()

    builder.append("java")
    builder.append("scala")
    builder.append("hadoop")

    println(builder.toString())

//scala的方式

    val a = "java"
    val b = 1000
    val c = 3.14

    //底层还是StringBuilder
    val str = s"$a\t${b}java\t$c"

    println(str)