Java中数组的理解

最新推荐文章于 2023-02-16 10:07:29 发布

QDNBD

最新推荐文章于 2023-02-16 10:07:29 发布

阅读量352

点赞数 1

分类专栏： java基础

本文链接：https://blog.csdn.net/QDNBD/article/details/102650337

版权

java基础专栏收录该内容

8 篇文章 1 订阅

订阅专栏

数组的定义
本质上就是存放相同类型的变量集合。例如：

public class test {
    public static void main(String[] args) {
        int[] array =  {1,2,3,4,5};
        double[] array =  {1.0,2,3.0,4,5};
    }
}

那是不是所有类型都可以用数组表示定义呢？
答案当然不是，boolean类型不能用数组定义。

数组的创建
数组的初始化有以下形式：

 public static void main(String[] args) {
       int[] array = {1,2,3};//静态初始化
       int[] array2 = new int[]{1,2,3};//动态初始化
       int[] array1 = new int[10];//只是定义了一个数组，默认值为0；
    }

注意: 静态初始化的时候, 数组元素个数和初始化数据的格式要保持一致。
那该怎么计算数组长度？又怎么特定输出某个数组元素呢？

	int[] array = {1,2,3};
	//计算数组长度
    int se = array.length;
    System.out.println(se);
    //访问某个数组元素
    System.out.println(array[0]);//结果为1
    System.out.println(array[1]);//结果为2
    array[0] = 100;
    System.out.println(array[0]);//结果为100

注意：

使用 arr.length 能够获取到数组的长度。"." 点号这个操作为成员访问操作符。后面一般接属性，行为等。
使用 [ ] 按下标取数组元素。需要知道下标从 0 开始计数的。
使用 [ ] 操作既能读取数据，也能修改数据。
下标访问操作不能超出有效范围 [0, length - 1] ，如果超出有效范围,，会出现下标越界异常。

异常
越界异常

        int[] array = new int[10];
        System.out.println(array[20]);
//输出结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 20
	at test.main(test.java:6)

空指针异常

        int[] array = null;
        System.out.println(array[2]);
//输出结果
Exception in thread "main" java.lang.NullPointerException
	at test.main(test.java:6)

要出现异常时知道是什么异常，方便修正。

数组的遍历
数组的遍历是指访问数组中的每一个元素，做到不漏不错。通常是采用循环语句。

int[] array = {1, 2, 3};
for (int i = 0; i < array.length; i++) {
  System.out.println(array[i]);
}

使用for-each语句：

int[] array = {1, 2, 3};
for (int x : array) {
  System.out.println(x);
}

这俩个循环语句都是可以遍历数组中所有的元素。
for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错。但是它不能访问数组下标的。

数组作为方法的参数
先来一个代码示例感受一下。

	public static void main(String[] args) {
       int[] array = {1,2,3};
        printArray(array);//打印array数组内容
    }

    public static void printArray(int[] arr) {
        for (int x:arr) {
            System.out.println(x);
        }
    }

这就是一个方法的应用。int[] arr 是函数的形参, int[] array 是函数实参。
理解引用类型(重点/难点)
传参内置类型

public static void main(String[] args) {
  int num = 0;
  func(num);
  System.out.println("num = " + num);
}
public static void func(int x) {
  x = 10;
  System.out.println("x = " + x);
}
// 执行结果
x = 10
num = 0

我们发现改变形参x,实参num没有改变。
画图解析：
在这里插入图片描述
Java中是按值传递，num 把值传递过去后，x接收，x的在内存上的改变并不影响num的值大小。
既然如此我们看以下这个代码：

     public static void main(String[] args) {
        int[] array = {1,2,3};
        func(array);
        System.out.println(array[0]);
    }
    public static void func(int[] arr) {
        arr[0] = 99;
        System.out.println(arr[0]);
    }

//输出结果
arr[0] = 99;
array[0] = 99;

看到这个结果是不是特别惊讶，为什么没有返回值array[0] = 0？
答案：这是数组的引用。引用相当于一个 “别名”, 也可以理解成一个指针.
创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址。看似是按值传递，其实是相当于传了这个原数组的内存地址。如下图：

在这里插入图片描述
1.开始的时候创建了一个内存，里面放了1，2，3。
2.相当于将上一个内存地址传给了arr[],指向array[]的内存；
3.将arr[0]的值改成了99；因为是指向同一地址，
所以array[0]也改成了99。

	public static void main(String[] args) {
        int[] array = {1,2,3};
        transform(array);
        System.out.println(array);
     }
	public static void transform(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
		arr[i] = arr[i] * 2;
		}
		System.out.println(arr);
	}


//输出结果
array：2，4，6
arr：2，4，6

