scala函数，方法，数组，集合基础使用说明

scala的高阶函数
1、函数和方法二则都是在定义逻辑
方法
def sum_m(a:Int,b:Int):int=a+b
函数
val sum_f:(Int,Int)=>Int=(x,y)=>x+y
函数和方法可以互换
方法可以转为函数：
val f1=sum_m
函数可以转为方法：
def m1=sum_m
2、高阶函数的定义

(方法|函数)f可以作为（方法|函数）ff的参数，也可以作为（方法|函数）ff的返回值
方法和函数就是执行逻辑
高阶函数的通俗解释
	1、可以把一段逻辑当做参数，传递给另一段处理逻辑
	2、也可以让某一段处理逻辑的返回值，就是一个函数
方法可以作为方法的参数
函数可以作为方法的参数
方法可以作为函数的参数
函数可以作为函数的参数
方法可以作为方法的返回值
函数可以作为方法的返回值
方法可以作为函数的返回值
函数可以作为函数的返回值

	object Basics_Day01 {
	  def main(args: Array[String]): Unit = {
		//调用m1方法传入f1函数
		val  a= m1(f1)
		println(a)
		//调用m1方法传入f2函数
		val a1=m1(f2)
		println(a1)
		//调用m2方法传入f1函数
		val  b= m2(f1,2,4)
		println(b)
		//调用m2方法传入f2函数
		val b1=m2(f2,3,4)
		println(b1)
		//调用m2方法传入m3函数
		println(m2(m3,2,4))

	}
	  /**定一个方法
		* 方法的参数是个函数，函数的参数是两个int类型
		* 返回值为int类型
		*/
	  def m1(f:(Int,Int)=>Int):Int=f(1,2)
	  //定义一个计算数据可变的函数
	  def m2(f:(Int,Int)=>Int,x:Int,y:Int):Int=f(x,y)
	  //定义一个需要两个Int类型参数的方法
	  def m3(a:Int,b:Int):Int=a+b
	  //定义一个函数，参数类型是两个int类型，返回值是一个int类型
	  val f1=(x:Int,y:Int)=>x+y
	  val f2=(a:Int,b:Int)=>a*b

	}

数组
定长数组
package com.liu.meng.day13

	/**
	  * scala的数组的学习
	  * 定长定长数组和可变数组
	  * 定长数组Arrray
	  * 定长数组没有add，inster，remove操作只能修改某个位置的元素的值，要实现删除
	  * 可以通过过滤生成新的 Array 的方式来删除不要的元素
	  * 可变数组ArrayBuffer
	  * 可变数组可以进行增加，删除等操作
	  *
	  * 定长数组和可变数组之间的转换 通过调用toBuffer（）和toArray()来实现
	  *
	  */
	object ArrayClass {
	  def main(args: Array[String]): Unit = {
	 //初始化一个数组
		val arr=Array(1,2,3,4,5,6,7,8)

		//增强for循环
		for (i<-arr){
		  println(i)
		}
		println("=============================")

		//使用to可以生成一个序列作为脚标
		for (i<-(0 to arr.length-1)){
		  println(arr(i))
		}
		println("=============================")

		for (i<-(0 until arr.length)){
		  println(arr(i))
		}
		println("=============================")

		//步长为2
		for (i<-0 until (arr.length,2)){
		  println(arr(i))

		}
		println("=============================")

		//反转
		for (i<-(0 until arr.length).reverse){
		  println(arr(i))
		}
		println("=============================")

        //数组转换将偶数取出乘以10以后在生成一个新数组
		val res=for (e<-arr if e%2==0)yield e * 10
		println(res.toBuffer)

		println("===============")
		//更高级写法，filter 是过滤，接收一个返回值为boolean的函数
		//map相当于将数组中的每一个元素取出来，应用传进去的函数
		val r=arr.filter(_%2==0).map(_*10)
		println(r.toBuffer)
		
		//数组中的常用算法
		//求和
		println(arr.sum)
		//最大值
		println(arr.max)
		//最小值
		println(arr.min)
		//返回带有集合元素信息的集合名称
		println(arr.toString)
		//数组转为字符串
		println(arr.mkString())
		//数组转为字符串指定分隔符
		println(arr.mkString(“,”))
		//数组转为字符串指定分隔符和前后标记
		println(arr.mkString(“<”,“,”,“>”))
	  }
	}

