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
}
}
}*/