看这个代码有什么问题吗？
这个代码固然可行, 但是破坏了原有数组。有时候我们不希望破坏原数组, 就需要在方法内部创建一个新的数组, 并由方法返回出来。

	public static void main(String[] args) {
        int[] array = {1,2,3};
        transform(array);
        System.out.println(array);
     }
	public static void transform(int[] arr) {
		int[] ret = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
		ret[i] = arr[i] * 2;
		}
		System.out.println(arr);
	}

//输出结果
array：1，2，3
arr：2，4，6

数组转字符串

/**
普通实现版本
*/
	public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        System.out.println(toString(arr));
    }
    public static String toString(int[] array) {
        String arr1 = "[";
        for (int i = 0; i <array.length ; i++) {
            arr1 += array[i];
            if(i != array.length - 1) {
                arr1 += ",";
            }
        }arr1 += "]";
        return arr1;
    }

/**
Array 方法版本
*/
	import java.util.Arrays
	public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
		String newArr = Arrays.toString(arr);
		System.out.println(newArr);
    }
		
// 执行结果
[1, 2, 3, 4, 5, 6]

数组拷贝

import java.util.Arrays
	public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
		int[] newArr = Arrays.copyOf(arr, arr.length);
		System.out.println("newArr: " + Arrays.toString(newArr));
    }
    public static String toString(int[] array) {
        arr[0] = 10;
		System.out.println("arr: " + Arrays.toString(arr));
		System.out.println("newArr: " + Arrays.toString(newArr));
    }

该方法为深拷贝。
深拷贝：在拷贝过程中不会修该原数组的值；
浅拷贝：在拷贝过程中会修改原数组的值；

数组的拷贝共有四种方法：

 1、for循环去拷贝
 2、System.arraycopy
 3、Arrays.copyOf
 4、数组名.clone();  clone是Object的方法
    返回一个副本
   数组名->你要拷贝的数组

二分查找

	public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9};
        int[] newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("二分查找:" + binarySearch(newArr,5,arr.length));
    }
    public static int binarySearch(int[] array,int key,int right) {
        int left = 0;
        if(left > right) {
            return -1;
        }
        int mid = (left+right) >>> 1;
        if(array[mid] == key) {
            return mid;
        }else if (array[mid] < key) {
            return binarySearch(array,key,left = mid+1);
        }else {
            return binarySearch(array,key,right = mid-1);
        }
    }

针对有序数组, 使用更高效的二分查找.

啥叫有序数组?
有序分为 “升序” 和 “降序”
如 1 2 3 4 , 依次递增即为升序.
如 4 3 2 1 , 依次递减即为降序.

以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小. 如果小, 就去左边找; 否则就去右边找.代码如上。

学习Arrays类当中的方法：

 	 Arrays.toString();//输出数组
     Arrays.copyOf();//拷贝数组
     Arrays.copyOfRange();//拷贝部分数组 [ )左闭右开形式
     Arrays.binarySearch();//二分查找 [ )左闭右开形式
     Arrays.equals();//判断数组是否相同
     Arrays.fill(array,9); //数组的填充
     Arrays.fill(array,2,7,88);[2,7)//下标填充为88 [ )左闭右开形式
     Arrays.sort(array);//将数组进行排序

二维数组
二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组.

	public static void main10(String[] args) {
        //二维数组
        int[][] array = {{1,2,3},{4,5,6}};
        int[][] array2 = new int[][]{{1,2,3},{4,5,6}};
        int[][] array3 = {{1,2},{4,5,6}};
      /**
        都可以用以下方式输出二维数组
      */
		for (int i = 0; i < array3.length; i++) {
        	for (int j = 0; j < array3[i].length; j++) {
            System.out.print(array3[i][j] + " ");
            }
         }

小技巧
可变参数编程

    public static void main(String[] args) {
         System.out.println(sum(1,2,3,4,5));
         System.out.println(sum(1,2,3,4,5,6));
    }
    public static int sum(int... array) {
        int ret = 0;
        for (int x:array) {
            ret += x;
        }
        return ret;
    }

看代码中一个方法就可以完成同类型的多个参数的多次调用,极大的方便了实际的需要。

Java中数组的冒泡排序，二分查找，顺序查找，最大值，最小值，数组逆序，数组数字排列等代码看以下链接：
https://blog.csdn.net/QDNBD/article/details/102656055

QDNBD

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Java中数组的理解

数组的定义本质上就是存放相同类型的变量集合。例如：public class test { public static void main(String[] args) { int[] array = {1,2,3,4,5}; double[] array = {1.0,2,3.0,4,5}; }}那是不是所有类型都可以用数组表示定义呢？...
复制链接

扫一扫