【JAVA】一本糊涂账系列——数组

最新推荐文章于 2022-11-13 09:26:28 发布

郭慧鹏

最新推荐文章于 2022-11-13 09:26:28 发布

阅读量690

点赞数 3

CC 4.0 BY-SA版权

分类专栏： JAVA 文章标签： JAVA

本文链接：https://blog.youkuaiyun.com/Hit_the_lights/article/details/85395065

JAVA 专栏收录该内容

6 篇文章

订阅专栏

本文详细介绍了Java中数组的创建、初始化、排序、复制、二维数组的使用以及Arrays工具类的应用，包括排序、转换为字符串、搜索、判断数组是否相同以及填充等操作。特别强调了增强型FOR循环在遍历数组时的便利性及其限制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

创建数组：

1、在创建数组前，我们需要先声明数组。例如：int[] c; 声明了一个数组变量。[]表示该变量是一个数组，int 表示数组里的每一个元素都是一个整数，c 是变量名。
注意：有时候写成int c[];也是可以的，没有任何区别，自己怎么开心怎么来

2、创建数组的时候，要指明数组的长度。例如：new int[5]，如果变量代表一个数组，比如c,我们把c叫做引用。声明一个引用 int[] c; c = new int[5]; 让c这个引用，指向数组。

public class HelloWorld {
    public static void main(String[] args) {
        
        int[] c;//声明一个引用    
        c = new int[5];//创建一个长度是5的数组，并且使用引用a指向该数组
         
        int[] d = new int[5]; //声明的同时，指向一个数组         
    }
}

3、在访问数组的时候，数组下标0，代表数组里的第一个数。

4、数组长度：.length属性用于访问一个数组的长度，数组访问下标范围是0到长度-1，一旦超过这个范围,就会产生数组下标越界异常。

初始化数组:

1、分配空间与赋值分步进行

public class HelloWorld {
    public static void main(String[] args) {

        int[] a = new int[5]; //分配了长度是5的数组，但是没有赋值         
        System.out.println(a[0]);//没有赋值，那么就会使用默认值，作为int类型的数组，默认值是0
         
        //进行赋值     
        a[0] = 100;
        a[1] = 101;
        a[2] = 103;
        a[3] = 120;
        a[4] = 140;
    }
}

2、分配空间，同时赋值

public class HelloWorld {
    public static void main(String[] args) {
        
        int[] a = new int[]{100,102,444,836,3236};//写法一： 分配空间同时赋值
 
        int[] b = {100,102,444,836,3236}; //写法二： 省略了new int[],效果一样
                 
        int[] c = new int[3]{100,102,444,836,3236};
        /*写法三：同时分配空间，和指定内容，但这里长度是3，内容是5个，产生矛盾了。
        所以如果指定了数组的内容，就不能同时设置数组的长度*/        
    }
}

数组排序：

1、选择法排序：把第一位和其他所有的进行比较，只要比第一位小的，就换到第一个位置来，比较完后，第一位就是最小的；
然后再从第二位和剩余的其他所有进行比较，只要比第二位小，就换到第二个位置来，比较完后，第二位就是第二小的，然后以此类推。

public class HelloWorld {
    public static void main(String[] args) {
        int a [] = new int[]{18,62,68,82,65,9};
        //排序前，先把内容打印出来
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println(" ");
        //选择法排序
              
        for (int j = 0; j < a.length-1; j++) {
            for (int i = j+1; i < a.length; i++) {
                if(a[i]<a[j]){  
                    int temp = a[j];
                    a[j] = a[i];
                    a[i] = temp;
                }
            }
        }
         
        //把内容打印出来
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println(" ");       
    }
}

2、冒泡法排序：第一趟：从第一位开始，把相邻两位进行比较，如果发现前面的比后面的大，就把大的数据交换在后面，循环比较完毕后，最后一位就是最大的。第二趟：再来一次，只不过不用比较最后一位，然后以此类推。

public class HelloWorld {
    public static void main(String[] args) {
        int a [] = new int[]{18,62,68,82,65,9};
        //排序前，先把内容打印出来
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println(" ");
        //冒泡法排序
         
        for (int j = 0; j < a.length; j++) {
            for (int i = 0; i < a.length-j-1; i++) {
                if(a[i]>a[i+1]){  
                    int temp = a[i];
                    a[i] = a[i+1];
                    a[i+1] = temp;
                }
            }
        }
          
        //把内容打印出来
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println(" ");       
    }
}

