Scala语法(一) 基础语法(变量&常量&判断&循环&数组&集合)

一时失言乱红尘 2022-02-13 17:45 394阅读 0赞

前言

在前面的章节中, 我们介绍了如何在Eclipse内安装Scala环境. 本章开始, 我们将讲解下Scala的基本语法.

PS: 1. 个人虽然没有想转Scala语言开发的思想, 但是近来Scala语言被各种媒体炒的火热. 了解下总没有坏处. 就个人而言, 还是非常喜欢Java的简洁语法的.

  1. 另在学习过程中, Scala经常会去调用Java的语法. 个人感觉, Scala在某些方面做的仍然还没有到位和完全. 但是, 对于Spark等的大数据开发, Scala或许是一门不错的语言.
  2. Eclipse中的Scala IDE(Oxygen)做的仍然不是非常完善. 最需要的查看Scala内的源码的功能缺失, 后期Scala的开发可能会转向使用IDEA进行开发.(虽然, 个人非常不喜欢IDEA那些花里胡哨的所谓自动化功能.)
  3. 本文所涉及的代码, 都可以在我的github项目的https://github.com/SeanYanxml/arsenal 的 arsenal-scala/quick-scala下找到.

前置准备

Eclipse Scala环境的配置 根据上述的文章配置好相关的开发环境. (IDEA略过此步骤)

