Scala-翌日

23003 ワード

一、Scalaには方法と関数の二つの技術がある.
　　1.方法
定義:defメソッド名(パラメータ名:パラメータタイプ、パラメータ名:パラメータタイプ):[戻り値タイプ]={
メソッドボディ
　　　　　　　　}
　　　　　e.g:

 1     def test1(): Unit = {
 2       println("      ")
 3     }
 4     //return            ，      
 5     def test2(x: Int, y: Int): Int = {
 6       return x + y
 7     }
 8     //          ，Scala                   
 9     def test3(x: Int, y: Int) = {
10       x + y
11     }
12     //         ，        ，    （）
13     test1
14     var a = test2(1, 2)
15     println(a)
16     print(test3(1, 5))
17     //          
18     //    3
19     //    6

方法の注意事項:

メソッドの戻り値タイプは書かなくてもよく、Scalaはメソッドボディの最後の行に基づいてタイプを導出する

returnと戻り値タイプ、同生共死

メソッドに再帰操作がある場合は、戻り値のタイプを指定する必要があります.省略することはできません.

1   def foop(x:Int):Int={
2     if (x<=1){
3       return 1
4     }
5     return x*foop(x-1)
6   }
7     print(foop(3))
8 //    6

メソッドのパラメータの種類
　　　　1.既定のパラメータ

1     def test1(x: Int = 0):Int = {
2       return x
3     }
4     //        ，        ，         
5     println(test1())
6     println(test1(3))
7 ###  
8 0
9 3

　　　　2.バンド名パラメータ

1     def test2(x:Int=1,y:Int=2):Int={
2       return x+y
3     }
4     println(test2(x=3))
5     println(test2(x=3,y=3))
6 ###  
7 5
8 6

　　　　3.変長パラメータ:メソッドのパラメータが不定の場合、そのパラメータを変長パラメータとして定義できます.

 1     def test3(x: Int, num: Int*): Int = {
 2       //  num   
 3       println(num.getClass)
 4      //       sum  
 5       return num.sum + x
 6     }
 7 
 8     println(test3(1, 2, 3, 4))
 9 
10 ###       ，Scala          ，              
11     def test4(y: Int = 1, num: Int*) = {
12       num
13     }
14 
15     println(test4(2, 3, 4))
16   }
17 ###  
18 class scala.collection.mutable.WrappedArray$ofInt
19 10
20 WrappedArray(3, 4)

メソッドの呼び出し
　　　　1.接尾辞コール
　　　　2.接尾辞呼び出し
　　　　3.かっこ呼び出し
　　　　4.かっこなし呼び出し

 1     //    
 2     var a = Math.abs(-1)
 3     println(a)
 4     //              ()   
 5     var b=Math abs -1
 6     println(b)
 7 ###  
 8 1
 9 1
10     //to    
11     println(1 to 10)
12     println(1.to(10))
13 ###  
14 Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
15 Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
16     //                  ，     
17     var c=Math.abs{
18       println("       ")
19       -1
20     }
21     println(c)
22 ###  
23        
24 1
25     //     ，       ，         ，

　　2.関数＃カンスウ＃
Scalaは関数式プログラミングをサポートし、sparkなどのビッグデータフレームワークには多くの関数式プログラミングがある.
定義:
val関数名=(パラメータ名:パラメータタイプ,...)=>{
かんすうたい
　　　　}

 1     val fun1 = (x: Int, y: Int) => {
 2       x + y
 3     }
 4     println(fun1(1, 2))
 5     val fun2 = () => println("    ")
 6     fun2()
 7   }
 8 ###  
 9 3
10

関数の特徴

関数自体は独立したオブジェクト

である.

はメソッドに類似して戻り値があり、パラメータ

がある.

関数を定義する場合、defキーワード

は使用しません.

戻り値タイプを指定する必要はなく、return

を使用することはできません.
　　3.メソッドと関数の違い

メソッドはオブジェクト向けの概念であり、オブジェクトまたはクラスに属し、

は独立して存在しない.

関数自体がオブジェクトであり、Functionの親から継承され、apply、tupleなどのメソッド

がある.
　　4.メソッドを関数に変換

1     def test1(x: Int): String = {
2       return s"      ${x}"
3     }
4     //                +    +_
5     var a = test1 _
6     var b = a(2)
7     println(b)
8 ###  
9       2

