ScalaDay01

scala

• 一、Helloworld
• 二、变量
• • 1、val，var
  • 2、String
  • 3、类型转换
  • 4、方法函数
  • 5、递归
  • 6、函数参数的默认值
  • 7、可变参数
  • 8、循环判断
  • 9、if
• 三、IO流读取文件
• 四、异常处理
• 五、JDBC连接MySQL
• 六、解析JSON数据
• 七、Class类、重载构造函数
• 八、创建样例类
• 九、Apply方法
• 十、Concat字符串拼接
• 十一、高阶函数
• • 1、函数
  • 2、高阶函数
  • 3、数组
  • 4、高阶函数、以函数作为返回值
  • 5、参数和返回值都是函数
  • 6、map、filter

一、Helloworld

object Demo1Helloworld {
  
  def main(args: Array[String]): Unit = {
    //java的方式
    System.out.println("java")
    //scala的方式 底层和Java是完全一样的 只是将代码简化了
    println("scala")
  }

}

二、变量 1、val，var

object Demo3Base {
  def main(args: Array[String]): Unit = {
    
    val str: String = "scala"
    //常量不能再指向其他的对象
    //在java中使用final实现常量
    // str = "java"
    println(str)

    var str2: String = "hadoop"
    // 可以再指向其他的对象
    str2 = "hive"
    println(str2)

2、String

    val str3: String = "java,hadoop,spark"

    //字符串切分
    val arr: Array[String] = str3.split(",")
    println(arr)

    println("=" * 100)

    val str4: String = "1000"

3、类型转换

    //java的方式
    val int1: Int = Integer.parseInt(str4)
    println(int1)

    //scala的方式 scala动态增加的f方法
    val int2: Int = str4.toInt
    val d: Double = str4.toDouble
    println(int2)
    println(d)

4、方法函数

    def add(x: Int, y: Int): Int = {
      val i = x + y
      return i
    }

    //在scala中函数可以直接调用
    val j: Int = add(100, 200)
    println(j)

    
    def add1(x: Int, y: Int): Int = x + y

    val j1: Int = add1(10, 20)
    println(j1)
  }

}

5、递归

object Demo4Base {
  def main(args: Array[String]): Unit = {
    
    def plus(i: Int): Int = {
      if (i==1){
        //跳出条件
        1
      }else{
        //调用自己
        i * plus(i - 1)// 5 4 3 2 1
      }
    }

    val i: Int = plus(5)
    println(i)

6、函数参数的默认值

 
    def add(i: Int = 100,j: Int): Int = {
      i * j
    }

    //使用参数的名传值
    val i1: Int = add(j = 100)
    println(i1)

    println("=" * 100)

7、可变参数

 
    def test(i: Int*): Unit = {
       for (a <- i){
         println(a)
       }
    }
    test(1,2,3,4,6,7)
  }
}

8、循环判断

object Demo5Base {
  def main(args: Array[String]): Unit = {
    
    //构建数组
    val array: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

    //增强for循环
    for (i <- array) {
      println(i)
    }

    println("=" * 100)

    //通过下标遍历
    var i = 0
    while (i < array.length) {
      // 通过下标获取元素
      val j: Int = array(i)
      println(j)
      //递增下标
      i += 1
    }
    println("=" * 100)
    //scala中独有的方式 foreach
    array.foreach(println)

9、if

    

    val age = 20

    if (age >= 18) {
      println("已经成年")
    } else if (age < 19) {
      println("未成年")
    } else {
      println("其他")
    }
  }

}

三、IO流读取文件

import java.io.{BufferedReader, FileReader}
import scala.io.{BufferedSource, Source}

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

    
    //使用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()
    

    //底层还是java的io流
    val bufferedSource: BufferedSource = Source.fromFile("data/students.txt")

    //读取所有行得到一个迭代器
    val lines: Iterator[String] = bufferedSource.getLines()

    for (line <- lines) {
      println(line)
    }
  }

}

四、异常处理

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

    try {
//      val i: Int = 100 / 0
      //抛出异常
      throw new RuntimeException("运行时异常")
    }catch {

      //匹配异常类型
      case e: ArithmeticException =>
        println("除0异常")
        //打印异常的堆栈信息
        e.printStackTrace()

      case e: RuntimeException =>
      println("运行时异常")
      e.printStackTrace()
    }finally {
      println("都会执行")
    }
    println("代码结束")
  }

}

五、JDBC连接MySQL

import java.sql.{Connection, DriverManager, PreparedStatement, ResultSet}

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


    // 1、加载驱动
    Class.forName("com.mysql.jdbc.Driver")

    //2、建立连接
    val con: Connection = DriverManager.getConnection("jdbc:mysql://master:3306/bigdata", "root", "123456")

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

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

    //5、解析数据
    while (resultSet.next()) {
      //通过列名获取数据
      val id: Long = resultSet.getLong("id")
      val name: String = resultSet.getString("name")
      val age: Long = resultSet.getLong("age")
      val gender: String = resultSet.getString("gender")
      val clazz: String = resultSet.getString("clazz")

      println(id + "t" + name + "t" + age + "t" + gender + "t" + clazz)
    }

    //关闭连接
    stat.close()
    con.close()
  }

}

六、解析JSON数据

import com.alibaba.fastjson.{JSON, JSONArray, JSONObject}


