标签：不能   index   资料   入门   二维数组   内存分配   输出   数字   截取   

数组

参考资料：《Java从入门到精通》/明日科技编著. 4版. 北京：清华大学出版社，2016

数组是具有相同数据类型的一组数据的集合，每个元素具有相同的数据类型。在Java中同样将数组看作一个对象，虽然基本数据类型不是对象，但是由基本数据类型组成的数组却是对象。

一、一维数组

一维数组实质上是一组相同类型数据的线性集合。

1、创建一维数组

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

（1） 先声明，再用new进行内存分配

int arr[];    //声明int类型的一维数组
String str[];   //声明String类型的一维数组

声明数组后，还不能立即访问它的任何元素，想要使用数组，还要为它分配内存空间。在数组分配内存空间时，必须指定数组的长度。

arr = new int[5];   //创建有5个元素的整型数组
str = new String[4];

上述代码表示创建一个拥有5个元素的整型数组，并且将创建的数组对象赋值给引用变量arr，即引用变量arr引用这个数组。

说明：使用new关键字为数组分配内存时，整型数组中各个元素的初始值为0。

（2） 声明的同时为数组分配内存

int month[] = new int[12]; 

上述代码创建了一个整型数组，同时指定了数组的长度。

2、 初始化一维数组

数组的初始化有两种形式：

int arr[] = new int[]{1,2,3,4,5};
int arr2[] = {2,3,4,5};

二、二维数组

如果一维数组中的各个元素都是数组，那么它就是一个二维数组。二维数组常用于表示表，表中的信息以行和列的形式组织，第一个下标代表元素的行，第二个下标代表元素的列。

1、二维数组的创建

二维数组可以看作特殊的一维数组，因此，二维数组的创建也有两种方式：

（1）先声明，再用new关键字进行内存分配

int arr[][];    //声明一个int型二维数组
arr = new int[2][4];    //分配内存

同一维数组一样，二维数组在声明时也没有进行内存空间分配，同样需要使用new关键字来分配内存，然后才可以访问各个元素。

（2）声明的同时为数组分配内存

int arr[][] = new int[2][4];

上述代码创建了二维数组，二维数组arr包含了2个长度为4的一维数组。

int array[][] = new int[2][];
//分别为每一维分配内存
array[0] = new int[2];   //长度为2
array[1] = new int[3];   //长度为3

上述代码创建了二维数组，二维数组array包含了2个长度分别为2和3的一维数组。

2、二维数组的初始化

int myarr[][] = {{2,4}, {6,8,10}};

3、二维数组的使用

输出一个5行10列且所有元素为0的矩阵。

public class Matrix {
    public static void main(String[] args) {
        int a[][] = new int[5][10];
        for(int i=0; i<a.length; i++){
            for(int j=0; j<a[i].length; j++){
                System.out.print(a[i][j]);
            }
            System.out.println();
        }
    }
}

输出结果：
0000000000
0000000000
0000000000
0000000000
0000000000

说明：对于整型二维数组，分配内存后系统自动给每个元素赋予初始值0

三、数组的操作

1、遍历数组

遍历数组就是获取数组中的每个元素，通常使用for循环来完成。

public class Matrix {
    public static void main(String[] args) {
        //创建二维数组并赋初始值
        int a[][] = new int[][]{{1},{2,3},{4,5,6}};  
        for(int i=0; i<a.length; i++){
            for(int j=0; j<a[i].length; j++){
                System.out.print(a[i][j]);
            }
            System.out.println();
        }
    }
}

2、填充替换数组元素

数组中的元素定义完成后，可以通过Arrays类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可以完成对任意类型的数组元素的替换。

• 如果数组没有进行初始化，则fill()方法对数组进行填充；
• 如果数组已经进行初始化，则fill()方法对数组进行替换。

1. fill ( int[] a, int value )

• a：要进行填充或替换的数组名；
• value：要添加入数组元素中的值。

int b[] = new int[5];    //新建一个数组
Arrays.fill(b,8);     //数组中所有元素填入数字8

for(int i=0; i<b.length; i++){   //遍历数组
    System.out.print(b[i] + " ");
}

输出结果：
8 8 8 8 8 

2. fill ( int[] a, int fromIndex, int toIndex, int value )

