Scala从入门到了解第一课：scala基础语法汇总一

最新推荐文章于 2024-05-30 00:38:23 发布

二百四十九先森

最新推荐文章于 2024-05-30 00:38:23 发布

阅读量354

点赞数 2

分类专栏： Scala 文章标签： scala 概念

本文链接：https://blog.csdn.net/pengzonglu7292/article/details/79244767

版权

Scala 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1、scala的六大特性


    1、与java无缝整合
        基于jvm，可以在java代码中代用scala包、类，也可以在scala代码中调用java包、类。
        而不是指代码互相嵌套
    2、类型自动推断
        var a=100   会自动推导出a为int类型
    3、支持并行分布式
        scala崛起的重要原因，java和c在多核编程是哪个十分复杂，scala则 十分适用于多核编程
    4、Trait特性
        类似于java中抽象类接口的整合，但更为强大
    5、模式匹配
        类似于java的switch，但更为强大，case后可以接任意类型
    6、高阶函数
        用函数作为形参或返回值的函数，我们称之为高阶函数

2、变量

变量：var var a=10  等价于var a:Int =10
常量：val val b=20  等价于var b:Int =20

默认值：
    scala> var a:Int=_
    a: Int = 0

    scala> var a:Double=_
    a: Double = 0.0

    scala> var a:String=_
    a: String = null

    scala> var a:Boolean=_
    a: Boolean = false


惰性求值：
scala>var x:Int =10
>x : Int=10

scala>var y =20
>y : Int =20

scala>lazy val z = y-x
z : Int = <lazy>        #没有立即求解出z的值

scala>f*10
>res1 : Int =100

3、类型体系


Any:任何类的父类，Object类的子类
AnyRef:Any的子类，所有引用数据类型的超类
AnyVal:Any的子类，所有基本数据类型的超类


基本数据类型：
    九种基本数据类型中的八种与java一样，不说，只说Unit
    Unit:等价于java中的void

引用数据类型：
  Null:AnyRef的子类
    表示引用类型的值为空，但在scala中我们这种场景下通常不使用Null，使用Option
  None:Option类型的两个子类之一，另一个为some
  Nothing:所有类型的子类型，表示没有值。
    也表示程序异常终止。对于一个函数而言，如果返回值是Nothing，表明函数发生了异常。
  Nil:表示没有值的集合



注意：
    Scala的数据类型要首字母大写

4、类、对象、构造器

1、类和对象
类：
    由class声明，在类中书写非静态的变量、方法等。
    不含任何静态的代码。
对象：
    由object声明，在对象中书写静态的变量、方法等。
    不含任何非静态的代码。主方法在对象中声明。
    所有对象均单例。

#即使在类中声明main方法，该方法也是一个叫做main的普通方法


2、示例：
object MainTest {
  def main(args: Array[String]): Unit = { //主函数的固定写法
    val a=new Scala01()    //实例化
    print(a.min(1,2))    //调用类中的函数
  }
}

class Scala01 {
  def min(x:Int,y:Int):Int={
    if(x>y) y else x 
  }
}

备注：
    val的垃圾回收快于var
    实例化时，类中除了普通方法外，其他所有东西都会执行，因为这些东西相当于定义在构造器中
    

3、类的构造器
object MainTest {

  def main(args: Array[String]): Unit = {
    val a=new Scala01(1,2,3)
  }
}

class Scala01(x:Int,y:Int) {//相当于有一个双参构造
  var z:Int=_   //接收任意的Int类型数据

  def this(x:Int,y:Int,z:Int){
    //构造器重载,参数个数要多余重写前的，不然怎么第一行调之前的构造器啊
    this(x,y) //必须
    this.z=z    //给全局变量赋值
    print(x+y+z)
  }
}
    

4、伴生类和伴生对象（重要）

A、名称相同的类和对象，类叫做对象的伴生类，对象叫做类的伴生对象
B、对象中的方法和属性（包括私有）可以直接在类中通过"类名.方法"调用
C、类中的方法和属性（包括私有）可以直接在对象中通过"对象名.方法"调用


5、apply方法

应用1：
    创建对象不用new

class Scala01(x:Int,y:Int) {//相当于有一个双参构造

}
object Scala01{//在这个伴生对象中重写apply方法创建对象就不要new了
  def apply(x: Int, y: Int): Scala01 = {//返回一个Scala01对象
    new Scala01(x, y) 
  }
}

