scala 第二天

scala>:help //帮助
scala
-----------
1 to 10 //to 包含10
1 until 10 //until 不包含 10
------------
方法是针对对象的

1.*************************************函数
-------------
def define定义
1.scala>def add(a:Int,b:Int)=a+b //add:(a:Int,b:Int)Int
1.scala>def add(a:Int,b:Int):Int = a+b //有返回值定义
2.scala>val x = add(1,2) //x: Int = 3
递归函数定义
1.scala>def fac(n:Int):Int=if(n==1) 1 else n*fac(n-1) //递归函数必须有返回值
2.scala>val x=fac(5) //x:Int=120
默认参数和带名参数
1.scala>def decorate(str:String , left:String="[",right:String="]")=left +str +right ;
2.scala>val x=decorate("hello") //默认参数x:String = [hello]
2.scala>val x=decorate("hello","..") //默认参数改left，x:String = ..hello]
2.scala>val x=decorate("hello",right="..") //命名参数改right，x:String=[hello..
变长参数-------------------------
1.scala>def sum(args : Int*):Int = {
var s = 0;
for(i <- args){
s=s+i;
}
s;
} //循环
2.scala>val x= sum(1,2,3) //x:Int=6
2.scala>val x=sum(1 to 10) //错误，此为整数区间，而不是参数序列
2.scala>val x=sum(1 to 10:_*) //将1 to 10 当作参数序列处理，x:Int=55

1.scala>def sum(args:Int*):Int ={
if(args.length ==0)0
else args.head + sum(args.tail:_*);} //递归函数求参数序列总和,
2.scala>val x=sum(1,2,3,4) //x:Int=10，args.head:首个数，sum（args.tail:_*）：后面所有数的和
----------------------------------------

 

2.****************************************过程
特殊的函数，没有返回值，{}前没有等号。
scala>def sayhello{println("hello world");100} //过程，返回值是unit，会有警告
scala>def sayhello={println("hello world");100} //函数，返回int
scala>def sayhello:Int={println("hello world");return 100} //函数，返回Int
scala>def sayhello:Int={println("hello world");return 100} //函数，如果无参，可不带(),调用时不能带()
scala>def sayhello:Int={println("hello world");return 100} //函数，如果无参，可带(),调用时不能带()
--------------------------------------

3.**************************************加载文件
scala>：load f:\scala\for99.scala //加载scala脚本执行
scala> val x=scala.io.Source.fromFile("f:\\scala\\hello world.txt")mkString
//x:String = hello world
4.********************************懒值lazy：延迟加载
1.scala>lazy val x=scala.io.Source.fromFile("f:\\scala\\hello world.txt")mkString //x:String=<lazy>
2.scala>x //x:String = hello world
----------------------------------------
5.***************************************异常
throw //抛异常
throws //声明抛出异常
throwable //异常体系的根类

java.lang.Throwable
java.langError //错误
java.lang.Exception //异常 RuntimeException

1.scala>import scala.math._
2.scala>val x= -2
3.scala>val y=if(x>0) sqrt(2) else throw new IllegalArgumentException("x should not be negative");
//3会抛出异常java.lang.IllegalArgumentException:x should not be negative
捕获异常
try{...
}catch{
_ : XxxException => xxx; =>指向哪段处理代码异常：xxx
ex: YyyExceptin => ex.xxx}

try{
...}finally{ //finally无论如何都会被执行
...}
-----------------------------------------
6.**********************************定长数组
数字数组
scala>Array(1,2,3,4) //相当于Array.apply(1,2,3,4)
1.scala>val a=new Array [Int](10) //scala中的泛型
2.scala>a(0)=100 //根据下标赋值
3.scala>for (i <- a){println(i)} //循环输出

字符串数组:可直接赋值
scala>Array("hello","world") //Array.applu("hello","world")

7.*********************************变长数组 ArrayBuffer
1.scala>import scala.collection.mutable.ArrayBuffer
2.scala>val a=ArrayBuffer[Int]()
3.scala>a +=1 //向变长数组添加元素，格式必须为a += 1
3.scala>a +=2 //向变长数组添加元素
3.scala>a +=(3,4,5) //一次加多个元素
3.scala>a ++=Array(1,2,3,4,5) //追加数组
3.scala>a -=1 //去除值1
4.scala>a.trimEnd(3) //移除最后几个元素
4.scala>a.trimStart(3) //移除开头几个元素
4.scala>a.remove(index) //移除index处元素，index为下角标
4.scala>a.remove(index1,index2) //移除index1和index2闭区间的元素
5.scala>a.insert(index,x1,x2) //在index处插入x1,x2；index为下角标
5.scala>a.append(7,7,7) //在末尾追加7，7，7
5.scala>a.appendAll(Array(9,9,9,9)) //末尾追加一个集合

6.scala>val c =a.toArray //将变长转变为定长;c为定长

