ruby中数组的常用方法----例子

#初始化

a = Array.new
p a                                     #=>[]

a = Array.new(5)
p a                                     #=>[nil, nil, nil, nil, nil]

a = Array.new(5,0)
p a                                     #=>[0, 0, 0, 0, 0]

city = ["北京", "上海", "广州"]

p city                                  #=> ["北京", "上海", "广州"]

puts city                               #=>北京
                                        #=>上海
                                        #=>广州

city = Array.new
city[0] = "北京"
city[1] = "上海"
city[2] = "广州"
p city                                  #=> ["北京", "上海", "广州"]

city = %w(北京 上海 广州)
p city                                  #=> ["北京", "上海", "广州"]

#使用split函数进行分隔

city = '北京,上海,广州'.split(',')                 

p city                                            #=> ["北京", "上海", "广州"]

#使用%W{...}将字符串转换成数组

str = "深圳"
city_1 = %W{北京  上海  广州 #{str}}               

p city_1                                          #=>["北京", "上海", "广州", "深圳"]

#使用%w{...}进行转换

str = "深圳"
city_2 = %w{北京  上海  广州 #{str}}

p city_2                                          #=>["北京", "上海", "广州", "\#{str}"]

r = 1..5                                          # Range

#使用to_a、entries将范围类型数据转换成数组

p r.to_a                                          # Array， to_a等同于entries #=> [1, 2, 3, 4, 5]

p r.entries                                       #=> [1, 2, 3, 4, 5]

r = 'a'..'e'

p r.to_a                                          #=> ["a", "b", "c", "d", "e"]

#基本操作 

#数组的长度会按需要自动增加

city = Array.new

puts "数组的长度为：" + city.size.to_s             #0

city[2] = "香港"
puts "数组的长度为：" + city.size.to_s             #3

p city                                            #=> [nil, nil, "香港"]

city = ["北京", "上海", "广州", "深圳"]

#对一个元素赋值

city[4] = "香港"

#得到数组长度

puts "数组的长度为：" + city.size.to_s             #=> 数组的长度为：5

puts "数组的长度为：" + city.length.to_s           #5

puts "数组的长度为：" + city.count.to_s            #5

p city                                            #=> ["北京", "上海", "广州", "深圳", "香港"]

#获取某一元素

puts "第二个元素为：" + city[1]                    #上海

puts "倒数第二个元素为：" + city[-2]               #深圳

college = ["北京大学", "清华大学"]

college.unshift("浙江大学", "复旦大学")        #向数组头部添加元素列表

college.push("南京大学", "武汉大学")           #向数组尾部添加元素列表 

college << "南开大学"                          #向数组尾部添加一个元素

puts college.size.to_s                        #=> 7

p college                                     #=> ["浙江大学", "复旦大学", "北京大学", "清华大学", "南京大学", "武汉大学", "南开大学"]

#获取数组第一个元素，first(n),取前n个元素           

p college.first                               #=> "浙江大学"

p college.first(3)                            #=> ["浙江大学", "复旦大学", "北京大学"]

#获取数组最后一个元素，last(n),取后n个元素

p college.last                                #=> "南开大学"

p college.last(3)                             #=> ["南京大学", "武汉大学", "南开大学"]

puts college.shift                            #删除并获取数组第一个元素

puts college.pop                              #删除并获取数组最后一个元素，pop和push组合起来可以把一个Array直接当成Stack

puts college.size.to_s                        #=> 5

p college                                     #=> ["复旦大学", "北京大学", "清华大学", "南京大学", "武汉大学"]

p college[2,3]                                #截取从索引2开始，长度为3的元素列表

p college[2..3]                               #截取从索引2开始，到索引3的元素列表

p college[2...3]                              #截取从索引2开始，到索引3(不包括)的元素列表

city_1 = ["北京", "上海", "广州"]

city_2 = ["香港", "澳门"]

city_3 = city_1 + city_2

puts city_3.size.to_s                         #=> 5

city_1.concat(city_2)

puts city_1.size.to_s                         #=> 5

#两数组相连 +/concat

#a.concat(b)，连结，得到a中所有数据和b中所有数据组成的数组，并保存在a中，a变b不变

p ["北京", "上海", "广州"].concat(["广州", "香港", "澳门"])                    #=> ["北京", "上海", "广州", "广州", "香港", "澳门"]

#a + b，和集，得到a中所有数据和b中所有数据组成的数组，a、b均不变

p ["北京", "上海", "广州"] + ["广州", "香港", "澳门"]                          #=> ["北京", "上海", "广州", "广州", "香港", "澳门"]

#a - b，差集，得到由a中元素去除同时存在于a数组和b数组中的元素后剩余元素组成的数组

p ["北京", "上海", "广州"] - ["北京", "香港", "澳门"]                          #=> ["上海", "广州"]

#p&b，交集，取两个数组中都存在的元素，等于 a - (a - b)和b - (b - a)

p (["北京", "上海", "广州"] & ["北京", "香港", "澳门"])                        #=> ["北京"]

#a|b，并集，合并两个数组，并保证元素的唯一性，等于(a - b) + (b - a) + a&b

p (["北京", "上海", "上海", "广州"] | ["北京", "香港", "澳门"])                #=> ["北京", "上海", "广州", "香港", "澳门"]

#include?(obj)，判断数组元素中是否包含指定对象

citys = ["北京", "上海", "广州", "香港", "澳门"]
puts citys.include? "上海"                                      #=> true

#delete(X)，删除数组中所有与X相同的元素， 返回X

citys = ["北京", "上海", "广州", "北京", "香港", "澳门"]
p citys.delete("北京")                                          #=> "北京"

p citys                                                         #=> ["上海", "广州", "香港", "澳门"]

#delete_at(n)，删除第n个元素，返回被删除的元素对象

citys = ["北京", "上海", "广州", "北京", "香港", "澳门"]
p citys.delete_at(3)                                            #=> "北京"

p citys                                                         #=> ["北京", "上海", "广州", "香港", "澳门"]

#delete_if，删除满足条件的元素，返回处理后的原数组

abc = [ "a", "b", "b", "b", "c" ]
p abc.delete_if {|x| x >= "b" }                                 #=> ["a"]

#slice/each_slice/each_cons

#slice(m, n)返回原数组中下标为m到下标为n之间的元素组成的数组
#slice!(m, n)，同时改变原数组，从原数组中删除返回的元素

citys = ["北京", "上海", "广州", "香港", "澳门"]
p citys.slice(1, 3)                                             #=> ["上海", "广州", "香港"]
p citys                                                         #=> ["北京", "上海", "广州", "香港", "澳门"]
p citys.slice!(1, 3)                                            #=> ["上海", "广州", "香港"]
p citys                                                         #=> ["北京", "澳门"]

#each_slice，迭代取出间隔分割的数组，返回nil

citys = ["北京", "上海", "广州", "香港", "澳门"]
citys.each_slice(2){|city|
  p city
}
#=> ["北京", "上海"]
#=> ["广州", "香港"]
#=> ["澳门"]

#each_cons，迭代取出滑动分组的数组，返回nil

citys = ["北京", "上海", "广州", "香港", "澳门"]
citys.each_cons(2){|city|
  p city
}
#=> ["北京", "上海"]
#=> ["上海", "广州"]
#=> ["广州", "香港"]
#=> ["香港", "澳门"]

#insert(n, obj)，在某序列前插入元素对象，改变原数组

citys = ["北京", "上海", "广州", "香港", "澳门"]
p citys.insert(2, "2")                                          #=> ["北京", "上海", "2", "广州", "香港", "澳门"]
p citys                                                         #=> ["北京", "上海", "2", "广州", "香港", "澳门"]

#a[n..m]，选择改变数组

citys = ["北京", "上海", "广州", "香港", "澳门"]
citys[1..3] = [1, 2, 3]
p citys                                                         #=> ["北京", 1, 2, 3, "澳门"]

#Array.flatten，将数组中类型为数组的元素中的所有元素取出插入原数组中
#重复这个操作，直到原数组中所有的元素的数据类型均不为数组
#Array.flatten(n)，重复n次转变操作，结束后数组中元素仍可能为数组

nums = [[1, 2], [[2, 3], [3, 4]], 6]
p nums.flatten               #=> [1, 2, 2, 3, 3, 4, 6]

s = [ 1, 2, 3 ]           # [1, 2, 3]
t = [ 4, 5, 6, [7, 8] ]   # [4, 5, 6, [7, 8]]
a = [ s, t, 9, 10 ]       # [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
p a.flatten               #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

a = [ 1, 2, [3, [4, 5] ] ]
p a.flatten(1)              #=> [1, 2, 3, [4, 5]]
p a.flatten                 #=> [1, 2, 3, 4, 5]

#去重

nums = [1, 1, 2, 2, 3, 3]
p a.uniq                      #去除重复的元素，保证元素唯一   #=>[1, 2, 3]

#排序

arr = [9, 8, 7, 1, 2, 5, 3]
p arr.sort                    #=> [1, 2, 3, 5, 7, 8, 9]
p arr                         #=> [9, 8, 7, 1, 2, 5, 3]
p arr.sort!                   #=> [1, 2, 3, 5, 7, 8, 9]
p arr                         #=> [1, 2, 3, 5, 7, 8, 9]
p arr.sort{|a, b| b<=>a}      #=> [9, 8, 7, 5, 3, 2, 1]

wuwei = ['酸', '甘', '苦', '辛', '咸']

#min/min_by/max/max_by取最小/大值，均不改变原数组

#minmax/minmax_by，返回最小值、最大值组成的数组，均不改变原数组

puts wuwei.min                       #=> 咸

#取最大值

puts wuwei.max                       #=> 酸

puts wuwei.min_by{|v|                #=> 咸
  v = '0'
}

puts wuwei.max_by{|w|                #=> 酸
  w = '1'
}

p wuwei                              #=> ["酸", "甘", "苦", "辛", "咸"]

p wuwei.minmax                       #=> ["咸", "酸"]

p wuwei.minmax_by{|w|                #=> ["咸", "酸"]
  w
}

#shuffle，打乱元素顺序， 随机变化（ 洗牌）

nums = [ 1, 2, 3 ]
p nums.shuffle                     #=> [2, 3, 1]
p nums.shuffle                     #=> [3, 2, 1]
p nums.shuffle                     #=> [1, 3, 2]
p nums.shuffle                     #=> [1, 3, 2]

#遍历

#each/each_with_index/cycle/cycle(n)

#each/each()依次取出每一个元素，每次取出的一个元素可以被

#跟随的块函数接收，返回原数组；each_with_index/each_with_index()得到

#元素的同时还得到当前元素在数组中的序列值，返回原数组

#cycle，除非遇到break、return、exit等语句，否则无限循环数组，返回nil

#cycle(n)，除非遇到break、return、exit等语句，否则循环数组n次，返回nil

nums = [1, 2, 3]
b = nums.each{|value| p value}   #=>1
                                 #=>2
                                 #=>3
puts b                           #=> [1, 2, 3]

nums.each_with_index do |value, index|
  puts "#{index}  :  #{value}"
  puts ( value + index ).to_s
end
                               #=>0  :  1
                               #=>1
                               #=>1  :  2
                               #=>3
                               #=>2  :  3
                               #=>5

abc = ('a'..'c').to_a
#abc.cycle {|x| puts x }          # a, b, c, a, b, c,.. forever.

abc.cycle(2) {|x| puts x }       # a, b, c, a, b, c.

#reduce,别名inject，迭代累加/减，不改变原数组

#inject理解的难点在于block中的两个参数

#sum是上一次block的返回值，默认初始化为0或nil

#可以传入初始值c

#value是当前的元素对象

arry = (1..3).to_a
n = arry.reduce(:+)
puts n                         #=>6

n = arry.reduce(:-)
puts n                         #=>-4

#带有初始值的累加
c = 10
n = arry.reduce(c) do |sum, value|
  p sum
  sum + value
end
puts n
                                #=>10
                                #=>11
                                #=>13
                                #=>16

puts n = arry.inject(:+)        #=> 6

abc = ('a'..'c').to_a

puts abc.inject(:+)        #=> abc

puts abc.inject('A') {|sum, value| sum + value }      #=> Aabc      

#join 返回由数组中各元素连结成的一个字符串，原数组不变

abc = ['a', 'b', 'c']

p abc.join                     #=> "abc"

p abc.join('-')                #=> "a-b-c"

p abc                          #=> ["a", "b", "c"]

#map, 别名collect，处理数组中的每一个元素并放入新数组中，返回新数组

#map!、collect!将同时改变原数组

arry = %w(a b cD)
p arry                          #=> ["a", "b", "cD"]
s1 = arry.reduce(:+)
s2 = arry.map(&:upcase)
s3 = arry.map do |item|
  item.upcase
end
p arry
p s1
p s2
p s3
                                #=>["a", "b", "cD"]
                                #=>"abcD"
                                #=>["A", "B", "CD"]
                                #=>["A", "B", "CD"]

#find/find_all/select

# find到一个即返回，别名detect

rs = (1..8).to_a.find {|i|
  i % 2 == 0 and i % 4 == 0
}
p rs                            #=> 4

# find_all找到全部符合条件的对象，别名select

rs = (1..8).to_a.find_all {|i|
  i % 2 == 0 and i % 4 == 0
}
p rs                            #=> [4, 8]

# select，找到全部符合条件的对象，别名find_all

arry = (1..8).to_a
arrySelect = arry.select { |x|
  x % 2 == 0
}
puts arrySelect.to_s            #=> [2, 4, 6, 8]

#take(n)/take_while/drop(n)/drop_while

#取前n个元素/取满足条件的元素/取除去前n个元素剩余的元素/取除去满足条件的元素剩余的元素

#返回这些元素组成的数组，不改变原数组

a = ["北京", "上海", "广州", "香港", "澳门"]

p b = a.take(2)                             #=> ["北京", "上海"]

p a                                         #=> ["北京", "上海", "广州", "香港", "澳门"]

p b = a.drop(2)                             #=> ["广州", "香港", "澳门"]

b = a.take_while{|value|
  value == '北京'
}

p b                                         #=> ["北京"]

b = a.drop_while{|value|
  value == '北京'
}

p b                                         #=> ["上海", "广州", "香港", "澳门"]

# reject，迭代数组元素，从原数组中删除符合条件的元素对象，改变原数组，返回处理后的数组

arry = (1..8).to_a
arryReject = arry.reject { |x| x % 2 == 0 }
puts arryReject.to_s            #=> [1, 3, 5, 7]

#根据条件分组，分组后得到哈希表

arry = (1..8).to_a
arryGroupBy = arry.group_by{ |x| x % 2 == 0 }
puts arryGroupBy                #=> {false=>[1, 3, 5, 7], true=>[2, 4, 6, 8]}

puts arryGroupBy.class          #=> Hash

value = arryGroupBy[false]
p value                         #=> [1, 3, 5, 7]

puts value.class                #=> Array

arryGroupBy = arry.group_by{ |x| 2 }
puts arryGroupBy                #=> {2=>[1, 2, 3, 4, 5, 6, 7, 8]}

value = arryGroupBy[2]
p value                         #=> [1, 2, 3, 4, 5, 6, 7, 8]

puts value.class                #=>Array

#zip(Array,...)，遍历数组，对每个元素，从各个数组参数中取出与其序列相同的元素，组成新的

#数组作为代码块的传入参数，返回nil

a = [1, 4, 7]
b = [2, 5, 8]
c = [3, 6, 9]
d = a.zip(b, c){|e|
  p e
  e
}
p d
#=> [1, 2, 3]
#=> [4, 5, 6]
#=> [7, 8, 9]
#=> nil

#to_enum，转变成枚举类型，这样可以使用next

#不改变原数组，返回生成的枚举对象

p f = a.to_enum                             #=> #<Enumerator: [1, 4, 7]:each>

p a                                         #=> [1, 4, 7]

p f.next                                    #=> 1

p f.next                                    #=> 4

#all?/any?/none?/one?
#迭代取出元素并代入代码块，代码块均返回真？/
#迭代取出元素并代入代码块，代码块至少有一次返回真？/
#迭代取出元素并代入代码块，代码块均不返回真？/
#迭代取出元素并代入代码块，代码块有且仅有一次返回真？
#返回真或假，原数组内容不变

wuxing = ['金', '木', '水', '火', '土']

puts wuxing.all?{|value|                         #=> false
  value == '木'
}

puts wuxing.any?{|value|                         #=> true
  value == '木'
}

puts wuxing.all?{|value|                         #=> true
  value = '木'
}

p wuxing                                         #=> ["金", "木", "水", "火", "土"]

　　以上是根据个人的理解总结的一些方法，有理解不到位或错误的地方还请大家指正。