object MainTest {

  def main(args: Array[String]): Unit = {
    val a=Scala01(1,2)    //创建对象不用new
  }
}


应用2：
    函数调用

object MainTest {

  def main(args: Array[String]): Unit = {
    val f = (x: Int) => x + 1 //将匿名函数赋给f
    println(f.apply(3)) //调用函数
    println(f(3)) //调用函数，简写
  }
}



应用3：
    充当工厂

object MainTest {
  def main(args: Array[String]): Unit = {
    def apply(x: Int, xs: Int*): Array[Int] = {//返回一个至少有一个元素的Array
      val array = new Array[Int](xs.length + 1)
      array(0) = x
      var i = 1
      for (x <- xs.iterator) { array(i) = x; i += 1 }
      array
    }
  }
}

5、流程控制

1、判断语句
    if/if...else/if...else if...else
    和java一样，不说

2、while循环
    while/do...while
    和java一样，不说

3、for循环

A、range:

    for(i <- 1 to(10)) print(i+"\t")    
    for(i <- 1 to(10,2)) print(i+"\t")
    for(i <- 1 until(10)) print(i+"\t")
    for(i <- 1 until(10,2)) print(i+"\t")
    输出结果：
    1	2	3	4	5	6	7	8	9	10	
    1	3	5	7	9	
    1	2	3	4	5	6	7	8	9	
    1	3	5	7	9	

B、foreach
    (1 to(10)).foreach(s => println(s))
    (1 to(10)).foreach(print(_))
    (1 to(10)).foreach(println)


C、条件for循环
    for(i <- 1 to(10) if(i>5) if(i%2==0)) print(i+"\t")
    输出1-10范围内大于5的所有偶数
    
D、嵌套for循环
    for(i <- 1 to(2) ;j <- 1 to(i)) print(i+j+"\t")
    打印1+1 2+1 2+2的结果

F、yield
    scala> for (e <- 1-10 if e > 2) yield e    
    res1: Array[Int] = Array(3, 4, 5)
    #将for循环中每次满足条件的值记录下来，放入一个集合中，集合的类型与遍历集合的类型一致
    #yield的底层实现是一个缓冲区

6、函数

1、定义：
   def apply(x: Int=100, y: Int，z:Int*): Scala01 = {
    new Scala01(x, y)
  }
    def声明一个函数，函数返回值可以省略，返回值为Scala01对象
    等号可以省略，省略号返回值丢失，相当于返回值是Unit
    形式参数可以有默认值（不传值生效），示例中x默认值为100
    形参类型后加星号，代表可变参数
    函数的定义可以嵌套



2、匿名函数
    (形参)=>{函数体}
    val a:Int=(x:Int)=>x+1 
    #将匿名函数赋给一个变量,函数返回值类型为Int
    a(2)    //调用函数
   

3、偏应用表达式
  def showlog(age:Int)={
    println(s"我今年 $age 岁了")
  }
  val fun=showlog(_)  //将函数体赋值给一个变量，传入参数任意
  fun(1)  //函数调用

4、高阶函数

A)函数形参是函数
  def main(args: Array[String]): Unit = {
    showlog((x,y)=>x+y)   
  }
  def showlog(f:(Int,Int)=>Int)={
    val i = f(10,20)    //形参是函数，内部要用到这个函数才行
    println(s"我今年 $i 岁了")
  }

B)函数的返回值是函数

  def main(args: Array[String]): Unit = {
    val max = A(10,20) //调用函数A，返回一个函数
    print(max(1,2)) //调用A函数返回的函数，并输出结果

  }
  def A(x:Int,y:Int):(Int,Int)=>Int= {
    (x,y)=>if(x>y) x else y     //这儿的x,y和外层函数的x,y没任何关系
  }


C)函数的形参和返回值都是函数

  //主方法中调用函数A，返回匿名函数，调用匿名函数，并输出结果
  def main(args: Array[String]): Unit = print(A(x=>x+1)(1,2)) 

  //函数的形参和返回值都是函数，如果x>y返回x,否则返回f(20)
  def A(f:Int=>Int):(Int,Int)=>Int=(x,y)=>if(x>y) x else f(20)


5、柯里化函数
    柯里化函数把具有多个参数的函数转换为一条函数链，每个节点上都是单一函数
示例：
def add(x:Int)(y:Int)=x+y 

与def add(x:Int,y:Int)=x+y等价

