Scala集合

最新推荐文章于 2024-10-11 21:47:42 发布

·V

最新推荐文章于 2024-10-11 21:47:42 发布

阅读量519

点赞数

文章标签： scala 开发语言后端

本文链接：https://blog.csdn.net/weixin_71214112/article/details/131195508

版权

迭代器

7.1.1java中的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()
}

scala中的Iterable

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
}

比较器

7.2.1java中的比较器 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
}

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都属于序列

7.3.1不可变数组

数组的基本操作 , scala中的数组和java中的不太一样 ,这里的数组类似于一个数组对象 .有自己的方法!!

7.1.1.1数组的定义方式

方式一：创建一个长度固定的数组，后面再赋值

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)
 }
 } 
}

数组中的方法：

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

练一练：

需求一：有一个10个长度的数组，第一个位置放得是3，后面每个位置都是前一个位置的2倍加1,

现需要打印这个数组，然后将这个数组中的奇数位置和偶数位置互换

package com.doit.day01.day02

/**
 * 需求一：有一个10个位置的数组，第一个位置放得是3，后面每个位置都是前一个位置的2倍加1,
 * 现需要打印这个数组，然后将这个数组中的奇数位置和偶数位置互换
 */
object Test1 {
  def main(args: Array[String]): Unit = {

    val arr = new Array[Int](10)
    arr(0) = 3
    //构建数据
    for (elem <- 1 to 9) arr(elem) = arr(elem - 1) * 2 + 1
    //打印这个数组
    println(arr.mkString(","))
    //将这个数组中的奇数位置和偶数位置互换
    for (elem <- 0 until arr.length) {
      if((elem+1) %2 == 1){
        var tmp = arr(elem)
        arr(elem) = arr(elem + 1)
        arr(elem + 1) = tmp
      }
    }
    println(arr.mkString(","))
  }
}

可变数组--> ArrayBuffer

导入可变数组 : import 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

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

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 包

7.4.1不可变set

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

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

7.5.1不可变Map

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

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)})
 } 
}

元组

元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组。

示例内容：

（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")
  }
}