==Scala中集合Array的方法: ==
1、可以在电脑的DOS窗口输入：scala
2、创建一个数据组：var arr01=Array.range(1,10)
3、输入：arr02.
4、点击Tab键
首先声明四个测试数据：
第一个：
var arr01 = Array(1,2,3,4,5,6,7,8,9)
等同于：
var arr02:Array[Int]=Array(1,2,3,4,5,6,7,8,9)
等同于：
var arr03=Array.range(1,10)
第二个：
var arr04=Array(2,4,6,"abc")
第三个：
var a = Array(4, 9, 7, 32, 7, 5, 3, 1, 2, 6)
第四个：
var b = Array(1, 2, 3, 4, 5, 6, 7)
var c=Array(1,2,3,4)
1、函数名：== 或者 !=（面向引用类型或者值类型的区别）
面向引用类型时：==和equals以及!=都是比较地址
解释：比较两个数组的地址是否相同
例 ：scala> arr01==arr02
res0: Boolean = false
scala> arr01.equals(arr02)
res1: Boolean = false
scala> arr01!=arr02
res2: Boolean = true
面向基本值类型：== , != , equals都是比较两个值是否相等
scala> 1==1
res0: Boolean = true
scala> 1!=1
res1: Boolean = false
scala> 1.equals(1)
res2: Boolean = true
注：可以自定义一个方法来比较两个引用类型的值
在IDEA中写方法：
步骤：
导包：import scala.util.control.Breaks._(为了实现循环的中断)
import scala.util.control.Breaks._
object Test {
def main(args: Array[String]): Unit = {
def same(a1: Array[Int], a2: Array[Int]): Boolean = {
var same: Boolean = true
if (a1.size != a2.size) {
same = false
} else {
breakable {
for (i <- 0 until a1.size) {
if (a1(i) != a2(i)) {
same = false
break()
}
}
}
}
same
}
var arr01=Array.range(1,5)
var arr02=Array.range(1,5)
println(same(arr01,arr02))
}
}
对于集合元素
新增集合(元素)
+：
T +: arr 在数组前添加T,(单个元素或者把集和当作一个整体添加Array[Any] = Array(Array(1, 2, 3), a, b, c))
:+
arr:+T 在集合后添加元素，同+：
++:
合并集合，右边集合种类决定返回的集合种类
++
:Array(Any) （：后为返回值类型，下同）
A++B,合并A,B两个集合，可以不同类型
scala> arr01++arr02
res4: Array[Any] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 2, 4, 6, abc)
union(B)
合并两个集合，同++类型可不同
diff(b):Array[T]
取两个集合的差集,返回a中b不存在的元素
interstect(b):Array[T]
取两个集合的交集，a和b中都存在的元素
combinations(n:Int)
任选集合中的n个元素进行组合（返回一个迭代器）
padTo(len:Int,elem:T)
用指定元素填充为指定长度的新数组
clone
创建一个数组的副本，赋值数组的值，不会赋值地址，浅克隆
copyToArray(b):Unit
将当前的集合复制到b集合中，无返回值
copyToArray(b,start)
将集合拷贝到另一个数组中，从start开始
copyToArray(b,start,Len)
将集合元素从0开始拷贝到参数1数组从start开始长度为Lend 的数组中
copyToBuffer(Buffer[B])
将数组中的元素复制到Buffer中
seq:IndexedSeq[T]
产生一个引用当前序列的sequential视图，就是一个特殊的集合
删
distinct()
去除当前集合的重复元素
drop(n:Int)
删除数组前n个元素，返回新数组
dropRight(n:Int)
删除尾部的n个元素
dropWhile(B)
删除满足条件的的元素，返回剩余的数组，如果遇到不满足的元素，则不在继续寻找后面元素
init
去尾，返回当前序列不包含最后一个元素的序列
inits Iterator
重复init,对每次init生成的集合进行init,于tails类似
tail
去头，返回当前序列不包含第一个元素的序列，
tails:Iterator
重复执行tails,对生成的新的序列进行去头，
scala> c.tails.toArray
res32: Array[Array[Int]] = Array(Array(1, 2, 3, 4), Array(2, 3, 4), Array(3, 4), Array(4), Array())
改（操作）
patch(from:Int,that,n:Int)
批量替换，从from开始后的n个元素组成的序列替换为that
permutations ： Iterator
排列组合，考虑顺序，不能指定个数，
transform(x=>Int):WrappedArray[Int]
讲集合中的元素转换成指定的元素（同类型）
scala> var a=Array(1,2,3)
scala> a.transform(x=>7)
scala.collection.mutable.WrappedArray[Int] = WrappedArray(7, 7, 7)
updat(i:Int,x:Int):Unit
将集合中i位置的元素更新为x（同类型）修改原数组
updated(index:Int,elem:A) :Array[A]
将集合中i位置的元素更新为x（任意类型） ,并返回更新后的数组
reverse:Array[T]
反转序列
reverseIterator:Iterator[T]
生成反向迭代器
reverseMap(P) :Array[B]
同map,方向相反
flatMap(P) :Array[B]
先map后降维，对当前序列的每一个元素操作，结果放到新序列返回
flatten:Array[T]
扁平化，将二维数组变为一维数组
transpose:Array[Array[b]]
矩阵转置，二维数组行列转换
unzip:(Array[T],Arrat[T])
将含有两个二元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，返回这两个数组的元组
unzip3:(Array[T],Array[T],Array[T])
将含有三个三元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，第三个元素组成一个数组，返回这三个数组的元组
zip(B)
拉链操作，将两个序列对应位置上的元素组成一个元组数组，要求两个序列长度相同
zipAll(b,elem1,elem3)
同zip,但是两个序列长度可以不同，当前序列短，同elem1代替，如果b短，用elem2填充
zipWithIndex:Array[(A,Int)]
将序列中每个元素和其索引组成一个数组
元素查询
head
返回序列第一个元素，
headOption
返回序列的第一个元素的Option类型对象（Option(第一个元素)）,
last
返回序列最后一个元素
lastOption
返回序列最后一个元素的Option类型对象（Option(第一个元素)）
take(n:Int)
返回序列中前n个元素组成的序列
takeRight(n:Int)
返回序列中从右边开始n个元素组成的序列（后n个）
takeWhile(B)
返回从第一个满足条件的连续的元素组成的序列（遇到第一个不满足则不在继续查找）
max
返回序列中的最大元素
min
返回序列中的最小元素
maxBy(条件)
返回满足条件的第一个元素
minBy(条件)
返回不符合条件的第一个值
filter(偏函数)；Array[T]
找出满足条件的元素，组成新的集合并返回
fileterNot(偏函数)：Array[T]
找出不满足的
withFilter(偏函数)：FilterMonadic[T,Array[T]]
选出符合条件的元素，不返回集合，想要输出调用foreach
find(偏函数) :Option[T]
查找第一个符合条件的元素，返回Option
下标查询
apply(Index:Int):T
获取序列指定索引处元素
applyOrElse(index，{x:Int=>default value})
根据下标取元素，如果越界，返回默认值,第二个参数为偏函数
charAt(index:Index)
获取指定位置的字符，针对char类型
indexOf(elem:T):Int
获取元素elem第一次出现的索引
indexOf(elem:T,start:Int) :Int
从指定位置start开始查找元素elem第一次出现的索引
indexOfSlice(List):Int
查找序列是否包含序列，并返回第一次出现该序列的索引，找不到但会-1
indexOfSlice(List,start:Int):Int
从指定位置start开始查找是否存在序列list,返回第一个出现的索引，没有返回-1
indexWhere(条件) :Int
返回当前序列中第一个满足条件的元素的索引
indexWhere(条件,start:Int):Int
从指定位置开始查找满足条件的第一个元素的索引
indices
返回当前序列的索引,返回的是Range
scala> arr01.indices
scala.collection.immutable.Range = Range 0 until 10
scala> aarr01.indices.toArray
Array[Int] = Array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
lastIndexOf(elem):Int
返回元素最后一次出现的索引位置
lastIndexOf(elem,end:Int)
在指定位置end之前（包括）查找第一次出现的该元素的索引
lastIndexOfSlice(List)
查找序列是否包含序列，并返回最后一次出现该序列的索引，找不到但会-1
lastIndexOfSlice(List，end:Int)
从指定位置end之前查找是否存在序列list,返回第一个出现的索引，没有返回-1
lastIndexWhere(条件/偏函数) :Int
返回当前序列满足条件的元素的最后一个索引
lastIndexWhere(条件/偏函数，end:Int) :Int
在指定位置end之前返回当前序列满足条件的元素的最后一个索引
slice(fromIndex:Int,untilIndex:Int)
返回序列中从from到until之间的序列,不包括untilIndex位置
subSequence(fromIndex:Int,untilIndex:Int)
返回从from到until间的字符序列,不包括untilIndex位置 针对char类型
view(from:Int,until:Int):IndexedSeqView
索引序列返回当前序列从from开始到until之间的序列，不包括until
长度查询
count(偏函数)
统计满足条件的元素个数
scala> a.count(x=>x%2==0)
res61: Int = 4
length：Int
返回数组元素个数
lengthCompare(len:Int):Int
返回数组长度与指定长度的差值
prefixLength(B)
从第一个索引开始，返回满足条件B的元素数量，直到遇到不满足结束
segmentLength(p,fromIndex) ：Int
返回一个从fromInedx开始满足条件p的元素数量
scala> a.segmentLength(x=>x>3,3)
res93: Int = 3
size:Int
返回序列元素个数
方法作为参数
aggregate(初值)(方法1))(方法2)
聚合计算，柯里化方法，参数是两个方法
arr.aggregate(初值)(mapCal)(reduceCal)
map端聚合，mapCal生效，reduceCal失效
arr.partitionaggregate(初值)(mapCal(reduceCal)
par产生分区，mapCal->reduceCal
f1_ andThen f2_
f1 和 f2只有 一个参数，且类型相同先执行第一个函数，将第一个函数结果作为第二个函数的参数
①：val add=(x:Int)=>{x+10}
②：val mul=(x:Int)=>{x*11}
③：def mat=add andThen mul
f1 compose f2
与andThen相反，先执行f2
collet[First](fun):Array[B]
通过执行一个并行计算（偏函数），得到一个新的数组对象 [First]返回新数组对象的第一个值
scala> a.collect({case i if(i%2==0)=>i}).foreach(println)
4 32 2 6
scala> a.collectFirst({case i if(i%2==0)=>i}).foreach(println)
4
foreach(fun)
遍历集合中的元素
iterator
生成当前序列的迭代器
map(F)
对集合的元素进行F操作，返回生成的新的集合
runwith(F)
以第二个参数作为下标提取元素，作为第一个函数的入口，
①：下标存在，且满足函数规则，返回true,
②：下标存在，但是不满足函数，报异常，
③：下标不存在返回false
scala> a.runWith(x=>x match{case x if(x%2==0)=>x})(8)
res54: Boolean = true (8)代表集合下标
分组排序
groupBy(F):Map[k.Array[T]]
按指定的F条件分组,返回Map,一个k对应一个Array
grouped(size:Int) :lterator[Array[T]]
按指定数量分组，每组size个元素，返回迭代器
par mutable.ParArray[Int]
返回一个并行实现，产生的并行序列不能被修改 ,作用相当于hashcode分区
scala> a.par
res37: scala.collection.parallel.mutable.ParArray[Int] = ParArray(4, 9, 7, 32, 7, 5, 3, 1, 2, 6)
partition(p) ：Array(Array[T],Array[T])
将满足条件P 的元素放在第一个数组，不满足放在第二个，返回的是包含这两个数组的元组
span(P):(Array[T],Array[T])
将序列拆分成两个数组，从第一个位置开始，满足条件P就放到第一个数组，直到遇到第一个不满足条件的为止，后面所有的都放到第二个，返回的是元组
splitAt(Index:Int) :(Array[T],Array[t])
从指定位置处将序列分成两个数组，index之前放入第一个，index处以及其余放第二个
sliding(size:Int);Iterator[Array[T]]:Iterator
从第一个元素开始，每个元素和他后面的元素组成一个size长度的新数组，当剩余的元素个数不够size是结束
sliding(size:Int,step:Int):Iterator
第一个元素同上，第二次匹配时从上一次第一个元素后step个开始取元素
scala> var b = Array(1, 2, 3, 4, 5, 6, 7)
scala> b.sliding(2,3).toArray
res71: Array[Array[Int]] = Array(Array(1, 2), Array(4, 5), Array(7))
sorted;Array[T]
使用默认的规则对序列进行排序，默认为升序
sortBy(规则) :Array[T]
按指定的排序规则对序列排序
sortWith(_compareTo_):Array[T]
自定义排序方法
条件判断
contains[T] :Boolean
判断集合中是否包含指定元素T
containsSlice(Array) :Boolean
判断集合中是包含一个集合，对应下标下的元素是否相同，有一个不同就为false
canEqual(that:Any) :Boolean
判断两个集合是否可以进行比较，集合都可以比较
corresponds(B):Boolean
判断两个集合的长度以及对应位置元素是否符合条件
endsWith(Array)
判断集合是否以集合Array结尾，有一个不满足就为false
a = Array(4, 9, 7, 32, 7, 5, 3, 1, 2, 6)
scala> a.endsWith(Array(3,2,6))
res64: Boolean = false
sameElements(b):Boolean
判断两个序列长以及对应索引的元素是否相同
startsWith(Array)
判断集合是否以集合Array开头，有一个不满足就为false
exists(偏函数)：Boolean
判断集合是否包含符合偏函数的元素，只要存在就为true,
forall(偏函数):Boolean
判断集合是否全都满足偏函数(条件)，有一个不满足就为false,序列为空也是true
hasDefiniteSize
判断序列是否存在有限长度，对应Stream这样的流数据，返回false :Boolean
isDefindAt(index:Int):Boolean
判断序列是否存在指定索
isEmpty:Boolean
判断序列是否为空
nonEmpty:Boolean
判断是否不为空
isTraversableAgain:Boolean
判断是否可以反复遍历。迭代器只能遍历一次
字符串相关
addString
addString(b:StringBuffer):StringBuilderr
将数组中的元素逐个添加到StringBuilder中，返回StringBuilder
scala> var b=new StringBuilder
c: StringBuilder =
scala> a.addString(b,"-")
res26: StringBuilder = 49732753126
addSring(b,seq)将数组中的元素逐个添加到StringBuilder中，并用seq分隔符分开，
scala> var c=new StringBuilder
c: StringBuilder =
scala> a.addString(c,"-")
res26: StringBuilder = 4-9-7-32-7-5-3-1-2-6
addString(b,start,seq,end)
将集合中的元素放到StringBuilder中，在首位各添加一个分隔符，并指定中间的分隔符
mkString
A.mkSting:String
将集合中所有元素拼接成一个字符串
mkString(seq)
将集合中的元素用分隔符seq拼接为字符串
mkString(start,seq,end)
在首尾添加分隔符，以seq分隔符连接生成字符串
stringPrefix
返回toString结果的前缀
scala> a.toString
res31: String = [I@7780a93c
scala> a.stringPrefix
res32: String = [I
对集合指定计算
/: (初值/:a)(_运算符_):Int
指定一个初值，从左开始，对数组进行指定的运算符计算
:\ (a:\初值)(_运算符_):Int
指定一个初值，从右开始对数组进行指定运算符计算
fold(初值)(_运算符_):Int
同/:
foldLeft(初值)(_运算符_) ：Int
同fold
foldRight(初值)(_运算符_):Int
同:\ 从右计算
product
返回所有元素的乘积
reduce(_运算符_) :T
从左计算，不需要初始值
reduceLeft(_运算符_):T
从左开始计算 不需要初始值
reduceLeftOption(_运算符_):Option
同reduceLeft,返回Option
reduceOption(_运算符_):Option
同redeceLeftOption
reduceRight(_运算符_):T
从右开始计算，不需要初始值 ，
reduceRigthOption(_运算符_)：Option
从右计算， 返回Option
scan(初值)(_运算符_)：Array[T]
同fold，从左开始计算，但是scan会把每一步计算的结果放在一个新的集合中并返回， 集合第一个元素为初值
scanLeft(初值)(_运算符_)：Array[T]
同foldLeft 从左计算，返回每一步得到的记过组成的新的集合。
scanRight(初值)(_运算符_):Array[T]
同foldRight ,从右开始u计算，返回每一步结果组成的新的集合
sum:Int
集合求和，元素类型为Numeic[T]类型
类型转换
toBuffer
toIndexedSeq
toIterator
toIterable
toList
toMap
toSeq
toStream
toVector
595
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