6、递归函数
示例：
def fac(n:Int):Int=if(n<=0) 1 else n*fac(n-1)
执行过程：
fac(4)
--------------
4 * fac(3)
4 * (3 * fac(2))
4 * (3 * (2 * fac(1)))
4 * (3 * (2 * 1))
递归函数需要保持堆栈，容易造成堆栈溢出，所以我们尾递归函数对递归进行优化

尾递归优化：

  @tailrec    //记得导包
  def fac(x:Int,y:Int):Int=if(x<=0) y else fac(x-1,x*y)
  //将边界返回条件的值放入形参

执行过程：
fac(4,1)
--------------
3 * 4
2 * 12
1 * 24
0 * 24

7、String/Array/List/Set/Map/Tuple

1、String && StringBuilder
    String:
        比起java增加了一个字符串插值，其他全部一样
        s"$name love you"   在括号内引入外部变量

    StringBuilder:
        可变，参考java


2、Array && ArrayBuffer
Array:
    定义数组：
        val a=new Array[String](5)
        val c=Array(1,2,3,4,5)
    添加元素：
        a(0)="hadoop"
    方法：
        length     min    max    sum    mkString    concate
    遍历：
        for    a.foreach(print)

ArrayBuffer:（可变长度array）
    定义数组：
        val a=scala.collection.mutable.ArrayBuffer[Int]()
    添加元素：
        a+=1
        a+=(3,4)
        a++=Array(3,4)
        a.append(3,6)
    方法：
        insert    remove    trimEnd    trimStart    toArray    toList
    遍历：
        for(s <- a)    a.foreach(print)
    

3、List && ListBuffer

List:
    Nil是长度为0的list
    定义：
        val a=List(1,2,3,4,5)
    添加元素：

        
        12::a    将12加入集合a最前端
        a:::b    将集合a所有元素加入集合b最前端

    sc.makeRDD(List(1,2)::List(3,4)).foreach(print)    输出:List(1,2)34
    sc.makeRDD(List(1,2):::List(3,4)).foreach(print)    输出:1234
        

              
    方法：
        a.head（第一个元素） a.tail（除了head外所有元素）
        filter    count    map(一进一出)    flatmap(一进多出)
        遍历：
        for(s <- a)    a.foreach(print)

ListBuffer：(可变长度List)

    定义：
        val a=scala.collection.mutable.ListBuffer[Int]()
    添加元素：
        a+=1
        a+=(3,4)
        a++=List(3,4)
        a.append(6,7,8,9)
    方法：
        insert    remove    trimEnd    trimStart    toList    toArray


4、Set && mutable.Set

Set:
    自动去重
    定义：
        val set2 = Set(1,2,5)
    添加数据：
        
    方法：
        intersect（交集）    diff（差集）    subsetOf（子集）    
        max    min    toList    mkString
    遍历：
        for(s <- a)    a.foreach(print)
    
mutable.Set：
    定义：
        val s = scala.collection.mutable.Set[Int](1,2,3,4,5)
          
    添加数据：
        s.add(1)
        s+=1
    遍历：
       for(s <- a)    a.foreach(print)     
        

5、Map && mutable.map
    
Map：
    key不重复
    定义：
        val a=Map(1 -> "David",2 -> "Alice")
        val a=Map((1,"David"),(2,"Alice"))
    添加元素：
        a+(3 -> "Bob")
        a ++ List(4 -> "Lily",5 -> "Lucy")
        a-1
        a--List(1,2)    
    获取value：
        map.get(“1”).get
        map.get(100).getOrElse(“no value”)
    方法:
        contains    keys    values    filter    exist
    遍历：
        for(x <- map) println("key:"+x._1+",value:"+x._2)
        map.foreach(f => println("key:"+ f._1+" ,value:"+f._2))


mutable.map：（可变长度map）
    定义：
        val a =scala.collection.mutable.Map(1 -> "Lucy",2 -> "Lily")

    添加元素：
        a(1)="Jack"
        a.put(3,"Bob")
    
 
5、tuple 
    tuple可以存放各种类型的数据，最大长度为22。含一个元素的tuple类型为Tuple1,含2个元素的tuple类型为Tuple2......
    定义：
        val  tuple = Tuple（"hadoop","spark"）
    获取：
        tuple._1   获取第一个元素

    遍历：
       val iterator = tuple.productIterator
        while(iterator.hasNext){println(iterator.next())}   
  
    方法：
        swap（只针对tuple2,交换元素）
        toString

