scala學習筆記

来源:https://www.cnblogs.com/liangyan131/archive/2019/12/05/11991987.html
-Advertisement-
Play Games

元組 元組是一個輕量級集合,這個集合可以存儲任意元素 元組是使用小括弧,元素之間使用逗號分隔,元素的類型是任意的 若需要訪問元組中的元素 [元組名._數字] 數字是從1開始, 有多少個元素,這個1遞增多少次 例如: 有一個元組,元組中有三個元素 訪問每一個元素值 --> _1 _2 _3 元組屬於輕 ...


元組

元組是一個輕量級集合,這個集合可以存儲任意元素

元組是使用小括弧,元素之間使用逗號分隔,元素的類型是任意的

若需要訪問元組中的元素 [元組名._數字] 數字是從1開始, 有多少個元素,這個1遞增多少次

例如: 有一個元組,元組中有三個元素

　　訪問每一個元素值 --> _1 _2 _3

元組屬於輕量級的集合,數據最多只能存儲22個

ps:一般元組會代替Map在Spark中使用

對偶元組 --> 元組中存儲的數據是成對出現的,就將出現第一個值稱為key,第二個值的位置稱為Value

/**
  * 元組
  */
object TupleDemo {
  def main(args: Array[String]): Unit = {
    //這個就是元組的創建
    val t = ("sparkcore","sparkSQL","SparkStreaming")
    //獲取值
    val value: String = t._1

    //創建元組的同時,指定變數存儲數據(不推薦)
    val t1,(a,b,c) = ("sparkcore","sparkSQL","SparkStreaming")
    //
    val t1_1 = a
    
    //Scala中提供通過tuple元組類來創建
    //tuple1是無限大 
    //剩餘的tuple後面的數字代表了最多可以存儲多少個元素
     //系統給定元組的最大值是22個,超過22就無法存儲了,此時建議改為Array或List
    val tuple = new Tuple1(1.3,14,"你好")
    val tuple2 = new Tuple2(1.3,14)
  }

　　

元組的遍歷

val tuple = new Tuple1(1.3,14,"你好")
    val tuple2 = new Tuple2(1.3,14)

     //遍歷方式1(迭代器遍歷)
      for(ele <- tuple.productIterator){
        println(ele)
      }
    //遍歷集合 --> foreach 這個方法就是遍歷集合使用,沒有返回值
    //foreach方法是獲取集合每一個元素並處理, 返回值是一個泛型,所以最終輸出什麼數據類型由需求決定
    /*
    方法:
      def 方法名(參數列表):返回值類型 = { 方法體 }
    函數:
      val 函數名 = (參數列表) => {函數體}
     */
    //先定義一個函數
     val pt = (x:Any) =>{println(x)}
    tuple.productIterator.foreach(pt)

