import java.util.Date
class ScalaTest1 {
}
//在scala里面没有static关键词的,在 object修改的代码块中定义的方法或者变量或者常量都是静态的
object ScalaTest1{
def main(args: Array[String]) {
//常量
val name:String = "hello scala"
//变量
var age = 10
println(name + "\t" + age)
var person=new Person(name,age)
person.hello()
}
}
class Person(param1:String,param2:Int){
var name=param1
var age=param2
//Unit 表示没有返回值等同于void
def hello():Unit={
print("名称为："+name+"\t"+age)
}
}
object ScalaTest2{
def main(args: Array[String]): Unit = {
//if else
var age=18
if (age<18){
println("18岁")
}else if (18<=age && age<=20){
println("18-20之间")
}else{
println("大于20")
}
//for循环
for (i<- 1 to 10){
println(i)
}
for (i<- 1 until 10){
println(i)
}
//i<- 1 to 10 代表 将1 到10 的数据复制给i(包括10)
//i<- 1 until 10 代表 将1 到10 的数据复制给i(不包括10)
//双层for循环
for (i<- 1 to 10;j<- 1 until 10){
println("i="+i+"j="+j)
}
//for循环加判断打印偶数
for (i<-1 to 10;if (i%2==0)){
println(i)
}
//scala 可以不用写分好
//for循环的yield关键词用法，将每次迭代的数值存入一个list数组中
val list = for(i <- 1 to 10 ; if i % 2 == 0) yield i
for(elem <- list){
println(elem)
}
//while循环
//scala中不能使用count++，count--只能使用count = count+1 ，count += 1
var index = 0
while(index < 100 ){
println("第"+index+"次while 循环")
index += 1
}
//这是一个完整版的函数
def fun1(a:Int,b:Int):Int = {
return a+b
}
//这是一个简化版的函数 最后一行语句的执行结果就是这个函数的返回值
def fun1_01(a:Int,b:Int) = {
a+b
}
println(fun1(1,2))
println(fun1_01(1,2))
//创建一个带有默认值参数的函数 函数中参数的默认修饰符是val
def fun2(a:Int,b:Int=10,c:Int = 20)={
a+b+c
}
// println(fun2(1))
// println(fun2(1,2,3))
//创建一个可变参数长度的函数
def fun3(elems:Int*)={
for(elem <- elems){
println(elem)
}
}
fun3(1,2,3,4,5,6,7,8,9)
//递归函数 求解5 的阶乘 推测类型 需要有依据 找不根据推测不出类型的
def fun4(num:Int):Int = {
if(num == 1){
num
}else{
num * fun4(num - 1)
}
}
println(fun4(5))
//匿名函数 ： 没有名字的函数
val fun5 = (name:String,facePower:Double) => {
println(name + "\tfacePower:" + facePower)
}
fun5("scala",100)
//偏应用函数是一种表达式，不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数
def log(date:Date,log:String) = {
println(date + "\t" + log)
}
//在调用log函数的时候 每次都需要传入一个date对象 烦
val date = new Date()
log(date,"log1")
log(date,"log2")
log(date,"log3")
val logWithDate = log(date,_:String)
logWithDate("log1")
logWithDate("log2")
logWithDate("log3")
/**
* 什么是高阶函数？
* 函数的参数是函数，或者函数的返回类型是函数，或者函数的参数和函数的返回类型是函数的函数
* scala支持面向函数编程
* scala支持面向对象变成
*
* fun6函数的参数要一个函数 要一个什么样的函数？
*/
def fun6(f:(Int,Int) => Int):Int = {
f(100,200)
}
def f(a:Int,b:Int) = {
a+b
}
println(fun6(f))
//原则：匿名函数中参数在函数体中只出现一次可以用_代替
println(fun6((a:Int,b:Int)=>{a+b}))
println(fun6((_+_)))
val str1 = "hello scala1"
val str2 = "hello scala2"
val str3 = "HELLO scala3"
println(str1.indexOf('o'))
println(str1.equals(str3))
//不区分大小写
println(str1.equalsIgnoreCase(str3))
//创建一个可变长度的字符串
val strBuilder = new StringBuilder
strBuilder.+('F')
strBuilder.++=("Hello")
strBuilder ++= " World"
strBuilder.append(" Scala")
strBuilder += ('P')
println(strBuilder)
//创建了一个长度为10的数组 数组中元素的类型必须是Int
val arr = new Array[Int](10)
for(index <- 0 until arr.length){
arr(index) = index * index
}
arr.foreach((x:Int)=>{
println(x)
})
//简化版
arr.foreach(println)
//List集合
val list1 = List(1,2,3,4,5,6,7,8,9)
list1.foreach(println)
// filter:过滤元素
def fl(x:Int):Boolean={
x > 3
}
println("=============================================================")
var filtered = list.filter(fl)
filtered.foreach(println)
filtered = list.filter((x:Int) =>x > 3)
filtered.foreach(println)
// count:计算符合条件的元素个数
val count = list.count((x:Int) => {
x > 1
})
println(count)
// map：对元素操作
val list2 = List("hello 11111","hello 22222","hello 33333")
//map函数传入的匿名函数的参数的类型一定是与集合中元素的类型一致
//map函数传入的匿名函数的返回值的类型就是这个新集合的泛型
val rest = list2.map((x:String) => {
x.split(" ")
})
rest.foreach((x:Array[String])=>{
x.foreach(println)
})
// flatmap ：压扁扁平,先map再flat
val rest1 = list2.flatMap((x:String) => {
x.split(" ")
})
rest1.foreach(println)
//set集合
val set1 = Set(1,2,3,4,4)
val set2 = Set(1,2,5)
//交集 scala中字符有可能也是方法名
val rest3 = set1.intersect(set2)
val rest4 = set1.&(set2)
rest4.foreach(println)
println("===============取两个集合的差集===================")
//取两个集合的差集 在set1集合中存在的但是set2集合中没有的元素
set1.diff(set2)
set1.&~(set2).foreach(println)
val str = set1.mkString("~")
println(str)
set1.max
set1.min
set1.toList
val map = Map(
"1" -> "scala",
2 -> "scala1",
(3,"scala2")
)
val keyIterator = map.keys.iterator
while(keyIterator.hasNext){
val key = keyIterator.next()
println(key + "====" + map.get(key).get)
}
println(map.get("1"))
println(map.get("1000").getOrElse("no result"))
map.foreach((x:(Any,String)) => {
val key = x._1
val value = x._2
println("key:" + key + "\tvalue:" + value)
})
println(map.contains("1"))
//============================Tuple============================
val t2 = (1,2)
val t3 = Tuple3(1,2,3)
val t4 = Tuple4("scala",1,true,1.0)
val t44 = ("scala1",1,true,1.0)
println(t2._2)
val iterator = t44.productIterator
while(iterator.hasNext){
//在循环体内不要调用多次next方法
println(iterator.next())
}
//二元组对象才有swap：调换位置
val s2 = t2.swap
println(s2._1)
//============trait==============================
/**
* trait可以类比成java中的接口 但是比java接口更高级一些
* trait中可以定义方法也可以实现方法
*/
val s = new Student
s.read("scala")
s.listen("I Like")
s.sayName("scala Like")
}
}
trait Read {
def read(name:String){
println(name+" is reading")
}
def sayName(name:String):String
}
trait Listen {
def listen(name:String){
println(name + " is listenning")
}
}
class Student extends Read with Listen{
override def sayName(name: String): String = {
println("say you:" + name)
name
}
}
Scala简单基础语法
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。
推荐阅读更多精彩内容
- 这里小结一下scala和Java基础语法上的区别 1.变量的声明java :变量：private String n...
