精华内容
下载资源
问答
  • Scala 函数数组

    千次阅读 2020-08-24 20:10:32
    val 函数变量名 = (参数名:参数类型, 参数名:参数类型....) => 函数函数是一个对象(变量) 类似于方法,函数也有输入参数和返回值 函数定义不需要使用def定义 无需指定返回值类型 参考代码 scala>...

    函数

    scala支持函数式编程,将来编写Spark/Flink程序中,会大量使用到函数

    定义函数

    语法

    val 函数变量名 = (参数名:参数类型, 参数名:参数类型....) => 函数体

    1. 函数是一个对象(变量)
    2. 类似于方法,函数也有输入参数和返回值
    3. 函数定义不需要使用def定义
    4. 无需指定返回值类型

    参考代码

    scala> val add = (x:Int, y:Int) => x + y

    add: (Int, Int) => Int = <function2>

     

    scala> add(1,2)

    res3: Int = 3

    方法和函数的区别

    1. 方法是隶属于类或者对象的,在运行时,它是加载到JVM的方法区中
    2. 可以将函数对象赋值给一个变量,在运行时,它是加载到JVM的堆内存中
    3. 函数是一个对象,继承自FunctionN,函数对象有apply,curried,toString,tupled这些方法。方法则没有

    示例

    方法无法赋值给变量

    scala> def add(x:Int,y:Int)=x+y

    add: (x: Int, y: Int)Int

     

    scala> val a = add

    <console>:14: error: missing arguments for method add;

    follow this method with `_' if you want to treat it as a partially applied function

           val a = add

    方法转换为函数

    • 有时候需要将方法转换为函数,作为变量传递,就需要将方法转换为函数
    • 使用_即可将方法转换为函数

    参考代码

    scala> def add(x:Int,y:Int)=x+y

    add: (x: Int, y: Int)Int

     

    scala> val a = add  _

    a: (Int, Int) => Int = <function2>

    数组

    scala中,有两种数组,一种是定长数组,另一种是变长数组

    定长数组

    1. 定长数组指的是数组的长度不允许改变
    2. 数组的元素可以改变

    语法

    // 通过指定长度定义数组
    val/var 变量名 = new Array[元素类型](数组长度)

    // 用元素直接初始化数组
    val/var 变量名 = Array(元素1, 元素2, 元素3...)

    1. 在scala中,数组的泛型使用[]来指定
    2. 使用()来获取元素

    参考代码

    scala> val a = new Array[Int](100)
    a: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

    scala> a(0) = 110

    scala> println(a(0))
    110

    变长数组

    变长数组指的是数组的长度是可变的,可以往数组中添加、删除元素

    变长数组

    创建变长数组,需要提前导入ArrayBufferimport scala.collection.mutable.ArrayBuffer

    语法

    创建空的ArrayBuffer变长数组,语法结构:

    • val/var a = new ArrayBuffer[元素类型]()

    创建带有初始元素的ArrayBuffer

    • val/var a = ArrayBuffer(元素1,元素2,元素3....)

    示例一

    定义一个长度为0的整型变长数组

    参考代码

    val a = ArrayBuffer[Int]()

    示例二

    定义一个包含"hadoop", "storm", "spark"元素的变长数组

    参考代码

    scala> val a = ArrayBuffer("hadoop", "storm", "spark")

    a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, storm, spark)

    展开全文
  • 【大数据Scala系列】Scala 数组相关操作

    Scala 数组相关操作

    一、定长数组

    在 Scala 中,如果你需要一个长度不变的数组,可以使用 Array。但需要注意以下两点:

    • 在 Scala 中使用 (index) 而不是 [index] 来访问数组中的元素,因为访问元素,对于 Scala 来说是方法调用,(index) 相当于执行了 .apply(index) 方法。
    • Scala 中的数组与 Java 中的是等价的,Array[Int]() 在虚拟机层面就等价于 Java 的 int[]
    // 10 个整数的数组,所有元素初始化为 0
    scala> 
    展开全文
  • 1. 定长数组如果你需要一个长度不变的数组,可以使用Scala中的Array.val nums = new Array[Int](10) // 10个整数的数组 所有元素初始化为0 val strs = new Array[String](10) // 10个字符串的数组 所有元素初始...

    1. 定长数组

    如果你需要一个长度不变的数组,可以使用Scala中的Array.

    val nums = new Array[Int](10) // 10个整数的数组 所有元素初始化为0
    val strs = new Array[String](10) // 10个字符串的数组 所有元素初始化为null
    val s = Array("Hello", "World") // 长度为2的Array[String] 类型是推断出来的 
    s(0) = "GoodBye" // Array("GoodBye","World")
    

    备注

    已提供初始值时不要使用new,例如上面的数组s

    使用()而不是[]来访问元素

    在JVM中,Scala的Array以Java数组方式实现.

    2. 变长数组

    对于那种长度按需要变化的数组,Java有ArrayList.Scala中等效数据结构为ArrayBuffer.

    import scala.collection.mutable.ArrayBuffer
    val b = ArrayBuffer[Int]() // 或者 new ArrayBuffer[Int]() 创建一个空的数组缓冲来存放整数\
    b += 1 // ArrayBuffer(1) 用+=在尾端添加元素
    b += (1,2,3,5) // ArrayBuffer(1,1,2,3,5) 在尾端添加多个元素
    b ++= Array(8, 13, 21) // ArrayBuffer(1,1,2,3,5,8,13,21) 用++=操作追加任何集合
    b.trimEnd(5) // ArrayBuffer(1,1,2) 移除最后5个元素
    

    可以在任意位置插入或移除元素,但这样的操作不如在尾端添加或移除元素操作那么高效:

    b.insert(2,6) // ArrayBuffer(1,1,6,2) 在下标2之前插入
    b.insert(2,7,8,9) // ArrayBuffer(1,1,7,8,9,6,2) 插入任意多的元素
    b.remove(2) // ArrayBuffer(1,1,8,9,6,2) 删除下标2的元素
    b.remove(2,3) // ArrayBuffer(1,1,2) 第二个参数的含义是要移除多少个元素
    

    有时需要构建一个Array,但不知道最终需要装多少元素.这种情况下可以先构建一个数组缓冲,然后调用:

    b.toArray // Array(1,1,2)
    

    3. 遍历数组和数组缓冲

    使用for循环遍历数组和数组缓冲:

    val b = Array(6,5,4,3,2,1)
    for(i <- 0 until b.length){
      println(i + "-" + b(i))
    }
    

    输出结果:

    0-6
    1-5
    2-4
    3-3
    4-2
    5-1
    

    备注

    until 是RichInt类的方法,返回所有小于(但不包括)上限的数字

    如果想要每两个元素一跳,可以让i这样来进行遍历:

    val b = Array(6,5,4,3,2,1)
    for(i <- 0 until (b.length, 2)){
      println(i + "-" + b(i))
    }
    

    输出结果:

    0-6
    2-4
    4-2
    

    如果要从数组的尾端开始:

    val b = Array(6,5,4,3,2,1)
    for(i <- (0 until b.length).reverse){
      println(i + "-" + b(i))
    }
    

    如果在循环体中不需要用到数组下标,我们也可以直接访问数组元素:

    for(elem <- b){
      println(elem)
    }
    

    4. 数组转换

    从一个数组(数组缓冲)出发,以某种方式对它进行转换是很简单的.这些转换操作不会修改原是数组,而是产生一个全新的数组:

    val a = Array(1,2,3,4)
    val result = for(elem <- a) yield 2 * elem // resultArray(2,4,6,8)
    

    for(...) yield循环创建了一个类型与原实际和相同的新集合.新元素为yield之后的表达式的值,每次迭代对应一个.

    当你遍历一个集合时,如果只想处理满足特定条件的元素.可以通过for中的if来实现:

    val a = Array(1,2,3,4)
    val result = for(elem <- a if elem % 2 == 0) yield 2 * elem
    

    上面实例中对每个偶数元素翻倍,并丢掉奇数元素.

    5. 常用操作

    5.1 sum

    val a = Array(6,1,7,4)
    a.sum // 18
    

    要使用sum方法,元素类型必须是数值类型:整型,浮点数或者BigInteger/BigDecimal

    5.2 min max

    val a = Array(6,1,7,4)
    a.min // 1
    a.max // 7
    

    min和max输出数组或数组缓冲中最小和最大的元素

    5.3 sorted

    val a = Array(6,1,7,4)
    val asorted = a.sorted // Array(1, 4, 6, 7)
    
    val a = ArrayBuffer(6,1,7,4)
    val asorted = a.sortWith(_ > _) // ArrayBuffer(7, 6, 4, 1)
    

    sorted方法将数组或数组缓冲排序并返回经过排序的数组或数组缓冲,不会修改原始数组.可以使用sortWith方法提供一个比较函数.

    5.4 mkString

    val a = Array(6,1,7,4)
    a.mkString(" and ") // 6 and 1 and 7 and 4
    

    如果想要显示数组或者数组缓冲的内容,可以使用mkString,允许指定元素之间的分隔符

    val a = Array(6,1,7,4)
    a.mkString("<", ",", ">") // <6,1,7,4>
    该方法的另一个重载版本可以让你指定前缀和后缀
    展开全文
  • 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 函数可以转为方法:...

    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)
    					  
    		}
    
    展开全文
  • scala函数参数

    千次阅读 2019-09-15 00:04:19
    把一个函数作为参数传递给另一个函数的方式,在函数式编程中称为高级函数。 //绝对值函数 def abs(n:Int)={ if(n<0) -n else n } //阶乘函数 def factorial(n:Int):Int={ def go(n:Int,acc:Int):Int= if(n&...
  • Scala---数组

    2017-07-05 22:47:40
    Scala中提供了一种数据结构-数组,其中存储相同类型的元素的固定大小的连续集合。数组用于存储数据的集合,但它往往是更加有用认为数组作为相同类型的变量的集合。 取替声明单个变量,如number0, number1, ..., 和...
  • Scala—— 14.数组Array

    2020-02-18 20:53:04
    1.定长数组 var array=new Array[T] (n) val arr = new Array[Int](4) //底层 int[] arr = new int[4] println(arr.length) // 4 println("arr(0)=" + arr(0)) // 0 //数据的遍历 for (i <- arr) { ...
  • 目录一、定长数组Array二、可变数组ArrayBuffer三、 一、定长数组Array 数据的构建 使用new关键字创建一 个定长数组 //长度30的整数数组,所有元素初始化为0 val array = new Array[Int] (30) 直接使用Array...
  • scala-02-数组的操作

    2018-05-11 18:02:00
    scala中的数组和 java中的数组一样, 定义了长度后不可改变 1,产生一个数组: 有3种创建数组的方式, 分别直接new, 直接赋值, 或者使用 Array中的rang来产生 /** * 获取数组 */ def getArray() : Array...
  • scala的变量和常量 类型推断 Scala编译器可以推断出表达式的类型,因此不必显示声明。减少自动类型推断可以提高代码的阅读性。 var a=1 //直接赋值 var a:Int=_ //不赋值用下划线 scala数据类型 总体上分为两...
  • scala 与 java泛型数组

    2017-04-16 22:31:00
    java 泛型数组初始化 public class GenericArray<T> { private T[] arr; public GenericArray(){ arr = new T[10]; //编译错误 } } 使用这样的方式初始化jav...
  • Scala集合分为可变和不可变的集合,不可变集合可以安全的并发访问 可变集合可以在适当的地方被更新或拓展,这意味着你可以修改,添加,移除一个集合的元素 不可变集合,相比之下,永远不会改变。不过,仍然可以模拟...
  • Scala 2.8中新的数组

    万次阅读 2010-07-21 11:45:00
    Scala 2.8重新设计了集合框架,引入了许多新的特性来改良数组类型和已有String类型。这篇文章大部分翻译自官方的PDF,虽然简单,但是可以让我们快速的了解新版本中数组那令人激动的特性。
  • 文章目录数组三种声明方式遍历方法二维数组concat() 方法 合并数组range() 方法 创建区间数组iteratetabulatefillofDimrange元祖定义方法:访问方法productIterator(遍历输出)toStringswap 数组 三种声明方式 var ...
  • Scala-基础-数组(1)

    2017-04-28 18:27:00
    import scala.collection.mutable.ArrayBuffer; //数组(1) //知识点-定义数组,变长数组,遍历数组,数组转换 class Demo1 extends TestCase { //定义数组 def test_^^() { //定义数组语法1 val ...
  • Scala--数组函数

    2020-10-29 22:27:59
    ++:合并集合,并返回一个新的数组,新数组包含左右两个集合对象的内容。 val a = Array(1,2,3) val b = Array(4,5,6) val c = a ++ b //c中的内容是(1,2,3,4,5,6) ++: :与上个方法类似,但是该方法右边操纵数的...
  • Array Of Scala数组的三种创建方式 数组的三种创建方式 object demoArray { def main(args: Array[String]): Unit = { //数组创建方式一 var array:Array[String]=new Array[String](3) array(0)="hello" array...
  • scala数组函数

    2020-07-29 19:26:18
    scala数组函数 val a = Array(1,2,3,4) val b = Array(5,6,7,8) def ++ 合并集合,并返回一个新的数组,新数组包含左右两个集合对象内容 val c=a++b def ++: 合并成一个新的数组,右边操纵数的类型决定着返回...
  • scala val 函数变量名 = (参数名:参数类型, 参数名:参数类型…) => 函数函数是一个对象(变量) 类似于方法,函数也有输入参数和返回值 函数定义不需要使用def定义 无需指定返回值类型 示例 定义一个两个数值...
  • 如果你需要一个长度不变的数组,可以用Scala中的Array。例如: val numsArray = new Array[Int] (30) //长度30的整数数组,所有元素初始化为0 val stringArrays = new Array [String] (30) //长度30的字符串数组...
  • Scala数组函数总结

    2020-09-14 23:43:56
    Scala 数组函数 数组是一种可变的、可索引的数据集合。在Scala中用Array[T]的形式来表示Java中的数组形式 T[]。 ##变量:赋值后可以改变,生命周期中可以被多次赋值 ##常量:赋值后不变,类似Java中的final变量 ##...
  • Scala数组函数

    2020-09-18 23:32:16
    Scala数组函数 1、++ 说明:合并集合,并且返回一个新数组 注:因为数组中包含数字也包含字符串,所以会用Any顶级类型接收,如果数组中有重复内容,不会去重 2、++: 说明:合并集合,冒号右边的类型决定返回结果...
  • 1. 编写一段代码,将a设置一个n个随机整数的数组,要求随机数介于0(包含)和n(不包含)之间。 def fun (n :Int) ={ val random = new util.Random() val arr = for (i <- 0 until(n) ) yield random.nextInt...
  • scala调用java含数组函数...但是当在调用java中含可变参数函数时,会发生错误,Array解析成了只有一个对象(对象中包含Array数组)的数组,不符合预期,解决方案可以通过再封装一个函数用java数组接一下,从java...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,103
精华内容 4,841
热门标签
关键字:

scala函数参数为数组