scala_day01_安装_基础_IO_函数_递归_异常_方法_样例类_伴生对象

2022-07-08 00:32:39 阅读：186 来源： 互联网

标签：java String val scala Int day01 样例 println

scala学习

先看如下：

scala 安装

直接在idea中下载，然后配置 pom.xml 文件

配置 pom.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>scala_study</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <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>
</project>

学习一门语言，当然提前写hello，world

* object:可以理解为一个单例对象，相当于java给方法增加静态关键字
*
* main 函数需要放在object中才能直接运行
*
* def：scala中定义方法的关键字
* main：方法名
* args：Array[String]：方法的参数
* args:参数名
* Array[String]: 参数类型
* [String]:泛型
* Unit：相当于java中的void

package com.wt
/**
 * @author WangTao
 * @date 2022/7/7 18:42
 */

/**
 * object:可以理解为一个单例对象，相当于java给方法增加静态关键字
 *
 * main 函数需要放在object中才能直接运行
 *
 * def：scala中定义方法的关键字
 * main：方法名
 * args：Array[String]：方法的参数
 * args:参数名
 * Array[String]: 参数类型
 * [String]:泛型
 * Unit：相当于java中的void
 *
 */
object Demo1HelloWorld {
  def main(arg: Array[String]):Unit = {
    println("hello,world")
  }
}

scala基础

package com.wt
import java.util.Scanner

/**
 * @author WangTao
 * @date 2022/7/7 18:59
 */
object Demo2base {
  def main(args: Array[String]): Unit = {
    /**
     * 1.变量
     * 可变：var
     * 不可变：val
     *
     * scala会进行类型推断
     * 变量类型会自动通过等号右边的值推断出来
     */
    //类型自动推断
    //val是值不可变的类型
    val a = 100
    println(a)
    println(a.getClass)

    val b = "scala"
    println(b)
    println(b.getClass)

    //var是可变的变量
    //可变：变量的引用可以再指向其他的变量
    var c = "1234"
    println(c)
    c = "7878"
    println(c)

    println("=" * 100)

    /**
     * 2.字符串
     * scala中的字符串和java中的字符串是同一个，java中字符串所有的方法scala中都有
     *
     * scala和java兼容：java中的类在scala中可以使用，scala中的类在java中也可以使用
     * scala和java的语法不一样
     * 
     */
    val str: String = "java,spark,hadoop"
    //split:通过分隔符切分字符串
    val array: Array[String] = str.split(",")
    //mkString:通过一个分割符将序列拼接成一个字符串和split相反
    println(array.mkString("_"))

    /**
     * 字符串的拼接
     * 1.使用+，性能较差，会占用额外的内存空间
     * 2.StringBuffer,StringBuilder
     * 3.scala中的方法(推荐使用)
     *
     */
    //1.使用+
    val str1: String = "java" +","+ "hadoop" +","+ "spark"
    println(str1)

    //2.StringBuilder
    val builder = new StringBuilder
    builder.append("java")
    builder.append(",")
    builder.append("flink")
    builder.append(",")
    builder.append("linux")
    println(builder.toString())

    //3.scala中的方法
    val s1 = "java"
    val s2 = 1000
    val s3 = 3.14

    //底层也是StringBuilder，只是scala中的一种简写
    val value: String = s"${s1},${s2},${s3}"
    println(value)

    println("=" * 100)

    /**
     * 数组
     */

    val ints: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8)
    //通过下标获取元素
    println(ints(1))

    //打印数组中的元素
    println(ints.mkString("-"))

    //通过下标修改数据
    ints(1) = 999
    println(ints(1))

    println("=" * 100)

    /**
     * 算数运算符
     *
     */
    val i2 = 100
    val i3 = 3
    println(i2 + i3)
    println(i2 - i3)
    println(i2 * i3)
    println(i2 / i3)
    println(i2 % i3)

    println("=" * 100)

