scala小例子

用Java语言开发许久了，一直接触指令式的语言开发，同时也做的多了，也逐渐感觉到了静态语言的一些弊病。Scala的出现，可以使Java程序员平滑的过度，Scala语言也是运行在JVM上的，可以与Java无缝交互;Scala是面向对象的，可以通过提升接口的抽象级别来帮助管理复杂性。Scala是简洁的，Scala程序员曾报告说，与Java比起来，它的代码行数可以减少到Java的1/10，哈哈，是不是有些夸张呢？个人觉得，如果能减少三分之一，就非常成功了;Scala是静态的，它以Java的内嵌类型系统为基础，允许使用泛型参数化类型，用交集组合型类型和抽象类型隐藏实现细节，从而能够设计出安全而又能灵活使用的接口。

    我们先来安装Scala的开发包，我的版本是scala-2.9.0.1.zip，安装方式解压就可以，环境变量和Jdk的没什么区别，指向到bin目录下就可以了，打开dos窗口，运行scala，出现下面结结果就表示安装成功了
   


    好了，让我们开始Scala之旅吧。
    在Scala中，分号是可选的，你可以写或者不写;定义类和构造函数，Java中一般这么写

Java代码 复制代码 收藏代码
  1. public class MyTest {   
  2.   
  3.     private int id;   
  4.        
  5.     private int index;   
  6.        
  7.     public MyTest(int id, int index) {   
  8.         this.id = id;   
  9.         this.index = index;   
  10.     }   
  11. }  
public class MyTest {

	private int id;
	
	private int index;
	
	public MyTest(int id, int index) {
		this.id = id;
		this.index = index;
	}
}


而在Scala中，可以这么写

Java代码 复制代码 收藏代码
  1. class MyTest(id: Int, index: Int)  
class MyTest(id: Int, index: Int)


除了这些特性，尤其值得一提的是Scala是静态类型的语言，它支持指令式的编程，但更推荐的使用函数式的编程。比如下面的代码

Java代码 复制代码 收藏代码
  1. object HelloWorld {   
  2.   
  3.   def main(args: Array[String]): Unit = {   
  4.     var i = 0  
  5.     while(i < args.length) {   
  6.       println(args(i))   
  7.       i += 1  
  8.     }   
  9.   }   
  10.   
  11. }  
object HelloWorld {

  def main(args: Array[String]): Unit = {
    var i = 0
    while(i < args.length) {
      println(args(i))
      i += 1
    }
  }

}


我可以使用scalac HelloWorld.scala使他生成class字节码，也可以直接在JVM上执行，
scala HelloWorld.scala Hello World
打印结果将是 Hello World
大家不觉得这样有一丁点儿复杂吗，来看看Scala的函数式的编程是什么样的

Java代码 复制代码 收藏代码
  1. object HelloWorld {   
  2.   
  3.   def main(args: Array[String]): Unit = {   
  4.     args.foreach(arg => print(arg + " "))   
  5.   }   
  6.   
  7. }  
object HelloWorld {

  def main(args: Array[String]): Unit = {
    args.foreach(arg => print(arg + " "))
  }

}


arg就是你临时定义的变量，Scala默认为其开辟了临时的String变量arg。

体验了最初的简单函数式风格，我们再看下Scala中如何使用数组，在Java中，使用一个最简单数组是这样的

Java代码 复制代码 收藏代码
  1. public class ArrayTest {   
  2.   
  3.     public static void main(String[] args) {   
  4.         String[] strs = new String[]{"Hello", "World", "!"};   
  5.         for(String str : strs) {   
  6.             System.out.println(str);   
  7.         }   
  8.     }   
  9. }  
public class ArrayTest {

	public static void main(String[] args) {
		String[] strs = new String[]{"Hello", "World", "!"};
		for(String str : strs) {
			System.out.println(str);
		}
	}
}


