scala学习笔记1

scala

Java语言的脚本化。

REPL

read + evaluate + print + loop

安装scala解释程序

1.scala-2.12.1.msi
2.进入scala命令行

	//变量
	scala>var a = 100			//变量

	//常量
	scala>val a = 100			//常量，不能重新赋值。

	//定义类型
	scala>val a:String = "hello" ;
	scala>a = "world"			//wrong


//操作符重载 _ $
scala>1 + 2
scala>1.+(2)					//


//scala函数,没有对象.
//scala方法，通过对象调用。
scala>import scala.math._		//_ ===> *
scala>min(1,2)

//
scala>1.toString				//方法
scala>1.toString()				//方法形式
scala>1 toString				//运算符方式

//apply
scala>"hello".apply(1)			//等价于xxx.apply()
scala>"hello"(1)				//

//条件表达式,scala的表达式有值,是最后一条语句的值。
scala>val x = 1 ;
scala>val b = if x > 0 1 else -1 ;

//Any 是Int和String的超类。

//类型转换
scala>1.toString()
scala>"100".toInt()				//

//空值
scala>val y = (x = 1)			//y:Unit= ()类似于java void.
	

//粘贴复制
scala>:paste
		....
	ctrl + d					//结束粘贴模式

    javac               java
	*.java --------> *.class  -------->程序 


//输出
scala>print("hello")
scala>println("hello")
scala>printf("name is %s , age is %d", "tom",12);
//读行
scala>val password = readLine("请输入密码 : ") ;

//查看帮助
scala>:help



//循环
scala>:paste
	var i = 0 ;
	while(i < 10 ){
		println(i) ;
		i += 1;
	}

//99表格
scala>:paste
	var row = 1 ; 
	while(row <= 9 ){
		var col = 1 ; 
		while(col <= row){
			printf("%d x %d = %d\t",col,row,(row * col)) ;
			col += 1 ;
		}
		println();
		row += 1 ;
	}

//百钱买白鸡问题.
	100块钱100只鸡。
	公鸡:5块/只
	母鸡:3块/只
	小鸡:1块/3只

//公鸡
var cock = 0 ;
while(cock <= 20){
	//母鸡
	var hen = 0 ;
	while(hen <= 100/3){
		var chicken = 0 ;
		while(chicken <= 100){
			var money = cock * 5 + hen * 3 + chicken / 3 ;
			var mount = cock + hen + chicken ;
			if(money == 100 && mount == 100){
				println("cock : %d , hen : %d , chicken : %d",cock,hen,chicken) ;
			}
		}
	}
}

//for循环
//to []
scala>for (x <- 1 to 10){
	println(x) ;
}

//until [1,...10)
scala>for (x <- 1 10){
	println(x) ;
}

//scala没有break continue语句。可以使用Breaks对象的break()方法。
scala>import scala.util.control.Breaks._
scala>for(x <- 1 to ) {break() ; print(x)} ;


//for循环高级
//双循环,守卫条件
scala>for(i <- 1 to 3 ; j <- 1 to 4 if i != j ) {printf("i = %d, j = %d , res = %d ",i,j,i*j);println()} ;	

//yield，是循环中处理每个元素，产生新集合
scala>for (x <- 1 to 10 ) yield x % 2 ; 


//定义函数
def add(a:Int,b:Int):Int = {
var c = a + b  ;
return c  ;
}

scala>def add(a:Int,b:Int):Int =	a + b 

//scala实现递归 n! = n * (n - 1)!
4!  = 4 x 3!
4!  = 4 x 3 x 2!
4!  = 4 x 3 x 2 x 1!

//递归函数必须显式定义返回类型
scala>def fac(n:Int):Int = if(n ==1 ) 1 else n * fac(n-1) ;


//函数的默认值和命名参数
scala>def decorate(prefix:String = "[[",str:String,suffix:String = "]]") = {
	prefix + str + suffix 
}

scala>decorate(str="hello")
scala>decorate(str="hello",prefix="<<")

//变长参数
scala>def sum(a:Int*) = {
	var s = 0 ;
	for (x <- a) s += x;
	s
	}

scala>add(1 to 10)			//wrong
scala>add(1 to 10:_*)		//将1 to 10当做序列处理。
scala>def sum(args:Int*):Int = {if (args.length == 0) 0 else args.head + sum(args.tail:_*)}

//过程,没有返回值，没有=号。
scala>def out(a:Int){
	println(a) ;
}

//lazy延迟计算
scala>lazy val x = scala.io.Source.fromFile("d:/scala/buy.scala00").mkString()
		x:<lazy>
		x

//异常
scala>
	try{
	  "hello".toInt;
	}
	catch{					//交给
		case _:Exception    => print("xxxx") ;
		case ex:java.io.IOException => print(ex)
	}

_的意义

1.统配相当于*
2.1 to 10 :_*	,转成序列
3.case _:Exception    => print("xxxx") ;

数组(定长)

java : int[] arr = int int[4] ;
scala>var arr = new Array[Int](10);			//apply(10)
scala>var arr = Array(1,2,3,4,);			//推断
scala>arr(0)								//按照下标访问元素

变长数组

