Loading

数组

1. 数组概述

数组(array): 存储一个元素个数固定且元素类型相同的有序集

2. 数组的定义格式

  • 格式一

    数据类型[] 变量名
    int[] array; -->推荐
    
  • 格式二

    数据类型 变量名[]
    int array[];
    

3.数组的初始化

java中的数组必须先初始化才能使用

初始化: 就是为数组中的数据元素分配内存空间,并为每个数组元素赋值
  • 静态初始化

    初始化时,指定每个数组元素的初始值,由系统决定数组长度
    
    格式: 数据类型[] 变量名 = new 数据类型[]{元素1,元素2,...};
    int[] array = new int[]{1,2,3};
    
    简化: 数据类型[] 变量名 = {元素1,元素2,...}
    int[] array = {1,2,3}
    
    适合一开始就能确定元素值的业务场景
    
  • 动态初始化

    初始化时,只指定数组长度,由系统为数组分配初始值
    
    格式: 数据类型[] 变量名 = new 数据类型[数组长度]
    int[] array = new int[10]
    
    适合知道元素数量,不确定具体元素值的场景
    

4. 数组元素访问

  • 数组变量的访问方式

    格式: 数组名
    
  • 数组内部保存的数据的访问方式

    数组名[索引]
    
    索引: 数组中数据的编号方式
    作用: 用于访问数组中的数据,数据名[索引],等同于变联名,称为下标变量
    特征: ① 索引从0开始
         ⑤ 索引是连续的
         ③ 索引逐一增加,每次加一
    

5. 数组的常见操作

  • 遍历

    什么是遍历?
    获取数组中的每一个元素
    
    获取数组长度(元素个数)
    格式: 数组名.length 
    array.length
    
    //数组遍历的通用格式
    for(int i=0;i<array.length;i++){
        array[i]//对每个元素进行操作
    }
    
  • 获取最大值

    思路:
    1. 定义一个变量,用于保存最大值
    2. 取数组中的第一个元素,作为变量的初始值
    3. 与数组中剩余元素逐个比较,每次比较将最大值保存在变量中
    
    int max = array[0];
    for(int i = 1;i<array.length;i++){
        if(array[i]>max){
            max = array[i];
        }
        System.out.println("max:"+max);
    }
    
  • 元素打乱

    什么是元素打乱?
    	把数组中的元素随机交换位置,每次运行都可能产生不一样的结果
    	
    获取元素中的随机索引
    	Random random = new Random();
    	int index = random.nextInt(array.length)
    
    Random random = new Random();
    for(int i=0;i<array.length;i++){
        int index = random.nextInt(array.length);
        
        int temp = array[i];
        array[i] = array[index];
        array[index] = temp;
    }
    System.out.println(Arrays.toString(array))
    

6. 数组使用的三个问题

  • 指针越界

    访问了数组中不存在的索引对应的元素
    
  • 空指针异常

    数组变量不在指向堆内存,还想继续访问数据
    
  • 溢出

    操作系统会自动给每个进程分配一个最大栈空间2M
    操作系统会自动给每个进程分配一个最大堆空间4G
    如果数组过大,就会造成堆溢出
    

7. 二维数组概述

元素为一维数组的数组

8. 二位数组的定义格式

  • 格式一

    数据类型[][] 变量名;
    int[][] array;  --->推荐
    
  • 格式二

    数据类型 变量名[][];
    int array[][];
    
  • 格式三

    数据类型[] 变量名[];
    int[] array[];
    

9. 二位数组初始化

  • 静态初始化

    格式: 数据类型[][] 变量名 = new 数据类型[][]{元素1,元素2,元素3,...};
    int[][] array = new int[][]{{1,2,},{3,4}};
    
    简化: 数据类型[][] 变量名 = {{1,2},{3,4}} ;
    int[][] array = {{1,2},{3,4}};
    
  • 动态初始化

    格式: 数据类型[][] 变量名 = new 数据类型[m][n];
    int[][] array = new int[2][2];
    

10. 二位数组的元素访问

  • 获取二位数组

    数组名
    
  • 获取一维数组

    数组名[索引]
    
  • 获取每个二位数组的元素

    数组名[索引][索引]
    

