# 集合 scala中的集合分為兩種 ,可變集合和不可變集合, 不可變集合可以安全的併發的訪問! 集合的類主要在一下兩個包中 - 可變集合包 scala.collection.mutable - 不可變集合包 scala.collection.immutable 預設的 Scala 不可變集合，就是 ...

集合

scala中的集合分為兩種 ,可變集合和不可變集合, 不可變集合可以安全的併發的訪問!
集合的類主要在一下兩個包中

可變集合包 scala.collection.mutable
不可變集合包 scala.collection.immutable 預設的

Scala 不可變集合，就是指該集合對象不可修改，每次修改就會返回一個新對象，而不會對原對象進行修改。類似於 java 中的 String 對象
可變集合，就是這個集合可以直接對原對象進行修改，而不會返回新的對象。類似於 java 中 StringBuilder 對象
建議：在操作集合的時候，不可變用符號，可變用方法
scala預設使用的是不可變的集合 , 因此使用可變的集合需要導入可變集合的包
scala的集合主要分成三大類

Seq 序列
Set 不重覆集
Map 鍵值映射集

註意: 所有的集合都繼承自Iterator迭代器這個特質
不可變集合繼承圖

迭代器

java中的iterator

在java中用迭代器讀取文件中的數據，每次返回一行數據

package com.doit;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Iterator;

class MyHero implements Iterator<String> {
    BufferedReader buffer = null;
    String line = null;

