scala学习

1、学习网址：

     http://www.runoob.com/scala/scala-iterators.html

     http://blog.csdn.net/mapdigit/article/details/21878083

2、代码整理

     

//变量
/*var myVar:String="Foo"
var myVar=Foo""
val myVal:String="Foo"
val myVal="Foo"
val (myvar1:Int,myVar2:String)=Pair(40,"Foo")
val (myVal1,myVal2)=Pair(40,"Foo")
*/



//运算符
/*object Test{
	def main(args: Array[String])
	{
		var a=10;
		var b=20;
		var c=25;
		var d=25;
		println("a+b="+(a+b));
		println("a-b="+(a-b));
		println("a*b="+(a*b));
		println("b/a="+(b/a));
		println("b%a="+(b%a));
	}
}*/



//for循环
/*object Test{
	def main(args: Array[String])
	{
		/*var a=0;
		var b=0;
		for(a<- 1 to 3;b<- 1 to 3)
		{
			println("Value of a: "+a);
			println("Value of b: "+b);
		}*/

		var a=0;
		val numList=List(1,2,3,4,5,6,7,8,9,10);
		var retVal=for{a<-numList if a!=3; if a<8}yield a

		for(a<-retVal)
		{
			println("Value of a: "+a);
		}
	}
}*/



//for和foreach
/*object Test{
	def main(args:Array[String]){
		val arr=Array(1,2,3,4)
		//for
		for(a<-arr)
			print(" "+a)
		//或者
		for(i<- 0 to (arr.length-1))
			print(" "+arr(i))
			
		//foreach
		arr.foreach{
			a:Int=>print(" "+a)
		}
		//或者
		arr.foreach{
			a=>print(" "+a)
		}
	}
}*/


//break
/*import scala.util.control._
object Test{
	def main(args: Array[String])
	{
		var a=0;
		val numList=List(1,2,3,4,5,6,7,8,9,10);

		val loop=new Breaks;
		loop.breakable{
			for(a<-numList)
			{
				println("Value of a: "+a);
				if(a==4)
				   loop.break;
			}
		}
		println("After the loop");
	}
}*/
/*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;
					}

				}
			}
		}
	}
}*/



//函数基本定义
/*
object Test{
	def main(args: Array[String])
	{
		println("Return Value: "+addInt(3,8));
	}
	def addInt(a:Int,b:Int):Int={
		return a+b;
	}
}*/



//函数按名称调用
/*object Test{
	def main(args:Array[String]){
		delayed(time());
	}
	def time()={
		println("Geting time in nano second");
		System.nanoTime;
	}
	def delayed(t: => Long)={
		//println("In delayed mathod");
		println(t);
		//t;
	}
}*/



//使用命名参数
/*object Test{
	def main(args: Array[String]){
		printInt(b=5,a=7);
	}
	def printInt(a:Int,b:Int)={
		println("Value of a: "+a);
		println("Value of b: "+b);
	}
}*/



//递归函数
/*object Test{
	def main(args: Array[String])={
		for(i<- 1 to 10)
			println("Factorial of "+ i+":= "+fac(i));
	}

	def fac(n:Int):BigInt={
		if(n<=1)
			return 1;
		else
			return n*fac(n-1);
	}
}*/



//可变参数
/*object Test{
	def main(args: Array[String]){
		printStrings("AAA","BBB","CCC");
	}

	def printStrings(args: String*)={
		var i=0;
		for(arg<-args){
			println("Arg value[" + i + "]=" + arg);
			i+=1;
		}
	}
}*/



//默认参数函数
/*object Test{
	def main(args: Array[String]){
		println("Return Value: " + addInt(9));
	}
	def addInt(a:Int=5,b:Int=7):Int={
		return a+b;
	}
}*/



//函数赋值给变量
/*object Test{
	def main(args:Array[String]){
		var f1=func1 _//_将func1转化为函数变量赋值给f1
		f1("spark")
	}
	def func1(name:String)={
		println(name)
	}
}*/



