本文主要是介绍Java-数组详解，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

目录

一.数组的基本用法

1.什么是数组

2.创建数组

动态初始化

静态初始化

3.数组的基本使用

获取数组长度

访问数组元素

遍历数组元素

以字符串打印数组

二.数组作为方法的参数

1.基本用法

2.理解引用类型

传内置类型

传引用类型

3. 认识null

4.初识 JVM 内存区域划分 

三.数组作为方法的返回值 

四.数组的拷贝

1.for循环进行拷贝

2.Arrays.copyOf进行拷贝

3. Arrays.copyOfRange进行拷贝

4.通过System.arraycopy进行拷贝

5.通过array.clone()进行拷贝

6.深拷贝和浅拷贝

五.数组经典习题

1.查找最大元素

2.求数组中元素的平均值

3.查找数组中指定元素

顺序查找

二分查找

4.检查数组的有序性

5.数组排序

冒泡排序

Arrays.sort

6.数组逆序

7.数组数字排列

六.二维数组

1.基本语法

2.代码示例 

3.具体用法

总结-思维导图

---

一.数组的基本用法

1.什么是数组

数组：储存一组相同数据类型的数据的集合

本质：就是让我们能 "批量" 创建相同类型的变量

举例：比如我们创建一个整型变量可以使用int a = 1；那么如果创建多个整型变量就可以使用数组int [] array = {...}

注意事项：需要注意的是，在Java中，数组储存的变量必须是同一类型！！

2.创建数组

动态初始化

基本语法：数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 }; 

接下来举个例子来深入理解一下：

public class TestDemo {
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5};
    }
}

静态初始化

基本语法：数据类型[] 数组名称 = { 初始化数据 }; 

同样的，我们来举个例子：

public class TestDemo {
    public static void main(String[] args) {
        int[] array2 = {1,2,3,4,5,6};
    }
}

 需要注意的是: 静态初始化的时候, 数组元素个数和初始化数据的格式是一致的

3.数组的基本使用

获取数组长度

public class TestDemo {
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5};
        System.out.println("length:"+array.length);
    }
}

使用 array.length 能够获取到数组的长度，" .  " 这个操作为成员访问操作符，后面在面向对象中会经常用到

访问数组元素

public class TestDemo {
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5};
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println(array[3]);
        System.out.println(array[4]);
    }
}

 

1.使用 [ ] 按下标取数组元素，需要注意的是，下标从 0 开始计数，所以下标访问操作不能超出有效范围 [0, length - 1] ，如果超出有效范围，会出现下标越界异常

2. 使用 [ ] 操作既能读取数据, 也能修改数据

遍历数组元素

法一：使用for循环遍历数组元素

public class Demo {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        for (int i = 0; i <= array.length-1 ; i++) {
            System.out.print(array[i]+" ");
        }
    }
}

 

 法二：使用for each循环遍历数组元素

for each循环：又称增强for循环，是 for 循环的另外一种使用方式，能够更方便的完成对数组的遍历，可以避免循环条件和更新语句写错。但是for each循环是拿不到下标的，用在集合中比较多 

public class Demo {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        for (int x : array) {
            System.out.print(x+" ");
        }
    }
}

以字符串打印数组

如果我们要打印一个数组，除了写一个打印方法外还能怎么打印呢？首先我们来试一下直接打印，打印出来是：[I@1b6d3586，这显然不是我们想要的。直接打印行不通，这时候我们就需要借助Java的操作数组的工具类Arrays.toString，将参数的数组以字符串的形式进行输出

import java.util.Arrays;//导入数组工具类包
public class Demo {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(Arrays.toString(array));
    }
}

  

二.数组作为方法的参数

1.基本用法

public class Demo {
    public static void printArray(int[] a){
        for (int x : a) {
            System.out.print(x+" ");
        }
    }

    public static void main(String[] args) {
        int [] array = {1,2,3,4,5};
        printArray(array);
    }
}

在这里，你可以看到int [] a是形参，而int [] array是实参

2.理解引用类型

传内置类型

public class Demo2 {
    public static void func(int x){
        x = 10;
        System.out.println("x:"+x);
    }
    public static void main(String[] args) {
        int num = 20;
        func(num);
        System.out.println("num:"+num);
    }
}

我们发现，修改形参x的值，并不影响实参num的值！ 

传引用类型

//以传输组为例
public class Demo3 {
    public static void exchange(int[] array){
        int temp = array[0];
        array[0] = array[1];
        array[1] = temp;
    }

    public static void main(String[] args) {
        int[] array ={1,2,3,4,5};
        System.out.println("交换前：");
        System.out.println("array[0]="+array[0]+",array[1]="+array[1]);
        exchange(array);
        System.out.println("交换后：");
        System.out.println("array[0]="+array[0]+",array[1]="+array[1]);
    }
}

