Scala第二章

Scala元组 可以包含不同类型的元素 最多支持22个元素（Tuple1~Tuple22） 是用下划线 "_“访问元素，”_1"表示第一个元素

object demo3 { def main(args: Array[String]): Unit = {

元组定义方式1

var tupleDemo = ("hello",2.4,12,"world","a") println(tupleDemo) println(tupleDemo._1) println(tupleDemo._2) println(tupleDemo._3) println(tupleDemo._4) println(tupleDemo._5) var tupleDemon2 = (1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,11,12) println(tupleDemon2._10) tupleDemo.productIterator.foreach(x => println("value: "+x)) //迭代元组

元组定义方式2

var tupleDemon2 = new Tuple5("ab","cd","ef","gh","ij")

元组定义方式3

def mike = "mike" -> 5 -> 6 println(mike) println(mike.getClass) //输出scala.Tuple2 val tp2 = ("zs",21) val tp1 = ("zhangsan","安德门","19") val(name,address,age) = tp1 //将元组元素依次赋值给三个变量 println(name) println(address) println(age) val stream = (1 to 1000).toStream stream stream.head println(stream.tail) println(stream(3)) } }

Scala集合-1 Seq 序列，元素按顺序排列 Set 集合，元素不重复 Map 映射，键值对集合

利用集合进行wordcount

scala> val stringList = List("hello world hello gree","hello java hello scala", "hello wenwen hello kb09") scala> stringList.flatMap(x=>x.split(" ")).map(x=>(x,1)).groupBy(x=>x._1).map(x=>(x._1, x._2.size))

Scala集合-2 不可变集合 scala.collection.immutable，默认Scala选择不可变集合 可变集合：可以修改、添加或移除一个集合的元素 scala.collection.mutable

Scala集合-3 scala.collection.immutable Set：ListSet、HashSet、TreeSet Map：ListMap、HashMap、TreeMap Seq：Vector、String、Range、List、Stack、Stream、Queue

Scala集合-4 scala.collection.mutable

Scala集合-5 常用集合

名称可变/不可变示例Buffermutableval buffer = scala.collection.mutable.ArrayBuffer[Int](10, 20, 30); buffer+=(2,3)Arraymutableval arr = Array(1,2,3)Listimmutableval lst = List(1,2,3)Mapmutableval stu= Map(“name” -> “Jason”, “age” -> “18”)Setmutable/immutableval set=Set(1,2,3)Vectorimmutableval v=Vector(1, 3, 5, 7, 11, 13)Stackmutable/immutableval st=scala.collection.mutable.Stack(1,2,3) //堆栈，先进后出Queuemutable/immutableval q=scala.collection.mutable.Queue(1,2,3) //队列，先进先出BitSetmutable/immutableval bit=scala.collection.mutable.BitSet(3,2,0) //位集合ListMapimmutableval map = scala.collection.immutable.ListMap(1->“one”, 2->“two”)HashSetmutableval set= scala.collection.mutable.HashSet(1,2,3)HashMapmutableval stu= scala.collection.mutable.HashMap(“name” -> “Jason”, “age” -> “18”)

Scala List常用操作

var c = List[Char]('a', 'b', 'c') var x = 'x' +: c // (x, a, b, c) var y = c :+ 'x' // (a, b, c, x) import scala.collection.mutable._ var lb = ListBuffer[Int](1, 2, 3, 4) lb += 100 //1, 2, 3, 4, 100 lb += (21, 33)// 88 +=: lb //88, 1, 2, 3, 4, 100, 21, 33 List(77, 66) ++=: lb var l = List[Int](2, 3, 4, 6, 8, 9, 11, 20) var x = l grouped 3 //等价l.grouped(3) x.next() //(2, 3, 4) x.next() //(6, 8, 9) var y = l sliding 2 y.next() // (2, 3) y.next() // (3, 4) var a1 = Array[Int](1, 2, 3, 4) var a2 = Array[Int](100, 200, 300, 400) var a = List.concat(a1, a2)//Array->List a3=a1++a2 //Arrays->Array a(3) = 333 //Error a3(3)=333 //OK var b = Array(333, "333", '3', false ) var c = List.concat(a, b) val x = a.filter( _ %2 != 0 ) val y = a.reverse var m = a.groupBy(t => t%2 == 0) var n = a.slice(2, 4) a.sorted //1, 2, 3, 4, 100, 200, 300, 400 a.sorted( Ordering.Int.reverse ) a.sortWith( _ > _ ) a.sortBy( x => x ) //升序 a.sortBy( x => x*(-1) ) //降序

Scala Set常用操作

var s = Set("ab", "yz") s += "mn" //mn, ab, yz s += "mn" //?? s -= "yz" //mn, ab var t = Set("ab", "gh", "mn", "st", "yz" ) t -- s //gh, st, yz t ++ s //ab, gh, mn, st, ya var os = SortedSet(1, 99, 66, 54, 77 ) os //1, 54, 66, 77, 99 os += 33 os //1, 33, 54, 66, 7 var s = Set("ab", "yz") var t = Set("ab", "gh", "mn", "st", "yz" ) //求交集 t & s t intersect s //求并集 t | s t union s //求差集 t &~ s t diff s

Scala Map常用操作

var m = Map[String, Int]("a"->1, "b"->2, "c"->3, "d"->4, "e"->5, "f"->6, "g"->7, "h"->8, "i"->9) m("a") //1 m += ("j"->0) m += ("j"->0) //?? m += ("j"->11) //?? var n = m ++ Map[String, Int]("a"->3, "j"->99) //?? n -= ("g", "e")

Scala Stream & Vector Stream是List惰性版

val stream = (1 to 1000).toStream stream // Stream(1, ?) stream.head // 1 stream.tail // Stream(2, ?) stream(3) stream.tail // Stream(2,3,4,?)

Vector拥有连续的内存空间，利于随机存取（直接访问）

val v = Vector.empty :+ 2 :+ 2 val v1 = v ++ Vector[Int](3) v.length v1.length

Java Lambda表达式 函数式接口 一种只含有一个抽象方法声明的接口 可以使用匿名内部类来实例化函数式接口的对象 通过Lambda表达式可以进一步简化代码 Lambda语法

(paramenters) -> expression (paramenters) -> {statements;}

例：用lambda表达式进行加减乘除运算 代码：

public class TestDemo { public static void main(String[] args) { OperationInterface add = (Integer a,Integer b) -> a+b; OperationInterface jian = (Integer a,Integer b) -> a-b; OperationInterface ji = (Integer a,Integer b) -> a*b; // Integer sum2 = ji.operation(10,20); // System.out.println(sum2); TestDemo demo = new TestDemo(); Integer result = demo.getResult(20, 10, add); System.out.println(result); // OperationInterface operationInterface = new OperationInterfaceImpl(); // Integer sum = operationInterface.operation(10,10); // System.out.println(sum); } public Integer getResult(Integer a,Integer b,OperationInterface operationInterface) { return operationInterface.operation(a,b); } }

内置四大函数式接口 消费接口：Consumer 供给型接口：Supploer 断言型接口：Predicate 函数型接口：Function<T,R>

Consumer<String> consumer=(s)-> System.out.println(s.toUpperCase()); consumer.accept("testabc"); Supplier <Double> supplier = () -> Math.random(); System.out.println(supplier.get()); Predicate<String> condition=s -> s.length()>4; if(condition.test("hello")) System.out.println("true"); Function<String,String> toUpper=(s)->s.toUpperCase(); System.out.println(toUpper.apply("test"));

Scala函数 函数是Scala的核心 函数定义

def 函数名([参数列表]):[返回值] = { 函数体 return [表达式] }

函数调用 函数名(参数列表)

def square(x: Int): Int = { println(x) x * x //return } def sayHello(x:String):Unit={ println("Hello ! "+x) }

参数传递 传值调用（call-by-value），传值调用时，参数只在调用时计算一次，后续重复使用计算的结果

def square(x: Int): Int = { println(x) //3 x * x //计算3*3 } square(1+2) //先计算1+2

传名调用（call-by-name），传名调用时，参数在调用时不会计算，只有真正用到参数时才计算

def square(x: => Int): Int = { println(x) //计算1+2 x * x //计算(1+2)*(1+2) } square(1+2) //调用时不计算