一、映射<Map>
-----------------------------------------------------
1.创建一个不可变的映射Map<k,v> ==> Map(k -> v)
scala> val map = Map("tom" -> 1 , "tomasLee" -> 2 , "join" -> 3)
map: scala.collection.immutable.Map[String,Int] = Map(tom -> 1, tomasLee -> 2, join -> 3)
注意，这种方式创建的映射的元素是不可以改变的
2.访问Map
scala> map("tom")
3.创建可变的映射
scala> val map = scala.collection.mutable.Map(100 -> "tom",200->"tomsLee",300 -> "join")
map: scala.collection.mutable.Map[Int,String] = Map(200 -> tomsLee, 100 -> tom, 300 -> join)
scala> map(100) = "222"
scala> map
res1: scala.collection.mutable.Map[Int,String] = Map(200 -> tomsLee, 100 -> 222, 300 -> join)
4.创建空的可变映射：如果想从一个空映射开始，你需要选择一个映射实现hashmap和map的参数[Int,String]
scala> val map = new scala.collection.mutable.HashMap[Int,String]
map: scala.collection.mutable.HashMap[Int,String] = Map()
scala> map
res2: scala.collection.mutable.HashMap[Int,String] = Map()
scala> map(100)="111"
scala> map
res4: scala.collection.mutable.HashMap[Int,String] = Map(100 -> 111)
5.追加和移除元素
a.对于可变映射
scala> val map = scala.collection.mutable.HashMap[Int,String]()
map: scala.collection.mutable.HashMap[Int,String] = Map()
//添加元素
scala> map += (1->"100",2->"200")
res5: map.type = Map(2 -> 200, 1 -> 100)
//移除元素
scala> map -= 2
res9: map.type = Map(1 -> 100)
b.对于不可变映射
不可变映射是不能添加和移除元素的，但是可以变成另外一个映射
scala> val map = Map("tom" -> 1 , "tomasLee" -> 2 , "join" -> 3)
map: scala.collection.immutable.Map[String,Int] = Map(tom -> 1, tomasLee -> 2, join -> 3)
//immutable不可变集合添加元素是错误的
scala> map +=("xiao" -> 4)
<console>:12: error: value += is not a member of scala.collection.immutable.Map[String,Int]
map +=("xiao" -> 4)
//但是可以将map元素添加或者移除一个元素，之后重新赋值给一个新的不可变映射
scala> val map1 = map + ("xiao" -> 4)
map1: scala.collection.immutable.Map[String,Int] = Map(tom -> 1, tomasLee -> 2, join -> 3, xiao -> 4)
scala> map - "tom"
res15: scala.collection.immutable.Map[String,Int] = Map(tomasLee -> 2, join -> 3)
scala> map
res17: scala.collection.immutable.Map[String,Int] = Map(tom -> 1, tomasLee -> 2, join -> 3)
6.迭代
scala> for((k,v) <- map) println(k + ":" + v)
tom:1
tomasLee:2
join:3
//得到一个类似Set("tom", "tomasLee", "join")
scala> map.keys
res19: Iterable[String] = Set(tom, tomasLee, join)
scala> map.keySet
res20: scala.collection.immutable.Set[String] = Set(tom, tomasLee, join)
//遍历values
scala> for(v <- map.values) println(v)
1
2
3
//遍历keys
scala> for(v <- map.keys) println(v)
tom
tomasLee
join
//遍历keySet
scala> for(v <- map.keySet) println(v)
tom
tomasLee
join
//遍历values
scala> for(v <- map.keySet) println(map(v))
1
2
3
7.yield 迭代产生新的映射，比如kv调换
scala> map
res12: scala.collection.mutable.HashMap[Int,String] = Map(1 -> 100)
scala> for((k,v)<- map ) yield(v,k)
res11: scala.collection.mutable.HashMap[String,Int] = Map(100 -> 1)
二、元组tuple
-------------------------------------------------------------------
1.元组是不同类型的值的聚集 -- 映射是键值对的集合，键值对是元组的最简单的形式
2.元组的值是通过将单个的值包含在圆括号中构成的
(1,3.14,"Fred")
3.定义一个元组Tuple,最多22个元素
scala> val t = (1,3.14,"Fred")
t: (Int, Double, String) = (1,3.14,Fred)
4.访问元组中的元素
scala> t._1
res27: Int = 1
scala> t _2
res28: Double = 3.14
scala> t._3
res29: String = Fred
5.直接取出元组中的所有元素
scala> val(a,b,c) = t
a: Int = 1
b: Double = 3.14
c: String = Fred
6.数组的zip(咬合/拉链)
scala> val h = Array(1,2,3)
h: Array[Int] = Array(1, 2, 3)
scala> val w = Array(4,5,6)
w: Array[Int] = Array(4, 5, 6)
scala> h.zip(w)
res31: Array[(Int, Int)] = Array((1,4), (2,5), (3,6))
三、简单类
-----------------------------------------------------
1.定义类
class Person{
//定义变量,私有类型,必须初始化
//set/get也私有
private var id = 0 ;
//不声明就是public，public的常量自带get,没有set
val age = 100 ;
//不声明就是public，public的变量自带get，set
var name = "tom" ;
//默认public
def incre(a:Int) = {id += a ;}
//如果定义函数时，没有加(),调用就不能加()
def current() = id
}
2.使用类
scala> var p = new Person()
p: Person = Person@55dfebeb
//声明方法的时候带(),调用方法的时候可以带也可以不带
scala> p.current
res0: Int = 0
scala> p.incre(2)
scala> p.current()
res2: Int = 2
//调用get方法。注意p.name(),说错误的，不能加括号，因为定义的时候没有括号
scala> p.name
res5: String = tom
//调用set方法赋值，要加括号
scala> p.name_=("jarry")
scala> p.name
res9: String = jarry
//直接给公有的变量赋值
scala> p.name = "kkk"
p.name: String = kkk
3.private[this] 私有修饰 -- 对象私有化
private var value = 0; //其他对象可以通过一些手段访问
private[this] var value = 0; //只能在自己对象中访问
4.@BeanProperty 注解
当你将scala字段添加注解@BeanProperty的时候，自动生成javabean对应的setName() 和 getName()方法
class Person{
// _ 表示默认值[Unit]
@scala.reflect.BeanProperty var name:String = _
}
5.构造函数
a.scala构造函数分为主构造器和辅助构造器
b.辅助构造器
辅助构造器的名称都叫this
每一个辅助构造器都必须先调用，先前已经定义的其他辅助构造器或者主构造器
class Person{
var name = "";
var age = 0;
def this(name:String) {
this(); //调用主构造器this()
this.name = name;
}
def this(name:String , age:Int) {
this(name); //调用辅助构造器this(name)
this.age = age;
}
}
scala> var p = new Person("tom", 12);
p: Person = Person@2eb0cefe
scala> p.name
res13: String = tom
scala> p.age
res14: Int = 12
c.主构造器 : 直接放置在类名之后
class Person(var name:String, var age:Int){
//因为主构造器的参数会被编译成字段，所以下面代码可省略
//var name = "";
//var age = 0;
//def this(name:String , age:Int) {
// this(name); //调用辅助构造器this(name)
// this.age = age;
//}
//下面这些语句是在构造函数中，也就是说，每次创建对象都会调用一次
println("xxxxxx");
println("xxxxxx");
println("xxxxxx");
age += 100;
def hello() = {println("hello" + age);}
}
四、嵌套类 -- 内部类
-------------------------------------------------------------
1.对于scala，你可以在类中定义类，可以在方法中定义方法
class Person{
class Heart(val count : Int){
println("*****")
}
var name = "tom";
def fun(arg : String) = {
def fun1()
{
}
def fun2()
{
}
}
}
2.new Person().new Heart(80);
五、对象Object
------------------------------------------------------------
1.单例对象
a.scala中没有静态方法和静态字段，靠单例对象来实现
object Util{
var name = "tom";
def hello() = {println("hello")};
}
b.scala> Util.name
res3: String = tom
scala> Util.hello
hello
scala> Util.name = "ccc"
Util.name: String = ccc
2.类和类的伴生对象（类中的某个成员是静态的）
a.类和它的伴生对象可以互相访问私有成员 -- 但是，class和object必须在同一个文件中
class Account{
var id = Account.uniqueNumber();
...
}
object Account{
private def uniqueNumber() = { return 0 };
}
3.扩展[继承]类和特质[接口]的对象
a.scala中的抽象类
abstract class UndoAction (val description : String ){
def undo():Unit
def redo():Unit
}
b.scala中的继承
//类的继承
class DoNothingAction extends UndoAction ("Do nothing"){
override def undo(){}
override def redo(){}
}
//DoNothingAction这个对象（静态对象）可以被所有需要缺省行为对象的地方共有（需要do nothing就调用）
object DoNothingAction extends UndoAction ("Do nothing"){
override def undo(){}
override def redo(){}
}
4.apply方法
a.Object(参数1,....,参数N)
这样一个apply方法，返回的是伴生类的对象，比如Array("aaa","bbb","ccc")返回的是一个String的数组;
b.Array(100) 和 new Array(100)的 区别
Array(100)，返回的是一个只包含一个元素100的数组。100表示元素
new Array(100),返回的是一个有100个元素，每个元素都为空的数组。100表示数组中元素的个数
scala> Array(100)
res1: Array[Int] = Array(100)
scala> new Array(100)
res2: Array[Nothing] = Array(null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null)
c.自定义Apply方法--示例
object Hello
{
def apply(s:String) = {println(s)};
}
scala> Hello("hello")
hello
scala> Hello("hai")
hai
scala> Hello.apply("hai")
hai
d.应用程序对象 -- 带main函数的object[因为main函数是静态的，所以只能在对象中]
object Hello
{
def main(args : Array[String]) = {
println("xxx");
}
}
scala> Hello.main(Array())
xxx
六、Idea中安装scala插件
-------------------------------------------------------------
1.打开idea --> File --> settings --> plugins --> install xxx -->
--> 找到scala-intellij-bin for xxx.zip 或者使用网上下载安装方式进行安装
2验证安装是否成功
a.创建scala模块，选择sdk,添加maven支持
b.编写object
object Hello {
def main(args: Array[String]): Unit = {
println("Hello world");
}
}
c.运行object
七、trait特质[接口]
-----------------------------------------------------------
1.创建trait
trait Hello{
}
2.编译scalac
cmd:D:\share\scala\workspace> scalac trait-1.scala
3.反编译
cmd> javap Hello.class
public interface Hello {
}
八、包和包的导入
-----------------------------------------------------------
1.包对象
//编译包对象，编译完之后生成以xxx为package，下面含有类package.class + package.class
// .../a/aa/aaa/people/package.class
// .../a/aa/aaa/people/package$.class
package a.aa.aaa;
package object people
{
var name = "hello";
}
2.包的可见性约束
package a.aa.aaa;
class Person{
//在package包及其子包中可见
private[people] def func() = { println("xxx")}
//在aaa包及子包中可见
private[aaa] def func1() = {println("---")}
}
3.包的导入
a._表示通配
import java.awt.Color._
b.选取器selector
//只引入包中的几个成员类
import java.awt.{Color,Font}
c.选取器重命名，别名
比如 HashMap 在 java.util 和 scala.collection中都有。如果想同时导入两者，那么就必须将其中一个HashMap指定别名
否则就不知道hashMap指向的是哪个包了
import java.util.{HashMap => JavaHashMap}
import scala.collection.mutable.HashMap
d.隐藏导入成员
//将java包中的HashMap隐藏掉，不使用
import java.util.{HashMap => _}
import scala.collection.mutable.HashMap
大数据之scala（二） --- 映射，元组，简单类，内部类，对象Object，Idea中安装scala插件，trait特质[接口]，包和包的导入
猜你喜欢
转载自blog.csdn.net/xcvbxv01/article/details/83654808
今日推荐
周排行