通过这个运行结果我们可以发现，以数组为参数传参就可以修改变量的值，这是为什么呢？

1.原来，此时的array是一个引用变量，里面储存的是变量的地址。

2.引用指向的是对象，前面提到了对象储存在堆上面！Java中是能拿到堆上的地址的！

接下来再通过图来具体分析一下来帮助理解： 

关于引用的注意事项：

1.引用一定在栈上吗？这取决与变量的性质，如果是局部变量，就一定在栈上，如果是实例化成员变量就不一定了

2.一个引用能同时指向多个对象吗？不能！一个引用只能有一个对象！

3. 认识null

null：在 Java 中表示 "空引用" ， 也就是一个无效的引用

接下来通过代码让大家具体感受一下 

public class Demo4 {
    public static void exchange(int[] array){
        int temp = array[0];
        array[0] = array[1];
        array[1] = temp;
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        exchange(null);
    }
}

代码运行时报错了，我们来具体分析一下报错原因以及解决方案 

在传引用的时候null会报出空指针异常，null的作用类似于C语言中的null，都表示一个无效的内存位置，因此不能进行任何读取操作

4.初识 JVM 内存区域划分 

接下来一张图带你详细了解JVM区域划分 

这里补充一下Native 方法: JVM 是一个基于 C++ 实现的程序。在 Java 程序执行过程中，本质上也需要调用 C++ 提供的一些函数进行和操作系统底层进行一些交互。因此在 Java 开发中也会调用到一些 C++ 实现的函数。这里的 Native 方法就是指这些 C++ 实现的，再由Java 来调用的函数 

三.数组作为方法的返回值 

我们来写一个方法将数组元素都乘以2

import java.util.Arrays;
public class Demo4 {
    public static void transform(int[] array) {
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i] * 2;
        }
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        transform(array);
        System.out.println(Arrays.toString(array));
    }
}

这样写没有任何问题，但是会破坏原来数组，如果我们不希望破坏原来数组，应该怎样写呢？这时候需要在方法内部创建一个新的数组，并且返回该数组，接下来看看具体的代码实现

import java.util.Arrays;
public class Demo4 {
    public static int[] transform(int[] array) {
        int[] array2 = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            array2[i]=2*array[i];
        }
        return array2;
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] ret = transform(array);//创建一个数组来接收array2
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(ret));
    }
}

这样做就可以不破坏原来数组啦！同时，由于数组是引用类型，返回的时候只是将这个数组的首地址返回给函数调用者， 没有拷贝数组内容, 从而比较高效

四.数组的拷贝

1.for循环进行拷贝

import java.util.Arrays;
public class Demo5 {
    public static int[] copyArray(int[] array){
        int[] copy = new int[array.length];//定义一个数组的大小
        for (int i = 0; i < array.length; i++) {
            copy[i] = array[i];
        }
        return copy;
    }

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(Arrays.toString(copyArray(array)));
    }
}

2.Arrays.copyOf进行拷贝

我们通过帮助手册来了解一下copyOf的作用和使用方法：copyOf(需要拷贝的数组，拷贝的长度)

接下来通过代码实现

import java.util.Arrays;
public class Demo5 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] ret = Arrays.copyOf(array,array.length);
        System.out.println(Arrays.toString(ret));
    }
}

3. Arrays.copyOfRange进行拷贝

通过Arrays.copyOfRange拷贝局部

public class Demo5 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] ret = Arrays.copyOfRange(array,0,5);
        System.out.println(Arrays.toString(ret));
    }
}

相信看到 下标为5还不越界 这里一定有些懵， 这是因为Java的from和to都是左闭右开的，这里的to 5相当于<5，那就是取到4这里！

4.通过System.arraycopy进行拷贝

在使用Arrays.copyOf进行拷贝的时候，我们将光标移动到Arrays.copyOf上，按下ctrl键，可以得到

发现Arrays.copyOf调用了System.arraycopy，我们按住ctrl，点击System.arraycopy分析一下用法

import java.util.Arrays;
public class Demo5 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] copy = new int[array.length];
        System.arraycopy(array,0,copy,0,array.length);
        System.out.println(Arrays.toString(copy));
    }
}

5.通过array.clone()进行拷贝

.clone()会产生一个副本，里面的内容和原来的数组一模一样

import java.util.Arrays;
public class Demo6 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] copy = array.clone();
        System.out.println(Arrays.toString(copy));
    }
}

6.深拷贝和浅拷贝

首先来了解一下这俩的概念：

深拷贝：修改拷贝后的数组不会影响到原数组

浅拷贝：修改拷贝后的数组会影响到原数组

总结：想要达到深拷贝，需要对对象本身进行拷贝。刚刚我们所举得例子全是深拷贝。

