脚本语言
sql , js , shell , python
所见即所得.
repl //read -> evalute -> print -> loop
javac java
java : *.java ------->*.class ------->app
scala
java语句脚本化。
scala
1.下载2.11.8
2.安装
3.scala
scala>
1 + 1
1.+(1) //$plus
val //值类型,等价于java中常量
var //变量
//常量
val a = 1
a = 2 //wrong
//变量
var a = 1
a = 2 //ok
val a:Int = 1
//定义类型
val a:Int = 1
val a:Int = “abc” //wrong
val a:String = “abc”
val a:java.lang.String = “abc”
//同时初始化多个变量
val a,b = 1000
//
1.to(10)
1 to 10
1 == 1
1.==(1)
//字符串交集
“abc”.intersect(“bcd”);
//scala没有++ –,有+= -=
//java:方法和函数没区别
//scala:函数独立调用,不需要通过对象,方法通过对象调用
pow(3,3)
//java : import java.lang.*
//scala : import java.lang._
//import scala.math._
//幂函数
pow(2,2) //
pow(27,1.toFloat/3) //开立方
//平方根
sqrt(4,2);
//apply()
“hello”(4)
“hello”.apply(4)
//条件表达式
val x = 0 ;
var r = if(x > 1) 1 else -1 //Int
var r = if(x > 1) “1” else -1 //Any
var r = if(x > 1) “1” //else缺失,a:Unit = (),类似于null
//scala没有三元运算符 ? :
//换行问题
val r = if(x > 1) {1
}else -1
//粘贴模式
:paste
…
ctrl + D
//块的值
val r = {1 ;2;3;4} //4
//打印函数
println(“abc”)
//c风格打印
printf(“a=%d , b = %d , c= %s”, 1,2,”abc”)
//读取输入
var name = readLine(“please input your name: “)
printf(“your name is : %s\r\n” , name) ;
//while
var n = 1
while(n < 9){
println(n)
n += 1
}
for(x <- 1 to 10){
println(x)
}
//99表格
var r = 1 ;
while(r <= 9 ){
var c = 1 ;
while(c <= r){
printf(“%dx%d=%d\t”,c , r , (c * r))
c +=1
}
println()
r += 1
}
//99for循环
for(r <- 1 to 9){
for(c <- 1 to r){
printf(“%dx%d=%d\t”,c , r , (c * r))
}
println()
}
//while for实现百钱买百鸡
//100钱
//100鸡
// 5/公鸡 , 3/母鸡 1/3只小鸡
//to
1 to 10 //1 ~ 10
1 until 10 //1 ~ 9
//scala没有break 和 continue
import scala.util.control.Breaks._
for(x <- 1 to 10){println(x) ; break() ;}
for(x <- 1 to 10){println(x) ; continue ;}
//高级for循环,笛卡尔积
for(x <- 1 to 3 ; y <- 1 to 3){printf(“x=%d,y=%d\r\n”, x,y)}
//守卫条件
for(x <- 1 to 3 if x > 1 ; y <- 1 to 3 if x != y){printf(“x=%d,y=%d\r\n”, x,y)}
//yield,产生,生成,for循环推导式
for(x <- 1 to 4) yield x.toString
//计算阶乘,递归函数需要显式定义返回值类型
def fac(n:Int):Int= {if (n == 1) 1 else n * fac(n- 1);}
//带名参数和默认参数
def decorate(pre:String=”<<<”,str:String , suf:String=”>>>”) = pre + str = suf
decorate(str=”hello”)
decorate(str=”hello”,pre=”{{{“)
//变长参数
def sum(a:Int*) = {var s = 0 ; for(x <- a) s += x ; s}
//定义函数
def add(a:Int,b:Int) = a + b
def add(a:Int,b:Int):Int = a + b
//scala中的_用法
1.导包统配,等价于java中的*
import scala.math._
2.将Range对象转换成序列
1 to 10:_*
val
var
for
while
类型推断 : infer
val a:Int = 1 ;
if() else
1 to 10
1 until 10
1.+(1)
for(x <- ){
}
while(){
}
def add(a:Int = 1,b:Int = 2):Int = a + b
add(a = 10)
Unit = ()
//lazy value : 延迟求值。
lazy val words = scala.io.Source.fromFile(“d:/1.txt”)
//scala编写程序时不需要理会异常,(所有异常都是runtime)
//charAt
“hello”(4)
“hello”.apply(4)
//数组,定长数组
val arr = new ArrayString
arr(0)
arr.apply(0)
//变长数组:数组缓冲区
import scala.collection.mutable.ArrayBuffer
val buf = ArrayBufferInt
//=表示修改自身,没有=,表示原来内容不变。
buf += 1
buf ++= buf
buf ++ buf
buf += (1,2,3,4)
//删除后面的5个元素
buf.trimEnd(5)
//在指定位置插入元素,依次后移
buf.insert(0,100)
//删除指定索引的值
buf.remove(2)
//从哪个开始删除几个元素
buf.remove(2,3)
//转换成Array
buf.toArray()
//遍历缓冲区
for(x <- buf) …
//排序
buf.sort(<)
//数组常用方法
val arr = buf.toArray
arr.sum()
arr.max() //
arr.min() //
arr.mkString(“,”) //1,2,3
//多维数组
val arr = Array.ofDimInt //多维数组
for(x <- arr){
for(y <- x){
print(y.toString() + “\t”)
}
println()
}
//赋值
var arr = Array.ofDimInt
var index = 1 ;
var row = 0 ;
while(row < arr.length){
var col = 0 ;
while(col < arr(row).length){
arr(row)(col) = index
col += 1
index += 1
}
row += 1
}
//和java集合的互操作
import scala.collection.JavaConversions.bufferAsJavaList
def getLength(list:java.util.List[Int]) = println(list.size())
getLength(buf) //将scala Buf隐式转换成了java List
//将java list转换成scala buffer
import scala.collection.JavaConversions.as
val list:java.util.List[Int] = buf
val buf2:scala.collection.mutable.Buffer = list //只能是buffer,不能是ArrayBuffer
//映射,不可变集合
val map = Map(1->”tom”,2->”tomas”);
map(1)
map.apply(1)
//可变集合
val map = scala.collection.mutable.Map(1->”tom”,2->”tomson”)
map(1) = “newvalue”
//显式声明集合类型
val map = scala.collection.mutable.MapInt,String
map.+=((1,”tom”))
for((k,v) <- map){
println(k + “:” + v)
}
//对偶,couple,就是一对kv,是二元的元组。(x,y)
//对偶是特殊tuple,有个两个元素。
val c = 1 -> “tom”
val c = (1,”tom”)
val map = Map((1,”tom”),(2,”tomas”))
val map = Map((1->”tom”),(2->”tomas”))
//元组,是不同类型值集合
//元组的范围从Tuple1 ~ Tuple22
val t = (1, “tom”)
t_1
t_2
val t:Tuple3[Int,String,Int] = (1,”tom”,12)
val t:(Int,String,Int) = (1,”tom”,12)
val t = (1,”tom”,12)
t._3
t _3
//抽取元组值
val (id,name,age) = t
val (id,,) = t
val (id,name,_) = t
val ids = Array(1,2,3);
val ids = ArrayInt
ids(0) =1
ids(1) =2
ids(2) =3
//zip
val ids = Array(1,2,3);
val names = Array(“tom”,”tomas”,”tomasLee”);
ids.zip(names)
ids.zipAll(names,-1,”none”) //-1:默认id,”none” : 默认name,长度不等时使用。
ids.zipWithIndex //和索引构成元组
类
class Dog
val d = new Dog
class Counter{
private var value = 0 //定义成员变量
def incr(){value += 1} //过程,没有返回值
def curr() = value //方法
}
//使用scala编译类
scalac Dog.scala
//查看类结构
javap -p Counter.class
//从磁盘导入scala文件
:load d:/scala/Person.scala
val p = new Person()
p.name //p.name() 等价于get
p.name = //p.name_=(“”) 等价于set
//
class Person{
val age = 0 ; //没有set
var name = “tom” //get/set
}
//私有字段
class Person{
//控制name字段只能在自己的对象中访问。其他对象无法访问.
private[this] var name = “tom” ;
}
//标准get、set方法
import scala.beans.BeanProperty
class Person{
@BeanProperty var name = “tom”
}
val p = new Person()
p.setName(“”); //标准方法
//_使用方法
1.导包
import scala._
2.转换
1 to 10:_*
3.元组抽取
val (id,_) = t
4.属性默认值
class Person{
var name:String = _
}
//scala构造函数
class Cat{
var name = “tom”
//辅助构造
def this(color:String) = {
this()
println(“1”)
}
//重载辅助构造
def this(color:String,age:Int) = {
this(“color”)
println(“2”)
}
}
//主构造,如果private修饰,所有方法都使用private修饰.
class Cat(var name:String,val age:Int,color:String){
def whatColor() = println(color)
}
Compiled from “Cat.scala”
public class Cat {
private java.lang.String name;
private final int age;
public java.lang.String name();
public void name_$eq(java.lang.String); //setName
public int age();
public Cat(java.lang.String, int, java.lang.String);
}
1.主构造参数解释
a)使用var修饰
对应成员变量,生成读写访问
b)使用val修饰
对应final成员变量,只有get方法
c)没有修饰var | val 修饰
c.1)如果类中没有访问过,不生成成员变量
c.2)如果访问过,生成成员变量。没有方法。final
2.主构造使用默认值
class Dog(name:String = “dahuang” , age:Int = 2){
}
val d = new Dog()
val d = new Dog(age = 3);
object
单例对象,里面的成员对应java中的静态成员。
伴生对象:companion
伴生对象和类必须位于同一个scala文件中。
class Dog{}
object Dog{}
class Benz{
def run() = println("rrrrr...")
}
object Benz{
val brand = "BENZ"
}
object App{
def main(args:Array[String]):Unit = {
println(“hello world”)
}
}
idea下卸载插件
设置 -->plugin -> 搜索scaal -> uninstall
idea下安装scala插件
设置 -->plugin -> install plugin from disk ... -> 选择插件文件 -> ok -> 自动重启
class //class
object //static
trait(特质) //interface
idea下创建scala模块
//接口
trait USB{
def play()
}
//伴生对象
object Benz{
//apply方法
def apply(a:String) = new Benz(a) ;
}
Benz(“black”)
隐式导入
import scala._
import java.lang._
import Predef._ //定义了很多类的别名
//type String = java.lang.String
//继承
abstract class Animal{
def eat()
}
class Dog extends Animal{
def eat();
}
//类型检查
o instanceof Car //判断是否属于Car类型
(Car)o //强转
//scala
val a = “abc”
a.isInstanceOf[String] //o instanceof Car
val b = a.asInstanceOf[String] //(Car)o
classOf[String] //Class clazz = String.class
//继承类传参父类主构造
class Benz(var color:String) {
def run() = {
println(“run…”)
}
}
class MSDS(color:String ) extends Benz(color){
}
scala类结构图
Any
|—AnyValue
final abstract class Byte private extends AnyVal
final abstract class Int private extends AnyVal
final abstract class Long private extends AnyVal
final abstract class … private extends AnyVal
final abstract class Unit private extends AnyVal //不代表任何对象,等于void
|—AnyRef
XxxClass
Null类型, 只有一个值null
val e:Null = null ; //ok
val e:Int = null ; //wrong
Nothing理解所有类的子类
Nil === List[Nothing]
Nothing是类型,没有值。
val l : List[Int] = 1 :: 2 :: Nil
val l1 : List[String] = Nil == List[Nothing]
val l1 : List[Int] = Nil == List[Nothing]
val l1 : List[Long] = Nil == List[Nothing]
:Unit = ()
Null = null
Nothing
序列化
java :java.io.Serializable
scala:scala.Serializable
//调用shell脚本
import sys.prcoess._
“ls -al /” ! //linux
“dir d:/downloads” ! //windows
trait
trait White{
}
trait Rich{
}
trait Beau{
}
trait WB extends White with Beauti with Rich{
}
class WomanStar extends WB with Rich{
def rich(): Unit = ???
def white(): Unit = ???
def beauti(): Unit = ???
}
自身类型:self-type
trait Elec{
this:Benz =>
}
只有Benz类或者子类才能实现该接口
操作符
[中置操作符]
1 to 10
1 -> 10
[一元操作符]
1 toString
1.toString
+a
-a //a.unary_-
~a //a.unary_~
运算符结合性
Nil == List[Nothing]
1 :: Nil //Nil.::(1)
1::2::3::Nil //Nil.::(3).::(2).::(1)
apply() / update()
f(a,b,c) //f.applay(a,b,c)
f(a,b,c) = x //f.update(a,b,c,x)
//
class Fraction(n:Int,d:Int) {
}
object Fraction{
def apply(n:Int,b:Int) = new Fraction(n,b)
}
//apply方法
/**
* 定义伴生对象
*/
class Fraction(var n:Int,var d:Int) {
def *(b: Fraction) = {
Fraction(b.n * n , b.d * d)
}
override def toString = {
n + "/" + d
}
}
object Fraction{
def apply(n:Int,b:Int) = new Fraction(n,b)
}
object App{
def main(args: Array[String]): Unit = {
val f1 = Fraction(1,2)
val f2 = Fraction(1,3)
println(f1 * f2)
}
}
class Option
object None extends Option[Nothing] //null
case class Some extends Option[??]
//unapply()是apply()相反过程,反解析
object Fraction{
def apply(n:Int,b:Int) = new Fraction(n,b)
def unapply(f:Fraction) = {
if(f.d == 0) None else Some((f.n , f.d))
}
}
object App{
def main(args: Array[String]): Unit = {
val f1 = Fraction(1,2)
val f2 = Fraction(1,0)
val f3 = f1.*(f2)
//反解析
val Fraction(a,b) = f3
//常规手段调用unapply()
val r:Option[(Int,Int)] = Fraction.unapply(f3)
if(!r.isEmpty){
println(r.get._1)
}
}
}
//函数
一种映射关系,从指定类型到指定类型之间的一种关系
//高级函数
函数的参数或者返回值还是函数.
import scala.math._
val f = ceil _
f(3.14)
def x2(n:Int) = n * 2
Array(1,2,3,4).map(x2)
Array(1,2,3,4).map(x2 _) //
Array(1,2,3,4).map((x:Int) => x * 2) //匿名函数
val f = (x:Int) => x * 2
Array(1,2,3,4).map(f) //
//定义高阶函数
def op(f:(Int,Int)=>Int,a:Int,b:Int) = f(a,b)
def add(a:Int,b:Int) = a + b
op(add,1,2)
op((a:Int,b:Int)=>a + b,1,2)
op((a,b)=>a + b,1,2)
def x2(n:Int) = n * 2
Array(1,2,3,4).map((x:Int)=>x * 2); //
Array(1,2,3,4).map((x)=>x * 2); //
Array(1,2,3,4).map(x=>x * 2); //
Array(1,2,3,4).map(_ * 2); //
定义返回值是函数
def tt(n:Int): Int=>Int = {
(x:Int)=> n * x
}
def tt(n:Int) = {
(x:Int)=> n * x
}