    //匿名函數
    tuple.productIterator.foreach((x:Any) =>{println(x)})
    //簡化
    tuple.productIterator.foreach(x =>println(x))
    //只需要一個可以獲取數據的變數--> 此時可以使用 下劃線代替
    tuple.productIterator.foreach(println(_))
    //因為是列印數據,此時參數是預設(就是遍歷集合獲取來的,此時Scala允許再次省略下劃線)
    tuple.productIterator.foreach(println)

　　

拉鏈操作

作用:將兩個元組中的數據形成對偶元組

package Scala_03

/**
  * 拉鏈操作
  */
object TupleDemo2 {
  def main(args: Array[String]): Unit = {
      //zip就是元組的拉鏈操作,將兩個元組中數據進行合併,形成對偶元組
      val name = Array("tom","jerry","kitty")
      val scores = Array(2,3,4)
    //當前數組中存儲的是一個一個的元組對象
    //誰調用方法就是就是key,誰做參數傳遞 誰就是 value
    val tuples: Array[(String, Int)] = name.zip(scores)
    println(tuples.toBuffer)

    //兩個存儲數據的集合 中的數據不一致
    val name_1 = Array("tom","jerry","kitty")
    val scores_2 = Array(2,3)
    //ps:如果兩個集合數據長度不一致,此時拉鏈操作誰以最小長度的集合為基準 進行對偶元組合併,多餘的部分會刪除
    val tuples_2: Array[(String, Int)] = name_1.zip(scores_2)
    println(tuples_2.toBuffer)

    //zipAll 和zip是類似的,但是若齊總某一個集合集合中的元素缺少,將使用預設元素填充
    val xs = List(1,2,3)
    val zx = List("一","二","三","四")
    val tuples_3 = xs.zipAll(zx,0,'_')
    println(tuples_3)

    //zipwithIndex 將集合中元素和所以進行結合
    val list = List(1,2,3)
    val tuples_4 = list.zipWithIndex
    println(tuples_4.toBuffer)
    //若需要從指定位置開始組合
    val tuples_5 = list.zip(Stream from 1)
    

  }
}

　　

列表List

Scala中的集合是分為可變和不可變

Scala中預設使用是不可變集合包 scala.collection.immutable

package Scala_03

/**
  * list集合
  */
object ListDemo {
  def main(args: Array[String]): Unit = {
    val empty = List()  //空集合
    val names = List("xiaobai","xiaohong","xiaohuang") //有值
    val moreList = List(List(1,2,3),List(2,3,4))// 集合中存儲的數據是另外一個集合對象
    //運算符
    //列表中有一個預設空值 nil 它可以和 :: 中綴符 一起使用 構建集合對象
    // :: 和 nil一起使用 它 是右結合
    val str:List[String] = ("小明" :: ("小紅" :: ("小黃" :: Nil)))
    println(str)
    val s = List("姓名")
    //將其他集合中數據添加到當前集合彙總
     val strs :List[String] = "小明" :: "小紅" :: "小黃" :: s
     println(strs)
   //使用nil之後會將當前集合先看做是一個整體 nil就相當於創建了集合,所以當前所有數據 都會當前集合中元素進行存儲
     // s 就會當做一個List集合對象存儲到當前集合中
    val ss = "小明" :: "小紅" :: "小黃" :: s :: Nil
    println(ss)
   
  }
}

　　

列表添加數據

package Scala_03

object ListDemo2 {
  def main(args: Array[String]): Unit = {
      val  list = List(1,2,3)
     //所有不可變list操作都會返回一個全新的List
     val list2 =  0 :: list  //     添加數據
    val list3 = 0 +: list   //都是向集合的開頭添加數據
    val list4  = list :+ 4 //向集合的末尾提N家數據
    val list5 = list ++ list4 //將兩個集合合併
    //將某一個集合添加到當前集合的前面
   val list6 = list4 ++: list
    val list6_1  = list4 ::: list //此操作和上面的操作是一樣的
    
  }
}

　　

列表的常用操作方法

package Scala_03

object ListDemo3 {
  def main(args: Array[String]): Unit = {
    //遍歷集合的方法:
    /*
     1.map遍歷集合獲取集合中每一個元素,並將元素進行處理(自定函數函數),返回一個全新的集合
     2.filter遍歷集合獲取集合每一個元素,並將元素進行處理(這個自定義函數返回值必須是Boolean)
     然後只有得到true,才會存儲到新的集合中
     這兩個方法同樣適用於List
     */
    //3.foreach 這個方法主要作用即使遍歷集合併處理集合中數據(自定義函數),這個方法沒有返回值
    val list = List(1,2,3)
    val list_1: List[Int] = list.map(_*2)
    val list_2: List[Int] = list.filter(_>1)
    list.foreach((x:Int)=>println(x))
    list.foreach(x => println(x))
    list.foreach(println(_))
    list.foreach(println)
    /*
    map和foreach的區別
    1.map方法存在返回值,處理完數據之後會返回一個新的集合但是foreache是沒有返回值的,處理完數據之後時沒有返回結果的
    2.因為map具有返回值,所以map多用於進行集合中數據處理,而foreach沒有返回值,所以多用於列印集合集合中數據
     */
    //ps:s雖然foreach不具備返回值,但是foreach內部處理函數和Map其實是一樣的,所以foreach也可以對集合中數據操作,操作完成之後多用於輸出
    //例如 map將集合集合中的元素擴大二倍,foreach也可做到,但是不能返回值出新的集合
      list.foreach(x=>println(x*2))
     // list.max  最大值  list.min 最小值

    //head 返回列表第一個元素
      val head: Int = list.head
    //tail 返回除第一個元素之外的其他元素
      val tail: List[Int] = list.tail
    //concat 將兩個集合拼接 相當於是 ++
      val list1 = List(4,5,6)
    val newList: List[Int] = List.concat(list,list1)
    //反轉
     val reverse: List[Int] = list.reverse
    //長度
    //list.length    list.size
    //take -> TopN   提取列表前N個數據 --> N就是具體的數值
      val topN: List[Int] = list take 1
    //拉鏈 zip  zipAll  zipwithIndex都可以使用
    //list.sorted  list.sortwith 都可以使用排序
     //丟棄列表前N數據 --> N是具體的值

      val ints: List[Int] = list drop 1
  }
}

　　

可變list

package Scala_03
/*
可變ListBuffer
 */
object ListBufferDemo {
  def main(args: Array[String]): Unit = {
      import scala.collection.mutable.ListBuffer
      val list1 = ListBuffer[Int](1,2,3)
      val list2 = new  ListBuffer[Int]
      list2 += 4  //追加
      list2.append(1)
      list2 ++= list1 //添加集合
    
  }
}

對列表進行拆分
val list = List(1,2,3)
val List(a,b,c) = list
此時 a b 和c 就會獲取 1,2,3的值

　　

Set

建議使用HashSet

package Scala_03

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

/*
   不可變和可變 HashSet是排重
   Hash表 --> 數組+鏈表
 */
object HashSetDemo {
  def main(args: Array[String]): Unit = {
         val set = new HashSet[Int]()
         val set1: HashSet[Int] = set+1 //添加
         val set2 = set1 ++ Set(1,2,3)//合併集合
        println(set2)
      //除了HashSet之外 可以使用使用Set
       val s = Set(1,2,3)
      
        import  scala.collection.mutable._
        val mutableSet = Set(1,2,3)//可變Set
        val set3 = new mutable.HashSet[Int]()
         set3 += 2
         set3.add(4)
    //存在則刪除,不存在 不會報錯不生效
         set3  -= 2
         set3.remove(2)
  }
}

　　

兩個Set集合操作

package Scala_03

/**
  * 兩個Set集合操作
  */
object SetDemo2 {
  def main(args: Array[String]): Unit = {
      //合併Set集合
      val set1 = Set(5,6,9,20,30,45)
      val set2 = Set(50,60,9,20,35,55)
       val set  = set1 ++ set2
    //交集
      println(set1.&(set2))
    println(set1.intersect(set2))
    //並集
     println(set1.union(set2))
    //差集
     println(set1.diff(set2))
    //遍歷Set
      val iterator = set1.iterator
     while(iterator.hasNext){
       println(iterator.next)
     }
    
  }
}

　　

總結:

Scala中集合:分為可變和不可變

List Set Array Map -->可變和不可變,Array是定長和變長

元組輕量級存儲數據的一個集合,最多只能存儲22個元素多用於是對偶元組代替Map

在Spark中使用級別: 元組->Array-->List--->Map---->Set

整個集合記住基本操作 添加數據和創建,集合所有的常用方法必須記住

集合常用方法

ps:方法主要是以Array和List為主,其餘Map和Set可以使用個別方法
遍歷集合:
map 遍歷操作數據並返回
filter遍歷操作數據並返回 滿足Boolean表達式
foreach  遍歷操作數據但是沒有返回多用於列印

package Scala_03

/**
  * 常用方法
  */
object CollectionMethodDemo {
  def main(args: Array[String]): Unit = {
        val list = List(List(1,2,3),List(4,5,6))
    //要求:  將集合進行處理 並得到 一個 新的集合 List(1,2,3,4,5,6)
      //壓平集合(可以將集合中存儲的集合進行扁平化處理)
     //將集合存儲的集合對象進行扁平化處理(將存儲在集合對象中集合數據獲取出來形成一個新的集合)
     val flatten: List[Int] = list.flatten
      println(flatten)

      val line = List("hello tom hello jerry","hello xiaobai hello")
    //需求將當前集合中的數據進行處理  -- >  List("hello","tom","hello".....)
       val stringses: List[Array[String]] = line.map(_.split(" "))
       stringses.foreach(x=>println(x.toBuffer))
        val list_1 = stringses.flatten
       println(list_1)

     //Scala中為了應對數據中存在集合套用集合的情況,推出 faltMap --> 就是flatten + Map  遍歷的同時並壓平
     val line_1 = List("hello tom hello jerry","hello xiaobai hello")
    val strings: List[String] = line_1.flatMap(_.split(" "))
    /*
    flatMap和Map的區別
    都可以對數據繼續進行遍歷處理,.map只是對數據處理並不具備對數據的扁平化處理,flatmap是Flatten+Map結合體,即可以遍曆數據也可以對數據進行
      扁平化處理,flatMap是Spark中比較常用獲取數據後的處理方法,其次是Map,但是flatMap是有局限性,在於它會壓平數據,不是所有的情況都需要壓平.
     */

    //forall 對整個集合中元素進行條件過濾.只有當所有元素都滿足的時候,才會返回true 否則就是false
       val  list_2 = List(1,2,3,4,5)
    val bool: Boolean = list_2.forall( _ < 3)

    //partition  分區 主要是對集合集合彙總數據進行分區(分組)
    //scala中體現就是出現不同集合, 但是在SparkCore中是存在不同分區中[Sparkcore中體現]
    val  list_3 = List(1,2,3,4,5,6)
    //這boolean類型表達式決定如何分數據
      val tuple: (List[Int], List[Int]) = list_3.partition(_%2 == 0)

    //fold 和  reduce
    //fold是一個聚合函數(求和) 需要兩個參數  第一個是預設值  第二個參數是計算邏輯
    //計算流程: 首先x會先獲取0這個初始值,然後y會獲取集合第一個元素然後相加
    //          之後的每一次計算 x獲取的都是上一次計算的結果 即 x  = x+y
    //           y值依舊獲取集合中剩餘的元素進行計算 ,最終停止是是y不能再獲取到集合元素時停止
    val  list_4 = List(1,2,3,4,5)
      val sum = list_4.fold(0)((x,y) => x+y)
    
    //reduce  
    //計算流程 首先x和y會獲取集合中第一個或第二個元素的值併進行計算 --> 1+2 = 3
     //       之後的每一次計算x獲取的是上一次計算的結果即 x = x+y  而y繼續獲取剩餘的集合中的元素參與運算 直到集合中沒有元素停止
    list_4.reduce((x,y)=>x+y)


  }
}

求和 sum 
排序 sorted , sortwith
最大值 max  和 最小值 min

　　

Scala版本的WordCount

 

package Scala_03
/*
Scala版本  模仿做的
 */
object WordCount {
  def main(args: Array[String]): Unit = {
    // 讀取文件數據存儲在集合中
    val line = List("hello tom hello jerry","hello xiaobai hello","hello tom")
    //將集合中的數據進行處理,,獲取集合中每一條字元串,將字元串進行拆分得到單詞
     val words: List[String] = line.flatMap(_.split(" "))
    //需要將單詞以KV的形式記性拼接  -->  (單詞,1) --> 明確當前存儲類型就是kv鍵值對
    // Scala中提供兩種方式 Map 和 元組 --> 推薦使用元組,原因在於元組擦操作數據更加方便,不會像Map一樣需要調用get方法獲取數據
    val tuples: List[(String, Int)] = words.map((_,1))
    //單詞和次數已經成為了元組,需要對次數進行累加,問題是不知道哪些單詞是一組
    //  將相同的單詞進行分組
    //            key 單詞   value 原有單詞所存在的元組
    val grouped: Map[String, List[(String, Int)]] = tuples.groupBy(_._1)
      //此時已經根據單詞進行了分組 相同的單詞會匯聚成List集合,通過reduce來進行計算可以相對來說比較麻煩
      val sumed:Map[String,Int] = grouped.mapValues(_.size)
    //Top1 ,數據已經存在Map集合中,此時進行排序
       val list: List[(String, Int)] = sumed.toList  //Map轉換為List時會將kv鍵值對以元組的形式存
    //這個排序是根據傳入的指定值來進行排序的,預設是升序,無法直接降序,Spark中有一個和這個方法一樣的sortBy,是可以自由升序降序
      val sortedList = list.sortBy(_._2)
       val reverseList = sortedList.reverse
        val top1 = reverseList take 1
    println(top1)

    //正常版本
    val top2 = line.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).mapValues(_.size).toList.sortBy(_._2).reverse.take(1)
 

  }
}

　　

