ruby之旅之数组

72 阅读 0 评论 48 点赞

我是靠谱客的博主拼搏小熊猫，最近开发中收集的这篇文章主要介绍ruby之旅之数组，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

数组：

①Ruby 数组可存储诸如 String、 Integer、 Fixnum、 Hash、 Symbol 等对象，甚至可以是其他 Array 对象。
②Ruby 数组不需要指定大小，当向数组添加元素时，Ruby 数组会自动增长

1.数组的创建

(1.1)通过 Array.new 创建
①创建一个不指定大小的空数组
arr = Array.new
②创建一个指定大小的空数组
arr = Array.new(20)
③创建数组的同时给每个数组元素赋值
【case1】只能初始化n个相同的值

代码如下：
	city_name = Array.new(4,"北京") 
	p "#{city_name}"
输出结果：
	["北京", "北京", "北京", "北京"]

【case2】使用带有 new 的块，每个元素使用块中的计算结果来填充

代码如下：
	nums = Array.new(10){|i| i=(i+1)*2}
	puts  "#{nums}"
输出结果：
	[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

(1.2)通过Array.[] 创建

代码如下：
	city_name = Array.[]("北京","上海","广州","深圳")
	puts "#{city_name}"
输出结果：
	["北京", "上海", "广州", "深圳"]

(1.3)通过Array[] 创建
代码如下：
names = Array[“Peking University”,“Tsinghua University”,“Sun Yat-sen University”]
puts names
输出结果：
[“Peking University”, “Tsinghua University”, “Sun Yat-sen University”]
(1.4)通过*() 创建【注】通过此方法创建括号内必须是个范围

代码如下：
	words = *("aaa".."aah")
	puts "#{words}"
输出结果：
	["aaa", "aab", "aac", "aad", "aae", "aaf", "aag", "aah"]

(1.5)通过[] 创建【推荐使用】

代码如下：
	traffic_tool = ["airplane","train","bus"]
	puts "#{traffic_tool}"
输出结果：
	["airplane", "train", "bus"]

(1.6)通过%w创建一个数组

代码如下：
	arr_1 = %w {bgp isis ospf}
	p arr_1
输出结果：
	["bgp", "isis", "ospf"]

2.数组的【增】

(2.1)array + other_array 返回一个新的数组，新数组通过连接两个数组产生第三个数组创建的。

代码如下：
	tiangan_1 = ["甲","乙","丙、","丁","戊"]
	tiangan_2 = ["己","庚","辛","壬（rén）","癸（guǐ）"]
	all_tiangan = tiangan_1+tiangan_2
	p all_tiangan
输出结果：
	["甲", "乙", "丙、", "丁", "戊", "己", "庚", "辛", "壬（rén）", "癸（guǐ）"]

(2.2)array << obj 把给定的对象附加到数组的末尾。该表达式返回数组本身，所以几个附加可以连在一起。

代码如下：
	arr_1 = ["可叹停机德","堪怜咏絮才","玉带林中挂"]
	obj_1 = ["玉带林中挂","金簪雪里埋"]
	arr_1 << obj_1
	p arr_1
输出结果：
	["可叹停机德", "堪怜咏絮才", "玉带林中挂", ["玉带林中挂", "金簪雪里埋"]]

(2.3)array.concat(other_array)
追加 other_array 中的元素到 self 中

代码如下：
	arr_1 = %w{才自精明志自高 生于末世运偏消}
	arr_2 = %w{清明涕泣江边望 千里东风一梦遥}
	p arr_1.concat(arr_2)
输出结果：
	["才自精明志自高", "生于末世运偏消", "清明涕泣江边望", "千里东风一梦遥"]

(2.4)array.push(obj, …)
把给定的 obj 附加到数组的末尾。该表达式返回数组本身，所以几个附加可以连在一起

代码如下：
	arr01 = %w{一而十 十而百}
	obj01 = "百而千"
	obj02 = "千而万"
	arr01.push(obj01,obj02)
	p arr01
输出结果：
	["一而十", "十而百", "百而千", "千而万"]

3.数组的【删】

(3.1)array - other_array 返回一个新的数组，新数组是从初始数组中移除了在 other_array 中出现元素。

代码如下：
	arr_1 = ["toe","foot","shank","thigh","pea","banana"]
	arr_2 = ["pea","banana","orange"]
	p arr_1-arr_2
输出结果：
	["toe", "foot", "shank", "thigh"]

(3.2)array | other_array 通过把 other_array 加入 array 中，移除重复项，返回一个新的数组【去重】。

代码如下：
	arr_1 = ["10","20","30","20","40"]
	arr_2 = ["30","60","50"]
	arr_3 = arr_1 | arr_2
	p arr_3
输出结果：
	["10", "20", "30", "40", "60", "50"]

(3.3)array.clear
从数组中移除所有的元素

 代码如下：
	arr_1 = %w{二十年来辨是非 榴花开处照宫闱 三春争及初春景 虎兕相逢大梦归}
	len_1 = arr_1.length
	p "未做clear之前数组的长度#{len_1}"
	arr_1.clear
	len_2 = arr_1.length
	p "做完clear之后数组的长度#{len_2}"
 输出结果：
	"未做clear之前数组的长度4"
	"做完clear之后数组的长度0"

(3.4)array.delete(obj)
array.delete(obj) { block }
从 self 中删除等于 obj 的项。如果未找到相等项，则返回 nil。如果未找到相等项且给出了可选的代码 block，则返回 block 的结果。

 代码如下：
	arr_1 = %w{10.1.1.1 10.1.2.1 10.1.2.4}
	arr_2 = %w{10.1.1.1 10.1.2.1 10.1.2.4}
	str_3 = "10.1.1.1"
	str_4 = "10.1.5.1"
	p arr_1.delete(str_3),arr_1
	p arr_2.delete(str_4)
	p arr_2.delete(str_4){"10.1.5.1删除成功"}
	
 输出结果：
	"10.1.1.1"
	["10.1.2.1", "10.1.2.4"]
	nil
	"10.1.5.1删除成功"

(3.5)array.delete_at(index)
删除指定的 index 处的元素，并返回该元素。如果 index 超出范围，则返回 nil

 代码如下：
	arr_1 = %w{富贵又何为 襁褓之间父母违 展眼吊斜辉 湘江水逝楚云飞}
	p arr_1.delete_at(1),arr_1.delete_at(4)
 输出结果：
	"襁褓之间父母违"
	nil

(3.6)array.delete_if { |item| block }
当 block 为 true 时，删除 self 的每个元素
array.reject { |item| block }
返回一个新的数组，包含当 block 不为 true 时的数组项。
array.reject! { |item| block }
当 block 为真时，从 array 删除元素，如果没有变化则返回 nil。相当于 Array#delete_if

代码如下：
	arr_1,arr_2 = %w{欲洁何曾洁 云空未必空},%w{可怜金玉质 终陷淖泥中 王熙凤}
	arr_3,arr_4 = %w{三纲者 君臣义 父子亲 夫妇顺},%w{曰春夏 曰秋冬 此四时 运不穷}
	arr_1.delete_if{arr_1.length <=2}
	arr_2.delete_if{arr_2.length >5}
	p arr_1,arr_2
	p arr_3.reject{|ele| ele=~/三/}
	p arr_3.reject{|ele| ele.length<=3}
	p arr_4.reject!{|ele| ele=~/秋/}
	p arr_4.reject!{|ele| ele=~/三/}	
输出结果：
	[]
	["可怜金玉质", "终陷淖泥中", "王熙凤"]
	["君臣义", "父子亲", "夫妇顺"]
	[]
	["曰春夏", "此四时", "运不穷"]
	nil

(3.7)array.pop
从 array 中移除最后一个元素，并返回该元素。如果 array 为空则返回 nil

代码如下：
	arr = %w{首孝悌 次见闻 知某数 识某文}
	p arr.pop
	p arr
输出结果：
	"识某文"
	["首孝悌", "次见闻", "知某数"]

4.数组的【改】

(4.1)array & other_array 返回一个新的数组，包含两个数组中共同的元素，没有重复【去重】。

代码如下：
	part_dizhi = ["子","丑","寅","卯","辰"]
	all_dizhi = ["子","丑","寅","卯","辰","巳","午","未","申","酉（yǒu）","戌","亥"]
	comm_dizhi = part_dizhi &all_dizhi
	p comm_dizhi
输出结果：
	["子", "丑", "寅", "卯", "辰"]

(4.2)arrayint arraystr
①array * int 将原数组的所有元素复制int次，放入到新数组中返回
代码如下：
shengxiao = [“子鼠”,“丑牛”,“寅虎”,“卯兔”]
new_s_x = shengxiao*2
p new_s_x
输出结果：
[“子鼠”, “丑牛”, “寅虎”, “卯兔”, “子鼠”, “丑牛”, “寅虎”, “卯兔”]
(4.3)array.abbrev(pattern = nil)
为self中的字符串计算明确的缩写集合。如果传递一个模式或一个字符串，只考虑当字符串匹配模式或者以该字符串开始时的情况，其结果集是个hash

代码如下：
	require 'Abbrev.rb'
	p %w{cat bg mj}.abbrev("b")

输出结果：
	{"bg"=>"bg", "b"=>"bg"}

②array * str 在原数组的每个元素后面加入str的内容，以字符串的形式返回。

代码如下：
	address = ["江苏省","南京市","雨花台区","软件谷"]
	separator = "|"
	new_addr = address*separator
	p new_addr
输出结果：
	"江苏省|南京市|雨花台区|软件谷"

(4.3)替换数组中的元素
①array[index] = obj 若index小于原数组的长度,则替换原数组对应索引处的元素为obj;若index等于原数组的长度,则等效于给原数组末尾添加元素;若index大于原数组的长度，则将原数组变为长度为index+1的数组，其中索引从原数组.length处到index-1处的元素为nil,索引为index的元素为obj.

代码如下：
		class Replace_elem
			def replace_1(str)
				arr = ["甲子","乙丑","丙寅","丁卯"]
				arr[1]= str
				p arr
			end
			def replace_2(str)
				arr = ["甲子","乙丑","丙寅","丁卯"]
				arr[-1]= str
				p arr
			end
			def replace_3(str)
				arr = ["甲子","乙丑","丙寅","丁卯"]
				arr[4]=str
				p arr
			end
			def replace_4(str)
				arr = ["甲子","乙丑","丙寅","丁卯"]
				arr[6]=str
				p arr
			end
		end
		rep = Replace_elem.new
		rep.replace_1("乙丑年")
		rep.replace_2("")
		rep.replace_3("戊辰")
		rep.replace_4("庚午")
	
	输出结果：
		["甲子", "乙丑年", "丙寅", "丁卯"]
		["甲子", "乙丑", "丙寅", ""]
		["甲子", "乙丑", "丙寅", "丁卯", "戊辰"]
		["甲子", "乙丑", "丙寅", "丁卯", nil, nil, "庚午"]	
		
②array[start, length] = obj or an_array or nil	替换原数组中索引从start 开始直至 length 个元素的子数组

	代码如下：
		def replace_1(start,len,my_arr)
			arr = ["name:Tom","gender:male","age:18","from:France","hobby:beauty","graduated:Oxford"]
			arr[start,len] = my_arr
			p arr
		end
		replace_1(1,2,["gender:female","age:24"])
		replace_1(3,0,["income:9000"])
		replace_1(9,3,"working in:Tencent")
		replace_1(4,2,nil)
	输出结果：
		["name:Tom", "gender:female", "age:24", "from:France", "hobby:beauty", "graduated:Oxford"]
		["name:Tom", "gender:male", "age:18", "income:9000", "from:France", "hobby:beauty", "graduated:Oxford"]
		["name:Tom", "gender:male", "age:18", "from:France", "hobby:beauty", "graduated:Oxford", nil, nil, nil, "working in:Tencent"]
		["name:Tom", "gender:male", "age:18", "from:France", nil]
		
③array[range] = obj or an_array or nil			将原数组中索引range 指定范围的元素替换
	代码如下：
		def replace_1(start,myend,my_arr)
			arr = ["桃园三结义","王司徒巧使连环计","董太师大闹凤仪亭","太史慈酣斗小霸王","下邳城曹操鏖兵","美髯公千里走单骑"]
			arr[start..myend] = my_arr
			p arr
		end
		replace_1(1,3,["汉寿侯五关斩六将","会古城主臣聚义","蔡夫人隔屏听密语"])
	
	输出结果：
		["桃园三结义", "汉寿侯五关斩六将", "会古城主臣聚义", "蔡夫人隔屏听密语", "下邳城曹操鏖兵", "美髯公千里走单骑"]
	
	
【注】如果索引大于数组的当前容量，那么数组会自动增长。负值索引从数组末尾开始计数。如果 length 为零则插入元素。如果在第二种或第三种形式中使用了 nil，则从 self 删除元素,替换为nil。

(4.4)array.compact
返回 self 的副本，移除了所有的 nil 元素,并返回移除nil元素之后的新数组，如果没有nil元素，返回self
array.compact!
返回 self 的副本，移除了所有的 nil 元素。如果没有变化则返回 nil。

 代码如下：
	arr_1 = ["林黛玉","薛宝钗",nil,"贾元春",nil]
	arr_2 = arr_1.compact
	arr_3 = arr_2.compact
	arr_4 = arr_2.compact!
	p arr_2,arr_3,arr_4
 输出结果：
	["林黛玉", "薛宝钗", "贾元春"]
	["林黛玉", "薛宝钗", "贾元春"]
	nil

(4.5)替换、修改给定范围的元素
array.fill(obj)
array.fill(obj, start [, length])
array.fill(obj, range)
array.fill { |index| block }
array.fill(start [, length] ) { |index| block }
array.fill(range) { |index| block }
前面三种形式设置 self 的被选元素为 obj。以 nil 开头相当于零。nil 的长度相当于 self.length。最后三种形式用 block 的值填充数组。block 通过带有被填充的每个元素的绝对索引来传递

 代码如下：
	module MyFill
		def MyFill.fill01(arr,str)
			arr.fill(str)
			p arr
		end
		def MyFill.fill02(arr,str,num)
			arr.fill(str,num)
			p arr
		end
		def MyFill.fill03(arr,str,start_num,end_num)
			arr.fill(str,start_num..end_num)
			p arr
		end
		def MyFill.fill04(arr)
			arr.fill{|index| 
				if arr[index]=~/北影/
					arr[index]="上戏"
				else
					arr[index]=arr[index]
				end
			}
			p arr
		end
		def MyFill.fill05(arr,start_num)
			arr.fill(start_num){|index| 
				if arr[index]=~/d{3,}/ 
					arr[index]= 5000000
				else
					arr[index]=arr[index]
				end
			}
			p arr
		end
		def MyFill.fill06(arr,start_num,end_num)
			arr.fill(start_num...end_num){|index|
				if index%2==0
					arr[index]= 18
				else
					arr[index]=arr[index]
				end
			}
			p arr
		end
	end
	arr01 = %w{人之初 性本善 性相近 苟不教 性乃迁 教之道 贵以专}
	arr02 = %w{人之初 性本善 性相近 苟不教 性乃迁 教之道 贵以专}
	arr03 = %w{人之初 性本善 性相近 苟不教 性乃迁 教之道 贵以专}
	str = "习相远"
	arr04 = %W{章子怡 female 28 演员 北京人 北影 1000000}
	arr05 = %W{章子怡 female 28 演员 北京人 北影 1000000}
	arr06 = %W{章子怡 female 28 演员 北京人 北影 1000000}
	MyFill.fill01(arr01,str)
	MyFill.fill02(arr02,str,3)
	MyFill.fill03(arr03,str,3,5)
	MyFill.fill04(arr04)
	MyFill.fill05(arr05,1)
	MyFill.fill06(arr06,1,3)
	
输出结果：
	["习相远", "习相远", "习相远", "习相远", "习相远", "习相远", "习相远"]
	["人之初", "性本善", "性相近", "习相远", "习相远", "习相远", "习相远"]
	["人之初", "性本善", "性相近", "习相远", "习相远", "习相远", "贵以专"]
	["章子怡", "female", "28", "演员", "北京人", "上戏", "1000000"]
	["章子怡", "female", "28", "演员", "北京人", "北影", 5000000]
	["章子怡", "female", 18, "演员", "北京人", "北影", "1000000"]

(4.6)数组扁平化
array.flatten
返回一个新的数组，新数组是一个一维的扁平化的数组（递归）
array.flatten!
把 array 进行扁平化。如果没有变化则返回 nil。（数组不包含子数组。

代码如下：
	arr01 = ["昔孟母",['择邻处','子不学',["断机杼","窦燕山","有义方","教五子"]],"名俱扬"]
	arr02 = %w{养不教 父之过 教不严 师之惰}
	p arr01.flatten!
	p arr02.flatten
	p arr02.flatten!
输出结果：
	["昔孟母", "择邻处", "子不学", "断机杼", "窦燕山", "有义方", "教五子", "名俱扬"]
	["养不教", "父之过", "教不严", "师之惰"]
	nil

(4.7)array.insert(index, obj…)
在给定的 index 的元素前插入给定的值，index 可以是负值。
代码如下：
arr = %w{为人子方少时习礼仪}
obj = “亲师友”
arr.insert(2,obj)
p arr
输出结果：
[“为人子”, “方少时”, “亲师友”, “习礼仪”]
(4.8)array.join(sep=$,)
返回一个字符串，通过把数组的每个元素转换为字符串，并使用 sep 分隔进行创建的

 代码如下：
	 arr = %w{香九龄 能温席 孝于亲 所当执}
	 p arr.join(",")
 输出结果：
	"香九龄,能温席,孝于亲,所当执"

(4.9)array.inspect
创建一个数组的可打印版本。

代码如下：
	 arr = %w{香九龄 能温席 孝于亲 所当执}
	 p arr.inspect
输出结果：
	"["香九龄", "能温席", "孝于亲", "所当执"]"

(4.10)array.replace(other_array)
把 array 的内容替换为 other_array 的内容，必要的时候进行截断或扩充

 代码如下：
	arr01 = %w{曰南北 曰西东 此四方 应乎中}
	arr02 = %w{曰水火 木金土 此五行 本乎数}
	arr01.replace(arr02)
	p arr01
 输出结果：
	["曰水火", "木金土", "此五行", "本乎数"]

(4.11)array.reverse
返回一个新的数组，包含倒序排列的数组元素
array.reverse! 把 array 进行逆转

代码如下：
	arr = %w{十干者 甲至癸 十二支 子至亥}
	p arr.reverse
输出结果：
	["子至亥", "十二支", "甲至癸", "十干者"]

(4.12)array.shift
返回 self 的第一个元素，并移除该元素（把所有的其他元素下移一位）。如果数组为空，则返回 nil

 代码如下：
	arr = %w{寒燠均 霜露改 右高原 左大海}
	p arr.shift
	p arr
 输出结果：
	"寒燠均"
	["霜露改", "右高原", "左大海"]

(4.13)给数组排序
array.sort
array.sort { | a,b | block }
返回一个排序的数组
array.sort!
array.sort! { | a,b | block }
把数组进行排序

代码如下：
	arr = %w{a g h d b r c}
	p arr.sort!
	p arr.sort{|a,b| b<=>a}
输出结果：
	["a", "b", "c", "d", "g", "h", "r"]
	["r", "h", "g", "d", "c", "b", "a"]

(4.14)array.transpose
假设 self 是数组的数组，且置换行和列

(4.15)array.uniq
返回一个新的数组，移除了 array 中的重复值。
array.uniq!
从 self 中移除重复元素。如果没有变化（也就是说，未找到重复），则返回 nil。

 代码如下：
	arr01 = %w{1 2 3 5 3 5 2 4 3 2 5}
	p arr01.uniq
 输出结果：
	["1", "2", "3", "5", "4"]

(4.16)array.unshift(obj, …)
把对象前置在数组的前面，其他元素上移一位。

 代码如下：
	arr = %w[d f g r k l b s]
	obj1 = "z"
	obj2 = "y"
	arr.unshift(obj1,obj2)
	p arr

 输出结果：
	["z", "y", "d", "f", "g", "r", "k", "l", "b", "s"]

(4.17)array.values_at(selector,…)
返回一个数组，包含 self 中与给定的 selector（一个或多个）相对应的元素。选择器可以是整数索引或者范围。

  代码如下：
	arr = %w[a b h t k d m c b t w r o]
	p arr.values_at(3,2,6,4)
  输出结果：
	["t", "h", "m", "k"]

(4.18)array.zip(arg, …) [or]
array.zip(arg, …){ | arr | block }
把任何参数转换为数组，然后把 array 的元素与每个参数中相对应的元素合并

  代码如下：
	arr  =  %w[1 6]
	arg1 = %w[1 2 3]
	arg2 = %w[4 7 9]
	p arr.zip(arg1,arg2)
  输出结果：
	[["1", "1", "4"], ["6", "2", "7"]]

5.数组的【查】

(5.1)arr <=> other_array 比较两个数组中相同位置的元素，如果索引为0的位置上的元素相同，比较索引为1的，如果数组arr索引为1的元素大于other_array,返回1，如果小于就返回0，如果比较完所有的元素都相同就返回0

代码如下：
	def equal_arr(str1,str2,str3,str4)
		new_arr = [str1,str2,str3,str4]
		init_arr = ["h","a","l","s"]
		@num = new_arr<=>init_arr
		case @num 
		when 1
			p "new_arr大于init_arr"
		when 0
			p "new_arr等于ini人之初，性本善。性相近，习相远。t_arr"
		else
			p "new_arr小于init_arr"
		end
	end
	equal_arr("h","b","d","c")
	equal_arr("h","a","l","s")
	equal_arr("g","c","z","x")
		
输出结果：
	"new_arr大于init_arr"
	"new_arr等于init_arr"
	"new_arr小于init_arr"

(5.2)array == other_array 如果两个数组包含相同的元素个数，且每个元素与另一个数组中相对应的元素相等（根据 Object.==），那么这两个数组相等。

代码如下：
	def equal_arr(str1,str2)
		new_arr = [str1,str2]
		init_arr = [10,20]
		if new_arr == init_arr
			p "new_arr和init_arr相等"
		else
			p "new_arr和init_arr不相等"
		end
	end
	equal_arr(10,20)
	equal_arr(10,30)

输出结果：
	"new_arr和init_arr相等"
	"new_arr和init_arr不相等"

(5.3)array.eql?(other)
如果 array 和 other 是相同的对象，或者两个数组带有相同的内容，则返回 true。

代码如下：
	def my_eql(arr1,arr2)
		if arr1.eql?(arr2)
			p "arr1和arr2相等"
		else
			p "arr1不等于arr2"
		end
	end
	arr01 = %[子系中山狼 得志便猖狂]
	arr02 = arr01
	arr03 = arr01
	arr04 = #w{金闺花柳质 一载赴黄粱}
	my_eql(arr01,arr02)
	my_empty(arr03,arr04)
输出结果：
	"arr1和arr2相等"
	"arr1不等于arr2"

(5.4)获取数组中的元素
①array[index] 返回数组array中索引为 index 的元素
②array[start, length] 返回数组array中从 start 开始直至 length 个元素的子数组
③array[range] 返回数组array中range指定范围的子数组
④array.slice(index) 返回数组array中索引为 index 的元素
⑤array.slice(start, length) 返回数组array中从 start 开始直至 length 个元素的子数组
⑥array.slice(range) 返回数组array中range指定范围的子数组
【注】负值索引从数组末尾开始计数（-1 是最后一个元素）。如果 index（或开始索引）超出范围，则返回 nil。

代码如下：
	arr = [["西安","多云","5℃"],["成都","阴","10℃"],["上海","小雨","14℃"],["深圳","晴","20℃"]]
	element1 = arr[1]
	element2 = arr[1][0,2]
	element3 = arr[1..2]
	element4 = arr.slice(3)
	element5 = arr.slice(3)[0]
	element6 = arr.slice(2,2)
	element7 = arr.slice(1...3)
	element8 = arr[-1]
	element9 = arr.slice(-1)
	p element1,element2,element3,element4,element5,element6,element7,element8,element9
输出结果：
	["成都", "阴", "10℃"]
	["成都", "阴"]
	[["成都", "阴", "10℃"], ["上海", "小雨", "14℃"]]
	["深圳", "晴", "20℃"]
	"深圳"
	[["上海", "小雨", "14℃"], ["深圳", "晴", "20℃"]]
	[["成都", "阴", "10℃"], ["上海", "小雨", "14℃"]]
	["深圳", "晴", "20℃"]
	["深圳", "晴", "20℃"]

(5.5)array.at(index)
返回索引为 index 的元素。一个负值索引从 self 的末尾开始计数。如果索引超出范围则返回 nil。

代码如下：
	arr_1 = %w{可叹停机德（宝钗） 堪怜咏絮才（黛玉） 玉带林中挂（黛玉） 金簪雪里埋（宝钗）}
	arr_2 = arr_1.at(2)
	arr_3 = arr_1.at(-1)
	p arr_2,arr_3
输出结果：
	"玉带林中挂（黛玉）"
	"金簪雪里埋（宝钗）"

(5.6)array.collect { |item| block } [or]
array.map { |item| block }
array.collect! { |item| block } [or]
array.map! { |item| block }
为 self 中的每个元素调用一次 block。创建一个新的数组，包含 block对self中每个元素操作后返回的值。

 代码如下：
	arr_1 = ["马化腾","踌躇满志","一马当先","马失前蹄","腾云驾雾","前瞻后仰"]
	arr_new = []
	arr_1.collect{|element|
	arr_new << element if element =~/马/
	}
	p arr_new
 输出结果：
	["马化腾", "一马当先", "马失前蹄"]

(5.7)array.each { |item| block }
为self 中的每个元素调用一次 block，传递该元素作为参数

代码如下：
	arr_1 = %w{5 453 546 689 4 67 82}
	nums_3 = []
	arr_1.each{|poem| 
		nums_3 << poem if poem.to_i%3 == 0
	}
	p nums_3
输出结果：
	["453", "546"]

(5.8)array.each_index { |index| block }
与 Array#each 相同，但是传递元素的 index，而不是传递元素本身。

代码如下：
	arr_1 = %w{5 453 546 689 4 67 82}
	nums_3 = []
	arr_1.each_index{|ind| 
		nums_3 << arr_1[ind] if arr_1[ind].to_i%3 == 0
	}
	p nums_3
输出结果：
	["453", "546"]

(5.9)array.reverse_each {|item| block }
与 Array#each 相同，但是把 array 进行逆转

代码如下：
	arr = %w{曰黄道 日所躔 曰赤道 当中权}
	arr_new = []
	arr.reverse_each{|ele| 
		arr_new << ele
	}
	p arr_new
输出结果：
	["当中权", "曰赤道", "日所躔", "曰黄道"]

(5.10)array.select {|item| block }
调用从数组传入连续元素的 block，返回一个数组，包含 block 返回 true 值时的元素

代码如下：
	arr = %w{赤道下 温暖极 我中华 在东北}
	arr_new = []
	arr.select{|ele| 
		arr_new << ele
	}
	p arr_new
输出结果：
	["赤道下", "温暖极", "我中华", "在东北"]

(5.11)array.empty?
如果数组本身没有包含元素，则返回 true。

 代码如下：
	def my_empty(arr_1)
		if arr_1.empty?
			p "arr_1是空数组"
		else
			p "arr_1不是空数组，其长度为#{arr_1.size}"
		end
	end
	arr_01 = %w{}
	arr_02 = %w{堪破三春景不长 缁衣顿改昔年装 可怜绣户侯门女 独卧青灯古佛旁}
	my_empty(arr_01)
	my_empty(arr_02)
 输出结果：
	"arr_1是空数组"
	"arr_1不是空数组，其长度为4"

(5.12)array.fetch(index) [or]
array.fetch(index, default) [or]
array.fetch(index) { |index| block }
尝试返回位置 index 处的元素。如果 index 位于数组外部，则第一种形式会抛出 IndexError 异常，第二种形式会返回 default，第三种形式会返回调用 block 传入 index 的值。负值的 index 从数组末尾开始计数。

代码如下：  
  arr_1 = %w{势败休云贵 家亡莫论亲 偶因济村妇 巧得遇恩人}
  p arr_1.fetch(1)
  p arr_1.fetch(0,"not found the element")
  p arr_1.fetch(-1){p "数组越界异常"}

  # p arr_1.fetch(6)
  p arr_1.fetch(5,"not found the element")
  arr_1.fetch(8){p "数组越界异常"}
输出结果：
  "家亡莫论亲"
  "势败休云贵"
  "巧得遇恩人"
  index 6 outside of array bounds: -4...4 (IndexError)
  "not found the element"
  "数组越界异常"

(5.13)array.first
array.first(n)
返回数组的第一个元素或前 n 个元素。如果数组为空，则第一种形式返回 nil，第二种形式返回一个空的数组
array.last
array.last(n)
返回 self 的最后一个元素。如果数组为空，则第一种形式返回 nil

 代码如下：
	arr01 = %w[昔孟母 择邻处 子不学 断机杼]
	arr02 = %w{}
	p arr01.first
	p arr01.first(2)
	p arr02.first
	p arr02.first(4)
	p arr01.last
	p arr01.last(2)
	p arr02.last
	p arr02.last(4) 
 输出结果：
	"昔孟母"
	["昔孟母", "择邻处"]
	nil
	[]
	"断机杼"
	["子不学", "断机杼"]
	nil
	[]

(5.14)array.frozen?
如果 array 被冻结（或排序时暂时冻结），则返回 true

 代码如下：
	arr = %w{子不学 非所宜 幼不学 老何为}
	p arr.frozen?
 输出结果：
	false

(5.15)array.hash
计算数组的哈希代码。两个具有相同内容的数组将具有相同的哈希代码(哈希代码是动态变化的，每次执行都会不同)

代码如下：
	arr = %w{子不学 非所宜 幼不学 老何为}
	p arr.hash
输出结果：
	269892756

(5.16)array.include?(obj)
如果 self 中包含 obj，则返回 true，否则返回 false

代码如下：
	def my_include(arr,str)
		if arr.include?(str)
			p "数组arr中包含str"
		else
			p "数组arr中不包含str"
		end
	end
	arr01 = %w{玉不琢 不成器 人不学 不知义}
	str = "不知义"
	my_include(arr01,str)
输出结果：
	"数组arr中包含str"

(5.17)array.index(obj)
返回 self 中第一个等于 obj 的对象的 index。如果未找到匹配则返回 nil
array.rindex(obj)
返回 array 中最后一个等于 obj 的对象的索引。如果未找到匹配，则返回 nil

代码如下：
	arr01 = %w[10 20 67 43 56 356 57 67 20 67 43 56 23 67 8937 231 435 232]
	obj   = 67
	p arr01.index(obj.to_s)
	p arr01.rindex(obj.to_s)
输出结果：
	2
	13

(5.18)array.length
返回 self 中元素的个数。可能为零
array.size
返回 array 的长度（元素的个数）

  代码如下：
	arr01 = %w{融四岁 能让梨 弟于长 宜先知}
	p arr01.size
	p arr01.length
  输出结果：
	4
	4

(5.19)array.slice(index)
array.slice(start, length)
array.slice(range)
array[index]
array[start, length]
array[range]
返回索引为 index 的元素，或返回从 start 开始直至 length 个元素的子数组，或返回 range 指定的子数组。负值索引从数组末尾开始计数（-1 是最后一个元素）。如果 index（或开始索引）超出范围，则返回 nil
array.slice!(index)
array.slice!(start, length)
array.slice!(range)
删除 index（长度是可选的）或 range 指定的元素。返回被删除的对象、子数组，如果 index 超出范围，则返回 nil

  代码如下：
	arr01 = %w{曰江河 曰淮济 此四渎 水之纪 曰岱华 嵩恒衡 此五岳 山之名}
	arr02 = %w{曰士农 曰工商 此四民 国之良 曰仁义 礼智信 此五常 不容紊}
	arr03 = %w{地所生 有草木 此植物 遍水陆 有虫鱼 有鸟兽 此动物 能飞走}
	p arr01.slice(3)
	p arr01.slice(2,3)
	p arr01.slice(2..5)
	p arr01[3]
	p arr01[2,3]
	p arr01[2..5]
	p arr01.slice!(3),arr01
	p arr02.slice!(2,3),arr02
	p arr03.slice!(2..4),arr03
  输出结果：
	"水之纪"
	["此四渎", "水之纪", "曰岱华"]
	["此四渎", "水之纪", "曰岱华", "嵩恒衡"]
	"水之纪"
	["此四渎", "水之纪", "曰岱华"]
	["此四渎", "水之纪", "曰岱华", "嵩恒衡"]
	"水之纪"
	["曰江河", "曰淮济", "此四渎", "曰岱华", "嵩恒衡", "此五岳", "山之名"]
	["此四民", "国之良", "曰仁义"]
	["曰士农", "曰工商", "礼智信", "此五常", "不容紊"]
	["此植物", "遍水陆", "有虫鱼"]
	["地所生", "有草木", "有鸟兽", "此动物", "能飞走"]