8.**********************************遍历数组
scala>val x=1 until 10 //1,2,3,4,5,6,7,8,9
scala>val x=(1 until (10,2)).reverse //9,7,5,3,1;倒序
1.scala>val x=1 until (10,2) //1,3,5,7,9
2.scala>for(i<-x)yield i*2 //2,6,10,14,18
2.scala>for(i<-x if i%3==0)yield i*2 //6,18;带守卫

1.scala>val a=Array(1,2,3,4)
2.scala>a.filter(_%2==0).map(2 *_) //4,8;map为函数

9.***********************************内置算法函数
1.scala>a=Array(2，4，6，0，1)
2，scala>a.sum //a的和
2，scala>a.max //a的最大元素值
2，scala>a.min //a的最小元素值
2，scala>a.sorted //a的排序：0，1，2，4，6
2，scala>(a.sorted).reverse //a的逆序：6，4，2，1，0

1.scala>val a=Array(1,7,4,6)
2.scala>scala.util.Sorting.quickSort(a) //对a快排序
3.scala>a //1,4,6,7
输出数组元素，可指定字符串分隔符
4.scala>a.mkString //String:1467
4.scala>a.mkString(";") //String:1;4;6;7
4.scala>a.mkString("<<<",",",">>>") //<<<1,4,6,7>>>
数组中加数字
1.scala>val a=Array(1,4,6,7)
2.scala>w=a.mkString("5") //w:String=1545657
3.scala>q=w.toCharArray //q=Array(1,5,4,5,6,5,7)