    /**
     * 流程控制
     */
    //if...else...
    val scanner = new Scanner(System.in)
    val age: Int = scanner.nextInt()
    if(age > 18){
      println("成年")
    }else{
      println("未成年")
    }

    println("=" * 100)

    /**
     * while 循环
     * for 循环
     */
    //while
    val array1: Array[Int] = Array(3, 4, 5, 6, 7, 8)

    println(array1.length)

    var j = 0
    while(j < array1.length) {
      println(array1(j))
      j += 1
    }

    //增强for循环
    for (elem:Int <- array1) {
      println(elem)
    }

  }
}

scala的IO读写

package com.wt

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

/**
 * @author WangTao
 * @date 2022/7/7 20:11
 */
object Demo3Io {
  def main(args: Array[String]): Unit = {
    /**
     * 读取文件
     * 1.可以使用java中的方法
     * 2.在scala中有source
     */
    //使用java中的IO流

    val bufferedReader = new BufferedReader(new FileReader("D:\\Softwore_java\\projects\\bigdata17_xiaoge\\scala_study\\src\\main\\java\\com\\data\\test.txt"))

    //读取第一行
    var line: String = bufferedReader.readLine

    //判断下一行是否为空
    while(line != null){
      println(line)

      //每次循环读取下一行
      line = bufferedReader.readLine()
    }
    bufferedReader.close()

    println("=" * 100)

    //scala 的方式
    val source: BufferedSource = Source.fromFile("D:\\Softwore_java\\projects\\bigdata17_xiaoge\\scala_study\\src\\main\\java\\com\\data\\test.txt")

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

    for (elem  <- iterator) {
      println(elem)
    }
      source.close()

    //写文件
    val fileWriter = new  FileWriter("D:\\Softwore_java\\projects\\bigdata17_xiaoge\\scala_study\\src\\main\\java\\com\\data\\out.txt")

    fileWriter.write("java")
    fileWriter.write(",")
    fileWriter.write("look")
    fileWriter.write(",")
    fileWriter.write("sqoop")
    fileWriter.write(",")
    fileWriter.write("hello")

    fileWriter.close()
  }
}

scala 的函数

package com.wt
import scala.language.postfixOps
/**
 * @author WangTao
 * @date 2022/7/7 20:40
 */
object Demo4Fun {
  def main(args: Array[String]): Unit = {
    /**
     * 函数的定义 -- 函数可以在任何位置定义
     * 1.函数可以定义在object中，object中的函数可以直接调用
     * 2.可以在方法或者函数内部定义函数
     */
    println(add1(100, 200))
    println(add2(99))
    println(add3(20, 200))
    println(add4(66, 22))
    pr

    println(plus(99, 99))

    def plus(i: Int,j: Int): Int = {
      i + j
    }
    /**
     * 函数的调用
     */
    //使用object名称调用
    println(Demo4Fun.add1(2, 2))

    //方法调用的简写
    val str = "java,hadoop,sqoop"
    val strings: Array[String] = str.split(",")

    //简写
    val strings1:Array[String] =  str split ","
  }
  /**
   * def:关键字
   * add：函数名
   * (x: Int,y: Int) 参数列表
   * Int：返回值类型
   * {} 函数体
   */

  def add1(x: Int,y: Int): Int = {
    x+y
  }
  /**
   * 函数的简写
   * 1.如果最后一行作为返回值，return可以省略
   * 2.如果函数的代码逻辑之后一行，{} 可以省略
   * 3.如果参数列表为空，()可以不写，如果定义没有括号，调用时也不能有括号
   */

  def add2(x:Int): Int ={
    x + x
  }

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

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

  def pr: Unit = println("scala")
}

scala 的递归

package com.wt

/**
 * @author WangTao
 * @date 2022/7/7 21:16
 */
object Demo5Fun {
  def main(args: Array[String]): Unit = {
    println(jieCheng(20))
  }

  //阶乘，递归
  def jieCheng(i: Long): Long = {
    if(i == 1){
      1
    }else{
      i * jieCheng(i-1)
    }
  }
}