==========================================================================================================================================

附录：方法大全

String

String 方法
	
char charAt(int index)
返回指定位置的字符  从0开始
	
int compareTo(Object o)
比较字符串与对象
	
int compareTo(String anotherString)
按字典顺序比较两个字符串
	
int compareToIgnoreCase(String str)
按字典顺序比较两个字符串，不考虑大小写
	
String concat(String str)
将指定字符串连接到此字符串的结尾
	
boolean contentEquals(StringBuffer sb)
将此字符串与指定的 StringBuffer 比较。
	
static String copyValueOf(char[] data)
返回指定数组中表示该字符序列的 String
	
static String copyValueOf(char[] data, int offset, int count)
返回指定数组中表示该字符序列的 String
	
boolean endsWith(String suffix)
测试此字符串是否以指定的后缀结束
	
boolean equals(Object anObject)
将此字符串与指定的对象比较
	
boolean equalsIgnoreCase(String anotherString)
将此 String 与另一个 String 比较，不考虑大小写
	
byte getBytes()
使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
	
byte[] getBytes(String charsetName
使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
	
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此字符串复制到目标字符数组
	
int hashCode()
返回此字符串的哈希码
16	
int indexOf(int ch)
返回指定字符在此字符串中第一次出现处的索引（输入的是ascii码值）
	
int indexOf(int ch, int fromIndex)
返返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索
	
int indexOf(String str)
返回指定子字符串在此字符串中第一次出现处的索引
	
int indexOf(String str, int fromIndex)
返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
	
String intern()
返回字符串对象的规范化表示形式
	
int lastIndexOf(int ch)
返回指定字符在此字符串中最后一次出现处的索引
	
int lastIndexOf(int ch, int fromIndex)
返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索
	
int lastIndexOf(String str)
返回指定子字符串在此字符串中最右边出现处的索引
	
int lastIndexOf(String str, int fromIndex)
返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
	
int length()
返回此字符串的长度
	
boolean matches(String regex)
告知此字符串是否匹配给定的正则表达式
	
boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等
28	
boolean regionMatches(int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等
	
String replace(char oldChar, char newChar)
返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的
	
String replaceAll(String regex, String replacement
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串
	
String replaceFirst(String regex, String replacement)
使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串
	
String[] split(String regex)
根据给定正则表达式的匹配拆分此字符串
	
String[] split(String regex, int limit)
根据匹配给定的正则表达式来拆分此字符串
	
boolean startsWith(String prefix)
测试此字符串是否以指定的前缀开始
	
boolean startsWith(String prefix, int toffset)
测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
	
CharSequence subSequence(int beginIndex, int endIndex)
返回一个新的字符序列，它是此序列的一个子序列
	
String substring(int beginIndex)
返回一个新的字符串，它是此字符串的一个子字符串
	
String substring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串
	
char[] toCharArray()
将此字符串转换为一个新的字符数组
	
String toLowerCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为小写
	
String toLowerCase(Locale locale)
使用给定 Locale 的规则将此 String 中的所有字符都转换为小写
	
String toString()
返回此对象本身（它已经是一个字符串！）
	
String toUpperCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为大写
	
String toUpperCase(Locale locale)
使用给定 Locale 的规则将此 String 中的所有字符都转换为大写
	
String trim()
删除指定字符串的首尾空白符
	
static String valueOf(primitive data type x)
返回指定类型参数的字符串表示形式

Array

def apply( x: T, xs: T* ): Array[T]
创建指定对象 T 的数组, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。
	
def concat[T]( xss: Array[T]* ): Array[T]
合并数组
	
def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit
复制一个数组到另一个数组上。相等于 Java's System.arraycopy(src, srcPos, dest, destPos, length)。
	
def empty[T]: Array[T]
返回长度为 0 的数组

def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T]
返回指定长度数组，每个数组元素为指定函数的返回值。
以上实例数组初始值为 0，长度为 3，计算函数为a=>a+1：
scala> Array.iterate(0,3)(a=>a+1)
res1: Array[Int] = Array(0, 1, 2)
	
def fill[T]( n: Int )(elem: => T): Array[T]
返回数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
	
def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]]
返回二数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
	
def ofDim[T]( n1: Int ): Array[T]
创建指定长度的数组
	
def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]]
创建二维数组
	
def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]]
创建三维数组
	