並行化par

原因:Spark是一個並行計算框架,基於記憶體,所以會開啟多個線程執行程式
Scala中可以使用par進行多線程模擬
package Scala_03

/**
  * 並行化
  */
object ParDemo {
  def main(args: Array[String]): Unit = {
      /*
      Spark在編寫程式的時候,可以提交集群運行,也可以在本地執行
      可以在編寫Spark程式的時候 進行本地運行配置setMaster 運行模式設置
      需要開啟本地運行--> 我們三種方式
      local   --> 單線程
      local[值]  --> 更值來開啟對應的線程數,用來模擬spark的平行計算
      local[*]  --> * 主要代表當前電腦空閑多少線程就使用多少線程來進行模擬計算
       */
      //用par模擬並行化計算
      //1.求和 -->聚合函數  --> sum , fold  ,reduce
      //1.1 sum進行計算
      println("--------------------------------sum計算------------------------------------")
      //ps:sum只能用來求和無法計算其他方式
      val arr = List(1,2,3,4,5,6,7,8,9,10) //55
      //單線程計算
       val sumed = arr.sum
       println("單線程sum:"+sumed)  // 1+2+3+4...
      //開啟平行化處理計算
       val sumed2 = arr.par.sum
      println("多線程sum:"+sumed)  //(1+2)+(3+4+5+6)+(7+8+9+10)
      //總結:無論是在單線程還是多線程計算求和計算結果都是沒有問題
      println("--------------------------------sum計算------------------------------------")

      //reduce 求和
    println("--------------------------------reduce計算------------------------------------")
    //ps:sum只能用來求和無法計算其他方式
    val arr_1= List(1,2,3,4,5,6,7,8,9,10) //55
    //單線程計算
    val sumed3 = arr_1.reduce(_+_)
    println("單線程reduce:"+sumed3)  // 1+2+3+4...
    //開啟平行化處理計算
    val sumed3_1 = arr_1.par.reduce(_+_)
    println("多線程reduce:"+sumed3_1)  //(1+2)+(3+4+5+6)+(7+8+9+10)
    //總結:無論是在單線程還是多線程計算求和計算結果都是沒有問題

    //reduce是可以寫自己的計算邏輯,既然可以使用+  同理也可以計算 -
    //單線程計算
    val sub = arr_1.reduce(_-_)   // 1-2-3-4...
    println("單線程reduce:"+sub)
    //開啟平行化處理計算  此時不知道有多少個線程線上程在執行(1-2)  -(3-4-5)  -  (9-10)
    val sub_1 = arr_1.par.reduce(_-_)
    println("多線程reduce:"+sub_1)
    //在計算求差值計算時候reduce是無法保證在多線程下計算記過準確
    // reduceleft  和 reduceright  --> 無論是單線程還是多線程 ->都是按照一個方向計算計算的
    //可以使用reduceleft來修正計算計算記過 --> 必須是從左向右計算
    val sub_2 = arr_1.par.reduceLeft(_-_)
    println("多線程reduce:"+sub_2)
    //在Spark並行計算中如果需要使用計算求差值這樣的計算,建議使用 reduceLeft   --> reduceRight計算邏輯和left是一樣的(從右向左)
    println("--------------------------------reduce計算------------------------------------")

    //fold 求和
    println("--------------------------------fold計算------------------------------------")
    //ps:sum只能用來求和無法計算其他方式
    val arr_2= List(1,2,3,4,5,6,7,8,9,10) //55
    //單線程計算
    val sumed4 = arr_2.fold(10)(_+_)
    println("單線程fold:"+sumed4)  // 1+2+3+4...
    //開啟平行化處理計算
    val sumed4_1 = arr_2.par.fold(10)(_+_)  //fold一旦開啟並行化,就會進行多次的計算--> 當前整個初始值只要進行進行一次線程計算
    //就會盡心一次10的相加 --> 例如: 10+1+2 --> 12   10+3+4
    println("多線程fold:"+sumed4_1)
     //總結在平行化的前提下,fold 不建議進行 求和計算,因為會多次計算初始值,如果需要當前初始值只計算一次
    //foldLeft 和 foldRight  --> 強制要求計算方式是從左向後  和 從右向左
    val sum5 = arr_2.par.foldLeft(10)(_+_)

     
    //聚合函數    aggregate 和 fold類似 但是 計數邏輯多
     //  aggregate(初始值)(局部聚合,全局聚合)  --> aggregateByKey(SparkCore中運算元)

    println("--------------------------------fold計算------------------------------------")
  }
}

　　