object Demo9Json {
  def main(args: Array[String]): Unit = {
    val str = "{"id": "001","name": "张三","item": [1,2,3,4]}"

    //解析json数据
    val nObject: JSONObject = JSON.parseObject(str)

    //使用key获取value
    //需要明确类型
    val id: String = nObject.getString("id")

    val name: String = nObject.getString("name")

    val item: JSONArray = nObject.getJSONArray("item")

    println(id)
    println(name)
    println(item)
  }

}

七、Class类、重载构造函数

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

    //创建类的对象 调用类的构造函数
    val student = new Student("001", "张三")
    //调用对象的方法
    student.print()

    val student1 = new Student("002", "李四", 24)
    println(student1)
  }
}


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


  //重写父类的构造方法

  override def toString: String =
    s"Student(" + _id + "t" + _name + "t" + _age + ")"


}

八、创建样例类

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

    // 创建类的对象
    val user = new User("001", "张三")

    println(user.id)
    println(user)

    //修改属性的值
    user.name = "李四"
    println(user)


    
    val user2 = User("003", "王五")
    println(user2)
  }

}


case class User(id: String, var name: String, age: Int = 20)

九、Apply方法

object Demo12Apply {
  def main(args: Array[String]): Unit = {
    Test.print()

    Test.apply()

    //调用对象的apply方法
    Test()

    //不通过new来创建对象
    val test: Unit = Test()
  }

}


object Test{
  def print(): Unit={
    println("test")
  }

  

//  def apply(): Unit ={
//    println("apply")
//  }

  def apply(): Test = new Test()
}

class Test{

}

十、Concat字符串拼接

object Demo13Concat {
  def main(args: Array[String]): Unit = {
    
    //java的方式
    val builder = new StringBuilder

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

    println(builder.toString())

    //scala的方式

    val s = "java"
    val i = 1000
    val d = 3.14

    //底层还是StringBuilder
    val str = s"$st${i}javat$d"
    println(str)
  }

}

十一、高阶函数 1、函数

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

    


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

    println(fun1("100"))


    
    val f: String => Int = fun1

    println(f("200"))
    println(f)
  }

}

2、高阶函数

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

    

    def fun(f: String => Int): Unit = {

      //对传进来的函数做调用
      val i = f("100")
      println(i)
    }

    //参数为String 返回值为Int类型的函数
    def f1(str: String): Int = str.toInt

    def f2(str: String): Int = str.toInt + 1000

    //调用fun 需要传入一个参数为String 返回值类型为Int类型的函数
    fun(f1)
    fun(f2)

    
    val f3: (String => Int) => Unit = fun


    

    fun((s: String) => {
      s.toInt + 200
    })

    //大括号可以省略
    fun((s: String) => s.toInt)

    //可以自动的推断参数的类型
    fun(s => s.toInt)

    //如果参数只是用了一次可以使用下划线来代替
    fun(_.toInt)

    println("=" * 100)

    

    val array = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

    
    def f5(i: Int): Unit = println(i)

    array.foreach(f5)

    array.foreach((i: Int) => {
      //i代表的是数组中的元素
      print(i)
    })

    //省略类型
    array.foreach(i => print(i))

    //下划线代替变量
    array.foreach(println(_))

    
    array.foreach(println)
  }

}

3、数组

object Demo16Fun3 {
  def main(args: Array[String]): Unit = {
    val array = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

    

    //使用循环的方式
    var i=0
    while(i

      array(i) = array(i)+1
      i +=1
    }

    //循环遍历
    array.foreach(println)
  }

}

4、高阶函数、以函数作为返回值

object Demo17Fun4 {
  def main(args: Array[String]): Unit = {
    
    def fun(): String => Int = {
      println("fun被调用")

      //参数为String返回值为Int类型的函数
      def f(str: String): Int = {
        println("f被调用")
        str.toInt
      }

      //反回一个函数
      f
    }

    //调用fun返回一个函数
    val ff: String => Int = fun()
    //调用返回的函数
    println(ff("100"))
    println(ff("1000"))
  }

}

5、参数和返回值都是函数

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

    //参数和返回值都是函数
    def fun(f: String => Int): String => Int ={
      f
    }

    //传进去一个函数返回一个函数
    val f: String => Int = fun((s: String) => s.toInt)

    val i: Int = f("100")
    println(i)
  }

}

6、map、filter

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

    //1、读取学生表的数据
    val students: Array[String] = Source.fromFile("data/students.txt").getLines().toArray

    

    val ids: Array[String] = students.map((student: String) => {
      //切分数据取出id
      val split: Array[String] = student.split(",")
      split(0)
    })

    ids.foreach(println)

    println("=" * 100)

    

    //java循环的思路
    for (student <- students) {
      //将数据拆分
      val split: Array[String] = student.split(",")
      //取出班级
      val clazz: String = split(4)

      //判断
      if ("文科一班".equals(clazz)) {
        println(student)
      }
    }
    println("=" * 100)

    

    val filterStudents: Array[String] = students.filter((student: String) => {
      //切分数据
      val split: Array[String] = student.split(",")
      //取出班级
      val clazz: String = split(4)
      //条件判断
      "文科一班".equals(clazz)
    })
    filterStudents.foreach(println)

    println("=" * 100)
    //简写
    val filter: Array[String] = students.filter(s => "文科一班".equals(s.split(",")(4)))
    filter.foreach(println)


    //这里的*是一个方法
    println("=".*(100))

    //简写
    println("=" * 100)
  }
}