Java_数组（声明、创建、初始化、复制、增强型for循环、二维数组、排序、Arrays类）

梦里梦外; 2023-03-01 08:50 19阅读 0赞

### Java\_数组 ###

*  数组的基本概念
 *  声明数组
 *  创建数组
 *  初始化数组
 *   *  方法一：分配空间与赋值分步进行
     *  方法二：分配空间，同时赋值
 *  增强型for循环
 *  复制数组
 *  二维数组
 *  排序
 *  Arrays类
 *   *  copyOfRange 数组复制
     *  toString() 转换为字符串
     *  sort 排序
     *  binarySearch 搜索
     *  equals 判断是否相同
     *  fill 填充

# 数组的基本概念 #

数组：一组**有序数据**的集合，数组中的每个元素都具有**相同的数据类型**，可以用统一的**数组名和下标**来唯一地确定数组中的元素。

# 声明数组 #

**数据类型\[ \] 数组** int\[ \] a;  
或 **数据类型 数组\[ \]** int a\[ \];  
但是，仅仅是这一句声明，不会创建数组

# 创建数组 #

1.  使用new为数组分配空间  
    **数组=new 数据类型\[ 长度 \]** int a\[ \] = new int\[5\];
2.  用静态的初始化器：int a\[ \] = \{1, 2, 10, 5, 9\};
3.  注意：一旦数组被创建，那么数组的长度就不能再改变。

# 初始化数组 #

## 方法一：分配空间与赋值分步进行 ##

public class Demo {
        
    	public static void main(String[] args) {
         
            int[] a = new int[3]; //分配了长度是5的数组，但是没有赋值
    		System.out.println(a[0]); //没有赋值，那么就会使用默认值；作为int类型的数组，默认值是0
    		a[0] = 100; //进行赋值	
    		a[1] = 101;
    		a[2] = 103;
        }
    }

## 方法二：分配空间，同时赋值 ##

public class Demo {
        
    	public static void main(String[] args) {
         
            int[] a = new int[]{
        100,102,444,836,3236}; //写法一： 分配空间同时赋值
            int[] b = {
        100,102,444,836,3236}; //写法二： 省略了new int[],效果一样
            //  int[] c = new int[3]{100,102,444,836,3236};  //error//写法三：同时分配空间，和指定内容
            //在这个例子里，长度是3，内容是5个，产生矛盾了。所以如果指定了数组的内容，就不能同时设置数组的长度
        }
    }

# 增强型for循环 #

*  增强型for循环在遍历一个数组的时候会更加快捷
 *  注：增强型for循环只能用来取值，却不能用来修改数组里的值  
    ![增强型for循环][for]

public class Demo {
        
    	public static void main(String[] args) {
         
    		int values [] = new int[]{
        18,62,10};     
            for (int i = 0; i < values.length; i++) {
         //常规遍历
    			System.out.println(values[i]);
    		}
            for (int each : values) {
         //增强型for循环遍历
    			System.out.println(each);
    		}
        }
    }

运行结果：  
![增强型for循环运行结果][for 1]  
练习： 用增强型for循环找出最大的数

public class Demo {
        
    	public static void main(String[] args) {
         
    		int values [] = new int[]{
        18,62,10};
    		int max = 0;
            for (int each : values) {
         //增强型for循环遍历
            	if(max<each) {
        
            		max = each;
            	}
            }
            System.out.println(max); //62
        }
    }

# 复制数组 #

**System.arraycopy(src, srcPos, dest, destPos, length)**

*  src: 源数组
 *  srcPos: 从源数组复制数据的起始位置
 *  dest: 目标数组
 *  destPos: 复制到目标数组的起始位置
 *  length: 复制的长度

例子：通过数组赋值把，a数组的前3位赋值到b数组

public class Demo {
        
    	public static void main(String[] args) {
         
    		int a [] = new int[]{
        18,62,68,82,65,9};
            int b[] = new int[3];//分配了长度是3的空间，但是没有赋值
            //方法一： for循环
            for (int i = 0; i < b.length; i++) {
        
                b[i] = a[i];
            }
            //方法二: System.arraycopy(src, srcPos, dest, destPos, length)
            System.arraycopy(a, 0, b, 0, 3);
            //把内容打印出来
            for (int i = 0; i < b.length; i++) {
        
                System.out.print(b[i] + " ");
            }
        }
    }

练习：合并数组  
首先准备两个数组，他俩的长度是5-10之间的随机数，并使用随机数初始化这两个数组。然后准备第三个数组，第三个数组的长度是前两个的和，通过System.arraycopy 把前两个数组合并到第三个数组中。

> 拓展：0-100的 随机整数的获取办法有多种，下面是参考办法之一: (int) (Math.random() \* 100)

public class Demo {
        
    	public static void main(String[] args) {
         
    		int a[] = new int[3];
            for (int i = 0; i < a.length; i++) {
        
                a[i] = (int)(Math.random() * 100);
                System.out.println("a[" + i + "]的值为：" + a[i]);
            }
            
            int b[] = new int[4];
            for (int j = 0; j < b.length; j++) {
        
                b[j] = (int)(Math.random() * 100);
                System.out.println("b[" + j + "]的值为：" + b[j]);
            }
    		
            int c[] =new int[a.length + b.length];
            System.arraycopy(a, 0, c, 0, a.length);
            System.arraycopy(b, 0, c, a.length, b.length);
            for (int k = 0; k < c.length; k++) {
         //把内容打印出来
                System.out.print(c[k] + " ");
            }
        }
    }