Maven的Pom.xml文件依赖. 由于之前的Maven创建模板内, Scala的某些依赖的版本号已经不适合个人使用的版本. 个人将其替换成了相应的版本. 读者可以根据个人需要, 从 https://mvnrepository.com/ 上查询并选择需要的版本.

  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <groupId>com.yanxml</groupId>
  6.     <artifactId>quick-scala</artifactId>
  7.     <version>0.0.1-SNAPSHOT</version>
  8.     <name>${project.artifactId}</name>
  9.     <description>My wonderfull scala app</description>
  10.     <inceptionYear>2010</inceptionYear>
  11.     <licenses>
  12.         <license>
  13.             <name>My License</name>
  14.             <url>http://....</url>
  15.             <distribution>repo</distribution>
  16.         </license>
  17.     </licenses>
  19.     <properties>
  20.         <maven.compiler.source>1.8</maven.compiler.source>
  21.         <maven.compiler.target>1.8</maven.compiler.target>
  22.         <encoding>UTF-8</encoding>
  23.         <scala.tools.version>2.11</scala.tools.version>
  24.         <scala.version>2.11.8</scala.version>
  25.     </properties>
  27.     <dependencies>
  28.         <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
  29.         <dependency>
  30.             <groupId>org.apache.commons</groupId>
  31.             <artifactId>commons-lang3</artifactId>
  32.             <version>3.7</version>
  33.         </dependency>
  34.         <dependency>
  35.             <groupId>org.scala-lang</groupId>
  36.             <artifactId>scala-library</artifactId>
  37.             <version>${scala.version}</version>
  38.         </dependency>
  42.         <dependency>
  43.             <groupId>org.scala-lang</groupId>
  44.             <artifactId>scala-library</artifactId>
  45.             <version>2.11.8</version>
  46.         </dependency>
  47.         <dependency>
  48.             <groupId>org.scala-lang</groupId>
  49.             <artifactId>scala-compiler</artifactId>
  50.             <version>2.11.8</version>
  51.         </dependency>
  52.         <dependency>
  53.             <groupId>org.scala-lang</groupId>
  54.             <artifactId>scala-reflect</artifactId>
  55.             <version>2.11.8</version>
  56.         </dependency>
  57.         <!-- https://mvnrepository.com/artifact/org.scala-lang/scala-actors -->
  58.         <dependency>
  59.             <groupId>org.scala-lang</groupId>
  60.             <artifactId>scala-actors</artifactId>
  61.             <version>2.11.8</version>
  62.         </dependency>
  63.         <!-- Test -->
  64.         <dependency>
  65.             <groupId>junit</groupId>
  66.             <artifactId>junit</artifactId>
  67.             <version>4.11</version>
  68.             <scope>test</scope>
  69.         </dependency>
  70.         <!-- <dependency> <groupId>org.specs2</groupId> <artifactId>specs2_${scala.tools.version}</artifactId> 
  71.             <version>3.0</version> <scope>test</scope> </dependency> -->
  72.         <!-- https://mvnrepository.com/artifact/org.scalatest/scalatest -->
  73.         <dependency>
  74.             <groupId>org.scalatest</groupId>
  75.             <artifactId>scalatest_2.11</artifactId>
  76.             <version>3.0.0-M16-SNAP6</version>
  77.             <scope>test</scope>
  78.         </dependency>
  80.         <dependency>
  81.             <groupId>org.scalatest</groupId>
  82.             <artifactId>scalatest_${scala.tools.version}</artifactId>
  83.             <version>3.0.0-M16-SNAP6</version>
  84.             <scope>test</scope>
  85.         </dependency>
  87.         <!-- spark -->
  88.         <dependency>
  89.             <groupId>org.apache.spark</groupId>
  90.             <artifactId>spark-core_2.11</artifactId>
  91.             <version>2.2.1</version>
  92.         </dependency>
  94.         <!-- akka -->
  95.         <!-- https://mvnrepository.com/artifact/com.typesafe.akka/akka-actor -->
  96.         <dependency>
  97.             <groupId>com.typesafe.akka</groupId>
  98.             <artifactId>akka-actor_2.11</artifactId>
  99.             <version>2.3.14</version>
  100.         </dependency>
  101.         <!-- https://mvnrepository.com/artifact/com.typesafe.akka/akka-remote -->
  102.         <dependency>
  103.             <groupId>com.typesafe.akka</groupId>
  104.             <artifactId>akka-remote_2.11</artifactId>
  105.             <version>2.3.14</version>
  106.         </dependency>
  108.     </dependencies>
  110.     <build>
  111.         <sourceDirectory>src/main/scala</sourceDirectory>
  112.         <testSourceDirectory>src/test/scala</testSourceDirectory>
  113.         <plugins>
  114.             <plugin>
  115.                 <!-- see http://davidb.github.com/scala-maven-plugin -->
  116.                 <groupId>net.alchim31.maven</groupId>
  117.                 <artifactId>scala-maven-plugin</artifactId>
  118.                 <version>3.1.3</version>
  119.                 <executions>
  120.                     <execution>
  121.                         <goals>
  122.                             <goal>compile</goal>
  123.                             <goal>testCompile</goal>
  124.                         </goals>
  125.                         <configuration>
  126.                             <args>
  127.                                 <arg>-make:transitive</arg>
  128.                                 <arg>-dependencyfile</arg>
  129.                                 <arg>${project.build.directory}/.scala_dependencies</arg>
  130.                             </args>
  131.                         </configuration>
  132.                     </execution>
  133.                 </executions>
  134.             </plugin>
  135.             <plugin>
  136.                 <groupId>org.apache.maven.plugins</groupId>
  137.                 <artifactId>maven-surefire-plugin</artifactId>
  138.                 <version>2.13</version>
  139.                 <configuration>
  140.                     <useFile>false</useFile>
  141.                     <disableXmlReport>true</disableXmlReport>
  142.                     <!-- If you have classpath issue like NoDefClassError,... -->
  143.                     <!-- useManifestOnlyJar>false</useManifestOnlyJar -->
  144.                     <includes>
  145.                         <include>**/*Test.*</include>
  146.                         <include>**/*Suite.*</include>
  147.                     </includes>
  148.                 </configuration>
  149.             </plugin>
  150.         </plugins>
  151.     </build>
  152. </project>

正文

从本节开始, 我们正式介绍Scala的语法.

本章主要介绍如下几个方面:

  • QuickStart - HelloWorld
  • 常量&变量
  • 判断(if)
  • 循环(while/for/map)
  • 数组(Array)
  • 元组(Tuple)
  • 集合(Map&List&Set)
HelloWorld

在进行学习之前, 先使用HelloWorld小程序判断当前的编译器环境是否配置完毕.

在Scala中, 主要有2种方式创建静态的Main方法. def main&extends scala.APP.

