Scala的学习笔记_第一天
2017-07-25 21:41
316 查看
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.batcmd>
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){
4000
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 //sumscala>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) ;c6a4
//
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.mapAsJavaMapscala>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.BeanPropertyscala>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" ;
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- scala学习笔记3-Actor、case class和object、loop和react的使用
- 第88讲：Scala中使用For表达式实现map、flatMap、filter学习笔记
- Vue.js第一天学习笔记（数据的双向绑定、常用指令）
- Scala学习笔记 --- scala中的数据类型和含义
- scala学习笔记
- scala学习笔记☞三：语法续①
- Scala 学习笔记(四)------定义递归函数
- Scala学习笔记
- Scala 学习笔记(五)------定义匿名函数
- [Scala]Scala学习笔记四 类
- Scala学习笔记--上界(<:)、视图界定(<%)、上下文界定(T:M)
- Spark学习使用笔记 - Scala篇（1）
- Scala学习笔记 - 快学scala第二章
- Scala学习笔记-基本数据类型
- scala学习笔记08--Option和case
- JavaScript学习笔记第一天——运算符
- Scala学习笔记1——初始Scala
- scala编程第19章学习笔记（1）——类型参数化
- scala快速学习笔记（二）：控制结构，类和对象
- scala学习笔记：高阶函数