目录
一、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)
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