运行结果：  
![合并数组练习][20200724114313468.png]

# 二维数组 #

*  这是一个一维数组, 里面的每一个元素，都是一个基本类型int  
    int a\[\] =new int\[\]\{1,2,3,4,5\};
 *  这是一个二维数组，里面的每一个元素，都是一个一维数组  
    int b\[ \]\[ \] = new int\[ \]\[ \]\{  
    \{1,2,3\},  
    \{4,5,6\},  
    \{7,8,9\}  
    \};

public class HelloWorld {
        
        public static void main(String[] args) {
        
           //初始化二维数组，
           int[][] a = new int[2][3]; //有两个一维数组，每个一维数组的长度是3
           a[1][2] = 5;  //可以直接访问一维数组，因为已经分配了空间
              
           //只分配了二维数组
           int[][] b = new int[2][]; //有两个一维数组，每个一维数组的长度暂未分配
           b[0]  =new int[3]; //必须事先分配长度，才可以访问
           b[0][2] = 5;
            
           //指定内容的同时，分配空间
           int[][] c = new int[][]{
        
                   {
        1,2,4},
                   {
        4,5},
                   {
        6,7,8,9}
           };
        }
    }

# 排序 #

[数组的排序][Link 1]

# Arrays类 #

Arrays是针对数组的工具类，，在 java.util 包中。可以进行 排序，查找，复制填充等功能。 大大提高了开发人员的工作效率。  
关键字：

*  copyOfRange 数组复制
 *  toString() 转换为字符串
 *  sort 排序
 *  binarySearch 搜索
 *  equals 判断是否相同
 *  fill 填充

## copyOfRange 数组复制 ##

> 与System.arraycopy进行数组复制类似， Arrays提供了一个copyOfRange方法进行数组复制。  
> 不同的是System.arraycopy，需要事先准备好目标数组，并分配长度。copyOfRange只需要源数组，通过返回值，就能够得到目标数组。  
> 除此之外，需要注意的是 copyOfRange的第3个参数，表示源数组的结束位置，是取不到的。

**copyOfRange(int\[\] original, int from, int to)**

*  参数original表示源数组
 *  参数int from表示开始位置(取得到)
 *  参数int to表示结束位置(取不到)

import java.util.Arrays;
    public class Demo {
        
    	public static void main(String[] args) {
         
    		int a[] = new int[] {
         18, 62, 68, 82, 65, 9 };
            int[] b = Arrays.copyOfRange(a, 0, 3);
            for (int i = 0; i < b.length; i++) {
        
                System.out.print(b[i] + " ");// 18 62 68 
            }
        }
    }

## toString() 转换为字符串 ##

> 如果要打印一个数组的内容，就需要通过for循环来挨个遍历，逐一打印  
> 但是Arrays提供了一个toString()方法，直接把一个数组，转换为字符串，这样方便观察数组的内容

import java.util.Arrays;
    public class Demo {
        
    	public static void main(String[] args) {
         
    		int a[] = new int[] {
         34, 67, 59, 7 };
            String b = Arrays.toString(a);
            System.out.println(b); // [34, 67, 59, 7]
        }
    }

## sort 排序 ##

> Arrays工具类提供了一个sort方法，只需要一行代码即可完成排序功能。

import java.util.Arrays;
    public class Demo {
        
    	public static void main(String[] args) {
         
    		int a[] = new int[] {
         81, 79, 100, 23, 7 };
            System.out.println("排序之前 :");
            System.out.println(Arrays.toString(a)); // [81, 79, 100, 23, 7]
            Arrays.sort(a);
            System.out.println("排序之后:");
            System.out.println(Arrays.toString(a)); // [7, 23, 79, 81, 100]
        }
    }

## binarySearch 搜索 ##

> 查询元素出现的位置 需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序  
> 如果数组中有多个相同的元素，查找结果是不确定的

import java.util.Arrays;
    public class Demo {
        
    	public static void main(String[] args) {
         
    		int a[] = new int[] {
         81, 79, 100, 23, 7 };
            Arrays.sort(a);
            System.out.println(Arrays.toString(a));//使用binarySearch之前，必须先使用sort进行排序:[7, 23, 79, 81, 100]
            System.out.println("数字81出现的位置:"+Arrays.binarySearch(a, 81)); //数字 81出现的位置:3
        }
    }

## equals 判断是否相同 ##

> 比较两个数组的内容是否一样

import java.util.Arrays;
    public class Demo {
        
    	public static void main(String[] args) {
         
    		int a[] = new int[] {
         81, 79, 100, 23, 7 };
            int b[] = new int[] {
         81, 79, 100, 23, 70 };
            System.out.println(Arrays.equals(a, b)); // 最后一个元素不相同，输出：false
        }
    }

## fill 填充 ##

> 使用同一个值，填充整个数组

import java.util.Arrays;
    public class Demo {
        
    	public static void main(String[] args) {
         
    		int a[] = new int[4];
            Arrays.fill(a, 5);
            System.out.println(Arrays.toString(a)); // [5, 5, 5, 5]
        }
    }

[for]: /images/20230209/63b395b59e3f40adb2aaa7acdeb9bb9e.png
[for 1]: /images/20230209/5733caf2d48c4ba08b14ea19ba99e78f.png
[20200724114313468.png]: https://img-blog.csdnimg.cn/20200724114313468.png
[Link 1]: https://how2j.cn/k/array/array-sort/282.html#nowhere