Java - 数组

数组操作指南

基本概念

[plain]  view plain  copy
  1. 数组是存放相同类型数据的有序集合,通过下标或者索引来使用数组  

声明创建

[plain]  view plain  copy
  1. 声明数组对象   
  2.     int[] a; 声明整型一维数组引用a  
  3. 创建数组对象  
  4.     创建时必须给定第一维的长度,否则系统无法分配空间,导致编译失败  
  5.     new int[4]; 创建整型一维数组对象  
  6.     a = new int[4]; 将引用a指向长度为4的整型一维数组对象  
  7. 二维数组声明      
  8.     int a [][] = new int[行的个数][列的个数]  
  9. 对于数组对象来说,对象一旦被创建,大小不可改变,  
  10.     也就是说数组的length属性是public,final,int的  

数组初始化

[plain]  view plain  copy
  1. 数组初始化包括默认初始化,循环初始化,枚举初始化  
  2. int[] day = {1,2,3,4,5};    
  3. int[] day = new int[]{1,2,3,4,5};//枚举初始化  
  4. int[][] day = {{1,12},{2,12}{3,12},{4,12},{5,12}};    
  5. int[][] day = new int[][]{{1,12},{2,12}{3,12},{4,12},{5,12}};  

交换两个原生数据类型的数据只能采用数组来交换

[java]  view plain  copy
  1. package com.itlwc;  
  2.   
  3. public class Test {  
  4.     public static void main(String[] args) {  
  5.         int[] i = { 12 };  
  6.         swap(i);  
  7.         System.out.println(i[0]);  
  8.         System.out.println(i[1]);  
  9.     }  
  10.   
  11.     public static void swap(int[] i) {  
  12.         int temp = i[0];  
  13.         i[0] = i[1];  
  14.         i[1] = temp;  
  15.     }  
  16. }  

数组遍历

[java]  view plain  copy
  1. package com.itlwc;  
  2.   
  3. public class Test {  
  4.     public static void main(String[] args) {  
  5.         int[] a = new int[] { 12345 };  
  6.         // 遍历1  
  7.         for (int i = 0; i < a.length; i++) {  
  8.             System.out.print(a[i]);  
  9.         }  
  10.         System.out.println();  
  11.         // 遍历2  
  12.         for (int i : a) {  
  13.             System.out.print(i);  
  14.         }  
  15.     }  
  16. }  

数组复制

[java]  view plain  copy
  1. package com.itlwc;  
  2.   
  3. import java.util.Arrays;  
  4.   
  5. public class Test {  
  6.     public static void main(String[] args) {  
  7.         int[] a = new int[] { 12345 };  
  8.         int[] b = new int[a.length];  
  9.         // 方法一  
  10.         System.arraycopy(a, 0, b, 0, a.length);  
  11.         // 方法二  
  12.         b = Arrays.copyOf(a, a.length);  
  13.         // 方法三  
  14.         b = Arrays.copyOfRange(a,0,a.length);  
  15.     }  
  16. }  

数组排序

[java]  view plain  copy
  1. package com.itlwc;  
  2.   
  3. import java.util.Arrays;  
  4.   
  5. public class Test {  
  6.     public static void main(String[] args) {  
  7.         int[] a = new int[] { 12345 };  
  8.         int[] b = new int[] { 12345 };  
  9.         // 方法一  
  10.         Arrays.sort(a);  
  11.         // 方法二  
  12.         Arrays.sort(a, 0, a.length);  
  13.         // 方法三  
  14.         mySort(b);  
  15.     }  
  16.   
  17.     public static void mySort(int[] b) {  
  18.         for (int i = 0; i < b.length; i++) {  
  19.             for (int j = 0; j < b.length; j++) {  
  20.                 if (b[i] > b[j]) {  
  21.                     int temp = 0;  
  22.                     temp = b[i];  
  23.                     b[i] = b[j];  
  24.                     b[j] = temp;  
  25.                 }  
  26.             }  
  27.         }  
  28.     }  
  29. }  

