2. 程式人生 > >9.2 scala函式 list map 元組

9.2 scala函式 list map 元組

阿新 • • 發佈：2019-01-24
基礎語法TestFunc.scala：package com.scalaobject TestFunc {//預設值函式def sayMyName(name : String = "Jack"){  println(name) }//多個int型別引數，相加 def sumMoreParameters(elem : Int*) = {   var sum = 0  for(e <- elem){   println(e)   sum += e  }   sum }//含參函式 def add(a:Int,b:Int) = a+b//一個自定義數值，和一個固定數值 def add2 = add(_:Int,2)// 遞迴函式// 必須自行定義函式返回型別
// f(n)=f(n)*f(n-1) def fac(n:Int):Int = if( n <= 0) 1 else n*fac(n-1)// 函式柯里化 // 柯里化,柯里化比較有意思,就是說定義 // 把這個引數一個個獨立開來寫,這就是柯里化,它可以達到什麼效果呢 def mulitply(x:Int)(y:Int) = x*y //一個固定值和一個傳參 def m2 = mulitply(2)_ // 同學們可能會說，這個看起來沒有什麼用處啊，但是我們說柯里化在遞迴，和控制抽象方面比較有用// 在目前我們不去深究這個使用場景，現在就是讓大家知道有這麼個形式，大家掌握到這就可以了// 柯里化就是把引數可以分開來，把部分函式引數可以用下劃線來代替
// => 匿名函式宣告方式    val t = ()=>{333;"xururyun"}//聲明瞭一個函式物件付給了t// :後面是資料型別,c代表傳進來的引數    def testfunc02(c : ()=>String )={      c()    }// 匿名函式val d1 = (a:Int)=> a+100// 匿名函式作為引數,其實就是引數名,後面跟上引數型別,然後是表示式    def testf1(callback : (Int,Int)=>Int )={     println(callback(123,123))    }// 巢狀函式,其實就是def裡面套一個def
 def add3(x:Int, y:Int ,z:Int) = {  def add2(x:Int, y:Int) = {   x + y  }  add2(add2(x,y),z) }// 能否看懂？？？    def sum(f : Int => Int) : (Int , Int) => Int = {      def sumF(a : Int , b : Int) : Int =         if (a >b ) 0 else f(a) + sumF( a + 1 , b)      sumF    }// def sum(f : Int => Int) : (Int , Int) => Int = {// def sumF(a : Int , b : Int) : Int ={// if (a >b ) 0 else f(a) + sumF( a + 1 , b)// } // return sumF// } def main(args: Array[String]) {    val sumF = sum(x=>x*2)     println(sumF(2,3))// sayMyName()// println(sumMoreParameters(1,2,3,4,5,6,7,8,9,10))// println(add(2,3))// println(add2(3))// println(fac(5))// println(d1(4))// println(t)// println(t())// println(testf1((x:Int, y:Int)=>{x*y}))// println( mulitply(123)(123))// println( m2(123))// println(testfunc02( t ))// println(testf1( (a:Int,b:Int)=> a+b))// testf1(add)// println(add3(1,2,3))// def sum(f :Int => Int) : (Int , Int) => Int = {// def sumF(a : Int , b : Int) : Int ={// if (a >b ) 0 else f(a) + sumF( a + 1 , b)// }// return sumF// }// val tttt = (a:Int,b:Int)=>a*b;// testf1(tttt);// testf1((a:Int,b:Int)=>a*b) }}=======================================================================基本用法2TestFunc02.scala 遍歷to untilpackage com.scalaobject TestFunc02 {  def test() : Unit = {   for(i <- 1.to(100)){    println(i)   }// for(i <- 1 to 100 ){// println(i)// } } def test2() = {   for(i <- 1 until 100 ){    println(i)   }  } def test3() = {  for(i <- 0 to 100 if (i % 2) == 1 ; if (i % 5) > 3 ){    println("I: "+i)  } }// switch  def testmatch(n:Any)={    n match {      case x:Int => {println("111") ;n}// break;     case s:String => println("2222") ;n     case _ => {println("other"); "test"}//default    }  }  def sum(elem : Int*) = {    var temp = 0    for(e <- elem){      temp += e    }    temp  } def main(args: Array[String]) {// test()// test2()// test3()// println(testmatch(100.0))// println(sum(1,2,3,4,5))// println(sum(1 to 5))   println(sum(1 to 5 :_*)) }}========================================================================基本用法3TestCollection.scala list map foreach distinct sortBy 元組package com.scalaobject TestCollection { def main(args: Array[String]) {  var t = List(1,2,3,5,5)// println("---001--"+t(2))// map 個位置相加 函式程式設計// 對集合裡面的每個元素進行操作,有返回值,這裡返回一個新的List// println(t.map( x => {x+2}))// println(t.map(_ + 2))  var t2 = t.+:("test") //新增元素// println(t2)// println(t)// println(t.::("test"))// println("test"::t)// println(6::t2)// println(t2.::(6))// println(List(6).:::(t2))// println((t2):::List(6))// println(t2)// t2 = t:::6::Nil //組成新的List t作為一個元素// println(t2)//遍歷// t2.foreach(a=>print("---+++"+a)) //去重複// println("/--***---"+t.distinct)//排序// println(t.sortBy{ x => -x })//切割 // println("---+++++********************Slice"+t.slice(0, 2))// println("-*--*--*--*--*--*--*--*--*-")// for(temp<-t2){// print(temp)// }// println("-*--*--*--*--*--*--*--*--*-")// for(i <- 0 until t2.length){// println(i)// println(t2(i))// }// println("-*--*--*--*--*--*--*--*--*-")// println(t./:(0)({// (sum,num)=>sum-num// }))  // 1,2,3,5,5  // reduce 就是對集合裡面的每個元素依次進行操作// println(t.reduce( (a,b) => a+b ))// println(t.reduce( _ - _))// // filter 是把匿名函式返回為True保留下來// println(t.filter ( _ > 3 ))// println(t.take(3)) //取前三個元素// println("-*--*--*--*--*--*--*--*--*-")// println(t.foldLeft(0)((sum,num)=>{ //帶初始值的reduce// print(sum+"--"+num+" ");// sum-num;// }))// println("-*--*--*--*--*--*--*--*--*-")// println(t.map(v =>v+2))// println("-*--*--*--*--*--*--*--*--*-")// 元組// var tuple01 = (1,2,3,5)// println(tuple01._1)// println(tuple01._4) var list = List(("yasaka",100),("xuruyun",100),("liangyongqi",50))  val temp = list.sortBy(x => (-x._2,x._1))  println(temp) }}

相關推薦

9.2 scala函式 list map 元組

基礎語法TestFunc.scala：package com.scalaobject TestFunc {//預設值函式def sayMyName(name : String = "Jack"){  p

Scala 陣列(Array)，列表(List)，元組(Tuple)，集(Set)，對映(Map)，迭代器(Iterator)

1. 陣列(Array) 陣列是程式設計中經常用到的資料結構，一般包括定長陣列和變長陣列。本教程旨在快速掌握最基礎和常用的知識，因此，只介紹定長陣列。 定長陣列，就是長度不變的陣列，在Scala中使用Array進行宣告，如下： val intValue

Python學習筆記(9)-列表list、元組tuple、字典dict、集合set

一，介紹 本篇主要介紹Python中的資料集合型別，包括list、tuple、dict、set。 二，概念區別 list，有序集合，基本相當於java中的ArrayList。 tuple，元素不

Python 基礎 - Day 2 Learning Note - 列表&元組

索引 import col 獨立 數據結構 如果 忽略 faye 個數 1. 列表 LIST 定義列表 >>> alist=[‘Lydia‘,‘Miranda‘,‘Tony‘,‘Cody‘,‘Lorries‘] >>> print

列表List與元組tuple的對比

bsp 對比 pri 歧義 進行 語句 方括號 內置 除了 #創建只有一個元素的tuple，需要用逗號結尾消除歧義 a_tuple = (2,) #tuple中的list mixed_tuple = (1, 2, [‘a‘, ‘b‘]) print("mixed_tu

list 字典 元組及常用字符串方法

pytho jmx OS 幫助 linu ace 空格 linux下 ear List練習1 # 校驗用戶名是否合法： # 輸入賬號 #input # 如果賬號存在的，提示已經被註冊，如果不存在的，就讓他註冊 all_us

列表list和元組tuple的區別

Python有兩個非常相似的集合式的資料型別，分別是list和tuple，定義形式常見的說法是陣列。 tuple通過小括號( )定義，定義後無法編輯元素內容（即不可變），而list通過中括號[ ]定義，其元素內容可以編輯（即可變），編輯動作包含刪除pop( )、末尾追加append( )、插入insert(

python-列表list和元組tuple

在資料型別和變數中我們提到，python除了整數，浮點數，字串等資料型別外，還包含列表，字典等資料型別，今天我們來學習列表和元組這兩種資料型別。 1.list list是一種有序的集合,可以隨時新增和刪除其中的元素，有點類似與C/C++中的陣列。例如，列出班級中所有同學的

python3裡函式怎麼樣使用元組或字典作為引數呼叫（複製他人部落格）

在python3中可以採用如下方法：         函式（*（元組））         函式（**{字典}） 如下例子：   &nb

Scala學習筆記之元組`Tuple`

Scala學習筆記之元組Tuple 元組是Scala提供的一種特殊的資料結構，或者說是一塊語法糖，它允許多個不同型別的元素組合在一起被使用，如下所示： val tup = (1, 3.14, "元組", true) 這是一個四元組，由4個元素組成。Scal

Scala中的Tuples元組

//scala中的元組 //和list一樣，元組也是不可變得，但是和list也有不同之處：元組可以包含不同型別的元素，但是list為元素為統一中型別 // 元組非常有用，例如， //如果需要從方法返回多個物件。 而在Java中你通常會建立一個類似JavaBean的類來儲存多個返回值， //在Scal

每日一python（9）：基礎資料結構 ---- 元組

Tuple是Python內建的另一種資料型別，元組。Tuple也是一種有序的集合，tuple和list非常類似，但是tuple一旦初始化就不能修改。 比如：同樣是列出同學的名字，如下： >>> classmates = ('Bob', 'Tract', 'Jac

scala學習(陣列，元組)

1. 陣列相關操作 如果需要一個長度不變的陣列，可以用Scala中的Array，提供初始值時不要使用new val nums = new Array[Int](10) //10個整數的陣列，所有元素初始化為0 val s = Array("hello

Python3 列表List或元組tuple中元素分解（賦值操作）

元組示例： p = (1,2,3,4,5,6,7,) a,b,c,d,e,f,g = p print (a,b,c,d,e,f,g) 輸出：1 2 3 4 5 6 7 注意：變數總數和結構要與序列相

Python教程補充內容（函式中接收元組、列表和lambda的用法）——簡明python教程學習筆記

本文大量內容來源於沈老師的簡明python教程，其中夾雜部分個人的理解如有偏頗之處還望海涵。 一. 在函式中接收元組和列表 \quad當要使函式接收元組或字典形式的引數的時候，有一種特殊的方法，它分別使用*和**字首。 這種方法在函式需要獲取可變數量的引數的

python sorted list 包含元組 字典 的多列排序

#包含字典dict的列表list的排序方法與dict的排序類似,如下： import operator x = [{'name':'homer', 'age':39}, {'name':'bart', 'age':10}, {'name':'aart', 'age':20}

Python入門筆記2 序列（字串、元組、列表）

操作字串的方法： a.索引取值   a='abcde'   a[0]、a[1]取a中元素，但一次只可以取一個。   用+號連線，如，a[1]+a[2]。得‘ab’ b.切片 可以從字串中進行擷取 分正負數，正數表示從左往右取，從0開始；負數代表從右往左取，最後一位為-1

Scala的對映和元組操作

對映和元組操作 構造Map // 構造一個不可變的MAP對映，類似與key -> value這樣的組合叫做對偶 val score = Map("Jack" ->

Scala中Tuple（元組）的使用

在我們使用某些程式語言開發時，有些時候總是希望函式（方法）返回多個值。一般情況下我們有幾種選擇，下面我們以Java為例。 將返回值作為引數參入函式或者方法，然後修改實參，這樣就相當於“返回值”。如: public void func1(String

如何在函式中接收元組、列表和字典

在Python，要用函式接收列表或元組或字典，我們可以採用在這幾種型別的引數前面加上 * 或 ** 即可解決。 在函式中接收元組，程式程式碼如下： #引數前面為 * ，代表這個位置的引數不知道有多少個引數，如果有，則將其儲存為元組 def x(a,b,*c)