在Scala中，同样是通过new来实例化对象，实例化过程中，可以用值和类型使对象参数化，使用值参数化实例可以通过把值传递给构造器的圆括号来实现，比如，Scala中数组是这么实现的，值得一提的是，在Scala中，数组是可变数据结构，这是和Java中有区别的地方

Java代码 复制代码 收藏代码
  1. object ArrayTest {   
  2.   
  3.   def main(args: Array[String]): Unit = {   
  4.     var greetString = new Array[String](3)   
  5.     greetString(0) = "Hello"  
  6.     greetString(1) = "World"  
  7.     greetString(2) = "!"  
  8.        
  9.     for(i <- 0 to 2) {   
  10.       println(greetString(i))   
  11.     }   
  12.   }   
  13.   
  14. }  
object ArrayTest {

  def main(args: Array[String]): Unit = {
    var greetString = new Array[String](3)
    greetString(0) = "Hello"
    greetString(1) = "World"
    greetString(2) = "!"
    
    for(i <- 0 to 2) {
      println(greetString(i))
    }
  }

}



i <- 这个表达式是表示左边的涵盖在右边范围之内。
下面我们来看看List，在Java中，List是可变的结构序列，而在Scala中，List是不可变的，在Scala中，List是不可变的数据结构，这么设计是为了函数式编程而设计的，奇特的是，Scala中并不需要通过new来创建List对象，比如下面一个例子，我创建了两个集合，并且把它们循环打印出来。

Java代码 复制代码 收藏代码
  1. def main(args: Array[String]): Unit = {    
  2.     var list1 = List("aaa", "bbb", "ccc")   
  3.     var list2 = List("ddd")   
  4.     var list3 = list1 ::: list2   
  5.     list3.foreach(list => print(list + " "))   
  6.   }  
def main(args: Array[String]): Unit = { 
    var list1 = List("aaa", "bbb", "ccc")
    var list2 = List("ddd")
    var list3 = list1 ::: list2
    list3.foreach(list => print(list + " "))
  }


打出的结果就是 aaa bbb ccc ddd

我们再来看看Set和Map，Scala致力于充分利用函数式和指令式两方面的好处，所以它的集合库区分为可变型和不可变型，都承接与Set，他们分别在Scala的不同包里。在Java中，我们称为“实现”了接口，而在Scala中，我们称为“扩展”或“混入”，下面我分别用Scala中的HashSet和HashMap的不可变数据类型，来做例子

Java代码 复制代码 收藏代码
  1. object SetTest {   
  2.   
  3.   def main(args: Array[String]): Unit = {   
  4.     var set = HashSet("b", 3, "c")   
  5.     set += "very"  
  6.     set.foreach(value => print(value + " "))   
  7.   }   
  8.   
  9. }  
object SetTest {

  def main(args: Array[String]): Unit = {
    var set = HashSet("b", 3, "c")
    set += "very"
    set.foreach(value => print(value + " "))
  }

}



这是Set的，下面是关于Map的

Java代码 复制代码 收藏代码

object MapTest {     

  def main(args: Array[String]): Unit = {    

    var map = HashMap(1 -> "a", 2 -> "b", 3 -> "c")   

    map += (4 -> "d")   

    map.foreach(value => print(value + " "))   

  }   

}  

object MapTest {

  def main(args: Array[String]): Unit = { 
    var map = HashMap(1 -> "a", 2 -> "b", 3 -> "c")
    map += (4 -> "d")
    map.foreach(value => print(value + " "))
  }

}


Scala的程序，只要后缀名命名为.scala就可以了。同时Eclipse也内置了对Scala的支持，安装插件的网址是http://download.scala-ide.org/nightly-update-wip-experiment-2.9.0.final
大家可以自行安装，安装完后就可以在Eclipse中运行了，如下图


现在对函数式编程有个了最初体会了，呵呵，以后还会继续探讨关于Scala函数式编程带来的一些好处，大家相互学习，还请多多指教。

posted @ 2012-04-22 20:05  牧涛  阅读(14501)  评论(0)  编辑  收藏  举报