• a：要填充或替换的数组名；
• fromIndex：开始填充的索引位置（填充该位置的数组元素）；
• toIdex：结束填充的索引位置（不填充该位置的数组元素）；
• value：要添加入数组元素中的值。

int b[] = new int[]{1,1,1,1,1};
Arrays.fill(b, 1, 2, 8);    //b[1]元素被替换

for(int i=0; i<b.length; i++){
    System.out.print(b[i] + " ");
}

输出结果：
1 8 1 1 1

注意：Arrays.fill()方法只能针对一维数组进行操作。

 int[][] map = new int[4][5];
 Arrays.fill(map,-1);  //执行失败

3、对数组进行排序

通过Arrays类的静态方法sort()可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。

int c[] = new int[]{23,12,5,15,7};
Arrays.sort(c);    //升序排序

for(int i=0; i<c.length; i++){
    System.out.print(c[i] + " ");
}

输出结果：
5 7 12 15 23

注意：String类型的数组是根据字典编排顺序排序的，因此数字排在字母前面，大写字母排在小写字母前面。

4、复制数组

Arrays类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。

• copyOf()方法是复制数组至指定的长度；
• copyOfRange()方法将数组的指定长度复制到一个新的数组。

（1） copyOf ( int[] a, newlength ) 方法

int d[] = new int[]{12,2,4,15,7};
int e[] = Arrays.copyOf(d,6);    //新的数组长度为6

for(int i=0; i<e.length; i++){
    System.out.print(e[i] + " ");
}

输出结果：
12 2 4 15 7 0

• 如果新数组的长度大于原数组，则根据数组的类型进行填充，整型数组用0填充，char型数组用null来填充。
• 如果新数组的长度小于原数组，则从原数组的第一个元素开始截取至满足新数组长度为止。

（2） copyOfRange ( int[] a, int formIndex, int toIndex )

int d[] = new int[]{12,2,4,15,7};
int e[] = Arrays.copyOfRange(d,1,3);

for(int i=0; i<e.length; i++){
    System.out.print(e[i] + " ");
}

输出结果：
2 4 

4、数组排序算法

常见的排序算法，即冒泡算法、直接选择排序和反转排序。

（1）冒泡排序

public class BubbleSort {
    public static void main(String[] args) {
        //创建一个数组
        int arr[] = new int[]{32,34,45,2,75,3,5,73,41,33};
        //创建一个冒泡排序的对象
        BubbleSort bubbleSort = new BubbleSort();
        //调用sort()方法对数组进行排序
        bubbleSort.sort(arr);
        //调用showArray()方法显示排序后的数组
        bubbleSort.showArray(arr);
    }
    //冒泡排序的算法
    public void sort( int[] arr1 ){
        for(int i = 1; i < arr1.length; i++){
            for(int j = 0; j < arr1.length-1; j++){
                if(arr1[j] > arr1[j+1]){  //判断第二个元素是否大于第一个
                    //后面元素与前面元素替换
                    int temp = arr1[j];
                    arr1[j] = arr1[j+1];  
                    arr1[j+1] = temp;
                }
            }
        }
    }
    //显示数组中的所有元素
    public void showArray( int[] arr2 ){
        for(int i=0; i<arr2.length; i++){
            System.out.print(arr2[i] + " ");
        }
    }
}

输出结果：
2 3 5 32 33 34 41 45 73 75

（2）直接选择排序

1.方法一（找最大值）

public class SelectSort {
    public static void main(String[] args) {
        //创建一个数组
        int arr[] = new int[]{2,5,12,65,32,41};
        //创建一个SelectSort类的实例
        SelectSort selectSort = new SelectSort();
        //调用sort()方法进行冒泡排序
        selectSort.select(arr);
        //调用showArray()方法显示数组所有元素
        selectSort.showArray(arr);
    }
    //直接排序算法
    public void select(int[] arr1){
        int index;   //index变量保存最大值的索引
        for(int i=1; i < arr1.length; i++){
            index = 0;   
            /*
            数组最后一位元素被确定，直至所有元素被确认
            数组最后一位元素被确定，index重置为0，即从第一个元素开始比较
            内存for循环代码“j<=arr1.length-i”保证了已经排序好的最后一位元素不参与比较
            */
            for(int j=1; j <= arr1.length - i; j++){  
                if(arr1[j] > arr1[index]){
                    index = j;
                }
            }
            /*
            将最大值与循环的最后一位元素进行替换
            替换完成，即最后一位元素确认，不在变化
            */
            int temp = arr1[arr1.length - i];
            arr1[arr1.length - i] = arr1[index];
            arr1[index] = temp;
        }
    }
    //显示数组中的所有元素
    public void showArray( int[] arr2 ){
        for(int i=0; i<arr2.length; i++){
            System.out.print(arr2[i] + " ");
        }
    }
}

