Scala学习第二天

通配符：_


until: 不包含上限的值


编译scala文件：
scalac Person.scala //生成Person.class 
javap Person.class//打印Person类的共有属性，使用 -private 打印私有属性




函数定义
-----------------------------------------------------------------------------------
def add(x: Int, y: Int) = x + y;
关键字 def ; 符号 = 左边的是函数名；右边是函数体；参数类型必须给出；

1、无返回值函数：
def add(x: Int, y: Int) = x + y;//加法函数
2、有返回值的函数：
def pro(x: Int) : Int = {//阶乘函数
if (x <=0) 1 else x * pro(x - 1);
}
3、带默认值的函数定义：
def decorate(str: String, left: String = "[", right: String = "]") = {
left + str + right;
}
命名参数：decorate("Hello", right = ">>");//将right的默认值改为">>"
4、变长参数函数定义：在类型后面加星号(*)
def add(args: Int*) = {
var n = 0;                                  
for(arg <- args) {                          
n = arg + n;                            
}                                           
n;                                          
}
def add(args: Int*): Int = {
if(args.length == 0 ) 0
else args.head + add(args.tail:_*);

}
传入函数的整数区间当作序列对待的处理方式：使用:_*符号标识
add(1 to 10: _*)
5、使用return 返回结果，需要在函数中显示申明类型



过程定义
-----------------------------------------------------------------------------------
定义：没有返回值的函数，如果函数体包含在花括号中则前面没有=
def sayHello() {
println("hello world");
}

Lazy关键字
-----------------------------------------------------------------------------------
当val值被lazy修饰，则变量初始化将被延迟，直到变量第一次被取值；

异常
-----------------------------------------------------------------------------------
1、直接抛出异常
-------------------------------------
var x = 3;
if(x >0) {
sqrt(x);
}
else 
throw new IllegalArgumentException("x is not allow be a negative value");

