scala语法入门

全栈工程师开发手册 (作者:栾鹏)
架构系列文章

Scala 特性

面向对象特性
Scala是一种纯面向对象的语言,每个值都是对象。对象的数据类型以及行为由类和特质描述。

类抽象机制的扩展有两种途径:一种途径是子类继承,另一种途径是灵活的混入机制。这两种途径能避免多重继承的种种问题。

函数式编程
Scala也是一种函数式语言,其函数也能当成值来使用。Scala提供了轻量级的语法用以定义匿名函数,支持高阶函数,允许嵌套多层函数,并支持柯里化。Scala的case class及其内置的模式匹配相当于函数式编程语言中常用的代数类型。

更进一步,程序员可以利用Scala的模式匹配,编写类似正则表达式的代码处理XML数据。

静态类型
Scala具备类型系统,通过编译时检查,保证代码的安全性和一致性。类型系统具体支持以下特性:

  • 泛型类
  • 协变和逆变
  • 标注
  • 类型参数的上下限约束
  • 把类别和抽象类型作为对象成员
  • 复合类型
  • 引用自己时显式指定类型
  • 视图
  • 多态方法

所以你会发现scala和java的语法基本相似。下面根据一个例子学习一下scala的语法。

import java.awt.{Color, Font}   //引入包内的部分成员
import java.awt._  // 引入包内所有成员

import java.util.{HashMap => JavaHashMap}   // 重命名成员
// 所有类名第一个都要大写
object demo {
  //  方法名称第一个要小写
  def main(args: Array[String]): Unit = {    // def 函数名(参数名:参数类型,参数名:参数类型):返回参数类型={             }
    System.out.println("Hello World!")
    var a = 0;
    // for 循环
    for( a <- 1 to 10){  //for循环,将1-10之间的数进行遍历,包含1和10。如果使用1 until 10只包含1,不包含10
      println( "Value of a: " + a );
    }
    // 输出所有数组元素
    for ( x <- args ) {
      println( x )
    }
  }


  def addInt( a:Int, b:Int ) : Int = {
    var sum:Int = 0
    sum = a + b

    return sum
  }

