Scala快速入门

最新推荐文章于 2024-05-30 00:38:23 发布

shanxiyaofeng

最新推荐文章于 2024-05-30 00:38:23 发布

阅读量702

点赞数

分类专栏： Scala 文章标签： scala java 开发语言

本文链接：https://blog.youkuaiyun.com/shanxiyaofeng/article/details/122047004

版权

Scala 专栏收录该内容

1 篇文章

订阅专栏

简介

Scala 是一门多范式（multi-paradigm）的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。

Scala 运行在 Java 虚拟机上，并兼容现有的 Java 程序。

Scala 源代码被编译成 Java 字节码，所以它可以运行于 JVM 之上，并可以调用现有的 Java 类库。

安装及环境配置

Scala是基于java之上，大量使用java的类库和变量，使用 Scala 之前必须先安装 Java（>1.5版本）。

1、安装JDK

在Oracle官网下载JDK1.8版本，进行安装并设置环境变量。

使用命令查看安装情况：

查看Java编译器是否安装成功：

2、安装Scala （Windows环境）

从 Scala 官网地址 Download Scala 2 | The Scala Programming Language 下载 Scala 二进制包

下载好后，双击安装包后，点击多个下一步之后便安装完成。然后再进行环境变量配置

右击【我的电脑】--【属性】--【高级系统设置】--【环境变量】，如图：

设置 SCALA_HOME 变量：单击新建，在变量名栏输入：SCALA_HOME: 变量值一栏输入： Scala 的安装目录。如图：

设置 Path 变量：找到系统变量下的"Path"如图，单击编辑。在"变量值"一栏的最前面添加如下的路径： %SCALA_HOME%\bin;%SCALA_HOME%\jre\bin;

设置 Classpath 变量：找到找到系统变量下的"Classpath"如图，单击编辑，如没有，则单击"新建":

"变量名"：ClassPath
"变量值"：.;%SCALA_HOME%\bin;%SCALA_HOME%\lib\dt.jar;%SCALA_HOME%\lib\tools.jar.;

注意："变量值"最前面的 .; 不要漏掉。最后单击确定即可。

检查环境变量是否配置成功

第一个Scala程序

object HelloWorld {
   def main(args: Array[String]) {
      println("Hello world!") 
   }
}

基础语法例子

变量

object demo {
	def main(args: Array[String]) {
  	// 使用var声明变量
    var name: String = "zhangsan"
    // 使用val声明常量
    val age: Int = 18
    // 不指定类型，系统会根据数据自动推算类型
    var address = "深圳"
  }
}

访问修饰符

私有成员（Private）

被private修饰的成员，它只允许类内部成员或内部类访问。

class Outer{
    class Inner{
        private def f(){
            println("f")
        }
        class InnerMost{
            f() // 正确
        }
    }
    (new Inner).f() //错误
}

保护成员（Protected）

被protected修饰的成员，它只允许在定义了该成员的子类中被访问。

package p{
		class Super{
    		protected def f() {println("f")}
    }
    class Sub extends Super{
        f()
    }
    class Other{
        (new Super).f() //错误
    }
}

公共成员（Public）

没有指定任何修饰符，则默认为public，这样的成员可以在任何地方被访问。

循环

while循环

do...while循环

for循环

object Test {
   def main(args: Array[String]) {
      var a = 0;
     // 包含 10
      for( a <- 1 to 10){
         println( "Value of a: " + a );
      }
     // 不包含 10
     for( a <- 1 until 10){
         println( "Value of a: " + a );
      }
     // 使用分号（;）来设置多个区间
     var i,j = 0;
     for(i <- 1 to 3; j <- 1 to 3) {
     	  println( "Value of i: " + i );
        println( "Value of j: " + j );
     }
     // 遍历集合
      val numList = List(1,2,3,4,5,6,7,8,9,10);
      for( a <- numList ){
         println( "Value of a: " + a );
      }
     // 过滤条件
      for( a <- numList
           if a != 3; if a < 8 ){
         println( "Value of a: " + a );
      }
     // 存储循环的返回值
     var retVal = for{ a <- numList
                        if a != 3; if a < 8
                      }yield a
     // 输出返回值
      for( a <- retVal){
         println( "Value of a: " + a );
      }
   }
}

break语句

import scala.util.control._

object Test {
   def main(args: Array[String]) {
      var a = 0;
      var b = 0;
      val numList1 = List(1,2,3,4,5);
      val numList2 = List(11,12,13);

      val outer = new Breaks;
      val inner = new Breaks;

      outer.breakable {
         for( a <- numList1){
            println( "Value of a: " + a );
            inner.breakable {
               for( b <- numList2){
                  println( "Value of b: " + b );
                  if( b == 12 ){
                     inner.break;
                  }
               }
            } // 内嵌循环中断
         }
      } // 外部循环中断
   }
}

