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("[email protected]")) } //可选 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 } } }*/