Scala的学习笔记_第一天_scala indices-优快云博客

本文链接：https://blog.youkuaiyun.com/Abandon_Sun/article/details/76099292

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 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 ;

}

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" ;

}