10.***********************************多维数组
1.scala>val a2 :Array[Array[Int]] = Array.ofDim[Int](3,4) //3行4列
2.scala>for(i<-a2)for(j<-i)print(j) //普通输出
2.scala>for(i<-a2){for(j<-i)print(j);println()} //以矩阵输出
3.scala>a2(a)(b)=x //赋值：a行；b列，c值
3.scala>var x=1 ;
for(i <- 0 until a2.length){
for(j <- 0 until a2(i).length){
a2(i)(j)=x;
x +=1;
}} //为数组全部数赋值1-12
-------------------------------------------------------------
11.***************映射（map）和元组（tuple）
scala>val a2=Map("001"->"tom","002"->"tomas","003"->"tomaslee") //key存值，不可变map；映射
scala>val m=Map(("id","1"）,("name","an"),("tel","111")) //映射就是对偶的集合
1.scala>val a2=Map(1->"tom",2->"tomas",3->"tomaslee") //key存值，不可变map；映射
2.scala>for(i<-a2)println(i) //查看所有值
2.scala>a2(1) //查看指定key的值
可变的map
1.scala>val a=scala.collection.mutable.Map(1->"tom",2->"toms",3->"tomslee") //key存值，可变map；映射
2.scala>a(1)="acg" //key 1的值变为acg
3.scala>val w=a + (4->"zyb") //添加key与值，产生新val
3.scala>a.put(4,"k") //在原val中添加key与值

对偶
scala>val a = "1"->"an" //对偶
scala>val a=("1","an") //对偶
scala>val a=("1","an",123) //三维元祖
映射就是对偶的一个集合
scala>val m=Map(("id","1"）,("name","an"),("tel","111")) //映射
scala>m.getOrElse("married",0) //m无married返回属性默认值0，有则返回映射值
1.scala>val b=scala.collection.mutable.Map("id"->"0","name"->"zyb","age"->12) //可变映射
2.scala>b += (("married",false)) //添加对偶
2.scala>b +=("married"->false) //另一种方法添加对偶
2.scala>b -=("id") //减去id这个key，可变map
2.scala>m - "id" //减去id这个key，不可变map
迭代map
scala>for((k,v)<-b)println(k+"==>"+v) //输出格式key==>value
scala>for(k<-b.keySet) println(k) //打印出所有key不打印value
scala>for(v<-b.values)println(v) //打印出所有value不打印key
排序map SortedMap
scala>val z=scala.collection.immutable.SortedMap("an"->80,"chao"->20,"guang"->10,"zhu"->100,"yan"->40,"bin"->30)
scala>for((k,v)<- z)println(k+":"+v) //按照key的字母排序
scala>import scala.collection.immutable.TreeMap //导入treemap包
scala>val cc=TreeMap(1->100,2->101,3->98) //写入treemap

map的合并： key相同时，没有将value相加，而是操作符右边的值把左边的值覆盖掉了
scala>val map1 = Map("key1" -> 1, "key2" -> 3, "key3" -> 5)
scala>val map2 = Map("key2" -> 4, "key3" -> 6, "key5" -> 10)
scala>println(map1 + ("key1" -> 3)) //Map(key1 -> 3, key2 -> 3, key3 -> 5)
scala>println(map1 ++ map2) //Map(key1 -> 1, key2 -> 4, key3 -> 6, key5 -> 10)

12.**************************scala转换为java
scala>import scala.collection.JavaConversions.mapAsJavaMap //导入转换包
scala>import java.awt.font.TextAttribute._ //导入java的Attribute包
scala>val attrs=Map(FAMILY ->"Serif",SIZE -> 12) //将转为java

元祖*******************下标从1开始****************************
1.scala> val t = (1,"tom",12) //写入元祖
2.scala> t._2 //tom;元祖从1开始数
3.scala>val (id,name,tel) = t //将t元祖中值依次赋给元祖型变量（id,name,tel）
4.scala>id //1
4.scala>name //tom
3.scala>val (id,name,_)=t //新的只会1和tom被赋值，12不会
对偶不一样
1.scala>val t=1 -> "tom" //对偶（特殊的元祖）
2.scala>t._1 //1 (对偶不一样 )
2.scala>t._2 //tom （对偶不一样）
----------------------------------------------------------
13.****************zipping：拉链操作：操作两个集合，将他们咬合在一起
1.scala>val wifes=Array("aaaa","bbbb","cccc")
1.scala>val husbands=Array("AAAA","BBBB","CCCC")
2.scala>val homes=wifes.zip(husbands) //aaaa和AAAA，bbbb和BBBB，cccc和CCCC分别成对
3.scala>for((k,v)<-homes)println(k+" with "+v) //将其成对输出
-----------------------------------------------------------
14.*****************************类
scala>class Counter{
private var value =0; //字段必须初始化
def increment() =value += 1 //复制.没有返回值Unit
def current() =value //有值，int
}
scala>val c=new Counter() //实例化对象
scala>c.increment() //调用increment（）
scala>c.current() //调用current（）
-------------------------------------------------
scala>class Person{
var age = 0 //默认有两个方法
//def age=age //方法一：get
//def age_=(value) //方法二：set
}
scala>var p = new Person() //实例化
scala>p.age //调用默认方法getter；0
scala>p age = 20 或者 p.age_=(20) 或者p.age=20 //调用默认方法setter为20
------------------------------------------------
实现属性时的4个方法
1.var foo:自动合成一个getter和setter //可读可写
2.val foo:自动合成一个getter //只可读
3.由你来定义foo和foo_=方法
4.由你来定义foo方法
-------------------------------------------------
15.****************************使用scala脚本
----------------------------
1.编写scala文件
[Person.scala]
class Person{
var age = 0;
}
2.编译scala文件 //在windows命令行输入scalac f:\scala\Person.scala
scalac Person.scala
3.生成class文件
Person.class
4.通过javap查看类 //在windows命令行输入javap -private Person.class
javap -private Person.class
------------------------------
private[this]:[限制只能在对象中访问]
class Car{
private[this] var age = 0; //当前对象访问，其余无法访问
class Engine{ //Engine为内部类
private[Car] var rate =100; //car在外部类可访问
}
}
-------------------------------------------
scala的bean属性
scala>import scala.beans.BeanProperty //导入scala的bean包
scala>class Dog{ //scala脚本dog.scala
@scala.beans.BeanProperty
var name:String = "dahuang"
}
scala>var d1 = new Dog() //实例化
scala>d1.name //gettername
scala>d1.name_=("erhuang") //settername
------------------------------------------
16.。****************************构造函数：分为主构造和辅助构造
1.scala>class Person{
private var name:String = "" ;
private var age:Int = 0;
//定义第一个辅助构造
def this(name:String){
this(); //主构造
this.name = name ;
}
//第二个辅助构造
def this(name:String,age:Int){
this(name); //第一个辅助构造
this.age = age ;

}
}
2.scala>var p=new Person("tom"); //通过第一个构造器赋值
2.scala>var p=new Person("tom",12); //通过第二个构造器赋值
--------------------------------------------------
scala>class Person(val name:String , private var age:Int){
//辅助构造1
def this(name:String,age:Int,desc:String){
this(name,age);
println(desc);
}
def this(){//辅助构造2
this("tom",12)
println("hhh")
}
}
scala>var p = new Person("an",12,"qq") //可只传前2个或3个，2个为主构造，3个为辅助构造1
scala>val a= new person //调用辅助构造2
--------------------------------------------------------
主构造函数参数不加val或var修饰，只要有一个方法访问，则转变成private[this]字段
scala>class Person(name:String,age:Int){ //无val或var，默认修饰符为val
def kk=name ; //var可以set和get，val只能get
}

scala可直接new内部类 var p = new 内部类名()
------------------------------------------------------------
17.***************************对象：object object修饰的类中的方法相当于java的静态方法（类不能加参）
单一对象
object MyObject{
def sayhello = print("hello world"); //scala中，object修饰的类中方法等价于java中静态方法（不能加参）
}

伴生对象：半生对象用object修饰，与正常类同名，此为正常类的半生对象；静态与非静态在scala中分开
class Banz{ //正常类 scalac生成脚本为 Banz.class
def color = "black"; //非静态成员
}
object Banz{ //此为上面类的半生对象，这里面是静态，scalac生成脚本为半生类Banz$.class
def brand = "BANZ"; //静态成员
}