/*高阶函数
*1.函数的参数是函数
*2.函数返回值是函数
*/

//函数的参数是函数
/*object Test{
	def main(args:Array[String]){
		println(func1(scala.math.ceil _))
		println(func1(f11))
	}
	def func1(f1:(Double)=>Double)=f1(100.55)//f1是函数参数，传入Double，返回Double
	def f11(x:Double):Double={
		if(x>10.0)
		   1.1
		else
		   0.0
	}
}*/

//返回一个函数的函数
/*object Test{
	def main(args:Array[String]){
		val quintuple=mulBy(5)
		var value=quintuple(20)
		println(value)
	}
	def mulBy(factor:Double)=(x:Double)=>factor*x
}*/



//匿名函数
/*object Test{
	def main(args:Array[String]){
		var inc=(x:Int)=>x+1
		println(inc(7))

		var mul=(x:Int,y:Int)=>x*y
		println(mul(3,4))

		var userDir=()=>{System.getProperty("user.dir")}
		println(userDir)
	}
}*/



//柯里化函数:原来接收两个参数的函数变成接收一个参数的函数的过程，新的函数返回一个以原有第二个参数
             //作为参数的函数(即柯里化函数接收多个参数构成一条链，每次取一个参数)
/*object Test{
	def main(args:Array[String]){
		println(mulBy(3,4));
		println(mulBy1(4)(6));
		println(mulBy2(7)(8));

		//var r=f1(3,4)(bigger(_,_))
		var r=f1(3)(4)(bigger(_,_))
		println(r)
	}
	//普通定义两个参数
	def mulBy(x:Int,y:Int)=x*y
	//柯里化函数
	def mulBy1(x:Int)=(y:Int)=>x*y
	//更简洁的柯里化
	def mulBy2(x:Int)(y:Int)=x*y

	//柯里化实例1
	/*def f1(x:Int,y:Int)(bigger:(Int,Int)=>Boolean)={
		if(bigger(x,y)) x else y
	}*/
	def f1(x:Int)(y:Int)(bigger:(Int,Int)=>Boolean)={
		if(bigger(x,y)) x else y
	}
	def bigger(x:Int,y:Int)={
		if(x>y) true else false
	} 
}
*/



//嵌套函数:scala允许在一个函数内部定义其他函数，在内部可被调用
/*object Test{
	def main(args:Array[String]){
		println(factorial(3))
		println(factorial(4))
		println(factorial(5))
	}
	def factorial(i:Int):Int={
		def fact(i:Int,accumulator:Int):Int={
			if(i<=1)
				accumulator
			else
				fact(i-1,i*accumulator)
		}
		fact(i,1)
	}
}*/



//部分应用函数:调用函数时，不指定函数所需的所有参数，这样 创建了一个新的函数，这个新的函数被称为原始函数的部分应用函数
/*import java.util.Date
object Test{
	def main(args:Array[String]){
		val logWithDateBound=log(_:Date,"time")
		logWithDateBound(new Date)
		Thread.sleep(1000)
		logWithDateBound(new Date)
		Thread.sleep(1000)
		logWithDateBound(new Date)
	}
	def log(date:Date,message:String)={
		println(date+"----"+message);
	}
}*/



//闭包:变量不在函数作用域范围之内还可以被调用
/*object Test{
	def main(args:Array[String]){
		var more=1;
		//函数变量addMore是一个"闭包"
		val addMore=(x:Int)=>x+more
		println(addMore(100))
		
		//当这个自由变量变化时，闭包能够捕获到这个变化，因此闭包捕获的是这个变量本身
		more=999;
		println(addMore(1))
		
		// 如果闭包在变化，也会反映到闭包外面的值
		val someNumbers=List(-11,-10,-5,0,5,10)
		var sum=0
		someNumbers.foreach(sum+=_) //_代表参数列表
		println(sum) //可以看到在闭包中修改sum的值，结果传递到了闭包的外面
	}
}*/



