1 什么是数组

数组（Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。

组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。

用于区分数组的各个元素的数字编号称为下标。元素的下标从0开始。

数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。 这些有序排列的同类数据元素的集合称为数组。

2 定义数组的方法

Shell中，数组用括号来表示，元素用"空格"符号分隔开。

数组包括的数据类型：

• 数值型
• 字符型 （如果元素值为字符类型，需要加单引号或双引号，防止单个元素中有空格被当成2个元素）
• 混合型数值加字符

方法一：

数组名=(value1 value2 value3 value4 ...)

方法二：

先定义列表，再引用列表的值定义数组

列表名="value1 value2 value3 value4 value5" 
数组名=($列表名)

方法三：

用过下标值定义每个元素。

数组名=([0]=value1 [1]=value2 [2]=value3)

方法四：

通过下标值，一个一个定义数组内的每个元素。

同时也可以通过这种方式修改元素的值。

数组名[0]=value1  ​  
数组名[1]=value2  ​
数组名[2]=value3  ​  
数组名[3]=value4

3.引用数组的值

方法

echo ${array[@]} 
或
echo ${array[*]}

[root@localhost djq]# array=(10 20 30 40)
[root@localhost djq]# echo ${array[@]}
10 20 30 40
[root@localhost djq]# echo ${array[*]}
10 20 30 40
[root@localhost djq]# echo $array
10

2、查看数组内某一个元素的值

${数组名[n]}       //n代表元素的下标  ​
echo ${array[0]}   //获取数组内第一个元素的值（下标为0的元素值）  
echo ${array[1]}   //获取数组内第二个元素的值（下标为1的元素值）

[root@localhost djq]# echo ${array[@]}
10 20 30 40
[root@localhost djq]# echo ${array[0]}
10
[root@localhost djq]# echo ${array[1]}
20
[root@localhost djq]# echo ${array[3]}
40

3、获取数组的长度