11. 二维数组的常见操作

  • 遍历

    for(int i=0;i<array.length;i++){
        for(int j=0;j<array[i].length;j++){
            System.out.print(array[i][j]+" ");
        }
        System.out.println();
    }
    // 外层循环得到一维数组
    // 内层循环得到每个二维数组的元素
    
  • 元素打乱

    Random random = new Random();
    for(int i=0;i<array.length;i++){
        for(int j=0;j<array[i].length;j++)[
            int x = random.nextInt(array.length);
            int y = random.nextInt(array[x].length)
            
            int temp = array[i][j];
            array[i][j] = array[x][y];
            array[x][y] = temp;
        ]
    }
    

12.数组中的常见算法

1. 使用输入值初始化数组
public static void main(String[] args) {
    int[] ints = new int[5];
    Scanner input = new Scanner(System.in);
    System.out.println("Enter"+ints.length+"values:");
    for (int i = 0; i < ints.length; i++) {
        ints[i] = input.nextInt();
    }
    System.out.println(Arrays.toString(ints));
}

2. 使用随机数初始化数组
public static void main(String[] args) {
    int[] ints = new int[10];
    Random random = new Random();
    for (int i = 0; i < ints.length; i++) {
        ints[i] = random.nextInt(20);
    }
    System.out.println(Arrays.toString(ints));
}

3. 显示数组
public static void main(String[] args) {
    int[] ints ={1,2,3,4};
    for (int i = 0; i < ints.length; i++) {
        System.out.print(ints[i]+" ");
    }
}

4. 对所有元素求和
public static void main(String[] args) {
    int[] ints = {1,2,3,4};
    int sum = 0;
    for (int i = 0; i < ints.length; i++) {
        sum += ints[i];
    }
    System.out.println(sum);
}

5.找出最大元素
public static void main(String[] args) {
    int[] ints = {1,2,3,4,89,100};
    int max = 0;
    for (int i = 0; i < ints.length; i++) {
        if (ints[i]>max){
            max = ints[i];
        }
    }
    System.out.println(max);
}

6.找出最大元素的最小下标值
public static void main(String[] args) {
    int[] ints = {1,2,5,4,5,5,};
    int index = 0;
    int max = 0;
    for (int i = 0; i < ints.length; i++) {
       if (ints[i]>max){
           max = ints[i];
           index = i;
       }
    }
    System.out.println(index);
}

7.随机打乱
public static void main(String[] args) {
    int[] ints = {1,2,3,4,5,6,7,8,9,10};
    int temp = 0;
    Random random = new Random();
    for (int i = 0; i < ints.length; i++) {
        int j = random.nextInt(9);
        temp = ints[i];
        ints[i] = ints[j];
        ints[j] = temp;
    }
    System.out.println(Arrays.toString(ints));
}

8.移动元素(向左移动一个元素)
public static void main(String[] args) {
    int[] ints = {1,2,3,4,5};
    int temp = ints[0];
    for (int i = 1; i < ints.length; i++) {
        ints[i-1] = ints[i];
    }
    ints[ints.length-1] = temp;
    System.out.println(Arrays.toString(ints));
}

9.简化编码
public static void main(String[] args) {
    String[] strings = {"one","two","three","four","five","six","seven"};
    Scanner input = new Scanner(System.in);
    System.out.println("Enter a mother number(1 to 7):");
    int num = input.nextInt();
    System.out.println(strings[num-1]);
}

10.编写一个程序,找出所有大小项平均值的项的个数
public static void main(String[] args) {
    int[] ints = {1,2,3,4,5,6,7,8,9,10};
    int sum = 0;
    int temp = 0;
    for (int i = 0; i < ints.length; i++) {
        sum += ints[i];
    }
    int num = sum/ints.length;
    for (int i = 0; i < ints.length; i++) {
        if (ints[i]>num){
           temp++;
        }
    }
    System.out.println(temp);
}

13.数组的复制

1. 使用循环语句,逐个的复制数组中的元素
2. 使用System类中的静态方法arraycopy
3. 使用clone方法复制数组