  //闭包案例。闭包是一个函数,返回值依赖于声明在函数外部的一个或多个变量
  def bibao(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 myVar:String = "Too"  //声明变量
val myVal:String = "Foo"  //声明常量
var myint = 10;  // 声明变量可以不给定类型,但是必须给定初始值
val xmax, ymax = 100  // 声明多个变量,xmax, ymax都声明为100
val pa = (40,"Foo") //声明元组


var z1 = new Array[String](3)   //声明数组
var z2 = Array("Runoob", "Baidu", "Google")   //声明并初始化数组
var myMatrix = ofDim[Int](3,3)   //多维数组
// 遍历多维数组
for (i <- 0 to 2) {
  for ( j <- 0 to 2) {
  myMatrix(i)(j) = j;
}
}

var myList1 = range(10, 20, 2)
var myList2 = range(10,20)

var myList3 =  concat( myList1, myList2)   //合并数组,copy复制数组,empty清空数组,fill填充数组


/////////////////////////容器///////////////////////////////////
// 定义整型 List
val x1 = List(1,2,3,4)
// 定义 Set
val x2 = Set(1,3,5,7)
// 定义 Map
val x3 = Map("one" -> 1, "two" -> 2, "three" -> 3)
// 创建两个不同类型元素的元组
val x4 = (10, "Runoob")
// 定义 Option
val x5:Option[Int] = Some(5)

//////////////////////////迭代器///////////////////////////////
val it = Iterator(20,40,2,50,69, 90)

while (it.hasNext){
  println(it.next())
}

println("最大元素是:" + it.max )
println("最小元素是:" + it.min )

println("ita.size 的值: " + it.size )
println("itb.length 的值: " + it.length )

//////////////////////////自定义类///////////////////////
class Point(xc: Int, yc: Int) {  //自定义类接收参数,相当于把java中的类定义和构造函数写在一起了
  var x: Int = xc
  var y: Int = yc
  //自定义方法
  def move(dx: Int, dy: Int) {
    x = x + dx
    y = y + dy
    println ("x 的坐标点: " + x);
    println ("y 的坐标点: " + y);
  }
}

///////////////////类的继承//////////////////////////
class Location(override val xc: Int, override val yc: Int,   //override 重写了父类的字段
               val zc :Int) extends Point(xc, yc){    //extends 关键字用来继承,Scala 只允许继承一个父类。
  var z: Int = zc

  def move(dx: Int, dy: Int, dz: Int) {
    x = x + dx
    y = y + dy
    z = z + dz
    println ("x 的坐标点 : " + x);
    println ("y 的坐标点 : " + y);
    println ("z 的坐标点 : " + z);
  }
}



//////////自定义函数================
def myfun() {
  val pt = new Point(10, 20);
  // 移到一个新的位置
  pt.move(10, 10);

  val loc = new Location(10, 20, 15);
  // 移到一个新的位置
  loc.move(10, 10, 5);
}
//Scala 模式匹配,也就是case函数
def matchTest(x: Any): Any = x match {
  case 1 => "one"
  case "two" => 2
  case y: Int => "scala.Int"
  case _ => "many"
}


////////////////////Trait(特征)(java接口)//////////////////////
trait Equal {
  def isEqual(x: Any): Boolean
  def isNotEqual(x: Any): Boolean = !isEqual(x)
}
//继承接口,和java中一样
class myclass() extends Equal {

  def isEqual(obj: Any) = true   //实现虚函数,这里是随意写的实现函数
}


////////////////////////文件 I/O///////////////////////////////
val writer = new PrintWriter(new File("test.txt" ))

Scala 数组方法

方法 描述
def apply( x: T, xs: T* ): Array[T] 创建指定对象 T 的数组, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。
def concat[T]( xss: Array[T]* ): Array[T] 合并数组
def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit 复制一个数组到另一个数组上。相等于 Java’s System.arraycopy(src, srcPos, dest, destPos, length)。
def empty[T]: Array[T] 返回长度为 0 的数组
def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T] 返回指定长度数组,每个数组元素为指定函数的返回值。以下实例数组初始值为 0,长度为 3,计算函数为a=>a+1:Array.iterate(0,3)(a=>a+1)
def fill[T]( n: Int )(elem: => T): Array[T] 返回数组,长度为第一个参数指定,同时每个元素使用第二个参数进行填充。
def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]] 返回二数组,长度为第一个参数指定,同时每个元素使用第二个参数进行填充。
def ofDim[T]( n1: Int ): Array[T] 创建指定长度的数组
def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]] 创建二维数组
def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]] 创建三维数组
def range( start: Int, end: Int, step: Int ): Array[Int] 创建指定区间内的数组,step 为每个元素间的步长
def range( start: Int, end: Int ): Array[Int] 创建指定区间内的数组
def tabulate[T]( n: Int )(f: (Int)=> T): Array[T] 返回指定长度数组,每个数组元素为指定函数的返回值,默认从 0 开始。以下实例返回 3 个元素:Array.tabulate(3)(a => a + 5)
def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]] 返回指定长度的二维数组,每个数组元素为指定函数的返回值,默认从 0 开始。

Scala Iterator 常用方法

下表列出了 Scala Iterator 常用的方法:

