重游Scala02
數(shù)組：
package com.henu.georgeimport scala.collection.mutable.ArrayBuffer/*** George* 定長數(shù)組和變長數(shù)組*/
object ArrayDemo {def main(args: Array[String]): Unit = {//初識化一個定長數(shù)組，其所有元素均為0val arr1 = new Array[Int](8)println(arr1)//調(diào)用mkString（“ ”）可以字符串輸出println(arr1.mkString(" "))//0 0 0 0 0 0 0 0//將數(shù)組轉換成數(shù)組緩沖，就可以看到原數(shù)組中的內(nèi)容了//toBuffer會將數(shù)組轉換長數(shù)組緩沖println(arr1.toBuffer)//ArrayBuffer(0, 0, 0, 0, 0, 0, 0, 0)for (elem <- arr1) {println(elem)}arr1(0) = 1println(arr1(0))//1//注意：如果沒有new，相當于調(diào)用了數(shù)組的apply方法，直接為數(shù)組賦值//初始化一個長度為1的定長數(shù)組，小括號中為數(shù)組的元素val arr2 = Array[Int](10)println(arr2.toBuffer)//ArrayBuffer(10)//定義一個長度為3的定長數(shù)組val arr3 = Array("George","love","who")println(arr3(1))//love//變長數(shù)組（數(shù)組緩沖）//如果想使用數(shù)組緩沖，需要導入import scala.collection.mutable.ArrayBuffer包//不使用new的時候，小括號中為元素，不是數(shù)組長度，小括號不能省略，里面可以不寫元素val arr01 = ArrayBuffer[Int]()//new的時候，小括號里面是元素個數(shù)，因為是變長數(shù)組，所以()可以省略val arr02 = new ArrayBuffer[Int]val arr03 = new ArrayBuffer[Int]()arr02+=1arr02+=(2,3,4,5,6)arr02++=Array(8,9)arr02++=ArrayBuffer(10)arr02.foreach(print)//1234568910//在數(shù)組某個位置插入元素用insert(位置，元素)//在下邊0之前插入元素println()arr02.insert(0,888)arr02.foreach(print)//8881234568910println()arr02.remove(7)arr02.foreach(print)//888123456910println()arr02.remove(6,2)arr02.foreach(print)//8881234510//遍歷數(shù)組val array = Array(1,2,3,4,5,6,7,8,9)for (elem <- array) {println(elem)}println("###################")//02468for (i <- 0 until(array.length,2)){print(i)//02468}for(i <- (0 until array.length).reverse)print(i)//876543210println("###################")array.foreach(print)//123456789println("*******************")val res = for (elem <- array) yield elem*2res.foreach(print)//24681012141618println()array.map(_ *3).foreach(print)//369121518212427println()val res2 = for (elem <- array if elem%2 == 0) yield elem * 10println(res2.toBuffer)//ArrayBuffer(20, 40, 60, 80)val res3 = array.filter(_ % 2 == 0).map(_ * 10)println(res3.toBuffer)//ArrayBuffer(20, 40, 60, 80)println(array.sum)println(array.max)println(array.min)println(array.sorted.toBuffer)/*** 45* 9* 1* ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9)*/}
}￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥
package com.henu.george/*** George* 元組，不能添加、刪除、修改。一旦創(chuàng)建，不會有變化。*/
object TupleDemo {def main(args: Array[String]): Unit = {//元組的創(chuàng)建val tuple1 = (1,2,3,"George")println(tuple1)//(1,2,3,George)//元組的創(chuàng)建最大能創(chuàng)建22個val tuple2 = Tuple3(1,2,3)println(tuple2)//(1,2,3)val a = (1,2,3,4,"George","never")println(a.productArity)//6println(a.productElement(4))//Georgeprintln(a._4)//4//元組的遍歷for (elem <- tuple1.productIterator) {print(elem)}println()tuple1.productIterator.foreach(print)println()/*** 4、將對偶的集合轉換成映射* 元組可以裝著多個不同類型的值。只有2個元素的元組稱為對偶。對偶是元組的一種形式。* 映射是K/V對偶的集合。*/val arrA = Array(("George",22),("Honey",20))println(arrA.toMap)//Map(George -> 22, Honey -> 20)/*** 拉鏈操作* zip命令可以將多個值綁定在一起* 注意：如果兩個數(shù)組的元素個數(shù)不一致，拉鏈操作后生成的數(shù)組的長度為較小的那個數(shù)組的元素個數(shù)*/val names = Array("George","Dage","GeorgeDage")val scores = Array(100,99,98)val ns = names.zip(scores)println(ns.toMap)//Map(George -> 100, Dage -> 99, GeorgeDage -> 98)}
}￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥
package com.henu.george/*** George* 集合* Scala的集合有三大類：序列Seq、集Set、映射Map，所有的集合都擴展自Iterable特質* 在Scala中集合有可變（mutable）和不可變（immutable）兩種類型，immutable類型的集合初始化后就不能改變了（注意與val修飾的變量進行區(qū)別）*/
object CollectionDemo {def main(args: Array[String]): Unit = {/*** 列表List* 不可變的序列 import scala.collection.immutable._* 在Scala中序列表要么為空（Nil表示空列表）要么是一個head元素加上一個tail列表。* 9 :: List(5, 2) :: 操作符是將給定的頭和尾創(chuàng)建一個新的列表* 注意：:: 操作符是右結合的，如9 :: 5 :: 2 :: Nil相當于 9 :: (5 :: (2 :: Nil))*///創(chuàng)建一個不可變的集合，長度不能改變，元素也不能改變val list1 = List(1,2,3)println(list1(0))//1val list2 = 0::list1list2.foreach(print)//0123println()val list3 = list1.::(0)list3.foreach(print)println()val list4 = 0+:list1val list5 = list1.+:(0)list5.foreach(print)//0123println()//將一個元素添加到lst1的后面產(chǎn)生一個新的集合val list6 = list1:+3val list7 = list1.:+("12")list7.foreach(print)//12312println()val newList1 = List(4,5,6)//將2 個list合并成一個新的Listval list8 = list1 ++ newList1list8.foreach(print)//123456println()val list9 = list1 ++: newList1list9.foreach(print)//123456println()//將newList1插入到list1的后面val list10 = list1.:::(newList1)list10.foreach(print)//456123println()val list11 = list1:::newList1list11.foreach(print)//123456}
}
￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥
package com.henu.georgeimport java.nio.charset.IllegalCharsetNameExceptionimport scala.collection.mutable.ListBufferobject MutListDemo {def main(args: Array[String]): Unit = {//構建一個可變列表，初始有3個元素1,2,3//小括號里面是元素，不是長度val list1 = ListBuffer[Int](1,2,3)//必須有括號，括號中可以不寫元素，沒有括號可以編譯通過，但運行報錯val list2 = ListBuffer[Int]()//必須有括號，括號中可以不寫元素，沒有括號可以編譯通過，但運行報錯val list3 = new ListBuffer[Int]val list4 = new ListBuffer[Int]()//取值，改變值list1(0) = 11println(list1(0))//向list1中追加元素，注意：沒有生成新的集合list1+=4list1.append(5)list1.append(6,7)for (elem <- list1) {print(elem + "%")} //11%2%3%4%5%6%7%println()val r1 = ListBuffer[Int](1,2,3,4)val r2 = ListBuffer[Int](5,6,7,8)//將lst0中的元素追加到lst1中， 注意：沒有生成新的集合r1 ++= r2r1.foreach(print) //12345678println()//將lst0和lst1合并成一個新的ListBuffer 注意：生成了一個集合val r3 = r1 ++ r2//將元素追加到lst1的后面生成一個新的集合val r4 = r1 :+ 5//將元素追加到lst1的前面生成一個新的集合val r5 = 5 +: r1val r6 = list1.+:(5)r6.foreach(print) //511234567println()val r7 = r1.map(print) //12345678println()println(list1.length)println(list1.size)val newRes = ListBuffer[Int](1,2,3,4,5)}
}￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥
/**
Scala中的集合對象都有foreach和map兩個方法。兩個方法的共同點在于：都是用于遍歷集合對象，
并對每一項執(zhí)行指定的方法。而兩者的差異在于：foreach無返回值（準確說返回Unit）,map返回集合對象。
運行結果：b.getClass 得到的是(), 而c.getClass得到的是colletion 。foreach和map的運行結果一致。
結論就是：foreach 無法代替map. 而map方法卻可以代替foreach。
*/
package com.henu.georgeimport scala.collection.{immutable, mutable}object arrayTest extends App {var increase = (x:Int) => x+1val someNumbers = List(-11,-10,-5,0,5,10)//b返回值為空var b: Unit = someNumbers.foreach(increase)//c返回集合對象var c: immutable.Seq[Int] = someNumbers.map(increase)println(c.getClass)c.foreach((x:Int) => print(x + " "))
}￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥
/**
集是不重復元素的結合。集不保留順序，默認是以哈希集實現(xiàn)。
如果想要按照已排序的順序來訪問集中的元素，可以使用SortedSet（已排序數(shù)據(jù)集），已排序的數(shù)據(jù)集是用紅黑樹實現(xiàn)的。
默認情況下，Scala 使用的是不可變集合，如果你想使用可變集合，需要引用 scala.collection.mutable.Set 包。
*/
object ImmutSetDemo extends App {val set = Set(1,2,3)println(set)//Set(1, 2, 3)//后面的括號可以省略val set1 = new HashSet[Int]val set2 = set1+4val set3 = set1 ++ Set(5,6,7)}
/**
Scala中的 Map 和 Java 類似，也是一個散列表，它存儲的內(nèi)容也是鍵值對 (kru-value) 映射。
Scala中，有可變 Map (scala.collection.mutable.Map) 和不可變 Map?(scala.collection.immutable.Map)。
Scala中不可變的 Map 是有序的，可變的Map 是無序的。
默認是immutable.Map，key-value 支持Any，在Map的底層，每對key-valye 是 Tuple2 。隊列數(shù)據(jù)存取符合先進先出策略在Java 里，null 是一個關鍵字，不是一個對象，所以對它調(diào)用任何方法都是非法的。
但是這對語言設計者來說是一件令人疑惑的選擇。為什么要在程序員希望返回一個對象的時候返回一個關鍵字呢？
為了讓所有東西都是對象，也為了遵循函數(shù)式編程的習慣，Scala鼓勵你在變量和函數(shù)返回值使用Option類型。在沒有值的時候，使用None，
這是Option的一個子類。如果有值可以引用，就使用Some來包含這個值。Some也是Option的子類。迭代器不是一種集合，而是遍歷集合的一個類。
迭代器 it 的兩個基本操作是 next 和 hasNext。
調(diào)用 it.next() 會返回迭代器的下一個元素，并且更新迭代器的狀態(tài)。
調(diào)用 it.hasNext() 用于檢測集合中是否還有元素。
*/
?
總結
- 上一篇： 拼多多的真实面试题：数亿的用户，如何用R
- 下一篇： 重游Scala03