面向對象

Scala語言和Java語言,世間萬物皆對象,Scala也是面向對象的語言,Scala的面向對象和Java的面向對象本質概念一樣,語法時區別

Java的面向對象Scala中面向對象
創建一個Java類只能使用class 創建一個類可以使用class和object
Java中有豐富許可權修飾符,每個許可權修飾符都可以很好限制對類和勒種屬性,方法的訪問方式 Scala中許可權修飾符本質只有兩個一個就是public和另外一個private,預設使用修飾符是public
Java中類的構造方法需要寫在類的內部,以方法的實行出現,並且主要是為了對屬性進行賦值 Scala中構造方法有兩種,一種是主構造器(一個類中只能有一個),另外一個是輔助構造器(一個類中可以有多個)
Java中是有抽象類,抽象類中可以定義抽象方法但是必須使用abstract Scala中也有抽象類,Scala中也存在抽象方但是不需要使用abstract,Scala允許抽象屬性
Java中類比較單一就是class修飾普通類,只不過功能上會進行區分(描述類和執行類) Scala中提供一個概念,伴生類和伴生對象(在同一個文件中類名相同,分別使用class和object修飾)
Java中介面分為兩種,一種是Java8之前的這個介面只能創建屬性和抽象方法,另外一種中是Java8之後這個介面即可以定義屬性和抽象方法也可以第定義實現方法(default修飾 和 static修飾) Scala中特質Trait本質上和Java中介面是沒有區別(應對的是Java8以後介面),允許定義屬性和抽象方法並且可以提供實現的方法
 
   