def range( start: Int, end: Int, step: Int ): Array[Int]
创建指定区间内的数组，step 为每个元素间的步长
	
def range( start: Int, end: Int ): Array[Int]
创建指定区间内的数组
	
def tabulate[T]( n: Int )(f: (Int)=> T): Array[T]
返回指定长度数组，每个数组元素为指定函数的返回值，默认从 0 开始。
以上实例返回 3 个元素：
scala> Array.tabulate(3)(a => a + 5)
res0: Array[Int] = Array(5, 6, 7)
	
def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]]
返回指定长度的二维数组，每个数组元素为指定函数的返回值，默认从 0 开始。

List

1	def +(elem: A): List[A]
前置一个元素列表
2	def ::(x: A): List[A]
在这个列表的开头添加的元素。
3	def :::(prefix: List[A]): List[A]
增加了一个给定列表中该列表前面的元素。
4	def ::(x: A): List[A]
增加了一个元素x在列表的开头
5	def addString(b: StringBuilder): StringBuilder
追加列表的一个字符串生成器的所有元素。
6	def addString(b: StringBuilder, sep: String): StringBuilder
追加列表的使用分隔字符串一个字符串生成器的所有元素。
7	def apply(n: Int): A
选择通过其在列表中索引的元素
8	def contains(elem: Any): Boolean
测试该列表中是否包含一个给定值作为元素。
9	def copyToArray(xs: Array[A], start: Int, len: Int): Unit
列表的副本元件阵列。填充给定的数组xs与此列表中最多len个元素，在位置开始。
10	def distinct: List[A]
建立从列表中没有任何重复的元素的新列表。
11	def drop(n: Int): List[A]
返回除了第n个的所有元素。
12	def dropRight(n: Int): List[A]
返回除了最后的n个的元素
13	def dropWhile(p: (A) => Boolean): List[A]
丢弃满足谓词的元素最长前缀。
14	def endsWith[B](that: Seq[B]): Boolean
测试列表是否使用给定序列结束。
15	def equals(that: Any): Boolean
equals方法的任意序列。比较该序列到某些其他对象。
16	def exists(p: (A) => Boolean): Boolean
测试谓词是否持有一些列表的元素。
17	def filter(p: (A) => Boolean): List[A]
返回列表满足谓词的所有元素。
18	def forall(p: (A) => Boolean): Boolean
测试谓词是否持有该列表中的所有元素。
19	def foreach(f: (A) => Unit): Unit
应用一个函数f以列表的所有元素。
20	def head: A
选择列表的第一个元素
21	def indexOf(elem: A, from: Int): Int
经过或在某些起始索引查找列表中的一些值第一次出现的索引。
22	def init: List[A]
返回除了最后的所有元素
23	def intersect(that: Seq[A]): List[A]
计算列表和另一序列之间的多重集交集。
24	def isEmpty: Boolean
测试列表是否为空
25	def iterator: Iterator[A]
创建一个新的迭代器中包含的可迭代对象中的所有元素
26	def last: A
返回最后一个元素
27	def lastIndexOf(elem: A, end: Int): Int
之前或在一个给定的最终指数查找的列表中的一些值最后一次出现的索引
28	def length: Int
返回列表的长度
29	def map[B](f: (A) => B): List[B]
通过应用函数以g这个列表中的所有元素构建一个新的集合
30	def max: A
查找最大的元素
31	def min: A
查找最小元素
32	def mkString: String
显示列表的字符串中的所有元素
33	def mkString(sep: String): String
显示的列表中的字符串中使用分隔串的所有元素
34	def reverse: List[A]
返回新列表，在相反的顺序元素
35	def sorted[B >: A]: List[A]
根据排序对列表进行排序
36	def startsWith[B](that: Seq[B], offset: Int): Boolean
测试该列表中是否包含给定的索引处的给定的序列
37	def sum: A
概括这个集合的元素
38	def tail: List[A]
返回除了第一的所有元素
39	def take(n: Int): List[A]
返回前n个元素
40	def takeRight(n: Int): List[A]
返回最后n个元素
41	def toArray: Array[A]
列表以一个数组变换
42	def toBuffer[B >: A]: Buffer[B]
列表以一个可变缓冲器转换
43	def toMap[T, U]: Map[T, U]
此列表的映射转换
44	def toSeq: Seq[A]
列表的序列转换
45	def toSet[B >: A]: Set[B]
列表到集合变换
46	def toString(): String
列表转换为字符串

Set