复制数组的两种方法：

public class HelloWorld {
    public static void main(String[] args) {
        int a [] = new int[]{18,62,68,82,65,9};         
        int b[] = new int[3];//分配了长度是3的空间，但是没有赋值
         
        //通过数组赋值把a数组的前3位赋值到b数组
         
        //方法一： for循环
         
        for (int i = 0; i < b.length; i++) {
            b[i] = a[i];
        }
        
        //方法二: System.arraycopy(src, srcPos, dest, destPos, length)
        //src: 源数组
        //srcPos: 从源数组复制数据的启始位置
        //dest: 目标数组
        //destPos: 复制到目标数组的启始位置
        //length: 复制的长度       
        System.arraycopy(a, 0, b, 0, 3);
         
        //把内容打印出来
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + " ");
        } 
    }
}

二维数组：

1、以下是一个一维数组, 里面的每一个元素，都是一个基本类型int 。

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

2、以下是一个二维数组，里面的每一个元素，都是一个一维数组，所以二维数组又叫数组的数组。

int b[][] = new int[][]{
   {1,2,3},
   {4,5,6},
   {7,8,9}
};

3、初始化二维数组：

public class HelloWorld {
    public static void main(String[] args) {
       //初始化二维数组，
       int[][] a = new int[2][3]; //有两个一维数组，每个一维数组的长度是3
       a[1][2] = 5;  //可以直接访问一维数组，因为已经分配了空间
          
       //只分配了二维数组
       int[][] b = new int[2][]; //有两个一维数组，每个一维数组的长度暂未分配
       b[0]  =new int[3]; //必须事先分配长度，才可以访问
       b[0][2] = 5;
        
       //指定内容的同时，分配空间
       int[][] c = new int[][]{
               {1,2,4},
               {4,5},
               {6,7,8,9}
       }; 
    }
}

Arrays：

Arrays是针对数组的工具类，可以进行排序，查找，复制填充等功能。大大提高了开发人员的工作效率。

1、数组复制：

与使用System.arraycopy进行数组复制类似， Arrays提供了一个copyOfRange方法进行数组复制。不同的是System.arraycopy需要事先准备好目标数组，并分配长度。 copyOfRange 只需要源数组就就可以了，通过返回值，就能够得到目标数组了。
另外需注意的是 copyOfRange 的第3个参数表示源数组的结束位置，是取不到的。

import java.util.Arrays;
 
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
 
        // copyOfRange(int[] original, int from, int to)
        // 第一个参数表示源数组
        // 第二个参数表示开始位置(取得到)
        // 第三个参数表示结束位置(取不到)
        int[] b = Arrays.copyOfRange(a, 0, 3);
 
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + " ");
        } 
    }
}

2、转换为字符串：

如果要打印一个数组的内容，就需要通过for循环来挨个遍历，逐一打印，但是Arrays提供了个toString()方法，直接把一个数组，转换为字符串，这样方便观察数组的内容。

import java.util.Arrays;
  
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        String content = Arrays.toString(a);
        System.out.println(content); 
    }
}

3、排序：

Arrays工具类提供了一个sort方法，只需要一行代码即可完成排序功能。

import java.util.Arrays;  
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        System.out.println("排序之前 :");
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println("排序之后:");
        System.out.println(Arrays.toString(a));  
    }
}

4、搜索：

查询元素出现的位置。需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序，如果数组中有多个相同的元素，那么查找结果是不确定的。

5、判断是否相同：

比较两个数组的内容是否一样。下面的第二个数组的最后一个元素是8，和第一个数组不一样，所以比较结果是false

6 、填充：

使用同一个值，填充整个数组。

增强型FOR循环：

它在遍历一个数组的时候会更加快捷。

public class HelloWorld {
    public static void main(String[] args) {
        int values [] = new int[]{18,62,68,82,65,9};
        //常规遍历
        for (int i = 0; i < values.length; i++) {
            int each = values[i];
            System.out.println(each);
        }         
        //增强型for循环遍历
        for (int each : values) {
            System.out.println(each);
        }         
    }
}

注：增强型for循环只能用来取值，而不能用来修改数组里的值。