Scala中定義類和屬性

ps:在scala中描述一個事物需要使用class修飾的,在Scala中需要執行代碼即執行類需要使用object來修飾

Scala中 object代表的是類的修飾,而Java中Object代表的是超級父類,Scala中的超級父類是Any

package Scala_03
//Scala類中屬性
/*
 在Scala中類並不需要使用public修飾,因為預設都是共有
 在Scala中class修飾的類都是用來描述事物的,在沒有指定構造發方法之前,預設是存在一個無參構造方法的
 */
class Student {
    //類中定義屬性
    /*
      因為Scala中對變數的修飾基本上即使var 和 val,這樣兩種修飾同樣適用於屬性
      定義屬性時使用var修飾,那麼就相當於屬性自帶getter和setter
      定義屬性時使用val修飾,那麼就相當於屬性自帶getter
       Scala類聲明屬性,如果使用自動推斷,必須顯示的進行賦值
                         不想使用自動推斷,此時必須明確表示該數據類型是什麼
     */
     var name  = "tom"
     var age:Int = _  //當前屬性並不需要初始值,此時可以使用 _ 作為占位符代替初始值
     //val修飾屬性不可以使用_ 占位因為是只讀屬性 只會被賦值一次,一但使用下劃線 就無法在賦新值
     //  val gender:String= _
     //沒有明確數據類型,此時不允許使用下劃線
     //var  address = _
     // 可以使用 私有修飾符 (伴生類可以訪問這個私有屬性)
     private  var height :Int  = 155
     