另外值得一提的是, 这边使用的是object的前缀, 千万不要使用class前缀. 这是初学者非常容易犯的错误.(笔者当初就因为这个问题, 以为是IDE环境的问题, 绕了好久. 希望各位引以为戒.)

  1. object App {
  3.   def main(args : Array[String]) {
  4.     println( "Hello World!" )
  5.   }
  6. }
  8. object HelloWorld extends App{
  9.   println("HelloWorld")
  10. }
常量&变量

在Scala中, 与Java一样. 也有8种基本数据类型, 但是不存在向Java内的那么复杂. 即不存在基础类与封装类(int & Integer)的区别. 而是统一的使用基础类.(Byte Short Int Long Float Double Char Boolean)

常量的定义使用val关键字, 变量的定义使用var关键字. 在定义的过程中, 可以直接指定变量&常量的数据类型, 也可以不进行指定, 由系统自动识别装配.(var hello = "123"/ var hello2:String = "hello")

  1. @Test
  2.   // 常见的变量与常量类型
  3.   def variable(){
  4.     // 常量
  5.     // 使用val修饰的变量值是不可变的,相当于java里用final修饰的变量.
  6.       val a = 1
  7.     // false. val can not change.
  8.     //  a = 2
  10.       // 变量
  11.       // < var a = xx >. scala会自动推断变量的类型.
  12.       // < var a : type(Int,String,...) >. 可以通过值得scala变量的类型.
  13.       var b1 = 1
  14.       var b2: String = "hello"  
  15.   }
判断(if)

Scala内的if判断与Java中的类似. 但是表达式更加的泛化, 并且可以直接赋值给变量. 并且if内的返回值可以是多种数据类型的.(详间下方Scala示例.)

  1. # Java
  2. int a=0;
  3. if(a>0){
  4.     a++;
  5. }else{
  6.     a--;
  7. }
  9. # Scala
  10.  def ifelse(){
  11.     println("if---else---test")
  12.     val x =  1
  13.     // 判断x的值 返回值给y
  14.     val y = if(x>0) 1 else -1
  15.     println(y)
  17.     // 支持混合类型表达式
  18.     val z = if(x>2) 1 else "error"
  19.     println(z)
  21.     // 缺失else 相当于if(x>2) else()
  22.     val m = if(x>2) 1
  23.     println(m)
  25.     // scala中有个Unit类, 相当于Java中的void.
  26.     val n = if(x>2) 1 else()
  27.     println(n)
  29.     val k = if(x<0) 0 else if(x>2) 1 else -1
  30.     println(k)
  31.   }
代码块(Block)

在Java中, 代码块是由{}中的代码体. 在Scala内也是如此. 唯一不同的是, Scala内的代码体是可以赋值的.

  1. # Java
  2. public static void main(String[]args){
  3.     int a=0;
  4.     int b=0;
  5. }
  7. # Scala
  8.  @Test
  9.   // 块表达式(如何确定block的返回值?)
  10.   def block(){
  11.      println("block---test")
  12.      val x = 0
  13.      val result = {
  14.        if (x>0) -1 else 1
  15.      }
  16.      println(result)
  17.   }
循环(For&While)

在Java内, 我们经常使用while/do-while/for三种循环体. 在Scala内, 我们也可以使用. 但是Scala中, 更经常使用for和map()函数进行循环操作.

  1. # java
  2. public static void main(String []args){
  3.     int a=2;
  4.     while(a>0){
  5.         a++;
  6.     }
  8.     do{
  9.         a++;
  10.     }while(a>0)
  12.     for(int i=a;i>0;i++){
  13.         a++;
  14.     }
  15. }
  17. # Scala
  18. @Test
  19.   // 常见的for循环
  20.   def forcycle(){
  21.     println("for---cycle---test")
  23.     // 遍历 to 是一个方法 
  24.     1 to 10
  25.     for(i <- 1 to 10){print(i)}
  26.     println()
  28.     // 数组的定义 (相当于使用数组的Object方法 也就是静态方法)
  29.     val arr = Array("a","b","c")
  30.     for(a<-arr){print(a)}
  31.     println()
  33.     // 循环带条件, 主要if判断前没有分号
  34.     for(i<- 1 to 3; j<- 1 to 3 if i !=j){
  35.       print(10*(i)+j+" ")
  36.     }
  37.     println()
  39.     //for推导式: for的循环的循环体以yield开始, 该循环会构建出一个集合
  40.     // 每次迭代生成集合的一个值
  41.     val v = for(i<-1 to 10) yield i *10
  42.     println(v)
  44.     1.to(10).map(_*10)
  46.     // 遍历数组
  47.     val arr2 = Array(1,2,3)
  48.     val t = for(i<-arr2) yield i*2
  49.     println(t)
  52.     // 偶数 奇数获取
  53.     val arrTmp = Array(1,2,3,4,5,6,7,8)
  54.     val arrResult = for(i<-arrTmp){if(i%2==0) i else()}
  55.     val arrResult2  = for(i<-arrTmp ; if(i%2==0)) yield i
  56.     val arrResult3  = for(i<-arrTmp ; if(i%2==0)) i
  57.     val arrResult4 = arrTmp.filter(_%2==0)
  59.     for(i <- 1 to arrTmp.length) print(arrTmp(i))
  61.     for(i <- 0 until arrTmp.length) println(arrTmp(i))
  63.   }