//字符串
/*object Test{
	var greeting:String="Hello,world !"
	var len=greeting.length();
	def main(args:Array[String]){
		println(len)
		
		//创建格式化字符串
		var floatVar=12.456
		var intVar=2000
		var stringVar="Hello,Scala"
		var fs=printf("The value of the float variable is "+"%f,while the value of the integer "
		+"Variable is %d,and the string " + "is %s",floatVar,intVar,stringVar)
		println(fs)
	}
}*/



//数组
/*import Array._
object Test{
	def main(args:Array[String]){
		//声明数组变量
		//var z=new Array[String](3)
		
		//打印数组元素
		/*var myList=Array(1.9,2.9,3.4,3.5)
		for(x<-myList){
			println(x)
		}
		
		//加和数组元素
		var total=0.0
		for(i<-0 to (myList.length-1)){
			total+=myList(i)
		}
		println("Total is "+total)
		
		//Finding the largest element
		var max=myList(0)
		for(i<- 1 to (myList.length-1)){
			if(myList(i)>max)
				max=myList(i)
		}
		println("Max is "+max)*/
		
		//多维数组
		/*var myMatricx=ofDim[Int](3,3)//scala不支持数组，但是提供ofDim方法来创建多维数组
		for(i<-0 to 2)
		{
			for(j<-0 to 2)
			{
				myMatricx(i)(j)=j
			}
		}
			
		for(i<-0 to 2)
		{
			for(j<-0 to 2)
			{
				print(" "+myMatricx(i)(j))
			}
			println()
		}*/

		//连接数组
		/*var myList1=Array(1.9,2.9,3.4,3.5)
		var myList2=Array(8.9,7.9,0.4,1.5)
		var myList3=concat(myList1,myList2)
		for(x<-myList3)
			println(x)*/
			
		//创建具有范围数组
		var myList1=range(10,20,2)
		var myList2=range(10,20)
		for(x<-myList1)
			print(" "+x)
		println()
		for(x<-myList2)
			print(" "+x)
	}
}*/



//集合
/*
1.Lists:元素类型相同、不可变(对象本身不能被改变)
2.Sets:元素类型相同、不能重复、默认是不可变集合
3.Map
4.Tuples:容纳不同类型的对象、不可变
5.Options:包含或者不包含某些事物的容器
6.Iterators:不是集合、用于访问集合的方法
*/
//1.Lists:元素类型相同、不可变(对象本身不能被改变)
/*object Test{
	def main(args:Array[String]){
		//定义Lists
		/*val fruit:List[String]=List("apples","oranges","pears")//第一种定义方式
	    val fruit="apples"::("oranges"::("pears"::Nil))//第二种定义方式
		val nums=Nil
		println("Head of fruit: "+fruit.head)
		println("Tail of fruit: "+fruit.tail)//返回列表除第一个元素外的所有元素
		println("Check if fruit is empty: "+fruit.isEmpty)
		println("Check if nums is Empty: "+nums.isEmpty)*/
		
		//串联列表:使用:::运算符或者List.:::()方法或者List.concat()方法
		/*val fruit1="apples"::("oranges"::("pears"::Nil))
		val fruit2="mangoes"::("banana"::Nil)
		val fruit=fruit1:::*/
		
		//创建统一列表
		/*val fruit=List.fill(3)("apples")//重复apple三次
		println("fruit: "+fruit)*/
		
		//制表
		/*val squares=List.tabulate(6)(n=>n*n)//List(0,1,4,9.16,25)
		println("squares: "+squares)
		val mul=List.tabulate(4,5)(_*_)//List(List(0,0,0,0,0),List(0,1,2,3,4,),List(0,2,4,6,8),List(0,3,6,9,12))
		println("mul: "+mul)*/
		
		//反转
		val fruit="apples"::("oranges"::Nil)
	    fruit.reverse
		println(fruit)
	}
}*/
//3.Map
/*object Test{
	def main(args:Array[String]){
		//基本操作
		/*val colors=Map("red"->"#FF0000","azure"->"#F0FFFF","peru"->"#CD853F")
		val nums:Map[Int,Int]=Map()
		println("Keys in colors: "+colors.keys)
		println("Values in colors: "+colors.values)
		println("Check if colors is empty: "+colors.isEmpty)
		println("Check if nums is empty: "+nums.isEmpty)*/
		
		//串联映射
		/*val colors1=Map("red"->"#FF0000","azure"->"#F0FFFF","peru"->"CD853F")
		val colors2=Map("blue"->"#0033FF","yellow"->"#FFFF00","red"->"#FF0000")
		var colors=colors1.++(colors2)
		println("colors1.++(colors2)): "+colors)*/
		
		//打印映射的键和值
		/*val colors=Map("red"->"#FF0000","azure"->"#F0FFFF","peru"->"CD853F")
		colors.keys.foreach{
			i:String=>print("Key= "+i) 
			          print("Value= "+colors(i))
		}*/
		
		//检查映射中的键
		val colors=Map("red"->"#FF0000","azure"->"#F0FFFF","peru"->"CD853F")
		if(colors.contains("red")){
			println("Red key exists with value: "+colors("red"))
		}
		else
			println("Red key does not exists !")
	}
}*/