     //對屬性更加嚴格的許可權控制 [this]代表只能當前類訪問 伴生類也不可以
    private[this] val cardID = "123456"
  
     //創建對象
     val student = new  Student()
      
  // val student = Student//這樣的創建多用於是伴生類 --> 觸發 apply方法  Student必須是一個Object類
  
}

　　

自定義getter和setter方法

package Scala_03
/*
自定義getter和setter
 */
class Ponit {
      /*
         為了保證數據安全,面向對象中封裝性
         會將屬性進行私有化設置 做私有化屬性時建議的命名規則 要求以 _ 為首碼, 定義屬性的名字 例如 _屬性名
         getter方法  def 方法名 =  當前屬性   --> 方法名是當前屬性的名字
         setter方法  def 方法名(參數列表):Unit = { 對屬性賦值}  --> 方法名必須是  屬性名_
       */
     private var  _x = 0
    //獲取這個屬性  getter
    def  x = _x
   //賦值  setter
    def  x_(x:Int):Unit = {
        _x = x
    }
     def  showInfos()={
         val p = new  Ponit()
         //獲取屬性
         println(p.x)
         p.x_(10)
     }

}

　　

Bean屬性

為了方便從Java程式猿轉變為Scala程式猿,方法理解和使用和Java中getter和Setter完全一樣