搜索指定元素

[java]  view plain  copy
  1. package com.itlwc;  
  2.   
  3. import java.util.Arrays;  
  4.   
  5. public class Test {  
  6.     public static void main(String[] args) {  
  7.         int[] a = new int[] { 12345 };  
  8.         // 方法一  
  9.         Arrays.binarySearch(a, 1);  
  10.         // 方法二  
  11.         Arrays.binarySearch(a, 0, a.length, 1);  
  12.     }  
  13. }  

比较数组的元素

[java]  view plain  copy
  1. package com.itlwc;  
  2.   
  3. import java.util.Arrays;  
  4.   
  5. public class Test {  
  6.     public static void main(String[] args) {  
  7.         int[] a = new int[] { 12345 };  
  8.         int[] b = new int[] { 12345 };  
  9.         Arrays.equals(a, b);  
  10.     }  
  11.   
  12.     // 比较的方法  
  13.     public static boolean equals(int[] a, int[] b) {  
  14.         if (a == null || b == null)  
  15.             return false;  
  16.         if (a.length != b.length)  
  17.             return false;  
  18.         for (int i = 0; i < a.length; i++)  
  19.             if (a[i] != b[i])  
  20.                 return false;  
  21.         return true;  
  22.     }  
  23. }  

二分查找

[java]  view plain  copy
  1. package com.itlwc;  
  2.   
  3. public class Test {  
  4.     public static void main(String[] args) {  
  5.         int[] a = { 123456789 };  
  6.         int value = 9;  
  7.         System.out.println(new Test().get(a, value));  
  8.     }  
  9.   
  10.     public int get(int[] a, int value) {  
  11.         int min = 0;  
  12.         int max = a.length - 1;  
  13.         int middle;  
  14.         while (min <= max) {  
  15.             middle = (min + max) / 2;  
  16.             if (a[middle] == value) {  
  17.                 return middle;  
  18.             }  
  19.             if (value < a[middle]) {  
  20.                 max = middle - 1;  
  21.             }  
  22.             if (value > a[middle]) {  
  23.                 min = middle + 1;  
  24.             }  
  25.         }  
  26.         return -1;  
  27.     }  
  28. }  
