Java基础之数组详解

前言

我们了解数组这个概念之前，我们先思考下面几个问题。

如果我们需要两个数据，那么直接创建两个变量即可

1. int a;
2. int b;

如果需要五个数据，那么可以创建五个变量

1. int a;
2. int b;
3. int c;
4. int d;
5. int f;

但如果我们需要100个甚至是1万个数据，那么我们创一万个变量？显然这是不现实的。这个时候就需要我们的数组来起作用！帮我们“批量”创建变量。

由上可以得出：数组的本质就是让我们能“批量”创建相同类型的变量！

一.数组的概念

数组是一种数据结构，用来存储同一类型的集合，也就是说数组包含的变量必须是相同类型！

二.创建数组

基本语法如下：

1. //动态初始化
2. 数据类型[] 数组名称 = new 数据类型 []{初始化数据};
3. //静态初始化
4. 数据类型[] 数组名称 = {初始化数据};

代码示例

1. public class TestDemo {
2. public static void main(String[] args) {
3. //动态初始化
4. //数据类型[] 数组名称 = new 数据类型 []{初始化数据};
5. int[] arr1 = new int[]{1,2,3};
6. //静态初始化
7. //数据类型[] 数组名称 = {初始化数据};
8. int[] arr2 ={1,2,3};
9. }
10. }

注意：静态初始化的时候，数组元素的个数和初始化数据的格式是一样的！

如果你学过其他语言，例如C语言，c语言的数组创建是这样的

1. 数据类型 数组名[]={初始化数据};
2.  
3. 例如： int arr[] = {1,2,3};

其实Java中也可以做到这样，但是不推荐这么写，Java是一种强类型语言，变量前面就是类型，一目了然！

三.数组的使用

我们看一个例子，如何获取数组的长度？

如果你学过C语言，那么肯定会说

1. int sz = sizeof(arr) / sizeof(arr[0]);

其实Java比c语言更方便，直接使用“数组名.length”就可以求出来数组的长度。

代码如下：

1. public class TestDemo {
2. public static void main(String[] args) {
3. int[] arr ={1,2,3};
4. int len = arr.length;
5. System.out.println(len);//3
6. }
7. }

毫无疑问这个代码运行结果是3；

那么我们如何访问数组元素呢？

我们来看下面的代码：

1. public class TestDemo {
2. public static void main(String[] args) {
3. int[] arr ={1,2,3};
4. int len = arr.length;
5. System.out.println(len);//3
6. System.out.println(arr[0]);//1
7. System.out.println(arr[1]);//2
8. System.out.println(arr[2]);//3
9. }
10. }

显而易见的是，直接使用数组名[数组元素下标]来访问数组元素。但出现了一个问题，为什么arr[0]是1而arr[1]是2？为什么不是arr[1]是1 arr[2]是2吗？

这里我们得出一个结论，数组的下标是从0开始的，不是从1开始的。

我们来尝试访问一下arr[3]看会出现什么情况.

1. public class TestDemo {
2. public static void main(String[] args) {
3. int[] arr ={1,2,3};
4. int len = arr.length;
5. System.out.println(len);//3
6. System.out.println(arr[0]);//1
7. System.out.println(arr[1]);//2
8. System.out.println(arr[2]);//3
9. System.out.println(arr[3]);
10. }
11. }

我们发现前面都和我们预想一样输出结果都正确，但唯独出现了一串红字，这串红字说明存在数组越界。

我们由此得出一个结论：在Java下标访问操作中不能超出有效范围也就是[0,length-1],如果超出有效范围，会抛出下标越界异常。

四.数组的遍历

所谓遍历，是指将数组中的所有元素都访问一遍，不重不漏，需要搭配循环语句！

我们学了数组的访问，那么我们如何遍历数组呢？有两种常用方法 一种是for循环，一种是foreach循环。

for循环示例

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

我们发现打印出来了数组的元素。

for-each示例

foreach基本使用方法：元素类型 变量：数组名

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

执行结果一致。

那么我们什么时候使用for循环，什么时候使用foreach循环？

foreach循环适用于不知道循环次数，或者是循环次数很难计算。

for循环适用于知道循环次数，在复杂的循环中效率更高。

如果是在循环中使用增删查改操作，for循环可以实现，因为foreach循环不能实现这些操作。

五.数组作为方法的参数

基本用法：

1.打印数组内容

代码示例：

1. public class TestDemo {
2. public static void printArray(int[] arr){
3. for(int x:arr){
4. System.out.print(x+" ");
5. }
6. }
7. public static void main(String[] args) {
8. int[] arr = {2,3,4,5,6};
9. printArray(arr);
10. }
11. }

2.求数组元素的和

1. public class TestDemo {
2. public static int sum(int []arr) {
3. int sum = 0;//一定要初始化为0，不然是随机值
4. for (int i = 0; i < arr.length; i++) {
5. sum += arr[i];
6. }
7. return sum;
8. }
9.  
10. public static void main(String[] args) {
11. int[] arr = {1,2,3,4,5};
12. int ret = sum(arr);
13. System.out.println(ret);
14. }
15. }