注:メソッドは関数に変換できますが、関数自体がオブジェクトであるため、関数はメソッドに変換できません.
二、配列
　　1.定義:同じデータ型を格納できるコンテナ
　　2.分類:1定長配列:開いたメモリ空間は可変ではない;格納されているコンテンツは可変です
②長くなる配列:配列の長さが可変で、配列の追加と削除が可能
　　3.ていちょうはいれつ

 1     //        
 2     var a=Array(1,2,3)
 3     //    (index)         ，     
 4     a(0)=2
 5     println(a.toBuffer)
 6 ###  
 7     //    ArrayBuffer(2, 2, 3)
 8     //     new   
 9     var b=new Array[Int](4)
10     b(0)=2
11     //      ，     
12     println(b.toBuffer)
13     println(b.length)
14     //  new   
15     var c= Array[Int](4)
16     c(0)=2
17     println(c.toBuffer)
18     println(c.length)
19 ###  
20 //    ArrayBuffer(2, 0, 0, 0)
21 //    4
22 //    ArrayBuffer(2)
23 //    1

　　4.へんちょうはいれつ

 1import scala.collection.mutable.ArrayBuffer

//   ：               0            +=         

 2   var a=ArrayBuffer[Int]()

 3     a+=1
 4     a+=1
 5     a+=1
 6     println(a.length)
 7     println(a.toBuffer)、
 8 ###  
 9 3
10 ArrayBuffer(1, 1, 1)
11 
12   //   ：  ，    ，     +=     
13   var b=ArrayBuffer(1,2,3)
14     b+=4
15     println(b.length)
16     println(b.toBuffer)
17 ###  
18 4
19 ArrayBuffer(1, 2, 3, 4)

配列の操作

+=追加要素を使用して配列の末尾に

を追加

-=削除要素の等号の後に付いているのは削除する要素

です.

+=を使用して1つの配列(定長または変長どちらでもよい)を1つの変長配列に追加し、変長配列のみがこの操作

を行う.

1  var b=ArrayBuffer(1,2,3)
2     b+=4
3     var a =Array(1,2,3)
4     var c = b++=a
5     println(c.toBuffer)
6 ###  
7 ArrayBuffer(1, 2, 3, 4, 1, 2, 3)

配列の遍歴

 1     var b=ArrayBuffer(1,2,3)
 2     b+=4
 3     //   ：for  
 4     for (ib)println(i)
 5     println("-------------")
 6     //   ：      
 7     for(i 0 until b.length)println(b(i))
 8 ###  
 9 1
10 2
11 3
12 4
13 -------------
14 1
15 2
16 3
17 4

配列のいくつかの関連操作

 1      
 2      var a = Array(1, 2, 3, 4)
 3     //b       
 4     var b = new Array[Int](3)
 5     //        ，            ，         copy  
 6     a.copyToArray(b, 0, 3)
 7     for (i  b) println(i)
 8 ###  
 9     //    1
10     //    2
11     //    3

 1     //        
 2     var a = Array(1, 2, 3, 4)
 3     //  "-"      
 4     var b = a.mkString("-")
 5     println(b)
 6 //    1-2-3-4
 7     //     ，    ，             
 8     var c =Array(5,4,8,6)
 9     var d=c.sorted
10     println(d.toBuffer)
11 //    ArrayBuffer(4, 5, 6, 8)
12     println(d.reverse.toBuffer)
13 //    ArrayBuffer(8, 6, 5, 4)

その他の一般的な方法

配列の長さ

a.length

配列内容求和

a.sum

配列の最大値

a.max

配列の最小値

a.min

最初のデータ

a.head

最初の要素の後のデータを除去

a.tial

三、元グループ
　　1.三要素

Scalaのタプルデータには、同じタイプの

は必要ありません.

メタグループのデータ内容、可変

Scalaタプルの個数は22個の

である.

ネットワークプロセスに見られるデータ伝送のための

　　2.フォーマットの定義

 1     //   ：       ：var/val    = （  1，  2，  3）//      22  
 2     var a = (1, "sss", 3)
 3     println(a.getClass)
 4     println(a)
 5     //class scala.Tuple3
 6     //(1,sss,3)
 7     //   ：var/val    =   1 ->   2               2   
 8     var b = 1 -> 2->3
 9     println(b)
10     //((1,2),3)

　　3.下付きアクセス

1     //              1   
2     var a = (1, "sss", 3)
3     println(a._1)
4     println(a._2)
5     //1
6     //sss

go-playground / validatorライブラリアップデート作業メモv8 -> v10

[参照解除](Unreference)オペレータと矢印オペレータ