<think>好的,用户现在问的是Java入门中的数组基础。我需要先回想一下之前的对话历史,用户之前问过关于IDEA的解释,现在转向Java基础,说明他们可能刚开始学习编程,或者是想巩固基础知识。首先,用户的需求是了解数组的基础知识,作为Java入门的一部分。我需要确保内容结构清晰,符合用户提到的系统级指令,比如行内数学公式用$...$,独立公式用$$...$$,同时用中文回答。 首先,数组Java中的基本数据结构,必须涵盖定义、声明、初始化、访问元素、遍历、多维数组、常见操作以及注意事项。可能需要分点来讲解,每个部分都要简明扼要,同时确保例子正确,语法无误。比如在声明数组的时候,有两种方式:数据类型[] 数组名 或者 数据类型 数组名[],但推荐前者。初始化部分要分静态和动态,静态初始化是在声明时赋值,动态是使用new关键字,之后赋值。 需要注意Java数组的索引从0开始,越界会抛异常,这点很重要。遍历部分可以用for循环或增强for循环,需要给出例子。多维数组部分,特别是二维数组,需要说明如何声明和初始化,并给出例子,比如二维数组的静态和动态初始化。 常见操作部分,用户可能需要知道如何获取长度,使用Arrays类的方法,比如排序、填充、复制等。注意事项里,数组长度不可变,引用类型的问题,以及性能考虑,比如连续内存分配和随机访问效率高,但增删元素效率低。这些都需要清晰列出。 另外,用户可能作为初学者,需要避免常见的错误,比如数组越界、空指针异常,这些在注意事项里提到会比较有帮助。同时,可能需要强调数组是对象,存储在堆内存中,而数组变量是引用,这点对于理解数组的传递和复制很重要。 还要检查是否有需要使用的数学公式,比如在解释数组长度时,可能用$length = n$,或者在多维数组中的表示,比如二维数组可以看作矩阵,用$array[i][j]$表示元素。不过根据之前的回答例子,可能不需要太多数学公式,但需要确保行内公式正确使用$符号。 最后,确保结构符合用户的要求,分点明确,步骤清晰,例子正确,并且用中文回答。同时,要检查是否有遗漏的部分,比如数组的默认值,当动态初始化时,元素会有默认值,比如int数组初始为0,对象数组为null,这也是需要注意的点。</think>我们将以结构化方式解析Java数组的核心知识点,重点标注$\boxed{关键语法}$和易错点: --- ### 一、数组定义与特性 $$数组 = \text{相同数据类型} \times \text{连续内存空间} \times \text{固定长度}$$ - **核心属性**: 1. 索引系统:$\boxed{下标从0开始}$,访问越界触发`ArrayIndexOutOfBoundsException` 2. 长度固定:$\boxed{array.length}$为最终属性(声明后不可变) 3. 堆内存分配:数组是$\boxed{对象}$,通过引用访问 --- ### 二、声明与初始化 #### 1. 声明方式对比 | 类型 | 语法示例 | 内存状态 | |---------------|---------------------------|-------------| | 声明未初始化 | `int[] arr;` | 仅创建引用 | | 静态初始化 | `int[] arr = {1,3,5};` | 立即分配内存 | | 动态初始化 | `int[] arr = new int[3];` | 分配默认值 | #### 2. 默认值规则 - 数值类型:$\boxed{0}$(int/double等) - 布尔类型:$\boxed{false}$ - 引用类型:$\boxed{null}$ --- ### 三、核心操作 #### 1. 元素访问(时间复杂度$O(1)$) ```java int[] scores = new int[]{90,85,77}; System.out.println(scores[1]); // 输出85 scores[2] = 80; // 修改第三个元素 ``` #### 2. 数组遍历(时间复杂度$O(n)$) ```java // 传统for循环 for(int i=0; i < scores.length; i++){ System.out.println(scores[i]); } // 增强for循环(只读访问) for(int score : scores){ System.out.println(score); } ``` --- ### 四、多维数组 #### 1. 二维数组本质:$\boxed{数组数组}$ ```java // 静态初始化 int[][] matrix = {{1,2}, {3,4,5}}; // 动态初始化 double[][] data = new double[2][3]; ``` #### 2. 不规则数组 ```java String[][] names = new String[2][]; names[0] = new String[3]; // 第一行3列 names[1] = new String[2]; // 第二行2列 ``` --- ### 五、工具类应用 #### `java.util.Arrays`常用方法 | 方法 | 功能描述 | 示例 | |------------------------|------------------------|--------------------------------| | `sort()` | 数组排序 | `Arrays.sort(arr);` | | `binarySearch()` | 二分查找 | `Arrays.binarySearch(arr,5);` | | `copyOf()` | 数组复制 | `int[] copy = Arrays.copyOf(arr,5);` | | `fill()` | 填充默认值 | `Arrays.fill(arr, 0);` | --- ### 六、典型错误案例 1. **长度混淆**: ```java int[] arr = new int[5]; System.out.println(arr[5]); // 抛出ArrayIndexOutOfBoundsException ``` 2. **空指针异常**: ```java int[][] arr = new int[3][]; System.out.println(arr[0][0]); // 第二维未初始化,触发NullPointerException ``` 3. **引用陷阱**: ```java int[] a = {1,2,3}; int[] b = a; // b与a指向同一数组对象 b[0] = 9; // 修改会影响a[0]的值 ``` --- ### 七、最佳实践建议 1. **内存优化**:优先使用基本类型数组而非包装类数组 2. **防御性编程**:关键操作前检查`array != null && index < array.length` 3. **集合替代**:频繁增删数据时建议使用`ArrayList` 是否需要通过具体代码案例进一步演示数组操作细节?
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值