//4.Tuples:容纳不同类型的对象、不可变
/*object Test{
	def main(args:Array[String]){
		//基本操作
		/*val t=(1,"Hello",2.1)//定义1
		val t1=new Tuple3(1,"Hello",2.1)//定义2
		
		//访问
		println("firse element: "+t1._1+"; second element: "+t1._2+"; third element: "+t1._3)*/
		
		//遍历元组
		/*val t=(4,3,2,1)
		t.productIterator.foreach{
			i=>println("Value= "+i)
		}*/
		
		//转为字符串
		var t=new Tuple2(1,"Hello,Scala !")
        println("Concatenated String： "+t.toString())		
	}
}*/
//5.Options:包含或者不包含某些事物的容器
/*object Test{
	def main(args:Array[String]){
		//使用模式匹配来对结果做不同的处理
		val capitals=Map("France"->"Paris","Japan"->"Tokyo")
		println(show(capitals.get("Japan")) )   //capitals.get("Japan")=Some(Paris)
		println(show(capitals.get("Indian")) )   //capitals.get("Indian")=None
		
	    //使用getOrElse()方法来对结果进行处理
		val a:Option[Int]=Some(5)
		val b:Option[Int]=None
		println("a.getOrElse(10): "+a.getOrElse(10))
		println("b.getOrElse(10): "+b.getOrElse(10))
	}
	def show(x:Option[String])=x match{
		case Some(s)=>s
		case None=>"?"
	}
}*/

//6.Iterators:不是集合、用于访问集合的方法
/*object Test{
	def main(args:Array[String]){
		val it=Iterator(20,40,2,50,69,90)
		/*while(it.hasNext)//遍历
		{	
			println(it.next())
		}*/
		//获取迭代器的长度
		println("迭代器it的长度为: "+it.length)
	}
}*/




//类和对象
/*
1.scala中的类不声明为public(缺省为public)
2.一个scala源文件中可以有多个类
3.scala不允许类保护静态元素，类似的功能是成为"单例对象"的对象
4.单例对象使用object关键字,单例对象叫做这个对象的伴生对象，相应的类叫做伴生类
5.伴生类和伴生对象要放在同一文件中，可以互相访问对方的私有成员
6.scala使用类参数，scala编译器会编译scala类定义包含的任何不属于类成员和类方法的其他代码，这些代码作为类的主构造函数
7.除主构造函数之外的构造函数都称为辅助构造函数,使用this(...)来定义辅助构造函数,所有辅助构造函数最终都会调用主构造函数

*/
/*import scala.collection.mutable.Map
object Test{
	def main(args:Array[String]){
		println(ChecksumAccumulator.calculate("welcome to scala"))
	}
}
//创建一个计算整数累计校验和的类
class ChecksumAccumulator{
	private var sum=0;
	def add(b:Byte):Unit=sum+=b
	def checksum():Int= ~ (sum & 0xFF) + 1
}

//创建ChecksumAccumulator单例对象
object ChecksumAccumulator{
	private val cache=Map[String,Int]()
	def calculate(s:String):Int={
		if(cache.contains(s))
			cache(s)
		else
			{
				val acc=new ChecksumAccumulator
				for(c<-s)
					acc.add(c.toByte)
				val cs=acc.checksum()
				cache +=( s -> cs )
				cs
			}
	}
}*/

