java 数组操作

Posted 2020-09-09 月光莫里亚

数组是一种数据结构，用来存储同一类型值的集合。

数组作为对象允许使用new关键字进行内存分配，在使用数组之前，必须首先定义数组变量所属的类型。

数组通过一个整型下标可以访问数组中得每一个值，例如，如果存在数组a。则a[i]就是数组中下标为i的整数（下标从0开始）。

1.数组的声明及初始化

 1 　　　　 //声明
 2         int [] iArr ;
 3         String sArr [];
 4         
 5         //声明并分配大小
 6         int [] iArr2 = new int[3]; //数组内默认值为0
 7         String [] sArr2 = new String[10];//数组默认值为null
 8         System.out.println(Arrays.toString(iArr2));//打印数组  
 9         System.out.println(Arrays.toString(sArr2));
10         /*输出
11          * [0, 0, 0]
12            [null, null, null, null, null, null, null, null, null, null]
13          */
14         
15         //声明并赋值
16         int [] iArr3 =  new int[]{2,3,4,6};
17         String [] sArr3 = {"ONE","TWO","THREE"};
18         System.out.println(Arrays.toString(iArr3));//[2, 3, 4, 6]
19         System.out.println(Arrays.toString(sArr3));//[ONE, TWO, THREE]
20         
21         //简单使用
22         iArr = new int[]{1,2,3};
23         sArr = new String[2];
24         sArr[0] = "hello";
25         sArr[1] = "friend";
26         System.out.println(iArr[1]);//2
27         System.out.println(Arrays.toString(sArr));//[hello, friend]

2.数组的操作

（1）数组的遍历

　　　　//数组的遍历
        int[] arr = {2,4,5,9,7}; 
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i]+"\t");//2    4    5    9    7
        }
        System.out.println();
        for(int num : arr){
            System.out.print(num+"\t");//2    4    5    9    7
        }

（2）数组的填充

Arrays.fill()方法能够对数组进行填充，fill()方法有很多重载的方法，能够满足任意数组元素的填充或者替换。

　　　　 int[] arr = new int[5];
        //填充
        Arrays.fill(arr, 6);
        System.out.println(Arrays.toString(arr));//[6, 6, 6, 6, 6]
        
        //替换
        Arrays.fill(arr,2,4,0);
        System.out.println(Arrays.toString(arr));//[6, 6, 0, 0, 6]

(3)数组的排序

Arrays.sort()方法能够对数组进行排序

　　　　 int[] arr = {5, 4, 3, 2, 1};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5]

（4）数组的复制

Arrays类中copyOf()方法和copyOfRange()方法可以实现对数组的复制，

前者是复制数组到指定长度，后者是将指定长度的数组复制到一个新的数组中（或者覆盖之前的数组）。

coypOf(arr, int newLength) 可用于数组的扩容

-arr: 要进行复制的数组

-newLength： 复制后数组的长度，如果新数组复制的长度大于arr，则用0或者null补充。如果新数组小于arr的长度，则复制arr的0为开始直至满足数组的长度。

int[] arr = new int[]{3,4,5};
arr = Arrays.copyOf(arr, arr.length*2);
System.out.println(Arrays.toString(arr));//[3, 4, 5, 0, 0, 0]

int[] newArr = Arrays.copyOf(arr, 2);
System.out.println(Arrays.toString(newArr));//[3, 4]

copyOfRange(arr, int fromIndex, int toIndex)

-arr: 要复制的数组

-fromIndex:指定要复制数组的开始索引位置，不能大于arr的长度

-toIndex：指定要复制数组的最后索引位置（不包括toIndex） 可以大于arr的长度

　　 int[] arr = {5, 7, 8, 2, 9};
    arr = Arrays.copyOfRange(arr, 0, arr.length*2);
    System.out.println(Arrays.toString(arr));//[5, 7, 8, 2, 9, 0, 0, 0, 0, 0]

    int[] newArr = Arrays.copyOfRange(arr, 1, 3);
    System.out.println(Arrays.toString(newArr));//[7, 8]

在System类中的arraycopy方法将数组的元素copy到另一个数组中，方法为：

System.arraycopy(src, srcPos, dest, destPos, length)

-src: 要复制的数组

-srcPos：将要复制的数组的索引位置

-dest: 目标数组

-destPos：目标数组的索引位置

-length：要复制的长度，从索引位置开始计数

int[] arr = {6, 4, 11, 12};
int [] newArr = new int[]{5,4,9,3,4,2};
System.arraycopy(arr, 2, newArr, 0, 2);
System.out.println(Arrays.toString(newArr));//[11, 12, 9, 3, 4, 2]

 3.数组的排序

（1） 冒泡排序

冒泡的基本思路是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面。

        //冒泡排序
        int[] arr = new int[]{12, 3, 65, 45, 88, 1, 7};
　　　   for(int i = 0; i < arr.length -1; i++){    
            for(int j = 0; j < arr.length - 1 - i; j++){
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));//[1, 3, 7, 12, 45, 65, 88]

（2）直接选择排序

直接选择排序的思路是将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素，找出最大数后与“最后”一个元素交换。

        //直接选择排序
        int[] arr = new int[]{12, 3, 65, 45, 88, 1, 7};
        int index;
        for(int i = 1; i < arr.length; i++){
            index =0;
            //找出最大值
            for(int j = 0; j <= arr.length - i; j++){
                if(arr[j] > arr[index]){
                    index = j;
                }
            }
            //最大值放到最后的位置上
            int temp = arr[index];
            arr[index] = arr[arr.length - i];
            arr[arr.length - i] = temp;

        }
        System.out.println(Arrays.toString(arr));//[1, 3, 7, 12, 45, 65, 88]

（3）反转排序

将数组的元素反转替换，即将元素的最后一个元素与第一个元素进行交换，倒数第二个元素与数组的第二个元素进行交换。。。。

        //翻转排序 -将数组的位置反过来
        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7};
        int arrLength = arr.length;
        for(int i = 0; i < arrLength/2 ; i++ ){
            int temp = arr[i];
            arr[i] = arr[arrLength-1-i];
            arr[arrLength-1-i] = temp;
        }
        System.out.println(Arrays.toString(arr));//[7, 6, 5, 4, 3, 2, 1]