数组（Java）-CSDN博客

本文链接：https://blog.csdn.net/qq_44768841/article/details/123894692

数组

1. 概念

一组连续的存储空间，存储多个相同数据类型的值，长度是固定的。

2. 定义方式

先声明、再分配空间：数据类型[] 数组名;

数组名 = new 数据类型[长度]; 声明并分配空间：

数据类型[] 数组名 = new 数据类型[长度]; 声明并赋值（繁）：数据类型[] 数组名 = new 数据类型[]{value1,value2,value3,...};

声明并赋值（简）：数据类型[] 数组名 = {value1,value2,value3,...}; //显示初始化，注意：不可换行

package com.edu.test1;
/**
 *  数组的4种创建方式
 * 
 */
public class Test1 {
    public static void main(String[] args) {
        // 方式1 先声明 再分配空间
        int [] arr1;
        arr1 = new int[5];
        
        
        // 方式2 声明并分配空间
        int [] arr2 = new int[10];
        
        // 方式3 声明并赋值 繁琐
        int [] arr3 = new int[] {11,22,33,44,55,20,30};
        
        
        // 方式4 声明并赋值 简单
        int arr4 [] =  {1,2,3,4,5};
        
        String [] strs = {"a","b","c","d"};
        
        
        
        
        
        
    }
}

3. 数组的使用

数组的访问

数组中的每个内容称之为：元素

通过下标访问数组中的每个元素，下标从0开始，依次+1

package com.edu.test2;
/**
 *  数组的访问
 *  数组中的每个内容称之为：元素
 *  通过下标访问数组中的每个元素，下标从0开始，依次+1
 *  
 *
 */
public class Test1 {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a);
        int [] arr1 = new int[6];
        
        // 赋值
        arr1[0] = 89;
        arr1[1] = 55;
        arr1[2] = 23;
        arr1[3] = 66;
        arr1[4] = 124;
        arr1[5] = 235;
//      arr1[7] = 778; 数组下标越界 因为长度为6  下标范围0 ~ 5 
        
        // 取值
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println(arr1[3]);
        System.out.println(arr1[4]);
        System.out.println(arr1[5]);
//      System.out.println(arr1[8]); 数组下标越界 因为长度为6  下标范围0 ~ 5
        
        
        System.out.println(arr1); // 直接打印数组名 会输出根据数组所存放的地址计算出来的hash值
    }
}

4.数组的遍历

数组的遍历

使用循环逐一对数组中的元素进行访问

package com.edu.test3;

import java.util.Scanner;

/**
 *  数组的遍历
 *  使用循环逐一对数组中的元素进行访问
 * 
 */
public class Test1 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int [] nums = new int[5];
        
        // 遍历赋值
        for(int i = 0;i < 5;i++) {
            System.out.println("请输入第"+ (i + 1)+"个元素的值");
            nums[i] = input.nextInt();
        }
        
        // 遍历取值
        for(int i = 0;i < 5;i++) {
            System.out.print(nums[i] + "\t");
        }
        System.out.println();
        
        
    }
}

5. 数组的属性length

数组的属性 length 是一个int类型的数值表示数组的长度

使用方式：使用数组名.length 来使用

package com.edu.test3;
/**
 *  数组的属性 length 是一个int类型的数值表示数组的长度
 *  使用方式：使用数组名.length 来使用
 * 
 */
public class Test2 {
    public static void main(String[] args) {
        int [] nums = {11,22,5,6,9,8,5,7,52,56,7,4,1,5,6,32,5,2,8,9,5,2,5,2,52};
        
        System.out.println(nums.length);
        
        
        for(int i = 0;i < nums.length;i++) {
            System.out.print(nums[i] + "\t");
        }
        System.out.println();
    }
}

6. 数组的默认值

数组中的元素是有默认值的，当我们开辟空间，默认值即存在

数组的默认值

整数：0

浮点：0.0

布尔：false

字符：\u0000

其他：null

package com.edu.test4;
/**
 *  数组的默认值
 *  整数：0
 *  浮点：0.0
 *  布尔：false
 *  字符：\u0000
 *  其他：null
 * 
 */
