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