集合
不可变集合
package com.liu.meng.day13

	/**
	  * scala集合简单操作
	  * scala集合有三大类序列Seq，集合Set，映射Map所有集合都扩展自iterable特质
	  * scala集合有可变（mutable）和不可变（immutable）两种类型
	  *
	  *
	  */
	object AggregateClass {
	  def main(args: Array[String]): Unit = {
		/**List序列
		*在scala中列表要么为空（NIl表示空列表）要么是一个head元素加上一个tail列表
		*9::List(5,2) ::操作符是将给定的头和尾创建一个新的列表
		*注意 ::操作符是右结合的，例如9::5::2::NIL相当于9::(5::(2::Nil))
		*/
		  //创建集合
		val list1=List(1,2,3)
		val list2=0::list1
		val list3=list1.::(0)
		val list4=0+:list1
		val list5=list1.+:(0)
		val list6=list1:+3
		val ls0=List(4,5,6)
		//集合合并
		val ls2=ls0++list1
		//将list1插入到ls0前
		val ls3=ls0++:list1
		//将list1插入到ls0前
		val ls4=list1.:::(ls0)
		println(ls4)
		//取列表最后一个元素
		println(list1.last)
		//取除了最后一个元素以外的元素
		println(list1.init)
		//反转
		println(list1.reverse)
		//截取前n个元素
		println(list1.take(2))
		//丢弃前n个元素
		println(list1.drop(1))
		//分割成2列表有第一个列表有n个元素
		println(ls4.splitAt(4))
	   //输出
		println(list1.toString())
		//转为String
		println(list1.mkString)
		//转为数组
		println(list1.toArray.toBuffer)
	  }
	}

可变列表

    package com.liu.meng.day13

	import scala.collection.mutable.ListBuffer

	/**
	  * 可变列表List
	  */
	object ArregateClass1 {
	  def main(args: Array[String]): Unit = {
		//创建可变列表
	val list0=ListBuffer[Int](1,2,3)
		//创建空的可变列表
		val list1=new ListBuffer[Int]
		//向集合中追加元素和、未生成新的集合
		list1+=4
		list1.append(5)
		//将list1中的元素追加到list0中，未生成新的集合
		list0++=list1
		//生成新集合
		val  list2=list0++list1
		val list3=list1:+5

	  }
	}

Set集合
package com.liu.meng.day13

	import scala.collection.immutable.HashSet
	import scala.collection.mutable

	/**
	  * set集合
	  */
	object AggregateSet extends  App {
		//不可变set
		val set1=new HashSet[Int]()
		//生成新的Set
		val set2=set1+4
		//set中的元素不能重复
		val set3=set2++Set(5,6,7)
		val set4=Set(1,3,4)++set1
		println(set4)

		  //创建一个可变的 HashSetval
	  val  set5 = new mutable.HashSet[Int]()
		  //向 HashSet 中添加元素
		  set5 += 2
		  //add 等价于+=
		  set5.add(4)
		  set5 ++= Set(1,3,5)
		  println(set1)
		  //删除一个元素
		  set5 -= 5
		  set5.remove(2)
		  println(set5)
	}

MAP集合

		package com.liu.meng.day13

		import scala.collection.mutable

		object MapClass  extends  App {
		  //创建Map
		val map1=new mutable.HashMap[String,Int]()
		  //向map中添加数据
		  map1.put("aa",1)
		  map1("b")=2
		  map1+=(("c",1))
		  println(map1)
		  //移除数据
		  map1-="aa"
		  map1.remove("b")
		  println(map1)
		  //修改数据
		  map1("c")=100
		  println(map1)
					  
		}