/*
//深入理解伴生对象
object Companion{
	def show=println("I am a companion")
}
class Companion{
	def shout=Companion.show
}
//反编译Companion.class得到以下内容
public class Companion extends java.lang.Object implements scala.ScalaObject{
	public static final void show()
	public Companion()
	public void shout()
}
//即伴生对象和它对应的类在字节码层面走到了一起，换句话说，在Scala里面的class和Object在java层面里面合二为一
*/


//下面定义一个有理数的类来介绍scala类定义的几个特征：类参数、构造函数、方法、操作符、私有成员、重载、过滤、条件检查、引用自身
//有理数定义：n/d，n和d都是整数，d不为0，并且支持有理数的规范表示，如2/10，规范表示为1/5，分子和父母的最小公倍数为1
/*class Rational(n:Int,d:Int){
	println("Created "+n+"/"+d)
}
new Rational(1,2)//打印Created 1/2，即编译器会编译scala类定义包含的任何不属于类成员和类方法的其他代码，这些代码作为类的主构造函数

//重新定义类的toString()方法
class Rational(n:Int,d:Int){
	override def toString()=n+"/"+d
}

//前提条件检查:scala会自动加载Predef对象，他有一个require方法，保证传入构造函数的参数的限制范围
class Rational(n:Int,d:Int){
	require(d!=0)
	override def toString()=n+"/"+d
}
*/

//添加成员变量:需要实现两个有理数相加的效果
/*class Rational(n:Int,d:Int){
	require(d!=0)
	val number=n//类成员变量
	val denom=d//类成员变量
	override def toString()=n+"/"+d
	def add(that:Rational):Rational={
		new Rational(number*that.denom+that.number*denom,denom*that.denom)
	}
}

//自身引用
def lessThan(that:Rational)={
	this.number*that.denom<that.number*this.denom//其中的this可以省略
}

//辅助构造函数: 这里如果定义一个整数，就没必要指明分母，此时整数本身就是一个有理数
def this(n:Int)=this(n,1)

//私有成员变量和方法:需要求分子和分母的最大公倍数的私有方法gcd，同时使用一个私有变量g来保存最大公倍数
class Rational(n:Int,d:Int){
	require(d!=0)
	private val g=gcd(n.abs,d.abs)
	val number=n/g //类成员变量
	val denom=d/g //类成员变量
	def this(n:Int)=this(n,1)
	override def toString()=n+"/"+d
	def add(that:Rational):Rational={
		new Rational(number*that.denom+that.number*denom,denom*that.denom)
	}
	private def gcd(a:Int,b:Int):Int={
		if(b==0) a else gcd(b,a%b)
	}
}

//定义运算符:之前两个数的加法可以写成X.add(Y)或者X add Y，可以定义+，这样可以直接X+Y
class Rational(n:Int,d:Int){
	require(d!=0)
	private val g=gcd(n.abs,d.abs)
	val number=n/g //类成员变量
	val denom=d/g //类成员变量
	def this(n:Int)=this(n,1)
	override def toString()=n+"/"+d
	def +(that:Rational):Rational={
		new Rational(number*that.denom+that.number*denom,denom*that.denom)
	}
	def *(that:Rational)={
		new Rational(number*that.number,denom*that.denom)
	}
	private def gcd(a:Int,b:Int):Int={
		if(b==0) a else gcd(b,a%b)
	}
} 

//方法重载:比如对于Rational对象，+的对象也可以为一个Int对象
def +(i:Int)=new Rational(number+i*denom,denom)

//隐式类型转化：上面定义了Rational的加法，并重载了+以支持整数，r+2,当我们需要2+r怎么办？这时就需要隐式类型转化了
//scala通过implicit def来定义一个隐式类型转化,对2+r的2进行自动调用该方法，把整数转为Rational数据类型
implicit def intToRational(x:Int)=new Rational(x)*/ 