Scala Set 常用方法
下表列出了 Scala Set 常用的方法：
序号	方法及描述
1	
def +(elem: A): Set[A]
为集合添加新元素，x并创建一个新的集合，除非元素已存在
2	
def -(elem: A): Set[A]
移除集合中的元素，并创建一个新的集合
3	
def contains(elem: A): Boolean
如果元素在集合中存在，返回 true，否则返回 false。
4	
def &(that: Set[A]): Set[A]
返回两个集合的交集
5	
def &~(that: Set[A]): Set[A]
返回两个集合的差集
6	
def +(elem1: A, elem2: A, elems: A*): Set[A]
通过添加传入指定集合的元素创建一个新的不可变集合
7	
def ++(elems: A): Set[A]
合并两个集合
8	
def -(elem1: A, elem2: A, elems: A*): Set[A]
通过移除传入指定集合的元素创建一个新的不可变集合
9	
def addString(b: StringBuilder): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区
10	
def addString(b: StringBuilder, sep: String): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
11	
def apply(elem: A)
检测集合中是否包含指定元素
12	
def count(p: (A) => Boolean): Int
计算满足指定条件的集合元素个数
13	
def copyToArray(xs: Array[A], start: Int, len: Int): Unit
复制不可变集合元素到数组
14	
def diff(that: Set[A]): Set[A]
比较两个集合的差集
15	
def drop(n: Int): Set[A]]
返回丢弃前n个元素新集合
16	
def dropRight(n: Int): Set[A]
返回丢弃最后n个元素新集合
17	
def dropWhile(p: (A) => Boolean): Set[A]
从左向右丢弃元素，直到条件p不成立
18	
def equals(that: Any): Boolean
equals 方法可用于任意序列。用于比较系列是否相等。
19	
def exists(p: (A) => Boolean): Boolean
判断不可变集合中指定条件的元素是否存在。
20	
def filter(p: (A) => Boolean): Set[A]
输出符合指定条件的所有不可变集合元素。
21	
def find(p: (A) => Boolean): Option[A]
查找不可变集合中满足指定条件的第一个元素
22	
def forall(p: (A) => Boolean): Boolean
查找不可变集合中满足指定条件的所有元素
23	
def foreach(f: (A) => Unit): Unit
将函数应用到不可变集合的所有元素
24	
def head: A
获取不可变集合的第一个元素
25	
def init: Set[A]
返回所有元素，除了最后一个
26	
def intersect(that: Set[A]): Set[A]
计算两个集合的交集
27	
def isEmpty: Boolean
判断集合是否为空
28	
def iterator: Iterator[A]
创建一个新的迭代器来迭代元素
29	
def last: A
返回最后一个元素
30	
def map[B](f: (A) => B): immutable.Set[B]
通过给定的方法将所有元素重新计算
31	
def max: A
查找最大元素
32	
def min: A
查找最小元素
33	
def mkString: String
集合所有元素作为字符串显示
34	
def mkString(sep: String): String
使用分隔符将集合所有元素作为字符串显示
35	
def product: A
返回不可变集合中数字元素的积。
36	
def size: Int
返回不可变集合元素的数量
37	
def splitAt(n: Int): (Set[A], Set[A])
把不可变集合拆分为两个容器，第一个由前 n 个元素组成，第二个由剩下的元素组成
38	
def subsetOf(that: Set[A]): Boolean
如果集合A中含有子集B返回 true，否则返回false
39	
def sum: A
返回不可变集合中所有数字元素之和
40	
def tail: Set[A]
返回一个不可变集合中除了第一元素之外的其他元素
41	
def take(n: Int): Set[A]
返回前 n 个元素
42	
def takeRight(n: Int):Set[A]
返回后 n 个元素
43	
def toArray: Array[A]
将集合转换为数组
44	
def toBuffer[B >: A]: Buffer[B]
返回缓冲区，包含了不可变集合的所有元素
45	
def toList: List[A]
返回 List，包含了不可变集合的所有元素
46	
def toMap[T, U]: Map[T, U]
返回 Map，包含了不可变集合的所有元素
47	
def toSeq: Seq[A]
返回 Seq，包含了不可变集合的所有元素
48	
def toString(): String
返回一个字符串，以对象来表示

Map方法