2. 方法二（找最小值）

public class SelectSort {
    public static void main(String[] args) {
        //创建一个数组
        int arr[] = new int[]{12,45,36,5,65,17,80,1};
        //创建一个SelectSort类的实例
        SelectSort selectSort = new SelectSort();
        //调用sort()方法进行直接选择排序
        selectSort.select(arr);
        //调用showArray()方法显示数组所有元素
        selectSort.showArray(arr);
    }
    //直接排序算法
    public void select(int[] arr1){
        int index;
        for(int i=0; i < arr1.length ; i++){
            index = i;     //每次循环后，index的值加1，即已经排序的元素不再参与比较
            /*
            index变量保存最小值的索引
            外层for循环每循环一次，首位元素被确定，直至所有元素被确认
            内层for循环代码“j=1+i”确保了已经排序的元素不参与比较
            */
            for(int j= 1 + i; j < arr1.length ; j++){
                if(arr1[j] < arr1[index]){
                    index = j;
                }
            }
            //最小值与第一位替换
            int temp = arr1[i];
            arr1[i] = arr1[index];
            arr1[index] = temp;
        }
    }
    //显示数组中的所有元素
    public void showArray( int[] arr2 ){
        System.out.println("最后排序结果为：");
        for(int i=0; i<arr2.length; i++){
            System.out.print(arr2[i] + " ");
        }
    }
}

（3）反转排序

public class ReverseSort {
    public static void main(String[] args) {
        //创建一个数组
        int arr[] = new int[]{10,20,30,40,50,60,70};
        //创建ReverseSort类的对象
        ReverseSort reverseSort = new ReverseSort();
        //使用reverse()方法进行反转排序
        reverseSort.reverse(arr);
        //使用showArray()方法显示所有数组元素
        reverseSort.showArray(arr);
    }
    //反转排序算法
    public void reverse(int[] arr1){
        int temp;   //定义临时变量，负责完成字符的替换
        /*
        反转是数组对边元素的替换，即第一位与最后一次替换，第二位与倒数第二位替换
        所有只要循环数组长度的半数次，如数组长度为7，则只需循环3次。
        */
        for(int i=0; i < (arr1.length/2); i++){
            temp = arr1[i];
            arr1[i] = arr1[arr1.length -1 -i];
            arr1[arr1.length -1 -i] = temp;
        }
    }
    //显示数组的各个元素
    public void showArray( int[] arr2 ){
        System.out.println("最后排序结果为：");
        for(int i=0; i<arr2.length; i++){
            System.out.print(arr2[i] + " ");
        }
    }
}

四、实践与练习

编写Java程序，将二维数组的行列互调显示出来。

例如：

1  2  3
4  5  6
7  8  9

显示结果为：

1  4  7
2  5  8
3  6  9

程序代码如下所示：

public class Convert {
    public static void main(String[] args) {
        int arr[][] = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        //显示转换前所有的数组元素
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }

        System.out.println("----------------");

        for (int i = 0; i < arr.length; i++) {
            for (int j = i; j < arr[i].length; j++) {   //注意变量j的初始化
                int temp = arr[i][j];
                arr[i][j] = arr[j][i];
                arr[j][i] = temp;
            }
        }
        //显示转换后所有的数组元素
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

输出结果：
1 2 3 
4 5 6 
7 8 9 
----------------
1 4 7 
2 5 8 
3 6 9 

Java基础05—数组

标签：不能   index   资料   入门   二维数组   内存分配   输出   数字   截取   

原文地址：https://www.cnblogs.com/xuliang-daydayup/p/12900898.html