Scala do…while 循环

数组&元组

Scala内的数组与Java内数组的定义略有不同. 且插入和删除操作也非常不一样. Scala内通过+和-来进行末尾增加和删除单个元素; ++来增加集合元素. 当然也可以通过insert()和remove()函数进行插入和删除多个元素.

  1. #Java
  2. public static void main(String []args){
  3.     String []array1= {"1","2","3"};
  4.     String []array2 = new String[10];
  5.     // 循环遍历1
  6.     for(String str:array2){
  7.     }
  8.     // 循环遍历2
  9.     for(int i=0;i<array2.length;i++){
  10.     }
  11. }
  13. # Scala
  15.   @Test
  16.   def initArray(){
  17.     // Test1
  18.      // 初始化一个长度为8的定长数组, 所有元素均为0
  19.     val array1 = new Array[Int](10)
  20.     // 直接打印定长数组, 内容为数组的hashcode值
  21.     println(array1)
  22.     // 将数组转换为缓冲, 可以看到数组内的内容
  23.     // to buffer 将数组转换为缓冲
  24.     println(array1.toBuffer)
  26.     // Test2
  27.     // 使用静态方法创建
  28.     val array2 = Array[Int](10)
  29.     println(array2.toBuffer)
  31.     // Test3
  32.     val array3 = Array("Hadoop","Strom","Spark")
  33.     println(array3(1))
  35.     // 变长数组
  36.     // 如果想使用数组缓冲,需要导入 import scala.collection.mutable.ArrayBuffer包
  37.     val arrayBuffer1 = ArrayBuffer[Int]()
  38.     // 尾部追加一个元素 +=尾部追加元素
  39.     arrayBuffer1 += 1
  40.     // 尾部追加多个元素
  41.     arrayBuffer1 += (2,3,4,5)
  42.     // 追加一个数组 ++=
  43.     arrayBuffer1 ++= Array(6,7)
  44.     // 追加一个缓冲数组 ++=
  45.     arrayBuffer1 ++= ArrayBuffer(8,9) 
  46.     // 打印缓冲
  47.     println(arrayBuffer1)
  49.     // 指定位置添加元素
  50.     val arrayBuffer2 = ArrayBuffer[Int]()
  51.     arrayBuffer2 += (1,2,3)
  52.     // 在数组角标为0的位置 开始插入2个元素
  53.     arrayBuffer2.insert(0, -1,0)
  54.     // 在数组角标位置为8的位置删除2个雅俗
  55.     arrayBuffer2.remove(1,2)
  57.   }
  59.   /**
  60.    * 遍历数组的方式主要有2种
  61.    * 1. for循环
  62.    * 2. 使用until生成角标, 0 until 10 (包含0不包含10 前封后开)
  63.    * 3. map方法
  64.    * */
  65.   @Test
  66.   def foreachArray(){
  67.     // 初始化
  68.     val array = Array(1,2,3,4,5,6)
  70.     // 使用for循环
  71.     for(i <- array){
  72.       print(i)
  73.     }
  75.     // 使用角标 (有时候需要获取数组的下标)
  76.     // .reverse可以将其进行反转
  77.     for(i<-(0 until array.length)){
  78.       print(array(i))
  79.     }
  81.     // 倒转遍历数组
  82.     for(i<-(0 until array.length).reverse){      
  83.     }
  85.     // map方式
  86.     // 方法转换为一个函数
  87.     array.map(println(_))
  89.   }
  91.   /**
  92.    * 转换数组, 生成一个新的数组
  93.    * 1. yield方式
  94.    * 2. map方法.
  95.    * */
  96.   @Test
  97.   def swapArray(){
  98.     val array = Array(1,2,3,4,5)
  100.     // 偶数取出来 乘以10
  101.     val arrayOdd = for(i<- array;if i%2==0)yield i*10
  102.     println(arrayOdd.toBuffer)
  105.     // map 方式的隐式函数 (一步一步的简化方式)
  106.     array.map((x:Int)=>x*10)
  107.     array.map(x=>x*10)
  108.     array.map(_*10)
  110.     val arrayOddMap = array.filter(_%2==0).map(_*10)
  111.     println(arrayOddMap.toBuffer)
  113.   }
  115.   /**
  116.    * 与Array相关的其他方法.
  117.    * 
  118.    * */
  119.   @Test
  120.   def otherArrayFunction(){
  121.      val array = Array(1,3,2,5,5)
  123.      // 求和运算
  124.      array.sum
  126.      // 排序
  127.      array.sorted
  129.      // 倒叙
  130.      array.sorted.reverse
  132.      array.sortBy(x=>x)
  134.      // 降叙
  135.      array.sortWith(_>_)
  137.      // 升序
  138.      array.sortWith(_<_)
  140.      // 写成方法体
  141.      array.sortWith((x,y) => (x>y))
  142.      array.sortWith((x,y) => (x<y))
  143.   }