Scala Map 方法
下表列出了 Scala Map 常用的方法：
序号	方法及描述
1	
def ++(xs: Map[(A, B)]): Map[A, B]
返回一个新的 Map，新的 Map xs 组成
2	
def -(elem1: A, elem2: A, elems: A*): Map[A, B]
返回一个新的 Map, 移除 key 为 elem1, elem2 或其他 elems。
3	
def --(xs: GTO[A]): Map[A, B]
返回一个新的 Map, 移除 xs 对象中对应的 key
4	
def get(key: A): Option[B]
返回指定 key 的值
5	
def iterator: Iterator[(A, B)]
创建新的迭代器，并输出 key/value 对
6	
def addString(b: StringBuilder): StringBuilder
将 Map 中的所有元素附加到StringBuilder，可加入分隔符
7	
def addString(b: StringBuilder, sep: String): StringBuilder
将 Map 中的所有元素附加到StringBuilder，可加入分隔符
8	
def apply(key: A): B
返回指定键的值，如果不存在返回 Map 的默认方法

10	
def clone(): Map[A, B]
从一个 Map 复制到另一个 Map
11	
def contains(key: A): Boolean
如果 Map 中存在指定 key，返回 true，否则返回 false。
12	
def copyToArray(xs: Array[(A, B)]): Unit
复制集合到数组
13	
def count(p: ((A, B)) => Boolean): Int
计算满足指定条件的集合元素数量
14	
def default(key: A): B
定义 Map 的默认值，在 key 不存在时返回。
15	
def drop(n: Int): Map[A, B]
返回丢弃前n个元素新集合
16	
def dropRight(n: Int): Map[A, B]
返回丢弃最后n个元素新集合
17	
def dropWhile(p: ((A, B)) => Boolean): Map[A, B]
从左向右丢弃元素，直到条件p不成立
18	
def empty: Map[A, B]
返回相同类型的空 Map
19	
def equals(that: Any): Boolean
如果两个 Map 相等(key/value 均相等)，返回true，否则返回false
20	
def exists(p: ((A, B)) => Boolean): Boolean
判断集合中指定条件的元素是否存在
21	
def filter(p: ((A, B))=> Boolean): Map[A, B]
返回满足指定条件的所有集合
22	
def filterKeys(p: (A) => Boolean): Map[A, B]
返回符合指定条件的的不可变 Map
23	
def find(p: ((A, B)) => Boolean): Option[(A, B)]
查找集合中满足指定条件的第一个元素
24	
def foreach(f: ((A, B)) => Unit): Unit
将函数应用到集合的所有元素
25	
def init: Map[A, B]
返回所有元素，除了最后一个
26	
def isEmpty: Boolean
检测 Map 是否为空
27	
def keys: Iterable[A]
返回所有的key/p>
28	
def last: (A, B)
返回最后一个元素
29	
def max: (A, B)
查找最大元素
30	
def min: (A, B)
查找最小元素
31	
def mkString: String
集合所有元素作为字符串显示
32	
def product: (A, B)
返回集合中数字元素的积。
33	
def remove(key: A): Option[B]
移除指定 key
34	
def retain(p: (A, B) => Boolean): Map.this.type
如果符合满足条件的返回 true
35	
def size: Int
返回 Map 元素的个数
36	
def sum: (A, B)
返回集合中所有数字元素之和
37	
def tail: Map[A, B]
返回一个集合中除了第一元素之外的其他元素
38	
def take(n: Int): Map[A, B]
返回前 n 个元素
39	
def takeRight(n: Int): Map[A, B]
返回后 n 个元素
40	
def takeWhile(p: ((A, B)) => Boolean): Map[A, B]
返回满足指定条件的元素
41	
def toArray: Array[(A, B)]
集合转数组
42	
def toBuffer[B >: A]: Buffer[B]
返回缓冲区，包含了 Map 的所有元素
43	
def toList: List[A]
返回 List，包含了 Map 的所有元素
44	
def toSeq: Seq[A]
返回 Seq，包含了 Map 的所有元素
45	
def toSet: Set[A]
返回 Set，包含了 Map 的所有元素
46	
def toString(): String
返回字符串对象

二百四十九先森

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Scala从入门到了解第一课：scala基础语法汇总一

1、scala的六大特性 1、与java无缝整合基于jvm，可以在java代码中代用scala包、类，也可以在scala代码中调用java包、类。而不是指代码互相嵌套 2、类型自动推断 var a=100 会自动推导出a为int类型 3、支持并行分布式 scala崛起的重要原因，java和c在多...
复制链接

扫一扫