2、捕获异常
-------------------------------------
try {
process(new URL("http://xxm/doc/ti.jpg");
} catch {
case _: IOException => print("bad url");
case ex: Exception => ex.printTrack();
}


------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
数组操作
-------------------------------------------------------------------------------------
1、定义定常数组
var array1 = new Array[Int](10);//定义一个长度为10的整型的数组,所有元素的值是0；
var array2 = Array("hello", "world");//定义长度为2的字符串数组；
array2[0] = "Rebot";//操作第一个数组元素；

2、定义变长数组：
导入scala.collection.mutable.ArrayBuffer;
import scala.collection.mutable.ArrayBuffer;
var varArr = ArrayBuffer[String]();//定义一个变长数组varArr;
varArr += 1; //在数组尾端添加一个元素
varArr ++= Array(1,3,5,6)//追加任何集合
varArr.trimEnd(4);//截除最后4个元素

数组操作：（插入操作）
varArr.insert(1, 1,2,4,54,65,7);//在指定的元素前插入元素
varArr.append(4，5)；//在数组的末尾追加元素
varArr.appendAll(Array(2,3,45));//追加集合

数组操作：（移除操作）
varArr.remove(1, 4);//移除从1开始的4个元素；
varArr.remove(3);//移除指定位置的元素

数组操作：（数组转换）
var a1 = varArr.toArray();//将变长数组varArr变成定长数组变量a1;

3、遍历数组
for (i <- 0 until varArr.length) {// 步长是1；
printf(i + ": " + varArr(i) + "\t");
}

for (i <- 0 until (varArr.length, 2)) {// 步长是2进行操作
printf(i + ": " + varArr(i) + "\t");
}

for (i <- (0 until varArr.length).reverse) {// 逆序操作；
printf(i + ": " + varArr(i) + "\t");
}

4、数组转换
使用for(...) yeild 产生类型与原集合相同的新集合
var a = Array(1, 2, 4);
for(i <- a) yield 2 * i;

对for循环添加守卫
var a = Array(1, 2, 4);
for(i <- a if(i > 2)) yield 2 * i;//添加守卫if(i > 2)
使用filter和map函数产生新的集合
var a = Array(1, 2, 4);===等价于== var a = Array(1, 2, 4);
a.filter(_ > 2).map(2 * _);    for(i <- a if(i > 2) yield 2 * i;

5、常用函数：
varArr.max //数组中最大的值；
varArr.min //数组中最小值
var bSorted = varArr.sorted(_ < _)//从小到大排序（存在bug）

使用quickSort方法进行排序
1、导入scala.util.Sorting.quickSort;
import scala.util.Sorting.quickSort
var arr = Array(2, 6, 2, 4, 5, 6);
quickSort(arr);//修改原集合

mkString()输出数组元素 
varArr.mkString(" And ");

6、多维数组
多维数组是通过数组的数组来实现
var matrix: Array[Array[Double]] = Array.ofDim[Double](3,4);//生成3行4列的double类型的二维数组
操作某个元素使用圆括号
matrix[1][2] = 2.0;

for(i <- 0 until matrix.length) {
for(j <- 0 until matrix(i).length) {
matrix(i)(j) = (i+1) * (j+1);
}
}
var k = 1;
for(i <- 0 until matrix.length) {
for(j <- 0 until matrix(i).length) {
matrix(i)(j) = k;
k += 1;
}
}

------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
映射和元组
-------------------------------------------------------------------------------------
A:映射:是键值对偶的集合；
1、构造不可变映射
var map = Map("Hello" -> 1, "miller" -> 2, "custome" -> 4);//构造了一个[String, Int]类型的不可变的映射
通过key读取值
map("Hello"); //返回 1；
2、构建可变的映射
导入scala.collection.mutable.Map;
import scala.collection.mutable.Map;
var map = Map("Hello" -> 1);

映射操作（获取值）
----------------------------
map.contains("custome");//判断映射中是否包含键"customer"

映射操作（更新键值）
----------------------------
map += ("ke" -> 4, "3" -> 4);//添加映射元素
map += (("li", "tang"), ("du", "tang"))//添加元组元素
map = map - ("du");

映射操作（递归操作）
----------------------------
for((k, v) <- map) yield (v, k)
keySet()操作键集合
var v = map2.keySet;//返回key Set
values()操作值集合
var k = map2.values;//返回所有的values，类型为hashMap
排序映射
----------------------------
import scala.collection.immutable.SortedMap;
val scores = SortedMap("a1" -> 1, "a4" -> 2, "a2" -> 3);

与Java互相操作
----------------------------
import scala.collection.


B:元组：元组是不同类型的值的集合，对偶是元组的最简单形式；
1、定义元组：使用圆括号
var tuple = (1, "name", "address");
访问元组元素使用_1,_2,_3访问；
tuple._1; //返回1；(元组访问下标从1开始)

2、定义元组变量
val (first, second, third) = tuple;
通过变量访问元组元素
first ; //返回1
second; //返回name

------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
类 
-------------------------------------------------------------------------------------
A:简单类
一个Scala文件可以定义多个scala类；所有这些类都具有可见性；
1、定义Scala类
----------------------------
class Counter {
private var value = 0 ;//必须初始化；默认是private
def increment() { value  += 1; };//默认是public 
def current() = value;//返回成员变量value的值
}
2、定义和操作对象
----------------------------
val c = new Counter;
c.current(); //返回成员value的值
c.increment();//成员变量value自增1；


B:带getter和setter属性
1、定义Person类
----------------------------
class Person {
var age = 1;
}
val person = new Person();//创建一个Person对象
person.age; //返回age的值
person.age_=(90)//设置年龄为90

a、如果将age定义为val,则只生成getter()方法；
b、如果不需要age的getter和setter方法，则将age定义为private[this];
c、如果age定义为private,则getter和setter方法都是private;

C:对象

D: Beans属性
使用JavaBeans规范访问成员变量；使用@BeanProperty标签标识规范的成员；
----------------------------
import scala.reflect.BeanProperty;
class Person {
@BeanProperty var age = 0;
}
将会产生四个函数
age: Int ;
age_=(x: Int): Unit;
getAge():Int;
setAge(x: Int): Unit;

E: 辅助构造函数
Scala中主构造器的最重要，可以有多个辅助构造器；
辅助构造函数的函数名是this;每一个辅助构造器都必须是对其他辅助构造或者主构造函数的调用；
----------------------------
class Person {
var name: String = null;
var age: Int = 0;

def this(name: String) {
this(); //调用主构造
this.name = name;
}

def this(name: String, age: Int) {
this(name); //调用辅助构造
this.age = age;
}
}

F: 主构造函数
主构造函数跟类定义交织在一起；
----------------------------
//类后的圆括号内参数即为主构造函数的参数
class Person(var name: String, var age: Int) {

def this(name: String, age: Int) {
this(name); //调用辅助构造
this.age = age;
}
}

如果主构造函数中的参数变量不加var或val修饰，则参数的处理取决于类中函数如何调用变量；
class Person(name: String, age: Int) {

def test = name ;

def this() {
this("mick", 10);
println("hhhhhhhhhhhh");
}

}

------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------

对象 

-------------------------------------------------------------------------------------

Scala没有静态方法和静态字段，使用object关键字来生成成员变量和成员函数都是static的静态类；

object对象定义

----------------------------

object Account {

private var lastNumber: Int = 0;

def newUniqueLast : Int = {

lastNumber += 1;

lastNumber;

}

}

一般作为工具类使用；或者作为共享的不变实例；

2、伴生对象：
在类中定义使用静态成员或者静态方法：
----------------------------
class Benz{
private var price: Double;
}

object Benz {
def brand = "Benz";
}
保存在一个scala文件中进行编译，查看Benz.class类