ps:這種方式不能私有化

package Scala_03

import  scala.beans.BeanProperty
class Person {
   //在創建屬性時候提供getter和setter方法,使用是一個註解
    @BeanProperty var name:String = _
}
object Person{
  def main(args: Array[String]): Unit = {
      val p = new Person()
     p.getName
      p.setName("1")
  }
}

　　

Scala中集合和Java中集合互相轉換

package Scala_03

import java.util

import scala.collection.mutable

/**
  * 集合互相轉換
  */
object ScalaToJava {
  def main(args: Array[String]): Unit = {
    import  scala.collection.JavaConverters._
    //將當前集合轉換為Java中的List
          val javaC: util.List[Int] = List(1,2,3,4).asJava
    //Java中集合轉換為Scala中集合
        val scalaC: mutable.Buffer[Int] = javaC.asScala
      //萬能方法 toXXXX -> XX就是你要轉換的集合
       scalaC.toList
    
  }
}

　　


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Java集合之ArrayList
    一、基礎 ArrayList不是線程安全的，多線程建議使用Vector或者CopyOnWriteArrayList; 底層實現是Object數組。預設容量DEFAULT_CAPACITY為10，最大數組大小MAX_ARRAY_SIZE為Integer.MAX_VALUE-8; 實現了RandomAc ...
  • golang socket與Linux socket比較分析
    在posix標準推出後，socket在各大主流OS平臺上都得到了很好的支持。而Golang是自帶runtime的跨平臺編程語言，Go中提供給開發者的socket API是建立在操作系統原生socket介面之上的。但golang 中的socket介面在行為特點與操作系統原生介面有一些不同。本文將對結合 ...
  • 【SDUT】【鏈表】2120 - 數據結構實驗之鏈表五：單鏈表的拆分
    Problem Description 輸入N個整數順序建立一個單鏈表，將該單鏈表拆分成兩個子鏈表，第一個子鏈表存放了所有的偶數，第二個子鏈表存放了所有的奇數。兩個子鏈表中數據的相對次序與原鏈表一致。 Input 第一行輸入整數N;；第二行依次輸入N個整數。 Output 第一行分別輸出偶數鏈表與奇 ...
  • GC與記憶體分配策略
    一、GC 第一步：判斷對象是否已死？有兩種方法：第一種是引用計數法，即給對象添加一個引用計數器，當被引用時，計數器就+1；當引用失效時，就-1；當計數器為0時，代表對象沒有被引用。但是計數器的缺點就是：對象之間相互引用時導致計數器不為零，無法被回收。第二種方法是可達性分析法，即通過定義一系列的GC ...
  • 埠占用問題：java.net.BindException: Address already in use: bind
    解決方法 方法一：換一個埠 若仍然想要使用該埠，則可以將占用該埠的進程殺死即可。 方法二：殺死占用該埠的進程 若仍然想要使用該埠，則可以將占用該埠的進程殺死即可 查找埠被占用的進程id netstat -nao | findstr “埠號” 查詢埠號對應的進程 tasklist | ...
  • 教你用Python實現免費蹭WiFi，只要有WiFi的地方，你就不會斷網！
    想象一下，程式員沒有WIFI會怎樣？ 程式員沒有網路肯定會寸步難行！ 但是對於Python程式員來說，只要附近有熱點，分分鐘就能蹭網成功！ 想要WIFI破解，python+字典，這是必少不了的。熱點加弱口令也是核心。字典自己加精，你的字典有強大，你能破解的WIFI就越多，提供兩種方法，一般人學到一種 ...
  • python判斷文件夾和文件是否存在
    1.os.path.exists()既可以判斷文件是否存在，又可以判斷文件夾是否存在 2.os.path.isfile()判斷文件是否存在 3.os.path.isdir()判斷文件夾是否存在 ...
  • 俠夢說pinpoint--左側服務地圖調用量和WasOn過濾
    前言 這篇文章主要是從pinpoint web界面入手，我們的目標是弄清楚兩個問題： 1、 pinpoint左側服務地圖上的調用量數據是怎麼查詢的？ 2、界面查詢條件WasOnly是什麼意思？ 左側服務地圖調用量來源 從下圖可以看出，A顯示被USER調用299次,線上數值代表著調用量。 我們F12跟 ...
