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）经过元素的次序进行拜访，调用方