//Scala Trait(特征):相当于Java的接口，与接口不一样的是它还可以定义属性和方法的实现
/*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):Boolean={
		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))
	}
}*/



//模式匹配
/*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("name: "+name+"  age: "+age)
			}
		}
	}
}
//样例类
case class Person(name:String,age:Int)*/



//scala正则表达式
/*import scala.util.matching.Regex
object Test{
	def main(args:Array[String])
	{
		/*val pattern=new Regex("(S|s)cala")//首字母可以是大写S或小写s
		val str="Scala is scalable and cool"
		println((pattern.findAllIn(str)).mkString(","))//使用逗号，连接返回结果
		
		//或者这样简写
		println(pattern findAllIn str).mkString(","))*/
		
		//替换replaceFirstIn()、replaceAllIn()
		/*val pattern="(S|s)cala".r//使用String类的r()方法构造了一个Regex对象
		val str="Scala is scalable and cool"
		println(pattern replaceAllIn(str,"Java"))*/
		
		/*val pattern=new Regex("abl[ae]\\d+")
		val str="ablaw is able1 and able234 and able111"
		println((pattern findAllIn str).mkString(","))//打印able1,able234,able111*/
	}
}*/



//异常处理: 由于case子句是按照次序来捕获异常的，因此，越具体的异常写在最前面，越普通的写到越后面
/*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")
			} 
		}*/
		
		//finally:不管正常还是有异常发生时都需要执行
		try{
			val f=new FileReader("input.txt")
		}
		catch{
			case ex:FileNotFoundException =>{
				println("Missing file exception !")
			}
			case ex:IOException =>{
				println("IO Exception")
			} 
		}
		finally{
			println("Exiting finally......")
		}
	}
}*/



//scala提取器
/*
  1、它是有一个unapply方法(提取器必须有这个方法)的对象，用来拆分对象，apply(可选)用来组合对象
  2、编译器在实例化时会调用apply()方法，
  3、通过apply方法无需使用new就可以创建对象
  4、使用match语句时，unapply将会自动执行*/

/*object Test{
	//基本使用
	/*def main(args:Array[String]){
		println("Apply方法："+apply("Zara","gmail.com"))
		println("unapply方法: "+unapply("Zara@gmail.com"))
	}
	//可选
	def apply(user:String,domin:String)={
		user+"@"+domin
	}
	//必须
	def unapply(str:String):Option[(String,String)]={
		val parts=str split "@"
		if(parts.length==2)
		{
			Some(parts(0),parts(1))
		}
		else
			None
	}*/
	
	//提取器使用模式匹配
    def main(args:Array[String]){
		val x=Test(15)//实例化时，调用apply方法
		println(x)
		
		x match{//unapply将会自动执行
			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/3) else None
}*/



//文件I/O
//import java.io._
/*import scala.io.Source
object Test{
	def main(args:Array[String]){
		//写文件：scala的文件写操作，直接用的是java中的I/O类
		/*val writer=new PrintWriter(new File("test.txt"))
		writer.write("菜鸟教程")
		writer.close()*/
		
		//从屏幕上读取用户输入
		/*val line=Console.readLine
		println("你输出的是："+line)*/
		
		//读文件：使用Source类及伴生对象来读取文件
		Source.fromFile("test.txt").foreach{
			print
		}
	}
}*/