    public MyHero() {
        try {
            buffer = new BufferedReader(new FileReader("data/hero.txt"));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    @Override
    public boolean hasNext() {
        try {
            line = buffer.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return line != null;
    }

    @Override
    public String next() {
        return line;
    }
}

public class MyIterator{
    public static void main(String[] args) {
        MyHero myHero = new MyHero();
        while (myHero.hasNext()){
            System.out.println(myHero.next());
        }
    }
}

在java中用迭代器讀取mysql表中的數據，每次返回一行數據

package com.doit;

import java.sql.*;
import java.util.Iterator;

public class ReadTable implements Iterator<Login> {
    ResultSet resultSet = null;
    public ReadTable(){
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try {
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/football", "root", "123456");
            PreparedStatement pps = conn.prepareStatement("select * from login ");
            resultSet = pps.executeQuery();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public boolean hasNext() {
        boolean flag = false;
        try {
            flag = resultSet.next();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return flag;
    }

    @Override
    public Login next() {
        Login login = new Login();
        try {
            login.setId(resultSet.getInt(1));
            login.setUser_id(resultSet.getInt(2));
            login.setClient_id(resultSet.getInt(3));
            login.setDate(resultSet.getString(4));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return login;
    }


}


class Login {
    private int id;
    private int user_id;
    private int client_id;
    private String date;

    public Login() {
    }

    public Login(int id, int user_id, int client_id, String date) {
        this.id = id;
        this.user_id = user_id;
        this.client_id = client_id;
        this.date = date;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getUser_id() {
        return user_id;
    }

    public void setUser_id(int user_id) {
        this.user_id = user_id;
    }

    public int getClient_id() {
        return client_id;
    }

    public void setClient_id(int client_id) {
        this.client_id = client_id;
    }

    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }

    @Override
    public String toString() {
        return "login{" +
                "id=" + id +
                ", user_id=" + user_id +
                ", client_id=" + client_id +
                ", date='" + date + '\'' +
                '}';
    }
}

java中的Iterable

代表可迭代的，返回的是一個迭代器

package com.doit;

import java.util.Iterator;

public class ReadTableIterable implements Iterable<Login>{
    @Override
    public Iterator iterator() {
        return new ReadTable();
    }
}


//測試
package com.doit;

import java.util.Iterator;

public class Test3 {
    public static void main(String[] args) {
        ReadTableIterable logins = new ReadTableIterable();
        //可迭代的都會有一個迭代器對象，獲取出來後用hasnext next獲取數據
        Iterator iterator = logins.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //可迭代的java底層都封裝了增強for迴圈，也可以直接使用
        for (Login login : logins) {
            System.out.println(login);
        }
    }
}

scala中的 iterator

package com.doit.day01.day02

import scala.io.{BufferedSource, Source}

object MyIter {
  def main(args: Array[String]): Unit = {
    val iter: MyIter = new MyIter
    while (iter.hasNext){
      println(iter.next())
    }
  }

}

class MyIter extends Iterator[String]{
  //讀取數據
  private val source: BufferedSource = Source.fromFile("data/hero.txt")
  private val lines: Iterator[String] = source.getLines()
  //用scala中返回迭代器中的hasNext方法直接判斷
  override def hasNext: Boolean = lines.hasNext
  //用scala中返回迭代器中的next方法獲取數據
  override def next(): String = lines.next()
}
7.1.4scala中的Iterable
Scala
package com.doit.day01.day02

import scala.io.{BufferedSource, Source}

object MyIter {
  def main(args: Array[String]): Unit = {
    val iter: MyIter1 = new MyIter1
    val iterator: Iterator[String] = iter.iterator
    while (iterator.hasNext){
      println(iterator.next())
    }

    for (elem <- iter) {
      println(elem)
    }
  }
}

class MyIter1 extends Iterable[String]{
  override def iterator: Iterator[String] = new MyIter
}

比較器

java中的比較器 Comparator

package com.doit;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;

public class Test3 {
    public static void main(String[] args) {
        Order or1 = new Order("001", 100, "2022-7-12");
        Order or2 = new Order("002", 99, "2022-7-11");
        Order or3 = new Order("003", 88, "2022-7-15");
        Order or4 = new Order("004", 103, "2022-7-13");
        Order or5 = new Order("005", 55, "2022-7-10");

        ArrayList<Order> list = new ArrayList<>();
        list.add(or1);
        list.add(or2);
        list.add(or3);
        list.add(or4);
        list.add(or5);
        Collections.sort(list,new ComparatorDeme());
        System.out.println(list);
        Collections.sort(list,new ComparatorDeme1());
        System.out.println(list);
    }
}

class ComparatorDeme implements Comparator<Order>{

    @Override
    public int compare(Order o1, Order o2) {
        return -o1.getOrderAmount() + o2.getOrderAmount();
    }
}

class ComparatorDeme1 implements Comparator<Order>{

    @Override
    public int compare(Order o1, Order o2) {
        return o1.getOrderTime().compareTo(o2.getOrderTime());
    }
}

java中的比較器 Comparable

package com.doit;
//類實現Comparable 介面，重寫裡面的compareTo 方法
public class Order2 implements Comparable<Order2>{
    private String orderId;
    private int orderAmount;
    private String orderTime;

    public Order2() {
    }

    public Order2(String orderId, int orderAmount, String orderTime) {
        this.orderId = orderId;
        this.orderAmount = orderAmount;
        this.orderTime = orderTime;
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public int getOrderAmount() {
        return orderAmount;
    }

    public void setOrderAmount(int orderAmount) {
        this.orderAmount = orderAmount;
    }

    public String getOrderTime() {
        return orderTime;
    }

    public void setOrderTime(String orderTime) {
        this.orderTime = orderTime;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderId='" + orderId + '\'' +
                ", orderAmount=" + orderAmount +
                ", orderTime='" + orderTime + '\'' +
                '}';
    }

    @Override
    public int compareTo(Order2 o) {
        return this.orderAmount - o.orderAmount;
    }
}

package com.doit;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;

public class Test3 {
    public static void main(String[] args) {
//        Order or1 = new Order("001", 100, "2022-7-12");
//        Order or2 = new Order("002", 99, "2022-7-11");
//        Order or3 = new Order("003", 88, "2022-7-15");
//        Order or4 = new Order("004", 103, "2022-7-13");
//        Order or5 = new Order("005", 55, "2022-7-10");
//
//        ArrayList<Order> list = new ArrayList<>();
//        list.add(or1);
//        list.add(or2);
//        list.add(or3);
//        list.add(or4);
//        list.add(or5);
//        Collections.sort(list,new ComparatorDeme());
//        System.out.println(list);
//        Collections.sort(list,new ComparatorDeme1());
//        System.out.println(list);
//        System.out.println("===========華麗的分割線==========");

        Order2 o1 = new Order2("001", 100, "2022-7-12");
        Order2 o2 = new Order2("002", 99, "2022-7-11");
        Order2 o3 = new Order2("003", 88, "2022-7-15");
        Order2 o4 = new Order2("004", 103, "2022-7-13");
        Order2 o5 = new Order2("005", 55, "2022-7-10");

        ArrayList<Order2> list1 = new ArrayList<>();
        list1.add(o1);
        list1.add(o2);
        list1.add(o3);
        list1.add(o4);
        list1.add(o5);
        //這邊就不需要再傳入比較器了
        Collections.sort(list1);
        System.out.println(list1);
    }
}

scala中的比較器 Ordering 類比於java中的Comparator

package com.doit.day01.day02

import scala.util.Sorting
    
object Demo_Ordering {
  def main(args: Array[String]): Unit = {
    val e1: Employee = new Employee(1, "濤哥", 10000)
    val e2: Employee = new Employee(2, "星哥", 8000)
    val e3: Employee = new Employee(3, "行哥", 5000)
    val e4: Employee = new Employee(4, "源哥", 3500)
    val e5: Employee = new Employee(5, "娜姐", 2000)
    val list: Array[Employee] = List(e1, e2, e3, e4, e5).toArray
    Sorting.quickSort(list)(MyOrdering())
    println(list.mkString(","))

  }
}
case class MyOrdering() extends Ordering[Employee] {
  override def compare(x: Employee, y: Employee): Int = (x.salary - y.salary).toInt
}

class Employee(val id:Int,val name:String,val salary:Double){

  override def toString = s"Employee(id=$id, name=$name, salary=$salary)"
}

scala中的比較器 Ordered 類比於java中的Comparable

package com.doit.day01.day02

import scala.util.Sorting

object Demo_Ordering {
  def main(args: Array[String]): Unit = {
    val e1: Employee = new Employee(1, "濤哥", 10000)
    val e2: Employee = new Employee(2, "星哥", 8000)
    val e3: Employee = new Employee(3, "行哥", 5000)
    val e4: Employee = new Employee(4, "源哥", 3500)
    val e5: Employee = new Employee(5, "娜姐", 2000)
    val list: Array[Employee] = List(e1, e2, e3, e4, e5).toArray
    Sorting.quickSort(list)
    println(list.mkString(","))
  }
}

class Employee(val id:Int,val name:String,val salary:Double) extends Ordered[Employee]{

  override def toString = s"Employee(id=$id, name=$name, salary=$salary)"

  override def compare(that: Employee): Int = (this.salary - that.salary).toInt
}

序列

許多數據結構是序列型的，也就是說，元素可以按特定的順序訪問，如：元素的插入順
序或其他特定順序。collection.Seq是一個trait，是所有可變或不可變序列類型的抽象，其子trait collection.mutable.Seq及collection.immutable.Seq分別對應可變和不可變序列。
從上面的圖中可以看出Array,String ,List都屬於序列

不可變數組

數組的基本操作 , scala中的數組和java中的不太一樣 ,這裡的數組類似於一個數組對象 .有自己的方法!!

數組的定義方式

方式一：創建一個長度固定的數組，後面再賦值

object TestArray{
 def main(args: Array[String]): Unit = {
 //（1）數組定義
 val arr01 = new Array[Int](4)
 println(arr01.length) // 4
 //（2）數組賦值
 //（2.1）修改某個元素的值
 arr01(3) = 10
 //（2.2）採用方法的形式給數組賦值
 arr01.update(0,1)
 //（3）遍曆數組
 //（3.1）查看數組
 println(arr01.mkString(","))
 //（3.2）普通遍歷
 for (i <- arr01) {
 println(i)
 }
 //（3.3）簡化遍歷
 def printx(elem:Int): Unit = {
 println(elem)
 }
 arr01.foreach(printx)
 // arr01.foreach((x)=>{println(x)})
 // arr01.foreach(println(_))
 arr01.foreach(println) 
 //（4）增加元素（由於創建的是不可變數組，增加元素，其實是產生新的數組）
 println(arr01)
 val ints: Array[Int] = arr01 :+ 5
 println(ints)
 } 
}

方式二：使用 apply 方法創建數組對象，並且在定義數組的時候直接賦初始值
代碼示例：

object TestArray{
 def main(args: Array[String]): Unit = {
 var arr02 = Array(1, 3, "bobo")
 println(arr02.length)
 for (i <- arr02) {
  println(i)
 }
 } 
}
數組中的方法：
Scala
val arr = Array(1,3,5,7,9,2,6,4)
 // 數組中的最大和最小值
 val min: Int = arr.min
 val max: Int = arr.max
 // 首個元素
 val head: Int = arr.head
 //最後一個元素
 val last: Int = arr.last
 // 去除首個元素的子數組
 val arr11: Array[Int] = arr.tail
 // 將數組轉換成List集合
 val list: List[Int] = arr.toList
 // 獲取和後面數組中不同的元素
val diff: Array[Int] = arr.diff(Array(1,111,222))
 //求數組元素的和
 val sum: Int = arr.sum
 // 數組的長度
 arr.length
 //修改指定位置的元素
 arr.update(1,100)
// 取出數組中的前n個元素
 val arr3: Array[Int] = arr.take(3)
 //  後面添加一個元素  生成 新的數組
 val arr2: Array[Int] = arr.:+(11)
 //  後面添加一個數組
 val  res = arr ++ arr3
// 統計符合條件的個數
 val i: Int = arr.count(_>2)
 // 數組反轉
 arr.reverse
// 將不可變數組轉換成可變數組
val buffer: mutable.Buffer[Int] = arr.toBuffer

可變數組--> ArrayBuffer

導入可變數組 : import scala.collection.mutable.ArrayBuffer ,可以修改元素的數組為可變數組
定義：
定義變長數組
val arr01 = ArrayBuffer[Any](3, 2, 5)
（1）[Any]存放任意數據類型
（2）(3, 2, 5)初始化好的三個元素
（3）ArrayBuffer 需要引入 scala.collection.mutable.ArrayBuffer
實例操作：

import scala.collection.mutable.ArrayBuffer
object TestArrayBuffer {
 def main(args: Array[String]): Unit = {
 //（1）創建並初始賦值可變數組
 val arr01 = ArrayBuffer[Any](1, 2, 3)
 //（2）遍曆數組
 for (i <- arr01) {
 println(i)
 }
 println(arr01.length) // 3
 println("arr01.hash=" + arr01.hashCode())
 //（3）增加元素
 //（3.1）追加數據
 arr01.+=(4)
 //（3.2）向數組最後追加數據
 arr01.append(5,6)
 //（3.3）向指定的位置插入數據
 arr01.insert(0,7,8)
 println("arr01.hash=" + arr01.hashCode())
 //（4）修改元素
 arr01(1) = 9 //修改第 2 個元素的值
 println("--------------------------")
 for (i <- arr01) {
 println(i)
 }
 println(arr01.length) // 5
 } 
}

不可變 List

說明：
（1）List 預設為不可變集合
（2）創建一個 List（數據有順序，可重覆）
（3）遍歷 List
（4）List 增加數據
（5）集合間合併：將一個整體拆成一個一個的個體，稱為扁平化
（6）取指定數據
（7）空集合 Nil
示例:

object TestList {
 def main(args: Array[String]): Unit = {
 //（1）List 預設為不可變集合
 //（2）創建一個 List（數據有順序，可重覆）
 val list: List[Int] = List(1,2,3,4,3)
 
 //（7）空集合 Nil
 val list5 = 1::2::3::4::Nil
 //（4）List 增加數據
 //（4.1）::的運算規則從右向左
 //val list1 = 5::list
 val list1 = 7::6::5::list
 //（4.2）添加到第一個元素位置
 val list2 = list.+:(5)
 //（5）集合間合併：將一個整體拆成一個一個的個體，稱為扁平化
 val list3 = List(8,9)
 //val list4 = list3::list1
 val list4 = list3:::list1
 //（6）取指定數據
 println(list(0))
 //（3）遍歷 List
 //list.foreach(println)
 //list1.foreach(println)
 //list3.foreach(println)
 //list4.foreach(println)
 list5.foreach(println)
 } 
}

// 不可變的List集合 數據不允許被修改
  private val ls1 = List("SCALA", "HDP", "SPARK" , 12 , 34)
  // 向Nil空隊列中添加元素組成新的隊列
  val ls2 = "HIVE" :: "MYSQL" :: "HBASE" :: Nil
  // Nil 和 List.empty[Nothing]是等價的
  private val ll = List.empty[Nothing]
  ls1(0) // 獲取指定位置元素
  // 添加一個元素生成新的List
  val ls3 = ls1 :+ "PYTHON"
  //合併兩個集合 生成新的集合
  val ls4 = ls1 ++ ls2
  ls1.foreach(println)
  // 獲取前兩個元素 組成新的List
  ls1.take(2)
  println(ls1.take(2))
  println(ls1.takeRight(2))  // 從右邊取數據
// 遍歷每個元素   參數是一個偏函數
 ls1.collect({ case x: Int => x })
  // 查找匹配的元素 僅僅返回一個元素 
 ls1.find(x=>x.toString.startsWith("S"))
// 判斷是否為null集合
 ls1.isEmpty
// 轉換成可變List集合
ls1.toBuffer

可變List-->ListBuffer

說明：
（1）創建一個可變集合 ListBuffer
（2）向集合中添加數據
（3）列印集合數據
代碼實現：

import scala.collection.mutable.ListBuffer
object TestList {
 def main(args: Array[String]): Unit = {
 //（1）創建一個可變集合
 val buffer = ListBuffer(1,2,3,4)
 //（2）向集合中添加數據
 buffer.+=(5)
buffer.append(6)
buffer.insert(1,2)
 //（3）列印集合數據
 buffer.foreach(println)
//（4）修改數據
buffer(1) = 6
buffer.update(1,7)
//（5）刪除數據
buffer.-(5)
buffer.-=(5)
buffer.remove(5)
 } 
}

set

Set和list的最大區別在於Set中不可以存儲重覆數據 ,通常使用Set來實現元素的去重!!
Set集合也分為可變Set和不可變的Set,使用包名來區分可變和不可變,需要引用scala.collection.mutable.Set 包

不可變set

說明：
（1）Set 預設是不可變集合，數據無序
（2）數據不可重覆
（3）遍歷集合
代碼示例：

object TestSet {
 def main(args: Array[String]): Unit = {
 //（1）Set 預設是不可變集合，數據無序
 val set = Set(1,2,3,4,5,6)
 //（2）數據不可重覆
 val set1 = Set(1,2,3,4,5,6,3)
 //（3）遍歷集合
 for(x<-set1){
 println(x)
 }
 } 
}

可變mutable.Set

說明：
（1）創建可變集合 mutable.Set
（2）列印集合
（3）集合添加元素
（4）向集合中添加元素，返回一個新的 Set
（5）刪除數據
代碼示例：

object TestSet {
 def main(args: Array[String]): Unit = {
 //（1）創建可變集合
 val set = mutable.Set(1,2,3,4,5,6)
 //（3）集合添加元素
 set += 8
 //（4）向集合中添加元素，返回一個新的 Set
 val ints = set.+(9)
 println(ints)
 println("set2=" + set)
 //（5）刪除數據
 set-=(5)
 //（2）列印集合
 set.foreach(println)
 println(set.mkString(","))
 } 
}

Map映射

Scala 中的 Map 和 Java 類似，也是一個散列表，它存儲的內容也是鍵值對（key-value）映射，同樣分為可變Map和不可變Map , 使用包名來區分是可變Map還是不可變Map

不可變Map

說明：
（1）創建不可變集合 Map
（2）迴圈列印
（3）訪問數據
（4）如果 key 不存在，返回 0
代碼示例：

object TestMap {
 def main(args: Array[String]): Unit = {
 // Map
 //（1）創建不可變集合 Map
 val map = Map( "a"->1, "b"->2, "c"->3 )
 //（3）訪問數據
 for (elem <- map.keys) {
 // 使用 get 訪問 map 集合的數據，會返回特殊類型 Option(選項):
有值（Some），無值(None)
 println(elem + "=" + map.get(elem).get)
 }
 //（4）如果 key 不存在，返回 0
 println(map.get("d").getOrElse(0))
 println(map.getOrElse("d", 0))
 //（2）迴圈列印
 map.foreach((kv)=>{println(kv)})
 } 
}

可變 Map

說明
（1）創建可變集合
（2）列印集合
（3）向集合增加數據
（4）刪除數據
（5）修改數據
代碼示例：

object TestMap {
 def main(args: Array[String]): Unit = {
 //（1）創建可變集合
 val map = mutable.Map( "a"->1, "b"->2, "c"->3 )
 //（3）向集合增加數據
 map.+=("d"->4)
 // 將數值 4 添加到集合，並把集合中原值 1 返回
 val maybeInt: Option[Int] = map.put("a", 4)
 println(maybeInt.getOrElse(0))
 //（4）刪除數據
 map.-=("b", "c")
 //（5）修改數據
 map.update("d",5)
map("d") = 5
 //（2）列印集合
 map.foreach((kv)=>{println(kv)})
 } 
}

元組

元組也是可以理解為一個容器，可以存放各種相同或不同類型的數據。說的簡單點，就是將多個無關的數據封裝為一個整體，稱為元組。
註意：元組中最大隻能有 22 個元素
示例內容：
（1）聲明元組的方式：(元素 1，元素 2，元素 3)
（2）訪問元組
（3）Map 中的鍵值對其實就是元組,只不過元組的元素個數為 2，稱之為對偶
代碼實現：

object TestTuple {
 def main(args: Array[String]): Unit = {
 //（1）聲明元組的方式：(元素 1，元素 2，元素 3)
 val tuple: (Int, String, Boolean) = (40,"bobo",true)
 //（2）訪問元組
 //（2.1）通過元素的順序進行訪問，調用方式：_順序號
 println(tuple._1)
 println(tuple._2)
 println(tuple._3)
 //（2.2）通過索引訪問數據
 println(tuple.productElement(0))
 //（2.3）通過迭代器訪問數據
 for (elem <- tuple.productIterator) {
 println(elem)
 }
 //（3）Map 中的鍵值對其實就是元組,只不過元組的元素個數為 2，稱之為對偶
 val map = Map("a"->1, "b"->2, "c"->3)
 val map1 = Map(("a",1), ("b",2), ("c",3))
 map.foreach(tuple=>{println(tuple._1 + "=" + tuple._2)})
 } 
}

Option

Option(選項)類型用來表示一個值是可選的（有值或無值)
Option[T] 是一個類型為 T 的可選值的容器：如果值存在， Option[T] 就是一個 Some[T] ，如果不存在， Option[T] 就是對象 None 。
Option 有兩個子類別，一個是 Some，一個是 None，當他回傳 Some 的時候，代表這個函式成功地給了你一個 String，而你可以通過 get() 這個函式拿到那個 String，如果他返回的是 None，則代表沒有字元串可以給你。
代碼示例：

val myMap: Map[String, String] = Map("key1" -> "value")
val value1: Option[String] = myMap.get("key1")
val value2: Option[String] = myMap.get("key2")
println(value1) // Some("value1")
println(value2) // None

複習：

package com.doit.day01.day02

import scala.collection.mutable
import scala.collection.parallel.immutable


object ListTest {
  def main(args: Array[String]): Unit = {
    //1.定義一個長度為10的int類型的數組，裡面裝10個整數
    //    val arr: Array[Int] = new Array[Int](10)
    //    arr(0) = 1
    //    arr.update(0,1)
    //第二種遍歷方式
    val arr: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)

    //2.列印數組的長度
    //    println(arr.length)

    //3.遍曆數組
    //方式1：for迴圈
    //    for (elem <- arr) {println(elem)}
    //方式二，foreach
    //    arr.foreach(println)
    //4.查看數組中的元素，顯示成1--2--3...這樣的形式
    //    println(arr.mkString("--"))
    //5.找到數組中的最大值
    //    println(arr.max)
    //6.找到數組中的最小值
    //    println(arr.min)
    //數組中的第一個元素
    //    println(arr.head)
    //數組中的最後一個元素
    //    println(arr.last)
    //數組中除了第一個元素的後面所有的元素
    //    println(arr.tail.mkString(","))
    //數組中的前三個元素和後三個元素
    //    println(arr.take(3).mkString(","))//前三個
    //    println(arr.takeRight(3).mkString(","))
    //計算數組中大於4的個數
    //    println(arr.count(_ > 4))
    //將不可變數組轉換成可變數組
    val buffer: mutable.Buffer[Int] = arr.toBuffer
    //在可變數組中添加一個元素10
    //    buffer.append(10)
    //    buffer.+=(10)
    //    buffer += 10
    //在指定索引為1的位置插入11,12兩個元素
    //    buffer.insert(1,11,12)
    //刪除一個指定的元素元素
    //    buffer.-=(1)
    //    buffer -= 1
    //刪除指定索引位置的元素
    //    buffer.remove(1)
    //數組的反轉
    //    buffer.reverse

    val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7)
    //    val list1: List[Int] = 1 :: 2 :: 3 :: 4 :: 5 :: Nil
    //遍歷list
    //    for (elem <- list) {}
    //    list.foreach(println)
    list.head
    list.tail
    list.last
    list.max
    list.min
    list.take(2)
    //    list ::: arr.toList  正常都用不到
    //val ints: List[Int] = list.::(1)  加在最前面


    //    Set(1,2,2,6,3,4)

    //    val ints: mutable.Set[Int] = mutable.Set(1, 2, 3, 4, 5, 6, 7)
    //    for (elem <- ints) {}
    //添加一個元素
    //    ints.+=(1)
    //刪除索引位置的元素
    //    ints.remove(1)
    //刪除指定的元素
    //    ints.-=(1)

    //    val map: Map[String, Int] = Map("hadoop" -> 1, "hive" -> 2, "hbase" -> 3)
    //    val tail: Map[String, Int] = map.tail
    //    val head: (String, Int) = map.head
    //    val i: Int = map.getOrElse("hadoop", 0)
    //        map.get("he").get  //用這個的時候得註意報錯，正常情況下用getOrElse

    val map: mutable.Map[String, Int] = mutable.Map("hadoop" -> 1, "hive" -> 2, "hbase" -> 3)
//    map.update("hadoop", 111)
//    map.+=("he"->11)
//    map.put("haha",11 )
//    map.remove("hadoop")
//    for (elem <- map) {}

    //    for (elem <- map) {}
//    val tuple = (1,"sy",false,1.0)
//    val tuple2: (Int, String) = Tuple2(1, "hh")
  }
}

集合中的常用方法

forEach

迭代遍歷集合中的每個元素,對每個元素進行處理 ,但是沒有返回值 ,常用於列印結果數據 !

val ls = List(1,3,5,7,9)
ls.foreach(println) // 列印每個元素
ls.foreach(println(_))// 列印每個元素
ls.foreach(x=>println(x*10)) // 每個元素乘以10 列印結果
ls.foreach(x=>print(x+" "))// 列印每個元素 空格隔開

map

適用於任意集合
註意Map集合的用法：map函數遍歷每個元素處理返回原集合類型的新集合 , 也可以不返回數據列表,數組,Map中都有map函數元組中沒有map函數

val arr = Array[String]("JAVA", "C++", "SCALA")
val ls = List(1, 3, 5, 7, 9)
val set = Set(1, 3, 5, 7)
val mp = Map[String, Int]("ZSS" -> 100, "LSS" -> 99)
// map函數遍歷每個元素處理返回原集合類型的新集合
val new_arr: Array[String] = arr.map(x => x)
val new_list: List[Int] = ls.map(x => x)
val new_set: Set[Int] = set.map(x => x)
// Map集合使用map函數
val new_Map1: Map[String, Int] = mp.map({ case v: (String, Int) => (v._1, v._2 * 10) })
val new_Map2: Map[String, Int] = mp.map(e => (e._1, e._2 + 100))
 
// map函數也可以不返回數據
ls.map(println(_))

filter和filterNot

適用於: 數組 List Map
filter返回符合自己條件的新的集合,filterNot返回不符合自己條件的新的集合

val ls: List[Int] = List.range(1,10)
ls.filter(x=>x%2==0)
val new_list: List[Int] = ls.filter(_ % 2 == 0)//  _ 代表每個元素
new_list .foreach(x=>print(x+"  "))  // 2  4  6  8
ls.filterNot(_%2!=1).foreach(x=>print(x+"  ")) 1  3  5  7  9

每個元素進行過濾

val set = Set("spark" , "scala" , "c++" , "java")
val new_set: Set[String] = set.filter(_.startsWith("s"))
set.filter(_.length>3)

多條件filter進行條件過濾

val ls = "spark":: "scala" :: "c++"::"java"::1::2::12.34::Nil
// 過濾出String類型的和Double類型的數據
ls.filter{
  case i:String => true
  case i:Int=>false
  case i:Double=>true
}

連續使用多次filter進行條件過濾

// 連續使用多次filter進行條件過濾
val map = Map[String,Int](("zss" ,91),("zww",89),("zzx",92) , ("ww",23))
map.filter(_._1.startsWith("z")).filter(_._2>90)

collect

常用於： Array List Map
collect函數也可以遍歷集合中的每個元素處理返回新的集合

def map[B](f: (A) ⇒ B): List[B]
def collect[B](pf: PartialFunction[A, B]): List[B]

主要支持偏函數

val ls = List(1,2,3,4,"hello")
// 主要支持偏函數
 val new_list: List[Int] = ls.collect({case i:Int=>i*10})
 new_list.foreach(x=>print(x+" "))//10 20 30 40
// collect實現filter和map特性
list.collect({ case i: Int => i * 10
case i: String => i.toUpperCase
}).foreach(println)
val new_list2: List[Int] = ls.map({case x:Int=>x*10})
 new_list2.foreach(x=>print(x+" "))// 錯誤 hello (of class java.lang.String)
因為collect支持偏函數 , 所以我們可以使用collect實現filter和map的特性!!!
Scala
val res: List[Int] = List(1, 2, 3, 4, 5, 6,"hello").collect({case i:Int if i%2==0=>i*10})
res.foreach(println)  // 40  60

min和max

適用於：數組 List Map
• 數組

val arr = Array(1,2,345,67,5)
arr.min
arr.max
arr.sum

• List

val ls = List(1,2,345,67,5)
ls.min
ls.max
ls.sum

• Set

val set = Set(1,2,345,67,5)
set.min
set.max
set.sum

• map 預設按照key排序獲取最大和最小數據

val map = Map[String,Int]("a"->10, "b"->99 , "c"->88)
// map預設按照key排序獲取最大和最小數據
map.min  //(a,10)
map.max //(c,88)

minBy和maxBy

適用於：數組 List Map
集合中的min和max可以獲取任意集合中的最小和最大值 ,但是如果集合中存儲的是用戶自定義的類 , 或者是按照Map集合中的key, value規則排序的話就需要用戶指定排序規則
• map按照value取最大最小

val map = Map[String,Int]("a"->10, "b"->99 , "c"->88)
// map預設按照key排序獲取最大和最小數據
// 指定map排序  按照value排序 
map.maxBy(x=>x._2) //(b,99)
map.minBy(x=>x._2) //(a,10)

• 集合中存儲的是用戶自定義的類型

class User(val name:String ,val age:Int) {}

隱式轉換

implicit  def ordersUser(user:User)={
  new Ordered[User] {
    override def compare(that: User) = {
       user.age.compareTo(that.age)
    }
  }
}
val ls = List(new User("zs",22),new User("ww",18) ,new User("tq",34))
println(ls.max.name)
println(ls.min.name)


println(ls.maxBy(x => x.age).name)

sum

適用於數組 List Set
求集合中的所有元素的和 ,下麵三種集合類型常用

val arr = Array(1,2,345,67,5)
arr.sum

val ls = List(1,2,345,67,5)
ls.sum

val set = Set(1,2,345,67,5)
set.sum

count

適用於數組 List Map
def count(p: ((A, B)) => Boolean): Int
計算滿足指定條件的集合元素數量

val arr = Array(1,2,345,67,5)
arr.count(_>5)  // array list  set 統用

val ls = List("hello" , "hi" , "heihei" , "tom")
ls.count(_.startsWith("h"))
ls.count(_.equals("hello"))
ls.count(_ == "hello")
// 忽略大小寫
ls.count(_.equalsIgnoreCase("HELLO"))
// 統計符合條件的map元素的數量 
val map = Map[String,Int]("a"->10,"ab"->10, "b"->99 , "c"->88)
map.count(x=>x._1.startsWith("a"))
map.count(_._2>10)

find

適用於數組 List Map
查找符合要求的元素 , 匹配到就反回數據 ,最多只返回一個
Option中的數據要麼是Some(T) 要麼是None標識沒有找到

val arr = Array(1,2,345,67,5)
val e: Option[Int] = arr.find(x=>x>1)

val ls = List("hello" , "hi" , "heihei" , "tom")
val res: Option[String] = ls.find(_.contains("a"))
if(res.isDefined){
  println(res)  //Some(hello)
  println(res.get)  //hello
}
val map = Map[String,Int]("a"->10,"ab"->10, "b"->99 , "c"->88)
val res_map: Option[(String, Int)] = map.find(x=>x._2>20)
if(res_map.isEmpty){
  "沒有匹配到內容"
}else{
  // 列印數據
    println(res_map.get)
}

flatten

適用於數組 List
壓平將一個集合展開組成一個新的集合

val arr = Array(1,2,345,67,5.23)
//val res1: Array[Nothing] = arr.flatten  I數值了類型的無法壓平
val ls = List("hello" , "hi" , "heihei" , "tom")
val res2: Seq[Char] = ls.flatten  // 壓成單個字元  因為字元串屬於序列集合的一種
val map = Map[String,Int]("a"->10,"ab"->10, "b"->99 , "c"->88)
// map無法直接壓平
//val flatten: immutable.Iterable[Nothing] = map.flatten
// 壓平存儲Map集合的list   獲取Map中每個元素 
val ls1 = List[Map[String,Int]](Map[String,Int]("a"->10,"ab"->10) , Map[String,Int]("jim"->100,"cat"->99))
ls1.flatten   // List((a,10), (ab,10), (jim,100), (cat,99))

val res: List[Int] = List(Array(1,2,3),Array(4,5,6)).flatten
// 錯誤  註意壓平的數據的類型
 val res4 = List(Array(1,2,3),Array("hel",5,6)).flatten

flatMap

適用於數組 List
map+flatten方法的組合 ,先遍歷集合中的每個元素 , 再按照指定的規則壓平, 返回壓平後的新的集合

val ls = List("today is my first day of my life" , "so I feel so happy")
// map處理每個元素 就是處理每句話
 ls.map(x=>println(x))
// 獲取集合中的每個元素   獲取兩句話   然後再扁平成字元
ls.flatMap(x=>x)
// 指定扁平化的規則 按照空格壓平  壓平的規則
ls.flatMap(x=>x.split(" ")).foreach(println) // 獲取到每個單詞


// 讀取外部文件
val bs: BufferedSource = Source.fromFile("d://word.txt")
// 讀取所有的數據行
val lines: Iterator[String] = bs.getLines()
// m遍歷每行數據按照 \\s+ 切割返回一個新的迭代器
val words: Iterator[String] = lines.flatMap(_.split("\\s+"))
// 遍歷迭代器 獲取每個單詞
words.foreach(println)
// 讀取外部文件 
val bs2: BufferedSource = Source.fromFile("d://word.txt")
  // 獲取所有的行數據 
val lines2: Iterator[String] = bs2.getLines()
// 處理每行數據 切割單詞後  每行返回一個數組   將所有的數組封裝在迭代器中
val arrs: Iterator[Array[String]] = lines2.map(_.split("\\s+"))

mapValues

適用於 Map
mapValues方法只對Map集合的value做處理!

sorted

適用於數組 List Map
sorted 使用域簡單的數字, 字元串等排序規則簡答的集合進行排序 , 如果需要定製化排序建議使用sortBy 和 sortWith函數
List對數值

val  list = List (1, 34 , 32 , 12 , 20 ,44 ,27)
// 返回排好序的list集合   預設從小到達排序
val sorted: List[Int] = list.sorted
對Array字元串
Scala
val arr = Array("jim" , "cat" , "jong" , "huba")
// 字元串預設按照先後排序
val sorted_arr: Array[String] = arr.sorted
對map
Scala
val map = Map[String , Int]("aeiqi"->4 , "qiaozhi"->2 , "baji"->34)
// map集合也沒有sorted 函數 只有轉換成List或者Array集合 預設按照key字典先後排序
val sorted_map: Seq[(String, Int)] = map.toList.sorted
sorted_map.foreach(println)

sortBy和sortWith

適用於數組 List Map

var arr = Array(1, 11, 23, 45, 8, 56)
val arr1 = arr.sortBy(x => x) //ArraySeq(1, 8, 11, 23, 45, 56)
//按照數據倒序排列
val arr2 = arr.sortBy(x => -x) //(56, 45, 23, 11, 8, 1)
// 按照字典順序排序
val arr3 = arr.sortBy(x => x.toString) //ArraySeq(1, 11, 23, 45, 56, 8)
// x 前面的元素  y 後面的元素
arr.sortWith((x, y) => x > y)
arr.sortWith((x, y) => x < y)

var list = List("hello", "cat", "happy", "feel")
// 字典順序
list.sortBy(x => x)
// 執行排序
list.sortWith((x, y) => x > y)
list.sortWith((x, y) => x < y)

val map = Map("peiqi" -> 5, "jong" -> 3, "baji" -> 12)
map.toList.sortBy(x => x._1) //List((baji,12), (jong,3), (peiqi,5))
map.toList.sortBy(x => x._2) //List((jong,3), (peiqi,5), (baji,12))
// 指定key排序
map.toArray.sortWith((x,y)=>x._1>y._1)
map.toArray.sortWith((x,y)=>x._1<y._1)
//指定value排序規則
map.toArray.sortWith((x,y)=>x._2>y._2)
map.toArray.sortWith((x,y)=>x._2<y._2)

自定義類型在集合中的排序

val u1 = new User("wuji", 34)
val u2 = new User("zhiruo", 24)
val u3 = new User("zhoamin", 44)
val u4 = new User("cuishan", 64)

var arr = Array(u1, u2, u3, u4)
// 按照姓名字典排序
arr.sortBy(user => user.name)
//年齡小到大
arr.sortBy(user => user.age)
//數值類型的排序可以直接使用- 來倒序排列 年齡大到小
arr.sortBy(user => -user.age)
// 年齡大到小
arr.sortWith((user1, user2) => user1.age > user2.age)
// 年齡小到大
arr.sortWith((user1, user2) => user1.age < user2.age)
// 姓名字典升序
arr.sortWith((user1, user2) => user1.name < user2.name)
//姓名字典降序
arr.sortWith((user1, user2) => user1.name > user2.name)

grouped

將集合中的元素按照指定的個數進行分組

val  list1 = List(1,2,3,4,5,6,7,8,9)
val list2 = List("scala" , "is" , "option" , "fucntion")
val map = Map[String,Int]("peiqi" -> 5, "jong" -> 3, "baji" -> 12)
// 兩個元素分成一組 ,9個元素總共分成5組
val res: Iterator[List[Int]] = list1.grouped(2)
var i = 0
// 遍歷每個元素
res.foreach(list=>{
  i+=1
  list.foreach(x=>println(x+"----"+i))  // 列印每個元素和它所對應的組
})
// 將map集合按照個數進行分組
val res2: Iterator[Map[String, Int]] = map.grouped(2)
res2.foreach(i=>i.foreach(x=>println((x._1,x._2))))

groupBy

將集合中的數據按照指定的規則進行分組
序列集合

val  list1 = List(1,2,3,4,5,6,7,8,9)
val list2 = List("scala" , "is" , "option" , "fucntion")
 // 對序列數據進行分組
val res1: Map[Boolean, List[Int]] = list1.groupBy(x=>x>3) //HashMap(false -> List(1, 2, 3), true -> List(4, 5, 6, 7, 8, 9))
val res2: Map[Boolean, List[Int]] = list1.groupBy(x=>x%2==0)//HashMap(false -> List(1, 3, 5, 7, 9), true -> List(2, 4, 6, 8))
list2.groupBy(x=>x.hashCode%2==0)
//HashMap(false -> List(is, option, fucntion), true -> List(scala))
val res: Map[Boolean, List[String]] = list2.groupBy(x=>x.startsWith("s"))

鍵值映射集合分組

val map = Map[String,Int]("peiqi" -> 5, "jong" -> 3, "baji" -> 12)
 val arr = Array(("cat",21),("lucy",33),("book",22),("jack",34))
// 按照key和value的內容分組
 println(map.groupBy(mp => mp._1))
 println(map.groupBy(mp => mp._2))
 
//  根據key 或者 value 分成兩組  滿足條件的和不滿足條件的
 println(map.groupBy(mp => mp._1.hashCode%2==0))
 println(map.groupBy(mp => mp._2>2))

 // 對偶元組集合 和map的分組方式是一樣的
 arr.groupBy(arr=>arr._1)
 arr.groupBy(arr=>arr._2)

reduce

底層調用的是reduceLeft , 從左邊開始運算元素

val list = List(1,3,5,7,9)
// 每個元素累加  從左到右相加
val res1: Int = list.reduce(_+_)  // 25
//1-3)-5)-7)-9
val res2: Int = list.reduce(_ - _)  // -23
val arr = Array("haha", "heihei", "hehe")
// x 前面的元素  y 後面的元素  實現集合中字元串的拼接
val res3: String = arr.reduce((x, y) => x + " " + y) //haha heihei hehe
// 鍵值對元素的
val map = Map(("shaolin",88),("emei", 77),("wudang",99))
//(shaolin emei wudang,264)   key value分別做歸約操作
val res4: (String, Int) = map.reduce((m1,m2)=>(m1._1+" "+m2._1 , m1._2+ m2._2))

reduceLeft和reduceRight

  val list = List(1, 3, 5, 7, 9)
  val arr = Array("a", "b", "c","d","e")
  val map = Map(("shaolin",88),("emei", 77),("wudang",99))
  // 執行順序是  1+3)+5)+7)+9
  val res1: Int = list.reduceLeft(_+_)
  // 1-3)-5)-7)-9
  val res01: Int = list.reduceLeft(_-_)
  val res2: String = arr.reduceLeft((a1, a2)=>a1+","+a2)
  val res3: (String, Int) = map.reduceLeft((m1,m2)=>(m1._1+" "+m2._1 , m1._2+ m2._2))
  println(res1)  //25
  println(res2) //a,b,c,d,e
  println(res3)//(shaolin emei wudang,264)

  val res11: Int = list.reduceRight(_+_) //  25
  // 執行順序是  a,(b,(c,(d,e)))    a2  右邊的最後一個元素
  val res12: String = arr.reduceRight((a1, a2)=>a1+","+a2)//a,b,c,d,e
  val res13: (String, Int) = map.reduceRight((m1,m2)=>(m1._1+" "+m2._1 , m1._2+ m2._2))//(shaolin emei wudang,264)
 // 5-(7-9)-->5-(7-9)-->3-(5-(7-9))-->1-(3-(5-(7-9)))
  val res14: Int = list.reduceRight(_-_)
  println(res14) // 5
  println(res11)  //25
  println(res12) //a,b,c,d,e
  println(res13)//(shaolin emei wudang,264)
// 字元串的拼接
arr.reduce(_ ++ _)
// 字元串的拼接
println(arr.reduce(_ ++"."++ _))

fold,foldLeft 和foldRight

歸約操作類似於reduce函數 ,但是fold函數中多出來一個初始值

val arr = Array("tom" , "cat" , "jim" , "rose")
// 遍歷集合中的每個元素進行拼接  比reduce函數多出一個初始值
val res = arr.fold("hello")(_+" "+_)
val ls = List(1,3,5,7)
// 100+1)+3)+5)+7 底層調用的是  foldLeft
val res2 = ls.fold(100)(_+_)  // 116 
ls.foldLeft(100)(_+_) //  116
 
從右邊開始運算   預設的值先參與運算進來
// 7-10)-->5-(-3)-->3-8 -->1-(-5)
val res01: Int = ls.foldRight(10)(_-_) //6

交集差集並集

val arr1 = Array(1, 3, 5, 7, 0)
val arr2 = Array(5, 7, 8, 9)
val res1: Array[Int] = arr1.intersect(arr2) // 交集 5 7
val res2: Array[Int] = arr1.diff(arr2) // 差集  1  3
// 單純的合併兩個元素中的數據
val res3: mutable.ArraySeq[Int] = arr1.union(arr2) // 1,3,5,7 ,5,7,8,9
// 去除重覆數據
val res4: mutable.ArraySeq[Int] = res3.distinct //,3,5,7,8,9

distinct和distinctBy

去除集合中的重覆的元素 ,可以去除簡單類型的數據, 也可以除去自定義的類型(底層依然是hashcode和equals)

val arr1 = Array("a", "a","ab","cat" ,"hellocat" ,"hicat")
val newarr: Array[String] = arr1.distinct
newarr.foreach(println)

條件去重

val arr1 = Array(new User("ls",21),new User("ls",22),new User("zss",21))
// 去除重名的重覆數據
val res: Array[User] = arr1.distinctBy(x=>x.age)
res.foreach(x=> println(x.name))

zip

實現拉鏈式拼接, 只要操作的集合是迭代集合就可以拼接

val list1 = List("a" , "b" , "c" , "d")
val arr1 = Array(1,2,3,4)
val map  = Map[String,Int]("aa"->11,"cc"->22,"dd"->33)
// 以兩個迭代集合中少的一方為基準對偶拼接List((a,1), (b,2), (c,3))
val res: List[(String, Int)] = list1.zip(arr1)
//ArraySeq((1,(aa,11)), (2,(cc,22)), (3,(dd,33)))
val res2: Array[(Int, (String, Int))] = arr1.zip(map)

zipWithIndex

簡單理解為遍歷集合中的每個元素 , 將每個元素打上對應的索引值 , 組成元組(element , index) 返回新的集合 !

val list1 = List("a" , "b" , "c" , "d")
val arr1 = Array(1,2,3,4)
val map  = Map[String,Int]("aa"->11,"cc"->22,"dd"->33)
// List(((a,1),0), ((b,2),1), ((c,3),2), ((d,4),3))
list1.zip(arr1).zipWithIndex
//List((a,0), (b,1), (c,2), (d,3))
list1.zipWithIndex

scan

一個初始值開始，從左向右遍歷每個元素，進行積累的op操作

val arr = Array("cat" , "jim" , "tom")
// ArraySeq(hello, hello cat, hello cat jim, hello cat jim tom)
arr.scan("hello" )(_ +" "+ _)
val nums = List(1,2,3)
// List(10,10+1,10+1+2,10+1+2+3) = List(10,11,13,16)
val result = nums.scan(10)(_+_)   
nums.foldLeft(10)(_+_)  //   16

mkString

將集合中的每個元素拼接成字元串

val arr = Array("a", "b", "c")
val str = arr.mkString
arr.mkString(" ")
arr.reduce(_+_)
arr.reduce(_ + " " + _)

slice,sliding

slice(from: Int, until: Int): List[A] 提取列表中從位置from到位置until(不含該位置)的元素列表, 起始位置角標從0開始；
• slice

val arr = Array("a", "b", "c" ,"d","e","f")
arr.slice(0 ,2) // res0: Array[String] = ArraySeq(a, b)

• sliding
sliding(size: Int, step: Int): Iterator[List[A]] 將列表按照固定大小size進行分組，步進為step，step預設為1,返回結果為迭代器；

val nums = List(1,1,2,2,3,3,4,4)
// 參數一：子集的大小  參數二：步進
val res: Iterator[List[Int]] = nums.sliding(2,2)
res.toList // List(List(1, 1), List(2, 2), List(3, 3), List(4, 4))

take,takeRight,takeWhile

• take 預設從左邊開始取

val arr = Array("a", "b", "c" ,"d","e","f")
// 從左邊獲取三個元素，組成新的數組集合
arr.take(3)

• takeRight 預設從右邊開始取

val nums = List(1,1,1,1,4,4,4,4)
val right = nums.takeRight(4) // List(4,4,4,4)

• takeWhile

// 小於4 終止 
nums.takeWhile(_ < 4)
val names  = Array ("cat", "com","jim" , "scala" ,"spark")
// 從左到右遍歷符合遇到不符合條件的終止，儲存在新的集合中
names.takeWhile(_.startsWith("c"))

Scala集合

集合

迭代器