方法 描述
def hasNext: Boolean 如果还有可返回的元素,返回true。
def next(): A 返回迭代器的下一个元素,并且更新迭代器的状态
def ++(that: => Iterator[A]): Iterator[A] 合并两个迭代器
def ++[B >: A](that :=> GenTraversableOnce[B]): Iterator[B] 合并两个迭代器
def addString(b: StringBuilder): StringBuilder 添加一个字符串到 StringBuilder b
def addString(b: StringBuilder, sep: String): StringBuilder 添加一个字符串到 StringBuilder b,并指定分隔符
def buffered: BufferedIterator[A] 迭代器都转换成 BufferedIterator
def contains(elem: Any): Boolean 检测迭代器中是否包含指定元素
def copyToArray(xs: Array[A], start: Int, len: Int): Unit 将迭代器中选定的值传给数组
def count(p: (A) => Boolean): Int 返回迭代器元素中满足条件p的元素总数。
def drop(n: Int): Iterator[A] 返回丢弃前n个元素新集合
def dropWhile(p: (A) => Boolean): Iterator[A] 从左向右丢弃元素,直到条件p不成立
def duplicate: (Iterator[A], Iterator[A]) 生成两个能分别返回迭代器所有元素的迭代器。
def exists(p: (A) => Boolean): Boolean 返回一个布尔值,指明迭代器元素中是否存在满足p的元素。
def filter(p: (A) => Boolean): Iterator[A] 返回一个新迭代器 ,指向迭代器元素中所有满足条件p的元素。
def filterNot(p: (A) => Boolean): Iterator[A] 返回一个迭代器,指向迭代器元素中不满足条件p的元素。
def find(p: (A) => Boolean): Option[A] 返回第一个满足p的元素或None。注意:如果找到满足条件的元素,迭代器会被置于该元素之后;如果没有找到,会被置于终点。
def flatMap[B](f: (A) => GenTraversableOnce[B]): Iterator[B] 针对迭代器的序列中的每个元素应用函数f,并返回指向结果序列的迭代器。
def forall(p: (A) => Boolean): Boolean 返回一个布尔值,指明 it 所指元素是否都满足p。
def foreach(f: (A) => Unit): Unit 在迭代器返回的每个元素上执行指定的程序 f
def hasDefiniteSize: Boolean 如果迭代器的元素个数有限则返回true(缺省等同于isEmpty)
def indexOf(elem: B): Int 返回迭代器的元素中index等于x的第一个元素。注意:迭代器会越过这个元素。
def indexWhere(p: (A) => Boolean): Int 返回迭代器的元素中下标满足条件p的元素。注意:迭代器会越过这个元素。
def isEmpty: Boolean 检查it是否为空, 为空返回 true,否则返回false(与hasNext相反)。
def isTraversableAgain: Boolean Tests whether this Iterator can be repeatedly traversed.
def length: Int 返回迭代器元素的数量。
def map[B](f: (A) => B): Iterator[B] 将 it 中的每个元素传入函数 f 后的结果生成新的迭代器。
def max: A 返回迭代器迭代器元素中最大的元素。
def min: A 返回迭代器迭代器元素中最小的元素。
def mkString: String 将迭代器所有元素转换成字符串。
def mkString(sep: String): String 将迭代器所有元素转换成字符串,并指定分隔符。
def nonEmpty: Boolean 检查容器中是否包含元素(相当于 hasNext)。
def padTo(len: Int, elem: A): Iterator[A] 首先返回迭代器所有元素,追加拷贝 elem 直到长度达到 len。
def patch(from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B] 返回一个新迭代器,其中自第 from 个元素开始的 replaced 个元素被迭代器所指元素替换。
def product: A 返回迭代器所指数值型元素的积。
def sameElements(that: Iterator[_]): Boolean 判断迭代器和指定的迭代器参数是否依次返回相同元素
def seq: Iterator[A] 返回集合的系列视图
def size: Int 返回迭代器的元素数量
def slice(from: Int, until: Int): Iterator[A] 返回一个新的迭代器,指向迭代器所指向的序列中从开始于第 from 个元素、结束于第 until 个元素的片段。
def sum: A 返回迭代器所指数值型元素的和
def take(n: Int): Iterator[A] 返回前 n 个元素的新迭代器。
def toArray: Array[A] 将迭代器指向的所有元素归入数组并返回。
def toBuffer: Buffer[B] 将迭代器指向的所有元素拷贝至缓冲区 Buffer。
def toIterable: Iterable[A] Returns an Iterable containing all elements of this traversable or iterator. This will not terminate for infinite iterators.
def toIterator: Iterator[A] 把迭代器的所有元素归入一个Iterator容器并返回。
def toList: List[A] 把迭代器的所有元素归入列表并返回
def toMap[T, U]: Map[T, U] 将迭代器的所有键值对归入一个Map并返回。
def toSeq: Seq[A] 将代器的所有元素归入一个Seq容器并返回。
def toString(): String 将迭代器转换为字符串
def zip[B](that: Iterator[B]): Iterator[(A, B) 返回一个新迭代器,指向分别由迭代器和指定的迭代器 that 元素一一对应而成的二元组序列
展开阅读全文

没有更多推荐了,返回首页