改变数组的值（改变数组中的值）

1. 理解数组基本概念

2. 掌握数组的基本用法

3. 数组与方法互操作

相同类型元素的一个集合, 在内存中是一段连续的空间

T [] 数组名 = new T [ N ]; //数组的创建

T ：表示数组中存放元素的类型

T[] ：表示数组的类型

N ：表示数组的长度

数组的初始化主要分为动态初始化以及静态初始化

1. 动态初始化：在创建数组时，直接指定数组中元素的个数
int[] array = new int[18];
2. 静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定
int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9}; double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0}; String[] array3 = new String[]{"hell", "Java", "!!!"};
注意事项:

静态初始化虽然没有指定数组的长度,译器在编译时会根据 {} 中元素个数来确定数组的长度

静态初始化时, {} 中数据类型必须与 [] 前数据类型一致

静态初始化可以简写,省去后面的new T[]

虽然省去了 new T[], 但是编译器编译代码时还是会还原

静态和动态初始化也可以分为两步，但是省略格式不可以
int[] array1; array1 = new int[10]; int[] array2; array2 = new int[]{10, 20, 30}
// 注意省略格式不可以拆分 , 否则编译失败

// int[] array3;

// array3 = {1, 2, 3};

如果没有对数组进行初始化，数组中元素有其默认值

如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值

1.2.1 数组中元素访问

数组在内存中是一段连续的空间，空间的编号都是从 0 开始的，依次递增，该编号称为数组的下标，数组可以通过 下标访问其任意位置的元素

int[]array = new int[]{10, 20, 30, 40, 50};

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]);

// 也可以通过[]对数组中的元素进行修改

array[0] = 100;

System.out.println(array[0]);

注意事项:

1. 数组是一段连续的内存空间，因此 支持随机访问，即通过下标访问快速访问数组中任意位置的元素