3.数组每个元素乘2输出

1. public class TestDemo {
2. public static void multiplication(int[] arr){
3. for(int i = 0 ;i < arr.length;i++){
4. arr[i]=arr[i]*2;
5. }
6. }
7. public static void printArray(int[] arr){
8. for(int x:arr){
9. System.out.print(x+" ");
10. }
11. }
12. public static void main(String[] args) {
13. int [] arr = {1,2,3,4};
14. System.out.println("乘2前:");
15. printArray(arr);
16. System.out.println();
17. System.out.println("乘2后:");
18. multiplication(arr);
19. printArray(arr);
20. }
21. }

六.数组相关方法Arrays

Arrays是操作Java数组的工具类。

如果要对数组做什么事情，可以通过它来做，当然，有些事情是它做不了的，但是只要它能做到，我们调用它就OK。

1.数组转字符串：使用Arrays.toString();

1. import java.util.Arrays;
2.  
3. public class TestDemo {
4. public static void main(String[] args) {
5. int[] arr= {1,2,3,4,5,6};
6. String arr1 = Arrays.toString(arr);
7. System.out.println(arr1);
8. }
9. }

这个方法打印出来是以字符串形式打印，把我们要打印的数组，放到toString里面，那么就会帮我们把当前数组，转变为字符串进行输出

2.数组拷贝

如何将数组拷贝？最直观的方法是创建一个与当前数组大小相同，类型相同的数组，使用循环一个一个赋值。但Java中存在一些方法可以直接拷贝。

使用Arrays.copyOf(数组名，数组的长度）；

1. import java.util.Arrays;
2.  
3. public class TestDemo {
4. public static void main(String[] args) {
5. int[] arr1 ={1,2,3,4,5,6};
6. int[] arr2 = Arrays.copyOf(arr1,arr1.length);
7. System.out.println("拷贝的数组元素为:"+Arrays.toString(arr2));
8. }
9. }

范围拷贝使用Arrays.copyOfRange(数组名，从开始下标，到结束下标）

1. import java.util.Arrays;
2.  
3. public class TestDemo {
4. public static void main(String[] args) {
5. int[] arr1 = {1,2,3,4,5,6};
6. int[] arr2 = Arrays.copyOfRange(arr1,1,3);
7. System.out.println("范围拷贝的数组内容为:"+Arrays.toString(arr2));
8. }
9. }

注意：copyOfRange函数中，数组元素依然是从下标为0开始，且最后一个参数是取不到的，也就是说是取[1,3)左闭右开的元素。

3.数组排序

如果你学过C++，那么一定会对sort函数很熟悉，C++中sort函数使用代码示例如下

1. #include <iostream>
2. #include <algorithm>
3.  
4. using namespace std;
5.  
6. const int N = 100;
7.  
8. int main()
9. {
10. int arr[N];
11. int n = 0;
12. cin >> n;
13. for (int i = 0; i < n; i++)
14. {
15. cin >> arr[i];
16. }
17. sort(arr,arr+n);
18. for (int i = 0; i < n; i++)
19. {
20. cout << arr[i] << ' ';
21. }
22. return 0;
23. }

而Java中也存在这样的函数：Arrays.sort

1. import java.util.Arrays;
2.  
3. public class TestDemo {
4. public static void main(String[] args) {
5. int[] arr = {5,4,3,2,1};
6. Arrays.sort(arr);
7. System.out.println(Arrays.toString(arr));
8. }
9. }

我们可以看到，sort函数均是以升序排列。

4.数组查找

①.顺序查找：

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

②.二分查找

手动实现：

1. public class TestDemo {
2. public static int binarySearch(int [] arr,int x){
3. int left = 0;
4. int right = arr.length-1;
5. while(left<=right){
6. int mid = left+right>>1;
7. if(x<arr[mid]){
8. //表示在左边
9. right=mid-1;
10. }
11. else if(x>arr[mid]){
12. //表示在右边
13. left = mid + 1;
14. }
15. else {
16. //相等说明找到
17. return mid;
18. }
19. }
20. return -1;//循环结束，说明没找到;
21. }
22. public static void main(String[] args) {
23. int [] arr = {1,2,3,4,5};
24. System.out.println(binarySearch(arr,4));
25. }
26. }

但Java中 这个方法以及被封装好了 我们可以使用Arrays.binarySearch(数组名，要找的元素);来实现

1. import java.util.Arrays;
2.  
3. public class TestDemo {
4. public static void main(String[] args) {
5. int [] arr = {1,2,3,4,5};
6. System.out.println(Arrays.binarySearch(arr,4));
7. }
8. }

以上就是Java的数组讲解，感谢观看。

到此这篇关于Java基础之数组详解的文章就介绍到这了,更多相关java数组详解内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/JixTlhh/article/details/115704835