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类