public class Test1 {
    public static void main(String[] args) {
        byte [] b1 = new byte[3];
        for (int i = 0; i < b1.length; i++) {
            System.out.print(b1[i] + "\t");
        }
        System.out.println();
        
        short [] s1 = new short[5];
        for (int i = 0; i < s1.length; i++) {
            System.out.print(s1[i] + "\t");
        }
        System.out.println();
        
        int [] i1 = new int[5];
        for (int i = 0; i < i1.length; i++) {
            System.out.print(i1[i] + "\t");
        }
        System.out.println();
        
        long [] l1 = new long[2];
        for (int i = 0; i < l1.length; i++) {
            System.out.print(l1[i] + "\t");
        }
        System.out.println();
        
        float [] f1 = new float [3];
        for (int i = 0; i < f1.length; i++) {
            System.out.print(f1[i]+ "\t");
        }
        System.out.println();
        
        double [] d1 = new double[4];
        for (int i = 0; i < d1.length; i++) {
            System.out.print(d1[i]+ "\t");
        }
        System.out.println();
        
        
        boolean [] bl1 = new boolean[7];
        for (int i = 0; i < bl1.length; i++) {
            System.out.print(bl1[i]+ "\t");
        }
        System.out.println();
        
        char [] ch1 = new char[3];
        for (int i = 0; i < ch1.length; i++) {
            System.out.print(ch1[i] + "=" + "\t");
        }
        System.out.println();
        
        String [] strs = new String[5];
        for (int i = 0; i < strs.length; i++) {
            System.out.print(strs[i]+ "\t");
        }
    
        
    }
}

7. 数组的扩容

数组的长度是固定的，所以一旦指定长度将不能改变

如果需要存放超过长度的元素，则可以扩容

数组作为引用数据类型，其数组名(引用)中存储的是指向堆空间的地址，所以我们直接访问数组打印出来的是hash值，直接将一个数组赋值给另外一个数组，相当于地址的赋值。

package com.edu.test5;
/**
 *  数组的扩容
 *  创建一个更长的数组 将原数组的元素 依次复制到新的数组中
 * 
 */
public class Test1 {
    public static void main(String[] args) {
        int [] oldArr = {11,22,33,44,55};
        int [] newArr = new int[oldArr.length * 2];
        
        for(int i  = 0;i < oldArr.length;i++) {
            newArr[i] = oldArr[i];
        }
        
        
        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i] + "\t");
        }
        System.out.println();
        
        oldArr = newArr;
        
        
        
        
        
        
        
        int a = 10;
        int b = a;
        System.out.println(b); // 属于基本数据类型赋值
        
        int [] nums1 = {1,2,3,4,5};
        int [] nums2 = nums1;
        System.out.println(nums1);
        System.out.println(nums2);
        for (int i = 0; i < nums2.length; i++) {
            System.out.print(nums2[i] + "\t");
        }
        System.out.println();
        
    }
}

8. 练习题

求元素之和平均值

package com.edu.test6;
/**
 *  计算数组中元素之和  平均分
 * 
 */
public class Test1 {
    public static void main(String[] args) {
        int [] nums = {11,22,33,44,55};
        int sum = 0;
        
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        System.out.println("数组中元素之和是：" + sum);
        System.out.println("平均值是：" + sum / nums.length);
        
        
    }
}

求最大最小值

package com.edu.test6;
/**
 *  求一个数组中的最大值，或者最小值。
 * 
 */
public class Test2 {
    public static void main(String[] args) {
        int [] nums = {45,56,222,336,74,10,256,9996};
        
        // 1.假设一个最大值 任意一个位置都可以
//      int max = nums[0];
        
        int min = nums[0];
        
        // 2.使用循环依次与后续的元素进行比较
        for(int i = 1;i < nums.length;i++) {
            if(min > nums[i]) {
                min = nums[i];
            }
        }
        
        // 3.最终max的取值就是数组中的最大元素
//      System.out.println("数组中的最大值是：" + max);
        System.out.println("数组中的最小值是：" + min);
        
        
        
    }
}

