scala_day01_安装_基础_IO_函数_递归_异常_方法_样例类_伴生对象
作者：互联网
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