注意: 不能使用使用赋值语句复制数组,如list1 = list2,它是将list2的引用值复制给了list1,
list1和list2都将指向list2引用的数组,而list1引用的数组将被垃圾回收

1. 使用循环
public static void main(String[] args) {
    int[] ints = {1,2,3,4,5};
    int[] ints2 = new int[ints.length];
    for (int i = 0; i < ints.length; i++) {
        ints2[i] = ints[i];
    }
    System.out.println(Arrays.toString(ints2));
}
2. 使用方法arraycopy
语法: arraycopy(sourceArray, srcPos, targetArray, tarPos, length)
sourceArray: 原数组
targetArray: 目标数组
srcPos: 原数组的复制起始位置
tarPos: 目标数组的复制起始位置
length: 复制的长度

public static void main(String[] args) {
    int[] ints = {1,2,3,4,5};
    int[] ints2 = new int[ints.length];
    System.arraycopy(ints, 0, ints2, 0, ints.length);
    System.out.println(Arrays.toString(ints2));
}

14.可变长参数列表

当不确定方法中能传递进来多少参数的时候,可以使用可变长参数列表

格式: 参数类型...参数名

java将可变长参数列表当做数组处理

注意: 可变长参数列表必须是最后一个参数
public static void main(String[] args) {
    int i = searchMax(1, 2, 3, 4);
    System.out.println(i);
}
public static int searchMax(int ...nums){
    int max = 0;
    for (int i = 0; i < nums.length; i++) {
        if (nums[i]>max){
            max = nums[i];
        }
    }
    return max;
}

15. 数组的查找

  • 线性查找

    //返回一个索引
    public static void main(String[] args) {
        int[] ints = {1,2,3,4,5};
        int i = searchNum(ints, 1);
        System.out.println(i);
    }
    public static int searchNum(int[] nums,int key){
        int index = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] ==key){
                index = i;
            }
        }
        return index;
    }
    //返回索引数组
    public static void main(String[] args) {
        int[] ints = {1,2,3,4,5,1,1};
        int[] i = searchNum(ints, 1);
        System.out.println(Arrays.toString(i));
    }
    public static int[] searchNum(int[] nums,int key){
        int temp = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] ==key){
                temp++;
            }
        }
        int[] ints = new int[temp];
        int j = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] ==key){
                ints[j] = i;
                j++;
            }
        }
        return ints;
    }
    
  • 二分查找

    public static void main(String[] args) {
        int[] ints = {1,2,3,4,5,6,7,8,9};
        System.out.println(searchIndex(ints, 5));
    }
    public static int searchIndex(int[] ints,int key) {
        int max = ints.length-1;
        int min = 0;
        while (max > min) {
            int temp = (max + min) / 2;
            if(key > ints[temp]) {
                min = temp + 1;
            }else if(key == ints[temp]){
                return temp;
            }else{
                max = temp -1;
            }
        }
        return -1;
    }
    

16. Arrays类

这个类中包含一些常用的对数组操作的静态方法
  • 排序

    Arrays.sort(elementType[])
    	可以对byte short int long char double float Object类型的数据进行排序,没有返回值
    Arrays.sort(elementType[],num1,num2)
    	对数组中索引从num1到num2的元素进行排序
    Arrays.parallelSort(Object[])
    	和sort类似
    
  • 数组是否相等

    Array.equals(list1,list2);
    相等则返回true
    不相等返回false
    
  • 填充

    Arrays.fill(list1,num)
    	将num填充到list1中
    Arrays.fill(list1,num1,num2,num3)
    	将num3填充在list1[num1]到list1[num2-1]之间
    	
    注意: 填充是使目标值替换掉原始值
    
  • 打印

    Arrays.toString(list[])
    
    返回值为数组元素的字符表达
    

17. 数组在方法中的传递

数组在方法中不管是作为参数传入,还是作为返回值返回,传递的都是数组的引用
在数组作为参数传入的时候,可能会出现这种形式:
	new int[]{1,2,3}
	称为匿名数组
posted @ 2022-07-26 17:20  苏无及  阅读(24)  评论(0编辑  收藏  举报