元组

数组中的元素都是相同元素. 但是要应对不同元素组成的集合. 这在Scala内提供了新的数据集合:元组.

  1. @Test
  2.     def initTuple(){
  3.       // Tuple的三个值可以不相同.
  4.       val tuple1 = (1,"Spark",2.0)
  5.       // 映射和Map是特殊的元组 也就是对偶元组
  7.       val pairTuple = ("T",5)
  9.       var m = Map(("b",2),("a",10))
  10.       m += pairTuple
  11.       m += (("A",1),("B",2))
  13.       // x y z的方式取值
  14.       val tupleXYZ, (x,y,z) = (1,"Spark",2.0)
  17.       val array = Array(("a",1),("b",2))
  18.       // 转换为对偶元组
  19.       array.toMap
  21.       // 拉链操作
  22.       val arrayZip1 = Array("a","b","c")
  23.       val arrayZip2 = Array("1","2","3","4")
  24.       // 拉链对应转换. 但是有多的元素则不会再使用.
  25.       arrayZip1.zip(arrayZip2)
  26.     }
集合

Scala内的常用集合除了数组和元组外, 还有List、Map和Set.
值得一提的是, Scala内有可变集合import scala.collection.mutable.HashSet与不可变集合import scala.collection.immutable.HashSet.不可变集合多用于多线程中的某些数据的共享.
其基本使用主要如下所示:

  1. /**
  2.  * Scala 的集合三大类型: 序列 Seq 集Set 映射Map.
  3.  * 所有的集合都扩展自Iterable特质.
  4.  * 在Scala中集合有可变(mutable)和不可变(immutable)两种类型.
  5.  * immutable类型的集合初始化后即不可改变.(与val关键字不同. 主要用于多线程的常量场景.)
  6.  * 
  7.  * 
  8.  * */
  9. class QuickCollection {
  11.     // Sequence 序列相关操作 
  12.     @Test
  13.     def immutableListOperation(){
  14.       val list = List(1,2,3)
  16.       // 使用ListBuffer
  17.       val listBuffer = ListBuffer(1,2,3)
  18.       listBuffer(1) = 200
  19.       val newListBuffer = listBuffer.map(_*10)
  22.       // 其他操作
  23.       val list1 = List(1,2,3)
  24.       val list2 = 0::list1
  25.       val list3 = list1.::(0)
  26.       val list4 = 0+:list1
  27.       val list5 = list1.+:(0)
  29.       // 将一个元素加入到list后面形成新的集合
  30.       val lsit6 = list1 :+3
  32.       val list0 = List(4,5,6)
  33.       // 两个集合合并成为新的集合
  34.       val list7 = list1++list0
  35.       val list8 = list1 ++: list0
  37.     }
  39.     @Test
  40.     def mutableListOperation(){
  41.       // 构建一个可变列表, 初始有三个元素1,2,3
  42.       val list0 = ListBuffer[Int](1,2,3)
  44.       // 创建一个空的可变列表
  45.       val list1 = new ListBuffer[Int]
  46.       // 向list1中追加元素, 注意没有生成新的集合
  47.       list1 += 4
  48.       list1.append(5)
  49.       list1.append(1,2,3,4,5)
  51.       list1 ++= list0
  53.       val list2 = list1 ++ list0
  57.       list0 ++= list1
  58.     }
  60.     // HashSet 也有Immutable与Muttable 可变与不可变的两个版本.
  61.     @Test
  62.     def immuttableSetOperation(){
  63.       val set1 = new HashSet[Int]()
  64.       // 将元素与set1合并成为一个新的set
  65.       val set2 = set1 +1
  66.       // set中的元素不能重复
  68.       val set3 = set1 ++ Set(5,6,7)
  69.       val set0 = Set(1,2,3) ++ set1
  70.       println(set0.getClass)
  72.     }
  74.     // 可变的set的相关操作
  75.     @Test
  76.     def muttableSetOperation(){
  77.       // 创建一个可变的HashSet
  78.       val set1 = new scala.collection.mutable.HashSet[Int]()
  79.       // 向HashSet内添加元素
  80.       set1 += 2
  81.       // add等价于+=
  82.       set1.add(4)
  84.       set1 ++= Set(1,3,5)
  86.       // 删除一个元素
  87.       set1  -= 5
  88.       set1.remove(2)
  89.       println(set1)
  90.     }
  92.     // 不可变Map
  93.     @Test
  94.     def immutableMapOperation(){
  95.       val map1 = new HashMap[String, Int]()
  97.     }
  99.     @Test
  100.     def mutableMapOperation(){
  101.        val map1 = new scala.collection.mutable.HashMap[String, Int]()
  102.        // 向Map内添加元素
  103.        map1("spark") =1
  104.        map1 += (("hadoop",2))
  105.        map1.put("storm", 3)
  106.        println(map1)
  108.        //从map中移除元素
  109.        map1 -= "spark"
  110.        map1.remove("hadoop")
  111.        println(map1)
  113.     }
  114.       @Test
  115.   def initMap(){
  116.     // immutable 不可改变
  117.     val map1 = Map("a"->1, "b"->2)
  119.     // mutable 可以改变
  120.     // import scala.collection.mutable.Map
  121.     val map2 = Map("A"->1, "B" ->2)
  122.     // 访问和修改映射中的值
  123.     map2("A")=2
  124.     map2("C")=100
  126.     map2+=("D"->999)
  127.     map2+=(("F",2))
  129.     //import java.util.HashMap
  130.     // 载入Java的HashMap
  131.     val hm = new HashMap()
  133.     val map3 = Map(("a",1),("B",2))
  135.     map3.getOrElse("C", "123")
  136.   }
  137. }

Reference

[1]. Scala 教程
[2]. Scala：HelloWorld
[3]. Scala(二) 基础语法

发表评论

表情：
评论列表 （有 0 条评论，394人围观）

还没有评论，来说两句吧...

相关阅读

    相关 scala基础语法

    1.变量 scala中变量有两种类型：可变型和不可变型。 可变型：变量的值可以在声明后进行修改； 不可变型：变量的值在声明后无法被修改。 scala中使用va

    落日映苍穹つ落日映苍穹つ/ 0 赞/ 314 阅读

    相关 Scala基础语法

    如果你之前是一名 Java 程序员，并了解 Java 语言的基础知识，那么你能很快学会 Scala 的基础语法。 Scala 与 Java 的最大区别是：Scala 语句末尾

    柔情只为你懂柔情只为你懂/ 0 赞/ 284 阅读