Scala基础

一:Scala安装

(一)Scala学习之路 (一)Scala的安装

补充:下载速度慢,可以使用百度云等软件进行下载(将https改为http即可下载)

(二)命令行测试使用

(三)eclipse安装scala创建

https://baijiahao.baidu.com/s?id=1659239771083075892&wfr=spider&for=pc 

二:Hello World测试

(一)配置lib

选择版本需要和安装的Scala一致

(二)helloworld测试 

package test

object HelloWorld {
  def main(args:Array[String]):Unit={
    println("Hello World");
  }
}

三:基础数据类型

(一)Scala中所有的数据都是对象

Scala中所有的数据都是对象,也就是说scala没有java中的原生类型。在scala是可以对数字等基础类型调用方法的。

举例:数字 1是一个对象,就有方法(函数)

可以不用指定数据的类型,Scala会自动进行类型的推荐

举例:下面的两条语句是一样的

val a:Int = 10
val b = 10  ----> b的类型就是Int  一般这种就行

(二)Scala数据类型《首字母一定大写》

 

(1)数值类型:Byte、Short、Int、Long、Float、Double

(2)字符类型Char和字符串类型String

scala> var c1='x'                                                    
c1: Char = x
scala> var s1="adsaa"
s1: String = adsaa
scala> s"666 ${s1} ${c1}" 插值处理需要加上s指定为字符串
res10: String = 666 adsaa x

(3) 布尔类型

(4)Unit的类型

相当于void

说明返回值为空 

(5)Nothing类型

Nothing类型在Scala的类层级的最低端;它是任何其他类型的子类型。

(6)Any类型

 Any是所有其他类的超类

(7)AnyRef类型

AnyRef类是Scala里所有引用类(reference class)的基类

Null是所有AnyRef的子类,在scala的类型系统中,AnyRef是Any的子类,同时Any子类的还有AnyVal。
对应java值类型的所有类型都是AnyVal的子类。
所以Null可以赋值给所有的引用类型(AnyRef),不能赋值给值类型,这个java的语义是相同的。
null是Null的唯一对象。 Nothing是所有类型的子类,也是Null的子类。Nothing没有对象,但是可以用来定义类型。
例如,如果一个方法抛出异常,则异常的返回值类型就是Nothing(虽然不会返回)

四:变量与常量

在Scala中,常量用val关键字定义,变量用var关键字定义,注意在Scala里这两个关键字要用小写,否则会报错

五:函数与方法

Scala 中使用 val 语句可以定义函数,def 语句定义方法,但本质上两者没什么区别。Scala 方法是类的一部分,而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。
Scala 中的方法跟 Java 的类似,方法是组成类的一部分。
Scala 中的函数则是一个完整的对象,Scala 中的函数其实就是继承了 Trait 的类的对象。

六:条件表达式if else

七:循环语句: for、while、do..while、foreach迭代

(一)for表达式(和其他有所差距)

写法一:使用list列表:

1 to 10生成一个list:

写法二:使用list

写法三: 添加过滤器

补充:使用for和yield生成器

(二)while循环--差别不大 

还有一个值得注意的是,对var再赋值等式本身也是unit值,假设使用以下的例子,编译的时候,Scala会警告comparing values of types Unit and String using `!=' will always yield true,所以循环会变成死循环

(三)foreach循环

八:函数参数

(一)函数参数说明

1.call by value:对函数实参进行求值,并且只求一次

调用:    

func1(3+4,5)

执行过程:

1:fun1(7,5)
27+5
3:12

2.Call by name:函数实参在函数内部调用的时候,才会求值,每次都会求值。使用=>

调用:

func2(3+4,5)

执行过程:

1:func2(3+4,5)2:(3 + 4) +5
3:7 + 5
4: 12

3.举例说明

def bar(x:Int,y: => Int):Int = 1
def loop():Int = loop     //死循环函数
或者
def loop():Int ={
loop()
}

调用:

bar(1,loop)  输出:1
bar(loop,1)  进入了死循环
                

原因:bar(1,loop)调用的时候,x是call by value,y是call by name,所以这里会先对x做一个求值,x=1,而y在没有调用到它的情况下,是不会进行求值的;同样的bar(loop,1)也是一样的道理,对x做求值,这个时候程序就会进入一个死循环的情况。

(二)函数参数的类型

1.默认参数

 

2.代名参数

 

3.可变参数

在参数类型的后面加上星号(*),就说明参数的个数不确定,且均为这个类型

九:Scala的Lazy特性(懒执行特性)

 当一个变量被申明是lazy,他的初始化会被推迟,直到第一次使用他的时候,才会被初始化。即便该变量异常,也是只会在第一次使用时才抛出异常。注意:只有val才有该特性

 

 

十:异常处理

可以像Java一样用try..catch..finally来进行异常捕获

 

 

十一:数组

Scala里使用new实例化对象,实例化过程中,可以用值和类型使对象参数化,参数化的意思是指在创建实例的同时完成对它的“设置”,数组同样可以如此。

(一)定长数组:Array

             数组的索引从0开始,最大值为数组的长度-1,整数类型的数组初始值全部为0,而String类型的为Null
                 限定数组长度
                     val a = new Array[Int](10) 
                     val b = new Array[String](5)
                 对数组直接进行初始化
                     val c = Array("Tom","Mary","Mike")
                     val a = new Array[Int](12495) 
             注意,尽管使用的是val进行定义,但是数组内部的元素是可以被修改的,只是数组对象不能被重新赋值成新的数组
             对数组进行排序并输出,这里是降序排列
                 a.sortwith(_>_).foreach(print) 

(二)变长数组:ArrayBuffer

              import scala.collection.mutable._
              val d = ArrayBuffer[Int]()
              往变长数组中添加元素
              d += 1
              d += 2
              d += 3
              
              一次添加多个元素
              d += (10,20,30)
              去掉数组中的元素
              d.trimEnd(2)

(三)多维数组:通过数组的数组来实现

import Array._
 
object Test {
   def main(args: Array[String]) {
 
      //定义二维数组,设定长宽
      var myMatrix = ofDim[Int](3,3)
      
      //初始化数组
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
      
      //打印二维数组
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
    
   }

(四)区间数组:使用range方法生成数组

import Array._
 
object Test {
   def main(args: Array[String]) {
  
      //使用range方法生成数组,注意,是左闭右开区间,第三个参数为增长量
      var myList1 = range(10, 20, 2)
      var myList2 = range(10,20)
 
      // 输出所有数组元素
      for ( x <- myList1 ) {
         print( " " + x )
      }
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

十二:Map映射和Tuple元组

(一)映射

Map是一种可迭代的键值对(key/value)结构,所有的值都可以通过Key来获取,Map 中的Key都是唯一的。
Map 也叫哈希表(Hash tables)。
Map 有两种类型,可变与不可变,区别在于可变对象可以修改它,而不可变对象不可以。
默认情况下 Scala 使用不可变 Map。如果需要使用可变集合,要引入 import scala.collection.mutable.Map 类

(二)元组

与List一样,元组也是不可变的,但与列表不同的是元组可以包含不同类型的元素。
可以利用Scala的类型推断来隐式定义一个元组,也可以显式的new,但注意显式的情况下,Tuple后面要跟元组的长度,目前Scala Tuple的最大长度为22
Tuple不能直接用foreach来遍历,所以要使用迭代器再foreach进行遍历
Tuple还可以使用tostring方法来将元组转换成字符串

 

posted @ 2020-03-09 21:54  山上有风景  阅读(246)  评论(0编辑  收藏  举报