9. 复制数组

9.1 自己编写循环复制

复制数组方式1 自己编写循环实现复制

package com.edu.test7;
/**
 * 	复制数组 方式1 自己编写循环实现复制
 * 
 */
public class Test1 {
	public static void main(String[] args) {
		int [] nums1 = {1,2,3,4,5};
		int [] nums2 = new int[nums1.length];
		
		for (int i = 0; i < nums1.length; i++) {
			nums2[i] = nums1[i];
		}
		
		for (int i = 0; i < nums2.length; i++) {
			System.out.println(nums2[i]);
		}
		
	}
}

9.2 System.arraycopy()

复制数组方式2 System.arraycopy(原数组，起始位置，新数组，起始位置，长度)

注意：根据传入的下标不能超过所可以复制的元素个数不能写负数

package com.edu.test7;
/**
 *  复制数组 方式2 System.arraycopy(原数组，起始位置，新数组，起始位置，长度)
 * 
 *  注意：根据传入的下标 不能超过所可以复制的元素个数  不能写负数
 * 
 */
public class Test2 {
    public static void main(String[] args) {
        int [] nums1 = {1,2,3,4,5,6,7,8,9,10};
        int [] nums2 = new int[nums1.length];
        
        System.arraycopy(nums1, 2, nums2, 5, 2);
        
        for (int i = 0; i < nums2.length; i++) {
            System.out.print(nums2[i] + "\t");
        }
        System.out.println();
        
    }
}

9.3 Arrays.copyOf()

复制数组方式3 Arrays.copyOf(原数组，新长度) 会返回给我们一个新的数组

package com.edu.test7;

import java.util.Arrays;

/**
 *  复制数组 方式3 Arrays.copyOf(原数组，新长度)  会返回给我们一个新的数组
 * 
 */
public class Test3 {
    public static void main(String[] args) {
        int [] nums1 = {1,2,3,4,5,6,7,8,9,10};
        int [] nums2 = Arrays.copyOf(nums1, 5);
        for (int i = 0; i < nums2.length; i++) {
            System.out.println(nums2[i]);
        }
        System.out.println("------------------------------------");
        int [] nums3 = Arrays.copyOf(nums1, 10);
        for (int i = 0; i < nums3.length; i++) {
            System.out.println(nums3[i]);
        }
        System.out.println("------------------------------------");
        
        int [] nums4 = Arrays.copyOf(nums1, 15);
        for (int i = 0; i < nums4.length; i++) {
            System.out.println(nums4[i]);
        }
        
        
    }
}

10. 传递的区别

面试题：值传递和引用传递的区别？

基本数据类型传参，属于值传递，传递的是值本身(值的拷贝，副本)，在方法中对值的操作不会影响原变量

引用数据类型传参，属于引用传递，传递的是地址，在方法中对变量的操作会影响原变量

String类型属于特殊的引用数据类型，作为参数传递不会改变原来的值

package com.edu.test8;
/**
 *  面试题：值传递和引用传递的区别？
 *  基本数据类型传参，属于值传递，传递的是值本身(值的拷贝，副本)，在方法中对值的操作不会影响原变量
 *  引用数据类型传参，属于引用传递，传递的是地址，在方法中对变量的操作会影响原变量
 *  String类型属于特殊的引用数据类型，作为参数传递不会改变原来的值
 * 
 */
public class Test2 {
    
    public static void m3(String str) {
        str += "abc";
    }
    
    
    
    public static void m1(int num) {
        num += 1;
        System.out.println("m1方法中的num ：" + num);
    }
    
    
    public static void m2(int [] nums) {
        for (int i = 0; i < nums.length; i++) {
            nums[i] += 1;
        }
    }
    
    public static void main(String[] args) {
        String str = "hello";
        m3(str);
        System.out.println(str);
        
        
        int a = 10;
        m1(a);
        System.out.println(a);
        
        System.out.println("=====================================");
        
        int [] nums = {1,2,3,4,5};
        m2(nums);
        for(int i = 0;i < nums.length;i++) {
            System.out.print(nums[i] + "\t");
        }

    }

}