scala 的异常

package com.wt
import java.io.FileReader
/**
 * @author WangTao
 * @date 2022/7/7 21:24
 */
object Demo6Exaction {
  def main(args: Array[String]): Unit = {
    /**
     * scala 的异常和java原理一样
     * scala 默认将异常抛出
     */
    try {

      val reader = new FileReader("data/meiyou.txt")

      val i = 100 / 0

      Class.forName("com.shujia.Test")

      //抛出异常
      throw new RuntimeException("异常")

    }catch {
      case e : ArithmeticException =>
        println("0不能为除数异常")
      case e : ClassNotFoundException =>
        println("类找不到异常")
      case e : Exception =>
        println("其他异常")
    }finally (
      println("代码结束了")
    }
  }
}

scala 的方法

package com.wt
/**
 * @author WangTao
 * @date 2022/7/7 21:41
 */
object Demo7scala {
  def main(args: Array[String]): Unit = {
    val student = new Student("1001","a_tao")
    student.print()

    val student1 = new Student("1002","lisi",20)
    student1.print()

    //多态：父类的引用指向子类的对象
    val obj: Object = new Student("1003", "wangwu", 22)
    println(obj.toString)
  }
}
/*
  在类中可以定义，属性，方法，构造函数
  默认构造函数：{} 是scala默认构造函数的代码块，默认构造函数可以有参数

  scala的类同样是object的子类
 */
class Student(id: String,name: String){
    println("默认的构造函数")

  /**
   * 类的属性
   */
  val _id: String = id
  val _name: String = name

  //下划线代码的占位符，相当于给了一个默认值
  var _age: Int = _

  /**
   * 重载构造函数
   * 在重载构造函数的第一行需要手动调用默认的构造函数
   */
  def this(id: String,name: String,age:Int) {
    //调用默认的构造函数
    this(id,name)

    //给属性赋值
    this._age = age
  }

  /**
   * 在类中定义方法
   *
   */
  def print():Unit = {
    println(s"编号：${_id},姓名：${_name},年龄：${_age}")
  }

  /**
   * 重写父类的方法
   *
   */
  override def toString: String = s"编号：${_id},姓名：${_name},年龄：${_age}"
}

scala 样例类

package com.wt
/**
 * @author WangTao
 * @date 2022/7/7 22:26
 */
object Demo8CaseClass {
  def main(args: Array[String]): Unit = {
    val user = new User("001", "阿彬少年",18)
    //直接通过属性获取值
    println(user.id)
    println(user)

    //样例类可以不使用new创建对象
    val user1: User = User("002", "倒拔垂杨柳")
    println(user1)

    //修改属性，需要在被改变的属性上增加var
    user1.name = "鲁智深"
    println(user1)
  }
}

/**
 * 样例类
 * scala在编译的时候给样例类动态增加新的方法，属性，toString，序列化
 *
 * age：Int  = 0 :默认参数
 */
case class User(id: String ,var name: String,age: Int = 0)

scala 伴生对象

package com.wt
/**
 * @author WangTao
 * @date 2022/7/7 22:51
 */
object Demo9Apply {
  def main(args: Array[String]): Unit = {
    //调用对象的apply方法
    println(Score.apply("哈哈哈", 99))
    //apply方法可以直接使用对象名调用
    //Score()

    val score: Score = Score("001", 200)
    println(score)
  }
}
/**
 * Score object 是Score class 的伴生对象
 */
object Score {
  /**
   * apply:是object中的一个特殊方法，可以直接使用object的名称调度
   */
  def apply(sid: String , sco: Int): Score = {
    new Score(sid, sco)
  }
}
class Score(sid: String, sco: Int){
  override def toString: String = s"Score($sid,$sco)"
}

标签：java,String,val,scala,Int,day01,样例,println
来源： https://www.cnblogs.com/atao-BigData/p/16456726.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9