0 元组:
/**
* 元组
*/
object Test33 {
def main(args: Array[String]): Unit = {
//对偶其实是最简单元组，元组使用()表示
val t = (1,4,3,6,7,6)
// for(i <- t){
// }
// println(t)
// println(t _2) //元组下角标从1开始 “_”用于取元组元素
//利用模式匹配的方式遍历元组
val (first,second,third,forth,_,_) = t //“_”用作占位符
// println(first)
//返回值不是一个元素的函数(元组的引用场景)
def func(a:Int,b:Int,c:Int) = {
(a+1,b*1,c-1)
}
// println(func(100,100,100))
//拉链操作
val arr1 = Array('a','b','c','d') //第一步：定义两个数组
val arr2 = Array(1,2,3)
val arr3 = arr1.zip(arr2) //第二步：将两个数组联合到一起，组成一个新的数组
// println(arr3)
// println(arr3.mkString(","))
val map = arr3.toMap //第三步：将新的数组转换为map
println(map)
}
}
1 Array数组操作:
/**
* 主要介绍了 集合的 map函数和 reduce函数， map函数传递一元参数并对集合所有参数进行处理
* reduce函数 比如 reduceLeft 需要传递多元参数 并对所有参数进行聚合操作
* foldLeft 相当于reduce 但是是对集合增加一个初始值
*/
object forReduceMethod {
def main(args: Array[String]) {
// test1() //
// test2()
// test3()
test4()
}
// reudceleft ： 集合元素从左到右 依次按照函数来操作, 从左向右进行聚合 (聚合:多个值变成一个值)
def test1() : Unit ={
// var result = List(1,2,3,4,5).reduceLeft(_-_) // 匿名函数， 左边数字 - 右边数字
var result = List(1,2,3,4,5).reduceLeft((x,y)=>x-y)
println(result)
}
// reudceright ：
def test2() : Unit ={
//var result = List(1,7).reduceRight(_-_) // 匿名函数， 左边数字 - 右边数字
// var result = List(1,7,2,9).reduceLeft(_-_) (((1 - 7) - 2) - 9) = -17
// var result = List(1,7,2,9).reduceRight(_-_) // ( 1- ( 7 -(2-9)) ) = -13
var result = List(1,7,2,9).foldLeft(0)(_-_) // ((((0 - 1) - 7) - 2) - 9) = -19 fold等同于foldLeft
println(result)
}
// scanLeft ：将折叠和影射操作结合在一起 得到操作的所有中间结果
def test3() : Unit ={
var result = List(1,7,2,9).scanLeft(0)(_-_) // 得到结果 ： List(0, -1, -8, -10, -19)
println(result)
}
def test4() : Unit = {
var result = List(1,7,2,9).foldLeft(0)(_-_) // 得到结果 ： ((((0 - 1) - 7) - 2) - 9) = -19 fold等同于foldLeft
println(result)
}
2 set :
/**
* 可变集合 ArrayBuffer ListBuffer 增减元素用 += -=
* 不可变集合 比如 Array List 在增加元素 用 +:
*
*/
object forSet {
def main(args: Array[String]) {
//println("集合操作!")
test1() // 集合list用 :: 来标识元素组成
//test2() // 可变集合定义和增加元素 +=
}
// 不可变Set 定义
def test1(): Unit = {
var set1 = Set(1,2,3,3,4) // 对于不可变 必须用var接收 如果用val接收 那么必须要定义另一个集合变量来接收原来不可变集合增加元素后的新集合
set1.foreach(println)
//for(a<-set1) {
// println(a)
//}
// val res20=Set(3.0,5)
//for ( i <- res20 ) println(i)
}
// 可变Set 定义
def test2(): Unit = {
}
}
3 Map :
import scala.collection.mutable.Set
import scala.collection.mutable.Map
/**
*map又叫 映射 (zhangsan,8000)代表map中的一个键值对，也叫作对偶，用()表示对偶
*/
object forMap {
def main(args: Array[String]) {
//test1() // map操作
//test2() // 元组
// test3() // 模式匹配值匹配 就是 switch
//test4() // 模式匹配 类型匹配
// test5()
test31
/*可变的映射*/
val map2 = scala.collection.mutable.Map[String,Int]("zhangsan"->8000,"lisi"->10000,"wangwu"->15000)
map2("zhangsan") = 12000
}
// 定义 获取key 遍历集合
def test1(): Unit = {
var map1 = Map("zhangsan"->23,"lisi"->32)
// if(map1.contains("zhangsan1")) println(map1("zhangsan1"))
// println(map1.getOrElse("zhangsan1","no having"))
//println(map1("zhangsan1")) //获取某个Key的值
//for((k,v) <- map1) {
// println("k " + k + " : " + "v " + v )
//}
//map1+=("wangwu"->33)
//map1-=("zhangsan")
//map1("lisi")=40
/*for((k,v) <- map1) {
println("k " + k + " : " + "v " + v )
}*/
/* for( k <- map1.keys) { // 遍历所有的key
println("k " + k )
}*/
//for( v <- map1.values) { // 遍历所有的key
// println("v " + v )
//}
for(tmp <- map1) {
println(tmp )
}
}
// 元组定义， 里面可以有多个数值类型 ， 在获取的时候 用 _1 _2 _3这种方式获取 并且下标从1开始
def test2(): Unit = {
var p1 = ("hello", 33, 19)
println(p1._1 )
}
// 模式匹配的值匹配 增加首位_ 这个占位符
def test3(): Unit = {
val a = 3
val b = a match{ // _可以理解为占位符，表示参数a有多个值的时候，那么用_表示多个 如果a就一个值 比如 4那么直接写出4即可
case _ if a>=0 && a<4 => "小于4"
case 4 =>"等于4"
case _ => "大于4"
}
print(b)
}
def test31() :Unit = {
var a = 6
var b = a match {
case 1 => "this is 1"
case 2 => "this is 2"
case _ if a>=3 && a <= 5 => "[3,5]"
case _ => ">5"
}
println(b)
}
// 模式匹配的类型匹配
def test4(): Unit = {
val num:Any="1"
num match {
case i:Int => println("this is Int")
case s:String => println("this is String")
case _ => print("this is not Int and String, is other")
}
}
// 数组的模式匹配
def test5(): Unit = {
val array = Array(1,2,3)
array match {
case Array(1,2) => println("Array(1,2)")
case Array(1,2,_) => println("Array(1,2,_) 三个参数")
case Array(1,2,_*) => println("Array(1,2,_*) 三个以上参数")
case _ => print("不识别")
}
}
}
4 List :
import scala.collection.mutable.{ListBuffer, ArrayBuffer}
/**
* 可变集合 ArrayBuffer ListBuffer 增减元素用 += -=
* 不可变集合 比如 Array List 在增加元素 用 +:
*
*/
object forList {
def main(args: Array[String]) {
//println("集合操作!")
test1() // 集合list用 :: 来标识元素组成
// test2() // 可变集合定义和增加元素 +=
//test3()
}
// 不可变List 定义
def test1(): Unit = {
var list1 = List(1,2,3,4) // 对于不可变 必须用var接收 如果用val接收 那么必须要定义另一个集合变量来接收原来不可变集合增加元素后的新集合
// list1 = 0::list1
// list1.foreach(println)
//var list2 = 0::1::2::3::Nil
// list2 = list2 :+ 4
// list2 = 11::list2
//var result = list2.sum
list1 = list1 :+ 5
println(list1)
}
// 可变List 定义
def test2(): Unit = {
var list1 = new ListBuffer[Int] // 需要声明参数类型
list1 += 1
list1 += 2
list1 -= 1
list1.foreach(println)
}
// 可变List 定义
def test3(): Unit = {
var list1 = new ListBuffer[Int]() // 需要声明参数类型
list1 +=1
list1 +=2
list1.foreach(println)
}
}
5 分支控制语句: if for break continue
import scala.util.control.Breaks
/**
* Created by Administrator on 2017/9/3.
* 你好
*/
object forifbreakcontinue {
def main(args: Array[String]) {
//println("Hello World 你好!")
//demo01() // 正常的 if else
//demo02() // 可以返回值的 if else
//demo03() // 可以返回值的 if else
//demowhile() // 迭代器 + while
//demowhile1() // 数组 + while, 注意数组 不用 [] 而是用() 而且没有i++这一说
//demofor // i <- a to b 表示范围 [a,b] for循环
//demoforUtil // i <- a until b 表示范围 [a,b) for循环
// demoforTuidaoShi // for 推导式 直接将值赋值给变量
//demoforShouwei
//demoforShouwei1
demoforAndBreak1
//demoforTuidaoShi1 // for 推导式 + yield 赋值给新数组 + for遍历新数组
/**
* for推导式 + yield赋值新数组 + foreach遍历
* foreach 不是一个操作符，是集合的一个方法或者函数
* foreach和for一样 遍历的意思
*/
//demoforAndForEach
//demoforAndBreak // for + break ，注意break跳出点位置
//demoforAndContinue // for + continue, continue是break的另一种实现，在需要跳出的地方上包 break即可
}
def demo01(): Unit = {
val a = 0
var tmp: String = null
if (a == 0) {
tmp = "0"
} else {
tmp = "a != 0"
}
print(tmp)
}
def demo02(): Unit = {
val a = 0
var tmp: String = null
tmp = if (a == 0) " a == 0 " else " a != 0"
print(tmp)
}
def demo03(): Unit = {
val a = 3
var tmp: String = null
tmp = if (a == 0) " a == 0 " else " a != 0"
if(a == 0) {
tmp = "0"
}else if(a == 1) {
tmp = "1"
}else{
tmp = "其他"
}
print(tmp)
}
def demowhile(): Unit = {
val a = Array(1,2,3,4,5)
var iter = a.iterator
while(iter.hasNext) {
var b = iter.next()
println(b)
}
}
def demowhile1(): Unit = {
val a = Array(1,2,3,4,5)
var length = a.length
var i = 0
while(i <= length-1) {
var b = a(i)
println(b)
i=i+1
}
}
def demofor(): Unit = {
val a = Array(1,2,3,4,5)
var length = a.length
for(tmp <- 0 to length-1) {
println(a(tmp))
}
}
def demoforUtil: Unit = {
var a = Array(1,2,3,4,5);
var length = a.length
for(tmp <- 0 until length){
println(a(tmp))
}
}
def demoforTuidaoShi: Unit = {
var a = Array(1,2,3,4,5);
for(tmp <- a.reverse){
println(tmp)
}
}
// scala通过守卫方式控制 for循环变量值的选择
def demoforShouwei: Unit = {
var a = Array(1,2,3,4,5);
for(tmp <- a.reverse; if tmp %2 == 0){
println(tmp)
}
}
// scala修改步长来选择遍历的数值 结果是 1 3 5 ，2表示步长
def demoforShouwei1: Unit = {
var a = Array(1,2,3,4,5)
var length = a.length
for(tmp <- 0 to (length,2)){
println(a(tmp))
}
// println( 0 to 10) // Range(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
}
def demoforTuidaoShi1: Unit = {
var a = Array(1,2,3,4,5);
var b = for(i<-a) yield 2*i
for(tmp <- b){
println(tmp)
}
}
def demoforAndForEach: Unit = {
var a = Array(1,2,3,4,5);
var b = for(i<-a) yield 2*i
b.foreach(println)
}
def demoforAndBreak1: Unit = {
var a = Array(1, 2, 3, 4, 5)
var _break = new Breaks
_break.breakable{
for (tmp <- a) {
if (tmp == 2) {
_break.break()
}
println(tmp)
}
}
}
def demoforAndBreak: Unit = {
var a = Array(1, 2, 3, 4, 5)
var _break = new Breaks
_break.breakable { //因为要跳出for循环因此在for上包可跳出点 _break.breakable
for (tmp <- a) {
if (tmp == 2) {
_break.break()
}
println(tmp)
}
}
}
def demoforAndContinue: Unit = {
var a = Array(1, 2, 3, 4, 5)
var _break = new Breaks
for (tmp <- a) {
_break.breakable { //continue是break的一个变种，注意跳出位置
if (tmp % 2 == 0) {
_break.break()
}
println(tmp)
}
}
}
}
6 自定义函数和 集合的 map()方法
import scala.collection.mutable.Map
/**
*
*/
object forFunctionAndMapMethod {
def main(args: Array[String]) {
// test1() // 函数定义操作
// test2() // scala中调用Java类
// demo02()
test3() // 集合的map方法
}
// 定义函数
def sum(x:Int, y:Int): Int = {
x+y
}
// 定义函数1 可变参数
def sum1(x:Int*): Int = {
// 调用函数
var c = 0
for(a<-x) {
c=c+a
}
return c // return 可以有 可以不写
}
// 调用函数
def test1(): Unit = {
// 调用函数
// val c = sum(1,2)
var c = sum1(1,2,3,4,5)
println(c)
}
// 调用Java类
def test2(): Unit = {
// 调用Java类
val person = new Person()
val result = person.talk()
print(result)
}
// 不知道干嘛的 也没调用成功 ！！！
def demo02: Unit ={
def _double(b:Int) = 2*b
//定义一个参数为函数的函数
def f1(f:(Int)=>Int,a:Int):Int = f(a) // f(a) 表示调用前面定义的 f1函数的
val res = f1(_double,4)
println(res)
}
// 集合的map方法
def test3(): Unit ={
var list = List("a" ,"b","c")
// var newList = list.map(_.toUpperCase) // _表示集合所有元素
// newList.foreach(println) //
//print(mytoupcase("a"))
/**
* 隐式调用
* 调用集合的map函数，在函数中因为集合就一个个的元素，因此在传递给自定义函数mytoupcase时直接省略传参
*/
// var newList = list.map(mytoupcase)
// 显示调用
// var newList = list.map(tmp => mytoupcase(tmp))
// 调用匿名函数
var newList = list.map(tmp => {
tmp.toUpperCase
})
newList.foreach(println)
}
// 字母大写 自定义
def mytoupcase(a:String): String ={
a.toUpperCase()
}
7 集合的 reduce函数：
/**
* 主要介绍了 集合的 map函数和 reduce函数， map函数传递一元参数并对集合所有参数进行处理
* reduce函数 比如 reduceLeft 需要传递多元参数 并对所有参数进行聚合操作
* foldLeft 相当于reduce 但是是对集合增加一个初始值
*/
object forReduceMethod {
def main(args: Array[String]) {
// test1() //
// test2()
// test3()
test4()
}
// reudceleft ： 集合元素从左到右 依次按照函数来操作, 从左向右进行聚合 (聚合:多个值变成一个值)
def test1() : Unit ={
// var result = List(1,2,3,4,5).reduceLeft(_-_) // 匿名函数， 左边数字 - 右边数字
var result = List(1,2,3,4,5).reduceLeft((x,y)=>x-y)
println(result)
}
// reudceright ：
def test2() : Unit ={
//var result = List(1,7).reduceRight(_-_) // 匿名函数， 左边数字 - 右边数字
// var result = List(1,7,2,9).reduceLeft(_-_) (((1 - 7) - 2) - 9) = -17
// var result = List(1,7,2,9).reduceRight(_-_) // ( 1- ( 7 -(2-9)) ) = -13
var result = List(1,7,2,9).foldLeft(0)(_-_) // ((((0 - 1) - 7) - 2) - 9) = -19 fold等同于foldLeft
println(result)
}
// scanLeft ：将折叠和影射操作结合在一起 得到操作的所有中间结果
def test3() : Unit ={
var result = List(1,7,2,9).scanLeft(0)(_-_) // 得到结果 ： List(0, -1, -8, -10, -19)
println(result)
}
def test4() : Unit = {
var result = List(1,7,2,9).foldLeft(0)(_-_) // 得到结果 ： ((((0 - 1) - 7) - 2) - 9) = -19 fold等同于foldLeft
println(result)
}
}
8 类的基本内容
import scala.beans.BeanProperty
/**
* 类的基本内容
*/
class TestClass41{
// println("TestClass41")
@BeanProperty var value = 100 //默认生成对应的set和get方法
// @BeanProperty val value = 100 //使用val定义变量 不在提供对应的set方法
// @BeanProperty private var value = 100 //@BeanProperty和private不能同时使用
// private var value = 100 //使用private定义字段时，不在提供set和get方法
}
object Test41 {
def main(args: Array[String]): Unit = {
//在scala的类中，定义字段时，scala默认会生成对应set和get方法
val o = new TestClass41
// o.value = 1000 //set值 ，set方法名是value_=
// o.value_=(1000) //set值 ，set方法名是value_=
println(o.value) //get值,get方法名是value
//
// o.setValue(10000)
// println(o.getValue())
}
}
9
相关推荐
### Scala 集合数据操作详解 #### 一、引言 Scala作为一种融合了面向对象编程和函数式编程特点的编程语言，在数据处理方面展现出了极强的能力。它内置了一系列强大的集合类，使得开发者能够高效地对数据进行操作。...
Scala中集合的使用 大学生 1. List 列表的使用 2. Set 集合的使用 3.Map 映射的使用 4. 元组的使用
Scala集合框架的设计使得开发者可以根据具体需求选择最合适的集合类型。不可变集合适用于不需要修改的场景，而可变集合则适用于需要频繁修改的场景。理解不同集合类型之间的差异和特性有助于编写更高效、更安全的...
2. 高级特性：可能涉及函数式编程的概念，如高阶函数、惰性求值和不可变性，以及这些特性如何在Scala集合中实现。 3. 类型系统：解释Scala的类型系统如何支持集合操作，如类型推断、泛型和模式匹配。 4. 性能优化：...
此外，Scala集合库还支持高阶函数，如map、filter、fold等，使得代码更加简洁、可读性强。同时，由于Scala集合的优化，它们在性能上往往能与Java集合相媲美，甚至在某些情况下超越Java。 **Java开发经验分享** ...
共13页第15讲-Scala编程详解：面向对象编程之Trait 共14页第16讲-Scala编程详解：函数式编程 共14页第17讲-Scala编程详解：函数式编程之集合操作 共9页第18讲-Scala编程详解：模式匹配 共11页第19讲-Scala编程详解：...
Scala的`map`、`filter`、`fold`等函数都是高阶函数的例子，它们用于对集合进行操作，例如`map`可以对集合中的每个元素应用一个函数并返回新的集合。 柯里化 柯里化（Currying）是将接受多个参数的函数转换为一系列...
学习spark之前，大家必须先学会Scala这门语言，他是spark的基础，这里总结了一下Scala集合的相关知识点
你会学习到Scala的语法结构，包括变量声明、常量、数据类型（如基本类型、引用类型、集合类型）、运算符、流程控制语句（如if-else、for循环、while循环）以及函数和方法的定义。此外，你还将了解Scala的模式匹配和...
8. **集合库**：Scala的集合库非常强大，提供了各种操作和转换，如map、filter、reduce等。集合可以被视作惰性序列，允许延迟计算和高效处理大量数据。 9. **类型类**：类型类是一种设计模式，允许在运行时添加功能...
7. **集合库**：Scala的集合库非常强大，提供了各种高效、易用的数据结构，如List、Set、Map以及各种转换操作，方便进行复杂的数据处理。 8. **表达式导向编程**：Scala鼓励使用表达式而非语句，使得代码更像数学...
Scala 是一种多范式的编程语言，它融合了面向对象和函数式编程的特性。下面将详细解释题目中涉及的Scala知识点： 1. **var、val 和 def 的区别**： - `var` 定义可变变量，可以多次赋值。 - `val` 定义不可变变量...
- **过程**：函数体中有打印操作或其他副作用的函数。 - **表达式**：函数体仅包含计算，没有打印等副作用。 - **选项解析**： - A、deffoo(num: Int) = { println(num * 2) }：过程。 - B、deffoo() = { ...
- 折叠（fold）：也称为归约，是迭代集合元素并累计结果的过程，常见的折叠操作有sum、product和max/min等。 - 递归：函数式编程鼓励使用递归来处理循环逻辑。 - 隐式转换：允许在程序中自动地将一种类型的值转换成...
在大数据分析中，Scala的集合API是一大亮点，它提供了丰富的操作，如map、filter和reduce，这些在处理大规模数据时非常实用。 接下来是Apache Spark。Spark以其内存计算模型著称，极大地提高了数据处理速度，比传统...
除了上述的算子外，Scala 本身还提供许多强大的函数式编程特性，比如高阶函数、集合操作、模式匹配等，这些特性在 Spark 编程中也能得到充分利用。在学习 Spark 编程时，熟悉这些算子和 Scala 的函数式编程特性是...
从原有的面向对象编程（OO）到函数式编程（FP）的思想。本书面向实际的使用场景，提供了大量的Scala实例，同时，也给出底层的原理和相关的参考。对于Scala新手来说这是一本不错的入门书，对于老手来说也是一本夯实...
6. **集合库**：Scala的集合库非常强大，提供了各种操作和转换方法，支持高效的并行处理。 7. ** Actors模型**：Scala内置了Actors模型，用于并发编程，它基于消息传递，提供了一种安全的处理并发问题的方式。 8. ...
函数式编程在逻辑上摒弃了可变数据结构，倾向于使用不可变的数据集合以及纯函数。这种编程范式在处理并发时，能够提供很多优势，比如易于推理、减少程序中的副作用等。 Scala与Clojure都是运行在Java虚拟机（JVM）...