echo ${#数组名[*]}  
echo ${#数组名[@]}

[root@localhost djq]# echo ${array[@]}
10 20 30 40
[root@localhost djq]# echo ${array[*]}
10 20 30 40
[root@localhost djq]# echo ${#array[*]}
4
[root@localhost djq]# echo ${#array[@]}
4

4、查看数组内最后一个元素的值

方法一：

 echo ${array[-1]}    //获取最后一个元素的值
 echo ${array[-2]}    //获取倒数第二个元素的值

[root@localhost djq]# echo ${array[*]}
10 20 30 40
[root@localhost djq]# echo ${array[-1]}
40
[root@localhost djq]# echo ${array[-2]}
30

方法二：

 length=${#array[@]}    //获取数组的长度
 last=$[$length-1]      //数组的长度减1
 echo ${array[$last]}   //查看最后一个元素值
 #用这种方式查看最后一个元素值，可以判断这个数组的下标是不是完整的。因为如果中间跳过了一个下标，那么此种方法无法获取最后一个元素的值。
 ​
 echo ${array[${#array[@]}]}  //查看下标值为数组长度的元素，如果没有跳过某个下标值，那么这个应该为空。如果不为空，说明跳过了某个下标值，数组下标不完整。

[root@localhost djq]# length=${#array[@]}
[root@localhost djq]# last=$[$length-1]
[root@localhost djq]# echo ${array[$last]}
40
[root@localhost djq]# echo ${#array[@]}
4
[root@localhost djq]# echo ${array[${#array[@]}]}

[root@localhost djq]# 

4 数组的常用操作

4.1 数组分片（数组截取）

格式：

 ${数组名[@]:起始位置:截取长度}        //起始位置从0算起
 ​
 ${数组名[@]}           //获取整个数组的元素值
 ${数组名[@]:0:3}      //从下标为0的元素开始截取，共截取3个元素。（即截取元素1到元素3）
 ${数组名[@]:2:2}      //从下标为2的元素开始截取，共截取2个元素。（即截取元素3到元素4）

[root@localhost djq]# arr1=(10 20 30 40 50 60)
[root@localhost djq]# echo ${arr1[@]}
10 20 30 40 50 60
[root@localhost djq]# echo ${arr1[@]:0:3}
10 20 30
[root@localhost djq]# echo ${arr1[@]:2:3}
30 40 50
[root@localhost djq]# echo ${arr1[@]:2:5}
30 40 50 60

4.2 数组元素替换

1、临时替换（不会影响原有数组）

 echo ${数组名[@]/旧字符/新字符}    //会替换所有元素中能匹配到的字符，但这是临时替换，不会改变原有数组的值

root@localhost djq]# arr2=(10 20 30 40)
[root@localhost djq]# echo ${arr2[@]}
10 20 30 40
[root@localhost djq]# echo ${arr2[@]/30/100}
10 20 100 40
[root@localhost djq]# echo ${arr2[@]}
10 20 30 40

2、重新赋值（永久替换）

 数组名=(${数组名[@]/旧字符/新字符})

[root@localhost djq]# echo ${arr2[@]}
10 20 30 40
[root@localhost djq]# arr2=(${arr2[@]/30/200})
[root@localhost djq]# echo ${arr2[@]}
10 20 200 40

4.3 删除数组

1、删除数组内的某个元素

 unset 数组名[n]        //删除数组内的某一个元素，n为下标值

[root@localhost djq]# aa=(10 20 30 40)
[root@localhost djq]# echo ${aa[@]}
10 20 30 40
[root@localhost djq]# unset aa[2]
[root@localhost djq]# echo ${aa[@]}
10 20 40

2、删除整个数组

 unset 数组名[*]
 或
 unset 数组名[@] 

[root@localhost djq]# echo ${aa[@]}
10 20 40
[root@localhost djq]# unset aa[@]
[root@localhost djq]# echo ${aa[@]}

[root@localhost djq]# 

4.4 数组扩写，增加数组内的元素

当我们原本定义的数组不能满足我们的需求时，我们需要追加数组内的元素。

 #方法1
 数组名[n]=元素值       //使用下标值直接增加元素
 ​
 #方法2
 数组名+=(元素1 元素2 .....)
 ​
 #方法3
 数组名[数组长度]=元素值     //此种方法必须保证数组元素是完整的，如果某个下标被跳过了，此种方法会替换掉原来的某个元素
 ​
 #方法4
 数组名=("${数组名[@]}" 元素1 元素2 .....)
//引用数组值必须加双引号，不然原数组内有空格的单个元素（例如"zhang san"）会被当成2个元素。
//且必须使用@，因为加上双引号之后"$@"表示将所有参数当作个体，而$*表示将所有参数当作一个整体。

[root@localhost djq]# echo ${cc[@]}
10 20 30
[root@localhost djq]# cc[3]=40
[root@localhost djq]# cc[4]=50
[root@localhost djq]# echo ${cc[@]}
10 20 30 40 50

方法2示例：数组名+=(元素值

[root@localhost djq]# echo ${cc[@]}
1060 20 30 40 50
[root@localhost djq]# cc+=(60)
[root@localhost djq]# echo ${cc[@]}
1060 20 30 40 50 60
[root@localhost djq]# cc+=(70 80 90)
[root@localhost djq]# echo ${cc[@]}
1060 20 30 40 50 60 70 80 90

数组排序

1、数组排序(tr、sort、for)

使用tr命令将数组内每个元素之间的空格替换为换行符；

之后使用sort命令按从小到大重新排序；

最后使用for循环遍历排序后的元素值。

#!/bin/bash

arr=(63 4 24 1 3 15)
echo "原数组的顺序为：${arr[@]}"
#将每个元素之间的空格替换为换行符，然后重新排序
list=$(echo ${arr[@]} | tr ' ' '\n' | sort -n)
a=0
for i in $list
do
  arr[$a]=$i
  let a++
done
echo "排序后的数组顺序为：${arr[@]}"
~                                    

[root@localhost djq]# ./10.sh 
原数组的顺序为：63 4 24 1 3 15
排序后的数组顺序为：1 3 4 15 24 63

2、冒泡排序

类似气泡上涌的动作，会将数据在数组中从小到大或者从大到小不断的向前移动。

基本思想：

• 冒泡排序的基本思想是对比相邻的两个元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。

算法思路：

• 冒泡算法由双层循环实现，其中外部循环用于控制排序轮数，一 般为要排序的数组长度减1次，因为最后一 次循环只剩下一-个数组元素，不需要对比，同时数组已经完成排序了。而内部循环主要用于对比数组中每个相邻元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。

倒序排序

 #!/bin/bash
 ​
 arr=(63 4 24 1 3 15)
 echo "原数组顺序为：${arr[@]}"
 #获取数组的长度
 length=${#arr[@]}
 ​
 #使用冒泡排序
 #定义比较的轮数，比较轮数为数组长度减1，从1开始。
 for ((i=1;i<$length;i++))
 do
 #对比相邻元素，确定元素的位置，较大的值往右放，每轮的比较次数会随着比较轮数的增加而减少。每轮比较次数=数组长度-轮数
 #变量以左边元素为参数
     for ((j=0;j<$length-i;j++))
     do
         #定义左边元素的值
         left=${arr[$j]}
         #定义右边元素的值
         k=$[$j+1]
         right=${arr[$k]}
         #比较两边元素的值，如果左边的值大于右边的值，两个元素就互换
         if [ $left -gt $right ]
         then
             #使用临时变量temp保存左边元素的值
             tmp=$left
             #将右边元素的值赋给左边元素
             arr[$j]=$right
             #将原来的左边元素的值（保存在临时变量temp中）赋给右边元素
             arr[$k]=$tmp
         fi
     done
 done
 echo "排序后数组的顺序为：${arr[@]}"

3、直接选择排序

与冒泡排序相比，直接选择排序的交换次数更少，所以速度会快些。

基本思想：

• 将指定排序位置与其它数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的格式。

 #!/bin/bash 
 ​
 arr=(63 4 24 1 3 15)  #定义数组并赋值
 echo "排序前数组的顺序为：${arr[@]}"
 length=${#arr[@]}    #定义一个变量length,将数组长度赋值给它
  
 #使用直接选择排序
 #定义排序的轮数。一般为数组长度减1
 for ((i=1;i<length;i++))
 do
    #先假设第一个元素的值是最大的，第一个元素的下标为0
    index=0
    #用后续元素和假设的最大元素比较，如果比假设的元素值大，则记录这个元素的下标，后续元素就和这个元素比较，最终可以确定当前轮数的最大元素的下标位置
    for ((j=1;j<=length-i;j++))
    do
        if [ ${arr[$j]} -gt ${arr[$index]} ];then
        #当所有元素比较完后，index的值就是当前轮次的最大元素的下标位置
        index=$j
        fi
    done
    #确定完当前轮次的最大元素位置后，就拿这个最大元素和当前轮次的最后一个元素交换位置
    #定义每轮的最后一个元素的下标
    last=$[length - i]
    #先把每轮的最后一个元素的值赋给临时变量temp 
    temp=${arr[$last]}
    #把最大元素的值赋给最后一个元素
    arr[$last]=${arr[$index]}
    #把原来最后一个元素的值赋给原来最大元素，从而实现最大元素和当前轮次的最后一个元素的值交换
    arr[$index]=$temp
 done
 echo "排序后数组的顺序为：${arr[@]}"

4、反转排序

以相反的顺序把原有数组的内容重新排序。

基本思想：

• 把数组最后一个元素与第一个元素进行交换，倒数第二个元素与第二个元素进行交换，以此类推，直到把所有数组元素反转替换。

 #!/bin/bash
 #使用反转排序
 ​
 arr=(63 2 24 1 3 15)
 echo "原数组的排列顺序为：${arr[@]}"  
 #获取数组的长度
 length=${#arr[@]} 
 ​
 #将前面元素的值和倒数元素的值进行交换，倒数的元素的下标会随着前面的元素的下标增加而减少
 #元素的下标从0开始；折半对换，所以是长度除以2；下标值每次加1
 for ((i=0;i<length/2;i++))
 do
    #将第一个下标对应的元素值赋值给临时变量temp
    temp=${arr[$i]}   
    #将最后一个下标对应的元素值赋值给第一个下标对应的元素
    arr[$i]=${arr[$length-1-$i]}
    #再将第一个下标对应的元素值赋值给最后一个下标对应的元素，完成反转
    arr[$length-1-i]=$temp     
 done
 echo "反转排序后的数组顺序为：${arr[@]}"