2. 下标从 0 开始，介于 [0, N ）之间不包含 N ， N 为元素个数，不能越界，否则会报出下标越界异常

1.2.2 遍历数组

" 遍历 " 是指将数组中的所有元素都访问一遍 , 访问是指对数组中的元素进行某种操作

在数组中可以通过 数组对象 .length 来获取数组的长度

int[]array = new int[]{10, 20, 30, 40, 50}; for(int i = 0; i < array.length; i++){ System.out.println(array[i]); } // fori

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

1.2.3 数组的应用

1.保存数据

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

2. 作为函数的参数

1. 参数传基本数据类型 public static void main(String[] args) { //x = 10 int num = 0; //num = 0 func(num); System.out.println("num = " + num); } public static void func(int x) { x = 10; System.out.println("x = " + x); } //发现在func方法中修改形参 x 的值,不影响实参的 num 值
2. 参数传数组类型 ( 引用数据类型 )
public static void main(String[] args) { //a[0] = 10 int[] arr = {1, 2, 3}; //arr[0] = 10 func(arr); System.out.println("arr[0] = " + arr[0]); } public static void func(int[] a) { a[0] = 10; System.out.println("a[0] = " + a[0]); }
发现在 func 方法内部修改数组的内容 , 方法外部的数组内容也发生改变

因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的内容的

所谓的 " 引用 " 本质上只是存了一个地址 . Java 将数组设定成引用类型 , 这样的话后续进行数组参数传参 , 其实只是将数组的地址传入到函数形参中 . 这样可以避免对整个数组的拷贝 ( 数组可能比较长 , 那么拷贝开销就会很大 )

1.2.4 基本类型变量与引用类型变量的区别

基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值

而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址

引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该

地址，引用变量便可以去操作对象

有点类似 C 语言中的指针，但是 Java 中引用要比指针的操作更简单

null 在 Java 中表示 " 空引用 " , 也就是一个不指向对象的引用

null 的作用类似于 C 语言中的 NULL ( 空指针 ), 都是表示一个无效的内存位置 . 因此不能对这个内存进行任何读写操作 . 一旦尝试读写 , 就会抛出 NullPointerException

注意 : Java 中并没有约定 null 和 0 号地址的内存有任何关联

import java.util.Arrays; public class Test4 { public static void main(String[] args) { // newArr和arr引用的是同一个数组 // 因此newArr修改空间中内容之后，arr也可以看到修改的结果 int[]arr={1,2,3,4,5,6}; int[]newArr=arr; newArr[0]=10; System.out.println("newArr: "+Arrays.toString(arr)); // 使用Arrays中copyOf方法完成数组的拷贝： // copyOf方法在进行数组拷贝时，创建了一个新的数组 // arr和newArr引用的不是同一个数组 arr[0]=1; newArr=Arrays.copyOf(arr,arr.length); System.out.println("newArr: "+Arrays.toString(newArr)); // 因为arr修改其引用数组中内容时，对newArr没有任何影响 arr[0]=10; System.out.println("arr: "+Arrays.toString(arr)); System.out.println("newArr: "+Arrays.toString(newArr)); // 拷贝某个范围. int[]newArr2=Arrays.copyOfRange(arr,2,4); System.out.println("newArr2: "+Arrays.toString(newArr2)); } }

注意：数组当中存储的是基本类型数据时，不论怎么拷贝基本都不会出现什么问题，但如果存储的是引用数据类型，拷贝时需要考虑深浅拷贝的问题

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

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

public static void main(String[] args) { int[] arr = {1,2,3,10,5,6}; System.out.println(find(arr, 10)); } public static int find(int[] arr, int data) { for (int i = 0; i < arr.length; i++) { if (arr[i] == data) { return i; } } return -1; // 表示没有找到 } //3

以升序数组为例 , 二分查找的思路是先取中间位置的元素 , 然后使用待查找元素与数组中间元素进行比较：

如果相等，即找到了返回该元素在数组中的下标

如果小于，以类似方式到数组左半侧查找

如果大于，以类似方式到数组右半侧查找

public static void main(String[] args) { int[] arr = {1,2,3,4,5,6}; System.out.println(binarySearch(arr, 6)); } public static int binarySearch(int[] arr, int toFind) { int left = 0; int right = arr.length - 1; while (left <= right) {int mid = (left + right) / 2; if (toFind < arr[mid]) { // 去左侧区间找 right = mid - 1; } else if (toFind > arr[mid]) { // 去右侧区间找 left = mid + 1; } else { // 相等, 说明找到了 return mid; } } // 循环结束, 说明没找到 return -1; } //5

可以看到 , 针对一个长度为 10000 个元素的数组查找 , 二分查找只需要循环 14 次就能完成查找 . 随着数组元素个数越多 , 二分的优势就越大

算法思路

假设排升序：

1. 将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数组的末尾

2. 依次从上上述过程，直到数组中所有的元素都排列好

public static void main(String[] args) { int[] arr = {9, 5, 2, 7}; bubbleSort(arr); System.out.println(Arrays.toString(arr)); } public static void bubbleSort(int[] arr) { for (int i = 0; i < arr.length; i++) { for (int j = 1; j < arr.length-i; j++) { if (arr[j-1] > arr[j]) { int tmp = arr[j - 1]; arr[j - 1] = arr[j]; arr[j] = tmp; } } } // end for } // end bubbleSort //[2, 5, 7, 9]

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

public static void main(String[] args) { int[] arr = {9, 5, 2, 7}; Arrays.sort(arr); System.out.println(Arrays.toString(arr)); }

思路

设定两个下标 , 分别指向第一个元素和最后一个元素 . 交换两个位置的元素 .

然后让前一个下标自增 , 后一个下标自减 , 循环继续即可

public static void main(String[] args) { int[] arr = {1, 2, 3, 4}; reverse(arr); System.out.println(Arrays.toString(arr)); } public static void reverse(int[] arr) { int left = 0; int right = arr.length - 1; while (left < right) { int tmp = arr[left]; arr[left] = arr[right]; arr[right] = tmp; left++; right--; } }

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

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

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

1 2 3 4

5 6 7 8

9 10 11 12

二维数组的用法和一维数组并没有明显差别 , 因此不再赘述

同理 , 还存在 " 三维数组 ", " 四维数组 " 等更复杂的数组 , 只不过出现频率都很低

到此这篇改变数组的值（改变数组中的值）的文章就介绍到这了,更多相关内容请继续浏览下面的相关推荐文章，希望大家都能在编程的领域有一番成就！

上一篇：圈1电脑上怎么打出来表格（电脑中的圈1怎么打）

下一篇：反激电路的原理（反激电路原理图EMC）

版权声明：
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若内容造成侵权、违法违规、事实不符，请将相关资料发送至xkadmin@xkablog.com进行投诉反馈，一经查实，立即处理！

转载请注明出处，原文链接：https://www.xkablog.com/jszy-jszl/74908.html

1.2.1 数组中元素访问

1.2.2 遍历数组

1.2.3 数组的应用

1.2.4 基本类型变量与引用类型变量的区别

相关文章：