一周排行
    -Advertisement-
    Play Games
  • C#TMS系統學習（BaseCity頁面）
    C#TMS系統代碼-基礎頁面BaseCity學習 本人純新手，剛進公司跟領導報道，我說我是java全棧，他問我會不會C#，我說大學學過，他說這個TMS系統就給你來管了。外包已經把代碼給我了，這幾天先把增刪改查的代碼背一下，說不定後面就要趕鴨子上架了 Service頁面 //using => impo ...
  • C# - 委托與事件
    委托與事件 委托 委托的定義 委托是C#中的一種類型，用於存儲對方法的引用。它允許將方法作為參數傳遞給其他方法，實現回調、事件處理和動態調用等功能。通俗來講，就是委托包含方法的記憶體地址，方法匹配與委托相同的簽名，因此通過使用正確的參數類型來調用方法。 委托的特性 引用方法：委托允許存儲對方法的引用， ...
  • 解析 ABP vNext 依賴註入實現【屬性註入】的原理
    前言 這幾天閑來沒事看看ABP vNext的文檔和源碼，關於關於依賴註入(屬性註入)這塊兒產生了興趣。 我們都知道。Volo.ABP 依賴註入容器使用了第三方組件Autofac實現的。有三種註入方式，構造函數註入和方法註入和屬性註入。 ABP的屬性註入原則參考如下： 這時候我就開始疑惑了，因為我知道 ...
  • C#TMS系統學習（ShippingNotice頁面）
    C#TMS系統代碼-業務頁面ShippingNotice學習 學一個業務頁面，ok，領導開完會就被裁掉了，很突然啊，他收拾東西的時候我還以為他要旅游提前請假了，還在尋思為什麼回家連自己買的幾箱飲料都要叫跑腿帶走，怕被偷嗎？還好我在他開會之前拿了兩瓶芬達 感覺感覺前面的BaseCity差不太多，這邊的 ...
  • C#動態查詢：巧用Expression組合多條件表達式
    概述：在C#中，通過`Expression`類、`AndAlso`和`OrElse`方法可組合兩個`Expression<Func<T, bool>>`，實現多條件動態查詢。通過創建表達式樹，可輕鬆構建複雜的查詢條件。 在C#中，可以使用AndAlso和OrElse方法組合兩個Expression< ...
  • 在Biwen.QuickApi中整合一個極簡的發佈訂閱(事件匯流排)
    閑來無聊在我的Biwen.QuickApi中實現一下極簡的事件匯流排,其實代碼還是蠻簡單的,對於初學者可能有些幫助 就貼出來,有什麼不足的地方也歡迎板磚交流~ 首先定義一個事件約定的空介面 public interface IEvent{} 然後定義事件訂閱者介面 public interface I ...
  • WPF 穩定的全屏化視窗方法
    1. 案例 成某三甲醫預約系統， 該項目在2024年初進行上線測試，在正常運行了兩天後，業務系統報錯：The connection pool has been exhausted, either raise MaxPoolSize (currently 800) or Timeout (curren ...
  • 在 WPF 中集成 ASP.NET Core 和 WebView2 用於集成 SPA 應用
    背景 我們有些工具在 Web 版中已經有了很好的實踐，而在 WPF 中重新開發也是一種費時費力的操作，那麼直接集成則是最省事省力的方法了。 思路解釋 為什麼要使用 WPF？莫問為什麼，老 C# 開發的堅持，另外因為 Windows 上已經裝了 Webview2/edge 整體打包比 electron ...
  • C#事件
    EDP是一套集組織架構，許可權框架【功能許可權，操作許可權，數據訪問許可權，WebApi許可權】，自動化日誌，動態Interface，WebApi管理等基礎功能於一體的，基於.net的企業應用開發框架。通過友好的編碼方式實現數據行、列許可權的管控。 ...
  • .Net8.0 Blazor Hybird 桌面端 (WPF/Winform) 發佈到 Win7+
    .Net8.0 Blazor Hybird 桌面端 (WPF/Winform) 實測可以完整運行在 win7sp1/win10/win11. 如果用其他工具打包,還可以運行在mac/linux下, 傳送門BlazorHybrid 發佈為無依賴包方式 安裝 WebView2Runtime 1.57 M ...
所有分類