方法与函数

Scala中使用val语句定义函数，def语句定义方法。

class Test{
  def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b
      return sum
   }
  val f = (x: Int) => x + 3
}

闭包

object Test {  
   def main(args: Array[String]) {  
      println( "muliplier(1) value = " +  multiplier(1) )  
      println( "muliplier(2) value = " +  multiplier(2) )  
   }  
   var factor = 3  
   val multiplier = (i:Int) => i * factor  
}

数组

// 数组声明
var z:Array[String] = new Array[String](3)
var z = new Array[String](3)
// 初始化
z(0) = "Runoob"; z(1) = "Baidu"; z(4/2) = "Google"
// 声明并初始化
var z = Array("Runoob", "Baidu", "Google")

多维数组

import Array._
object Test {
   def main(args: Array[String]) {
      val myMatrix = Array.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();
      }
   }
}

集合

// 定义整型 List
val x = List(1,2,3,4)

// 定义 Set
val x = Set(1,3,5,7)

// 定义 Map
val x = Map("one" -> 1, "two" -> 2, "three" -> 3)

// 创建两个不同类型元素的元组
val x = (10, "Runoob")

// 定义 Option
val x:Option[Int] = Some(5)

迭代器

object Test {
   def main(args: Array[String]) {
      val it = Iterator("Baidu", "Google", "Runoob", "Taobao")    
      while (it.hasNext){
         println(it.next())
      }
   }
}

Trait(特征)

trait Equal {
  def isEqual(x: Any): Boolean
  def isNotEqual(x: Any): Boolean = !isEqual(x)
}

class Point(xc: Int, yc: Int) extends Equal {
  var x: Int = xc
  var y: Int = yc
  def isEqual(obj: Any) =
    obj.isInstanceOf[Point] &&
    obj.asInstanceOf[Point].x == x
}

object Test {
   def main(args: Array[String]) {
      val p1 = new Point(2, 3)
      val p2 = new Point(2, 4)
      val p3 = new Point(3, 3)

      println(p1.isNotEqual(p2))
      println(p1.isNotEqual(p3))
      println(p1.isNotEqual(2))
   }
}

模式匹配

object Test {
   def main(args: Array[String]) {
      println(matchTest("two"))
      println(matchTest("test"))
      println(matchTest(1))
      println(matchTest(6))

   }
   def matchTest(x: Any): Any = x match {
      case 1 => "one"
      case "two" => 2
      case y: Int => "scala.Int"
      case _ => "many"
   }
}

object Test {
   def main(args: Array[String]) {
        val alice = new Person("Alice", 25)
        val bob = new Person("Bob", 32)
        val charlie = new Person("Charlie", 32)
   
    for (person <- List(alice, bob, charlie)) {
        person match {
            case Person("Alice", 25) => println("Hi Alice!")
            case Person("Bob", 32) => println("Hi Bob!")
            case Person(name, age) =>
               println("Age: " + age + " year, name: " + name + "?")
         }
      }
   }
   // 样例类
   case class Person(name: String, age: Int)
}

正则表达式

object Test {
   def main(args: Array[String]) {
      val pattern = "(S|s)cala".r
     // val pattern = new Regex("(S|s)cala")
      val str = "Scala is scalable and cool"
     
      println(pattern replaceFirstIn(str, "Java"))
   }
}

异常处理

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Test {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException =>{
            println("Missing file exception")
         }
         case ex: IOException => {
            println("IO Exception")
         }
      }
   }
}

提取器

Scala 提取器是一个带有unapply方法的对象。unapply方法算是apply方法的反向操作。unapply是必须的，apply可选。

object Test {
   def main(args: Array[String]) {
     
      val x = Test(5)
      println(x)

      x match
      {
         case Test(num) => println(x + " 是 " + num + " 的两倍！")
         //unapply 被调用
         case _ => println("无法计算")
      }

   }
   def apply(x: Int) = x*2
   def unapply(z: Int): Option[Int] = if (z%2==0) Some(z/2) else None

文件I/O

写

import java.io._

object Test {
   def main(args: Array[String]) {
      val writer = new PrintWriter(new File("test.txt" ))
      writer.write("test")
      writer.close()
   }
}

读

import scala.io.Source

object Test {
   def main(args: Array[String]) {
      println("文件内容为:" )
      Source.fromFile("test.txt" ).foreach{
         print
      }
   }
}

参考文献

Scala官网

Scala教程