scala>import scala.collection.mutable.ArrayBuffer
scala>val buf = ArrayBuffer[Int]();			//创建数组缓冲区对象

//+=在末尾追加
scala>buf += 1

//操纵集合
scala>buf ++= ...

//trimEnd,从末尾移除元素
scala>buf.trimStart(2)
scala>buf.trimEnd(2)

//insert,在0元素位置插入后续数据
scala>buf.insert(0,1,2)

//remove按照索引移除
scala>buf.remove(0)

//toArray
scala>buf.toArray

//数组操作
scala>for (x <- 1 to 10 if x % 2 ==0) yield x * 2	//
scala>var a = Array(1 to 10)

//数组常用方法
scala>arr.sum
scala>arr.min
scala>arr.max


//排序
scala>import scala.util.Sorting._
scala>val arr = Array(1,4,3,2)
scala>quickSort(arr)				//arr有序

//Array.mkString
scala>arr.mkString("<<",",",">>")	//<<1,2,3,4>>

//多维数组
scala>var arr:Array[Int] =new Array[Int](4);
//二维数组,3行4列
scala>val arr = Array.ofDim[Int](3,4)
//下标访问数组元素
scala>arr(0)(1)
scala>arr.length


//和java对象交互，导入转换类型,使用的隐式转换
scala>import scala.collection.JavaConversions.bufferAsJavaList
scala>val buf = ArrayBuffer(1,2,3,4);
scala>val list:java.util.List[Int] = buf ;


//映射和元组
//key->value
//scala.collection.immutable.Map[Int,String] =不可变集合
scala>val map = Map(100->"tom",200->"tomas",300->"tomasLee")
//通过key访问value
scala>map(100)
scala>val newmap = map + (4->"ttt")

//可变
scala>val map = new scala.collection.mutable.HashMap[Int,Int]
scala>val map = scala.collection.mutable.HashMap[Int,Int]()
scala>map += (1->100,2->200)	//追加
scala>map -= 8					//移除元素

//迭代map
scala>for ((k,v)<- map) println(k + ":::" + v);

//使用yield操作进行倒排序(kv对调),
scala>for ((k,v)<- map) yield (v,k);

//元组tuple,元数最多22-->Tuple22
scala>val t = (1,"tom",12) ;

//访问元组指定元
scala>t._2
scala>t _2
//直接取出元组中的各分量
scala>val (a,b,c) = t		//a=1,b="tom",c=12

//数组的zip,
//西门庆 -> 潘金莲  牛郎 -> 侄女  ,
scala>val hus = Array(1,2,3);
scala>val wife = Array(4,5,6);
scala>hus.zip(wife)		//(1,4),(2,5),(3,6)

OOP

scala>class Person{
	//定义变量,私有类型,必须初始化
	//set/get也私有
	private var id = 0 ;
	
	//只有get方法，没有set方法
	val age = 100 ;

	//生成私有属性，和共有的get/set方法。
	var name = "tom" ;
	//默认public
	def incre(a:Int) = {id += a ;}
	//如果定义时，没有(),调用就不能加()
	def current() = id 
}

scala>var p = new Person();
scala>p.current()
scala>p.current
scala>p.incr(100)
scala>p.name
scala>p.name_=("kkkk")
scala>p.name = "kkkk"

private[this]作用,控制成员只能在自己的对象中访问。

class Counter{
	private[this] var value =  0 ;
	def incre(n:Int){value += n}

	def isLess(other:Counter) = value < other.value ;
}

定义BeanProperty注解

class Person{
	@scala.reflect.BeanProperty
	var  name:String  = _
}

构造函数

主构造器		//
辅助构造		//

class Person{
	var id = 1 ;
	var name = "tom" ;
	var age = 12;

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


//主构造
//val ===> 只读
//var ==> get/set
//none ==> none
class Person(val name:String,var age:Int , id :Int){
	
	def hello() = println(id)
}

Object

说明：scala没有静态的概念，如果需要定义静态成员，可以通过object实现。
      编译完成后，会生成对应的类，方法都是静态方法，非静态成员对应到单例类中
	  单例类以Util$作为类名称。

scala>object Util{
	//单例类中.(Util$)
	private var brand = "benz" ;
	//静态方法.
	def hello() = println("hello world");
}

伴生对象(companions object)

类名和object名称相同，而且必须在一个scala文件中定义。
class Car{
	def stop() = println("stop....")
}

object Car{
	def run() = println("run...")
}

抽象类

//定义抽象类
abstract class Dog{
	def a():Unit
}

object等价于java中的静态。

object Jing8 extends Dog{
	//重写方法
	override def a():Unit= print("hello") ;
}

object Util{
def apply(s:String) = println(s) ;
}

Util(“hello world”);
Util.apply(“hello world”);

trait

特质，等价于java中的接口.

scalac编译scala文件，产生class文件。

cmd>scalac xxxx.scala

运行class程序

cmd>scala Person

一步到位

cmd>scala Person.scala

idea中安装scala插件

trait

traint HelloService{
}

//包对象，编译完之后生成以xxx为package，下面含有类package.class + package.class
package object xxxx{

}

//约束可见性。

private[package|this]

导入

import java.io.Exception
import java.io.{A,B,C} //
import java.io.{A => A0} //别名