Scala的學習筆記_第一天
1.scala
REPL //read evaluate print loop
val //常量
var //變數
typeinfer //型別推斷.
java語言指令碼化。
2.環境搭建
---------------
1.下載2.12.1
2.在win7安裝.
選擇安裝目錄(不要含有中文和空格目錄).
自動在path新增scala的bin目錄。
3.進入scala shell
執行scala/bin/scala.bat
cmd>
4.scala區分大小寫
3.scala常用型別
------------------
plus()
Byte //java.lang.Byte
Char //java.lang.Charactor
Short //java.lang.Short
Int //java.lang.Integer
Long
Float
Double
Boolean
scala>val a = 100 ; //定義常量
scala>var a = 100 ; //定義變數
scala>a = 200 ;
scala>val b = "tom" //b:String ="tom"
scala>val b:String = "tom" //b:String = "tom"
scala>val a,b,c = 100 ; //同時定義多個變數
scala>1.toString() //直接轉換成字串
scala>1.toString() //直接轉換成字串
scala>1 to 10 //建立陣列1..10
scala>1.to(10) //建立陣列1..10
scala>1.to(10) //建立陣列1..10
scala>"hello".intersect("world") //"lo"
scala>1.toBigInt() //使用方法完成型別轉換
scala>var a += 1 ; //scala沒有++/--,可以用=+/-=
scala>var a = 1 ;
scala>a += 1 ;
4.REPL
--------------------------------
read-eval-printloop, or REPL.
讀 求值 列印 迴圈
5.方法和函式
方法和型別相關,通過類或物件呼叫。
函式和類不相關，可以直接呼叫。
scala>import scala.math._ ; //匯入scala.math包,_相當於*，通配。
scala>val a = sqrt(1) //開平方
scala>"hello".distinct //去重
6.apply
-------------------
scala>"hello".apply(4) //取出4號索引位置的字元
scala>"hello"(4) //簡寫為此.
scala>BigInt("9999999999999") //使用Apply直接構造大數。
scala>vala = Array(1,'2',"3",4) //定義陣列,===Array.apply(1,2,3,4);
scala>vala = Array(Array(1,2),Array(3,4)) //定義二維陣列,===Array.apply(1,2,3,4);
7.控制結構和函式
scala的表示式是有返回值的。最後一條語句的返回值.
scala>valx = 2 ;
scala>vala = if (x > 1) 1 else -1 //
scala>vala = if (x > 1) "1" else -1 //
8.Unit型別
無有用值得佔位符，表示(),類似於void.
scala>vala = if (x < 1) 1 //等價於 val a = if(x < 1) 1 else ()
//()是Unit型別，類似於java void型別.
9.貼上模式
scala>:paste
//貼上內容
ctrl+D //結束
scala>varr , n = 1 ;
scala>varx = if(n < 0) {r = r * n ; n -= 1 }
scala>//this is a demo ; //註釋
scala>printf("%d+ %d = %d",100,200 , 100 + 200) //c語言風格輸出方式
scala>readLine("yourname")
10.迴圈
scala>varn = 10 ;
scala>while(n> 0){
println(n);
n-= 1 ;
}
//99乘法表
scala>:paste
varr = 1 ;
while(r< 10){
varc = 1 ;
while(c< 10){
if(c<= r){
printf("%dx%d=%d\t",c,r,r*c);
}
c+= 1 ;
}
println();
r+= 1 ;
}
//for迴圈
scala>valn = 10 ;
scala>for(i<- 1 to n) println(i) //
scala>:paste
for(i<- 1 to 9){
for(j<- 1 to 9 ){
if(j<= i){
printf("%dx%d=%d\t",j,i,i*j);
}
}
println();
}
//break動作
scala>importscala.util.control.Breaks._ ; //首先要導包
scala>:paste
for(i<- 1 to 10 ){
println(i);
if(i== 5){
break;
}
}
//for迴圈增強
scala>for(i<- 1 to 3; j <- 1 to 5) println(i * j ); //前邊迴圈的值乘後邊的
//守衛條件
scala>for(i<- 1 to 10 if i % 2 == 0; j <- 1 to 3 if i != j) println(i +"," + j );
//多個條件的邏輯運算
scala>for(i<- 1 to 100) {
if(i% 2 == 0 && i % 3 == 0 && i % 5 == 0){
println(i);
}
}
//yield,產生,生成.產生一個集合
valx = for(i <- 1 to 4) yield i * 2 ;
for(j<- x){println(x)}
//執行原理
javac java
*.java ------->*.class ----->
scalac scala
*.scala ------->*.class ----->
11.方法
針對物件。
12.函式
-------------
def //define定義
scala>:load d:\scala\for99.scala //載入scala指令碼執行
scala>:help //幫助
scala>def add(a,b) = a + b //錯誤，必須給出所有引數型別
scala>def add(a:Int,b:Int) = a + b // 合法
//遞迴函式
scala>def add(a:Int,b:Int):Int = a + b //遞迴函式必須顯式宣告返回型別
scala>def fac(n:Int):Int = {
if(n == 1) 1
elsen * fac(n - 1)
}
//預設引數和命名引數
scala>def decorate(str:String ,left:String = "[" , right:String = "]") = left + str + right ; //
預設值
scala>val x =decorate("hello") ; //預設值
scala>val x =decorate("hello","[[","]]]") ; //預設
scala>val x =decorate("hello",right="]]") ; //命名引數
scala>val x = decorate(left="[[[",str="hello",right="]]") ;//命名引數
java變長引數：
public int sum(int... args){
ints = 0 ;
for(inti = 0 ; i < args.length ; i ++){
s= s + args[i];
}
returns ;
}
public int sum(int... args){
ints = 0 ;
for(intx: args){
s= s + x ;
}
returns ;
}
sum(1,2,3)
//變長引數
scala>def sum(args : Int*):Int = {
vars = 0 ;
for(x<- args){
s= s + x ;
}
s;
}
scala>val x = sum(1,2,3);
scala>val x = sum(1 to 10); //錯誤的，1 to 10產生的數字區間.
scala>val x = sum(1 to 10:_*); //1 to 10產生的數字區間.告知編譯器以數字序列方式對待.相當於統配每一個區間裡面的值
scala>def sum(args:Int*) : Int = {var s= 0 ; for(i <- args){s = s + i ;} s ;}
scala>def sum(args:Int*):Int = {
if(args.length== 0) 0
elseargs.head + sum(args.tail:_*) ;
scala>val x = sum(1,2,3,4) ; //head : 序列的首個元素,tail:首個元素之後的所有元素.
//過程
//特殊的函式，沒有返回值，{}前沒有等號。
scala>def sayHello{println("helloworld"); 100} //過程，返回值是Unit,會有警告
scala>def sayHello={println("helloworld"); 100} //函式,返回Int
scala>def sayHello:Int={println("hello world"); return 100} //函式,返回Int
scala>defsayHello:Int={println("hello world"); return 100} //函式,如果無引數，可以不帶(),呼叫時不能帶()
scala>defsayHello:Int={println("hello world"); return 100} //函式,如果無引數，可以帶(),呼叫時()可有可無。
13.//lazy,延遲
scala>lazy val x = scala.io.Source.fromFile("d:\\22.txt").mkString;
scala>x //
14.//異常
throw //拋異常
throws //宣告拋異常
Throwable //異常體系的根類
java.lang.Throwable
java.lang.Error //錯誤
java.lang.Exception //異常 RuntimeException
scala>val x = 2 ;
scala>val y = if(x > 0) {
sqrt(x);
}
else
thrownew IllegalArgumentException("x should not be negative");
try{
...
}
catch(AgeTooSmallException e){
e.println();
}
catch(AgeInvalidException e){
e.println();
}
try{
...
}
catch{
_ : XxxException => xxx ; //=>指向
ex: YyyyException => ex.xxx
}
15.//定長陣列
scala>Array(1,2,3,4) //Array.apply(1,2,3,4);
scala>val a = new Array[Int](10) //new int[10];
scala>a(0) = 100 //賦值，(下標索引)
scala>for(i <- a) println(i) ; //迴圈輸出
//字串陣列
scala>Array("hello","world") //Array.apply("hello","world");
16.//變長陣列
//ArrayBuffer // 陣列緩衝區
scala>importscala.collection.mutable.ArrayBuffer //導包
scala>val a = ArrayBuffer[Int]() //建立ArrayBuffer()物件.
scala>a += 1 //追加元素1
scala>a += 2 //追加元素1
scala>a += (3,4,5) //追加多個元素
scala>a ++= Array(6,7,8) //追加集合
scala>a.trimEnd(3) //濾除最後3個元素
scala>a.trimStart(3) //濾除開始3個元素
scala>a.insert(index,x1,x2,..) //在指定位置插入若干元素
scala>a.append(5,6,7) //在末尾追加元素
scala>a.appendAll(Array(1,2,4)) //在末尾追加集合
scala>a.remove(3,5) //刪除指定閉區間的元素
scala>a.toArray //將變長集合Buffer變成定長陣列Array
17.//遍歷陣列
scala>val x = 1 until 10 //===1.until(10)
scala>val x = 1 until (10,2) //===1.until(10)
scala>val x = (1 until (10,2)).reverse //倒序
scala>val a = Array(1,2,3)
scala>val b = for(i <- a) yield i * 2; //2,4,6
scala>val b = for(i <- a if i %2 == 0) yield i * 2 ; //加上限制條件
//過濾出偶數元素，再 x 2構成新集合。
scala>a.filter(_ % 2 == 0).map(_ * 2) //
18.//內建演算法函式
scala>a.sum //sum
scala>a.max
scala>a.min
//排序
scala>val a = ArrayBuffer(1,5,3,4)
scala>a.sorted(_ < _) //??????
scala>val a = Array(1,7,4,6)
scala>scala.util.Sorting.quickSort(a) //ok快速排序
//輸出陣列元素,可以指定字串分隔符
scala>a.mkString("==") //
//多維陣列
scala>val a2 : Array[Array[Int]] = Array.ofDim[Int](3,4) ; //三行四列
scala>var x = 1 ;
// //二維陣列賦值
for(i<- 0 until a2.length){//遍歷行
for(j<- 0 until a2(i).length){//每一行的長度
a2(i)(j)= x;
x+= 1 ;
}
}
19.//Map對映和元組(tuple)
scala>val a =Map("001"->"tom","002"->"tomas","003"->"tomasLee"); //Map[String,String]
scala>val a =Map("001"->"tom",2->"tomas","003"->"tomasLee"); //Map[Any,String]
scala>a("001") //tom
scala>a("001") //tom,key不存在，異常. java.util.NoSuchElementException: key not found:
scala>val a = newscala.collection.mutable.Map("001"->"tom","002"->"tomas"); //可變map
scala>a.put("004","tomason") //
//對偶是特殊的元組，只有兩個元素,key -> value | (key,value) 這就是元組 集合是元組的集合
scala>val a = "001" ->"tom" //對偶
scala>val a=("001","tom") //對偶
scala>val a=("001","tom",12) //
scala>val a=("001","tom",12,"hebei") //
scala>val a=("001","tom",12,"hebei","初中") //
scala>val b =scala.collection.mutable.Map(("id",1),("name","tom"),("age",12))
scala>val m =Map(("id",1),("name","tom"),("age",12))
scala>m.getOrElse("married",0); //返回屬性，沒有使用預設值。
scala>m += (("married",false)) //必須兩個括號,第一個是整體的括號,加兩個屬性就好理解了
scala>m += ("married" ->false) //
scala>m -= "id" //可變Map 需要導包cala.collection.mutable.Map
scala>m - "id" //不可變集合
20.//迭代map
scala>for((k,v) <- b) println(k +"==>" + v) ; //
scala>for((k,v) <- m) println(k +"==>" + v) ; //
scala>for(k <- b.keySet) println(k) ; //
scala>for(v <- b.values) println(v) ; //
21.//排序map SortedMap
scala>val mm =scala.collection.immutable.SortedMap("alice"->100,"bob"->98,"aaming"->101)
scala>for((k,v) <- mm) println(k +":" + v) ; //有序排列 按照K排序
22.//和java的互相訪問
scala>importscala.collection.JavaConversions.mapAsScalaMap //匯入轉換包
scala>val m:scala.collection.mutable.Map[String, Int] = new java.util.TreeMap[String, Int]
23.//scala轉java map
scala>importscala.collection.JavaConversions.mapAsJavaMap
scala>importjava.awt.font.TextAttribute._
scala>val attrs = Map(FAMILY ->"Serif", "" -> 12) //scala集合
scala>val font = newjava.awt.Font(attrs) //自動轉換成java集合
//元組,*****下標從1開始 *******
scala>val t = (1,"tom",12)
scala>t._2 //"tom" //注意”.” 元組得到訪問方式
//宣告元組型變數，分別提取元組的各個欄位值。
scala>val id = t._1 //注意”.” 元組得到訪問方式
scala>val name = t._2
scala>val (id,name) = t //相當於上面的兩部分的合成體
//zip操作拉鍊操作(咬合操作)
scala>val wifes =Array("wife1","wife2","wife3");
scala>val hus =Array("hus1","hus2","hus3");
scala>val home = wifes.zip(hus);
24.類
scala>class Counter{
privatevar value = 0 ; //欄位必須初始化
definrement() = value += 1 //複製，沒有返回值,Unit
defcurrent() = value //有值,Int
}
scala>val c = new Counter(); //建立物件
scala>c.inrement() //
scala>c.current()
//反編譯之後的原始碼
public class Person {
public int age(); //get方法
public void age_$eq(int); //set方法
public Person(); //構造方法
}
//
scala>class Person{
privatevar age = 0 ; //欄位始終私有
defage:Int = age ;
}
25.使用scala編譯指令碼
//1.編寫scala檔案
[Person.scala]
classPerson{
varage = 0 ;
}
//2.編譯scala檔案
scalacPerson.scala
//3.生成class檔案
Person.class
//4.通過javap檢視類
javap-private Person.class
//變數使用範圍
//private[this] //只能本類的一個成員使用
//private[Person] //可以Person的成員使用
class Person{
privateint age ;
publicboolean equals(Person p){
returnthis == p.age ;
}
}
//限制只能在物件中訪問。
class Car{
varcolor : String = "black";
defisCable(o:Engine) = o.rate > 100 ; //當前一個物件訪問。
classEngine{
private[Car]var rate = 100 ; //在外部類可以訪問
defcolor = Car.this.color ;
}
}
//scala的bean屬性
scala>import scala.beans.BeanProperty
scala>class Dog{
@scala.beans.BeanProperty
varname:String = "dahuang" ;
}
scala>var d1 = new Dog();
scala>d1.getName()
scala>d1.setName("dd")
//scala的語法
scala>d1.name
scala>d1.name = "" ;
scala>d1.name_=("ccc");
//構造,主構造和輔助構造
scala>class Person{
privatevar name:String = "" ;
privatevar age:Int = 0 ;
//定義輔助構造
defthis(name:String){
this(); //主構造
this.name= name ;
}
//輔助構造
defthis(name:String,age : Int){
this(name);//呼叫前一個輔助建構函式
this.age= age ;
}
}
//構造,主構造和輔助構造
scala>class Person2(val name:String ,private var age : Int){
//定義輔助構造
defthis(name:String){
this(); //呼叫主構造
this.name= name ;
}
//輔助構造
defthis(name:String,age : Int){
this(name);
this.age= age ;
}
}
//定義
class Person(val name:String , private varage : Int){
//輔助構造
defthis(name:String,age : Int,desc:String){
this(name,age);
println(desc);
}
//輔助構造
defthis(){
this("tom",12);
println("hhh");
}
}
//主建構函式引數不加val或者var修飾，只要有一個方法訪問，則轉變成private[this]欄位。
//name程式設計成員變數。final修飾的，預設修飾是val的。
scala>class Person(name :String,age:Int){
defkk = name ;
}
//Object等價於java的靜態
//定義的final+static成員.
26.//半生物件,將類中靜態成分抽象出來，存放在半生物件中。
scala>class Benz{
defcolor = "black" ;
}
scala>object Benz{ //Benz的伴生物件,不是單獨的一個類專門寫靜態方法
//Object等價於java的靜態
defbrand = "BENZ" ;
}