l = ["a","b","c","d","e","f",'g']

puts l.values_at(2,3,4,6)

# 获取index为2、3、4、6的元素

#

#

l1 = ["a","b","c","d","e","f",'g']

l2 =  ["a","b","c","d",1,2,3]

l = l1 & l2

# 取交集

puts l

l = l1 | l2

# 取并集

puts l

l = l1 - l2

# 获取在l1中，但是不是在l2中的元素

puts l

l = l1 + l2

# 获取l1和l2两个集合中的合集，这个是两个集合的简单相加，会有重复元素

puts l

puts "=" * 100

l = ["a","b","c","d",1,2,3]

l.unshift("0")

# 在数组头部追加一个元素

puts l

puts "=" * 100

l = ["a","b","c","d",1,2,3]

l.push(4)

# 在数组尾部追加一个元素

#

#

l<< 5

# 在数组尾部追加一个元素

puts l

puts "=" * 100

l = ["a","b","c","d",1,2,3]

a = l.shift

# 从头部删除一个元素，同时可以接受到删除的元素

puts l

puts a

puts "=" * 100

l = ["a","b","c","d",1,2,4]

a = l.pop

# 从数组的尾部删除一个元素，同时可以接受到删除的的元素

puts l

puts a

puts "=" * 100

l = ["a","b","c","d",1,2,4]

puts l.first

# 获取头部第一个元素

puts l.last

# 获取尾部第一个元素

#

#

#

#

puts "=" * 100

l1 = ["a","b","c","d","e"]

l2 = [1,2,3,"a"]

l1.concat(l2)

# 连接l1和l2，把l2追加到l1的后面，这个操作会重新赋值l1

puts l1

puts "=" * 100

l = [1,2,3,4,1,"a","b"]

l.delete(1)

# 删除数组中的指定元素

puts l

puts "=" * 100

l = [1,2,3,4,1,"a","b"]

l.delete_at(2)

# 删除数组中索引为2的元素

puts l

puts "=" * 100

l = [1,2,3,4,1,6,7]

l.delete_if {|i| i > 2 }

# 删除数组中大于2的元素

puts l

puts "=" * 100

l = [1,2,3,4,1,6,7]

l = l.reject {|i| i > 2 }

# 删除数组中大于2的元素，把删除后的元素赋值给一个新的数组，原来的数组不影响

puts l

puts "=" * 100

l = [1,2,3,4,1,6,7]

l.reject! {|i| i > 2 }

# 删除数组中大于2的元素，把删除后的元素赋值给原数组

puts l

puts "=" * 100

l = [1,2,3,4,1,6,7]

m = l.slice(1,3)

# 删除索引为1到3的元素，并把删除的元素赋值给新的数组，对原数组无影响

puts m

puts "=" * 100

l = [1,2,3,4,1,6,7]

m = l.slice!(1,3)

# 删除索引为1到3的元素，并把删除的元素赋值给新的数组，对原数组有影响

puts l

puts "=" * 100

l = [1,2,3,4,1,6,7]

m = l.uniq

# 移除数组中的重复元素，并把移除重复元素后的数组赋值给一个新的数组，对原数组无影响

# puts m

puts l

puts "=" * 100

l = [1,2,3,4,1,6,7]

m = l.uniq!

# 移除数组中的重复元素，并把移除重复元素后的数组赋值给一个新的数组，对原数组有影响

puts m

puts l

puts "=" * 100

l = [1,2,3,4,1,6,7]

m =  l.reverse

# 翻转数组，对原数组无影响，翻转后的数组赋值给新的数组

puts l

puts m

puts "=" * 100

l = [1,2,3,4,1,6,7]

m =  l.reverse!

# 翻转数组，对原数组有影响，翻转后的数组赋值给新的数组

puts m

puts l

puts "=" * 100

l = [1,2,3,4,1,6,7]

m =  l.collect {|item| item * 2 }

# 对原数组中的每个元素执行块中的运算，把计算后的元素赋值给一个新的元素，对原数组无影响

puts "=" * 100

l = [1,2,3,4,1,6,7]

m =  l.collect! {|item| item * 2 }

# 对原数组中的每个元素执行块中的运算，把计算后的元素赋值给一个新的元素，对原数组有影响

#

puts "=" * 100

l = [1,2,3,4,1,6,7]

m = l.map {|item| item + 100 }

# 效果同collect

puts "=" * 100

l = [1,2,3,4,1,6,7]

m = l.map! {|item| item + 100 }

# 效果同collect！

puts "=" * 100

l = [1,2,3,4,1,6,7]

l.fill(2)

# 替换数组中的所有元素为2

puts l

puts "=" * 100

l = [1,2,"a","a",1,6,7]

l.fill(3,3)

# 替换数组索引从3开始都尾部的所有的元素为3

puts l

puts "=" * 100

l = [1,2,"a","a",1,6,7]

l.fill(100,3,6)

# 替换数组索引从3开始到6结束的所有的元素为3

puts l

puts "=" * 100

l = [1,2,"a","a",[1,1,2,["c","c","d"]]]

l.flatten

# 展开嵌套的数组，对原数组无影响，展开后的数组会赋值给一个新的数组

puts "=" * 100

l = [1,2,"a","a",[1,1,2,["c","c","d"]]]

l.flatten!

# 展开嵌套的数组，对原数组有影响

#

#

#

puts "=" * 100

l = [1,2,0,100,1,6,7]

m = l.sort

# 对数组进行排序，不影响原数组

puts m

puts "=" * 100

l = [1,2,0,100,1,6,7]

m = l.sort!

# 对数组进行排序，影响原数组

puts m

puts "=" * 100

l = [1,2,0,100,1,6,7]

m = l.sort_by{|i| -i}

# 对数组进行指定方法的排序,对原数组无影响

puts m

puts "=" * 100

l = [1,2,0,100,1,6,7]

m = l.sort_by!{|i| -i}

# 对数组进行指定方法的排序,对原数组影响

puts m

l1 = ["a","b","c"]

l2 = ["A","B","C"]

l3 = ["x","y","z"]

r = l1.zip(l2,l3)

r.each do |i|

  puts i

end