如果数组放的是基本数据类型，就是深拷贝。如果数组放的是引用类型那就是浅拷贝。 

五.数组经典习题

温故而知新，接下来提供一些经典习题供读者练习，同时附上笔者解法，如有错误，请斧正！

1.查找最大元素

给定一个整型数组, 找到其中的最大元素 (找最小元素同理)

public class Test1 {
    public static void findMax(int[] array){
        int max = array[0];//从0下标开始寻找
        for (int i = 0; i < array.length; i++) {
            if(array[i]>max){
                max = array[i];
            }
        }
        System.out.println(max);
    }

    public static void main(String[] args) {
        int[] array = {1,5,7,9,11};
        findMax(array);
    }
}

2.求数组中元素的平均值

给定一个整型数组, 求平均值 

public class Test2 {
    public static double average(int[] array){
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        double num = (double)sum/(double)array.length;
        return num;
    }
    
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(average(array));
    }
}

3.查找数组中指定元素

给定一个数组, 再给定一个元素, 找出该元素在数组中的位置.

顺序查找

public class Test3 {
    public static int find(int[] array,int toFind){
        for (int i = 0; i < array.length; i++) {
            if (array[i] == toFind){
                return i;
            }
        }
        return -1;//表示未找到
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6};
        System.out.println(find(array,5));
    }
}

二分查找

二分查找有个缺陷，就是只能查找全是升序或者降序的数组，接下来以升序为例 

public class Test4 {
    public static int binarySearch(int[] array,int toFind){
        int left = 0;
        int right = array.length-1;
        while(left<=right){
            int mid =(right+left)/2;
            if(toFind>array[mid]){//在右半区去找，并且缩小范围
                left = mid+1;
            }else if(toFind<array[mid]){//在左半区去找，并且缩小范围
                right = mid-1;
            }else{
                return mid;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6};
        System.out.println(binarySearch(array,2));
    }
}

4.检查数组的有序性

给定一个整型数组, 判断是否该数组是有序的(升序) 

public class Test5 {
    public static boolean func(int[] array){
        for (int i = 0; i < array.length; i++) {
            if(array[i]<array[i+1]){
                return true;
            }
        }
        return false;
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(func(array));
    }
}

5.数组排序

给定一个数组, 让数组升序 (降序) 排序 

冒泡排序

import java.util.Arrays;
public class Test6 {
    public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length-1-i ; j++) {
                if(array[j]>array[j+1]){
                    int temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[] array = {1,8,9,5,4};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}

Arrays.sort

冒泡排序性能较低. Java 中内置了更高效的排序算法：Array.sort

import java.util.Arrays;
public static void main(String[] args) {
        int[] array = {1,8,9,5,4};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

6.数组逆序

给定一个数组, 将里面的元素逆序排列

思路：给定两个下标分别指向第一个元素和最后一个元素，让这两个元素交换，然后再实现自增和自减，重复该操作，直到走到数组的最中间 

import java.util.Arrays;
public class Test7 {
    public static void reverse(int[] array){
        int left = 0;
        int right = array.length-1;
        while(left < right){
            int temp = array[left];
            array[left] = array[right];
            array[right] = temp;
            left++;
            right--;
        }
    }

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        reverse(array);
        System.out.println(Arrays.toString(array));
    }
}

7.数组数字排列

给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分

基本思路：设定两个下标分别指向第一个元素和最后一个元素。 用前一个下标从左往右找到第一个奇数，用后一个下标从右往左找到第一个偶数，然后交换两个位置的元素. 依次循环即可 

import java.util.Arrays;
public class Test8 {
    public static void transform(int[] array){
        int left = 0;
        int right = array.length-1;
        while(left < right){
            while(left<right && array[left]%2==0){
                left++;//如果是偶数，则去判断下一个元素
            }
            while(left<right && array[right]%2!=0){
                right--;//如果是奇数，则去判断下一个元素
            }
            //交换奇数和偶数
            int temp = array[left];
            array[left] = array[right];
            array[right] = temp;
        }
    }
    public static void main(String[] args) {
        int[] array = {1,2,6,8,9,7};
        transform(array);
        System.out.println(Arrays.toString(array));
    }
}

六.二维数组

1.基本语法

数据类型[ ][ ] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 }; 

Java中二维数组可以省略列，不能省略行

int[][]array = {{1,2,},{3,4},{5,6}};
int[][]array2 = new int[3][2];
int[][]array3 = new int[][]{{1,2,},{3,4},{5,6}};

2.代码示例 

public class TestDemo {
    public static void main(String[] args) {
        int[][] arr = {
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11, 12}
        };
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.printf("%d\t", arr[i][j]);
            }
            System.out.println("");
        }
    }
}

3.具体用法

二维数组的具体用法与一维数组类似，这里不再赘述

总结-思维导图

这篇关于Java-数组详解的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！