Java数组学习笔记

weixin_47940048

已于 2023-03-05 14:40:53 修改

阅读量434

点赞数

分类专栏： java 文章标签： java 开发语言数据结构 Powered by 金山文档

于 2023-03-04 21:15:54 首次发布

本文链接：https://blog.csdn.net/weixin_47940048/article/details/129334924

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

数组长度一旦确定就不可修改

数组元素的默认初始化值：

数组元素是整型：0

数组元素是浮点型：0.0

数组元素是char型：0或'\u0000'，而非'0'

数组元素是boolean型：false

数组元素是引用类型：null

一维数组

//        1.一维数组的声明和初始化
        int num;//声明
        num = 10;//初始化
        int id = 1001;//声明+初始化

        int[] ids;//声明
//        1.1静态初始化：数组的初始化和数组元素的赋值操作同时进行
        ids = new int[]{1001,1002,1003,1004};
//        1.2动态初始化：数组的初始化和数组元素的赋值分开操作
        String[] names = new String[5];

//        也是正确写法
        int[] a = {1,2,3,4};
//        总结：数组一旦初始化完成，其长度就确定了
        int[] i = new int[]{1,2};
        int[] i2 = {1,2};
        int[] i3 = new int[3];

二维数组

//        2.二维数组的声明和初始化
        //静态初始化
        int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
        int[][] ar = {{1,2,3},{4,5},{6,7,8}};
        //动态初始化1
        String[][] arr2 = new String[3][2];
        //动态初始化2
        String[][] arr3 = new String[3][];

        //如何调用数组的指定位置的元素
        System.out.println(arr1[0][1]);//2
        System.out.println(arr2[1][1]);//null
//        System.out.println(arr3[1][0]);//java.lang.NullPointerException空指针异常
        arr3[1] = new String[4];
        System.out.println(arr3[1][0]);//null

        //获取数组的长度
        System.out.println(arr1.length);//3
        System.out.println(arr1[0].length);//3
        System.out.println(arr1[1].length);//2

//        int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
        //如何遍历二维数组
        for(int i=0; i< arr1.length; i++){
            for(int j=0; j<arr1[i].length; j++){
                System.out.print(arr1[i][j] + " ");
            }
            System.out.println();
        }

二维数组的使用

规定：二维数组分为外层数组元素，内层数组元素

int[][] arr = new int[4][3];

外层元素：arr[0]，arr[1]等

内层元素：arr[0][0]，arr[1][2]等

数组元素的默认初始化值

针对于初始化方式一：比如：int[][] arr = new int[4][3];

外层元素的初始化值为：地址值

内层元素的初始化值为：与一维数组初始化情况相同

针对于初始化方式二：比如：int[][] arr = new int[4][];

外层元素的初始化值为：null

内层元素的初始化值为：不能调用，空指针异常

总结：数组名指向的是数组的地址；数组元素为空就默认为类型的初始化值；数组没有定义就会空指针异常

int[][] arr = new int[4][3];
        System.out.println(arr[0]);//[I@1540e19d
        System.out.println(arr[0][0]);//0
        System.out.println(arr);//[[I@677327b6
        System.out.println("*************");

        float[][] arr1 = new float[4][3];
        System.out.println(arr1[0]);//地址值 [F@14ae5a5
        System.out.println(arr[0][0]);//0.0
        System.out.println("*************");

        String[][] arr2 = new String[4][2];
        System.out.println(arr2[1]);//地址值 [Ljava.lang.String;@7f31245a
        System.out.println(arr2[1][1]);//null
        System.out.println("***************");

        double[][] arr3 = new double[4][];
        System.out.println(arr3[1]);//null
        System.out.println(arr3[1][0]);//报错，空指针异常 java.lang.NullPointerException

数组的内存解析

内存的简化解构

一维数组的内存解析

二维数组的内存解析

关于数组的练习题

声明：int[] x,y[];在给x,y变量赋值以后，以下选线允许通过编译的是

a) x[0] = y; ×

b) y[0] = x; √

c) y[0][0] = x; ×

d) x[0][0] = y; ×

e) y[0][0] = x[0]; √

f) x =y; ×

一维数组：int[] x 或intx[]

二维数组：int[][] y 或 int[] y[] 或 int y[][]

使用二维数组打印一个10行杨辉三角

提示：

第一行有1个元素，第n行有n个元素

每一行的第一个元素和最后一个元素都是1

从第三行开始，对于非第一各元素和最后一个元素。即为：yanghui[i][j]=yanghui[i-1][j-1]+yanghui[i-1][j]

public class Test01YangHui {
    public static void main(String[] args){
        //1.声明并初始化二维数组
        int[][] yangHui = new int[10][];

        //2.给数组元素赋值
        for(int i=0; i<yangHui.length; i++){
            yangHui[i] = new int[i+1];

            //2.1给首末元素赋值
            yangHui[i][0] = yangHui[i][i] = 1;
            //2.2给每行的非首末元素赋值
            for(int j=1; j<yangHui[i].length-1; j++){
                yangHui[i][j]=yangHui[i-1][j-1]+yangHui[i-1][j];
            }
        }

        //3.遍历二维数组
        for(int i=0; i<yangHui.length; i++){
            for(int j=0; j<yangHui[i].length; j++){
                System.out.print(yangHui[i][j] + " ");
            }
            System.out.println();
        }
    }
}

数组中涉及的常见算法

一、数组元素的赋值（杨辉三角、回形数）

创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求元素的值各不相同。

回形数格式方阵的实现

二、求数值型数组中元素的最大值、最小值、平均数、总和等、

定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值、最小值、和值、平均值（随机数都是两位数）

提示：[0,1)*90 ->[0,90) + 10 -> [10,100)->[10,99]

(int)(Math.random()*90+10)

public class Test02Array {
    public static void main(String[] args) {
        int[] arr = new int[10];
        int max = 0;
        int min = 0;
        int sum = 0;
        int avg = 0;
        for(int i=0; i<arr.length; i++){
            arr[i] = (int)(Math.random()*(99-10+1)+10);
            System.out.print(arr[i] + "  ");
            sum += arr[i];
            max = arr[0];
            if(max < arr[i]){
                max = arr[i];
            }
            min = arr[0];
            if(min > arr[i]){
                min = arr[i];
            }
        }
        System.out.println();
        avg = sum/arr.length;
        System.out.println("最大值" + max);
        System.out.println("最小值" + min);
        System.out.println("总和" + sum);
        System.out.println("平均值" + avg);
    }
}

三、数组的复制、反转、查找（线性查找、二分法查找）

数组的复制

1) 创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组

2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19

3)显示array1的内容

4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值（如array[0]=0,array[2]=2）打印出array1

public class Test03Array {
    public static void main(String[] args) {
        int[] array1,array2;
        array1 = new int[]{2,3,5,7,11,13,17,19};
        for(int i=0; i<array1.length; i++){
            System.out.print(array1[i] + " ");
        }
        System.out.println();
//        array2 = array1;//不能称作复制，把array1的地址复制给了array2，相当于同一个数据
        array2 = new int[array1.length];
        for (int i=0; i<array1.length; i++){
            array2[i] = array1[i];
        }
        for(int i=0; i<array2.length; i+=2){
            array2[i] = i;
        }
        for(int i=0; i<array2.length; i++){
            System.out.print(array2[i] + " ");
        }
        System.out.println();
    }
}

2.数组的反转

public class Test04Array {
    public static void main(String[] args) {
        String[] arr = new String[]{"JJ", "DD", "MM", "GG", "AA"};
        //数组的复制（区别于数组变量的赋值：arr1 = arr）
        String[] arr1 = new String[arr.length];
        for(int i=0; i<arr1.length; i++){
           arr1[i] = arr[i];
        }
        //数组的反转
        String[] arr2 = new String[arr.length];
        //方式一
//        for(int i=0; i<arr.length/2; i++){
//            String temp = arr[i];
//            arr[i] = arr[arr.length-i-1];
//            arr[arr.length-i-1] = temp;
//        }
        //方式二
        for(int i=0, j=arr.length-1; i < j; i++,j--){
            String temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        for(int i=0; i<arr.length; i++){
            System.out.print(arr[i] + "  ");
        }

    }
}

3.数组的查找

线性查找

String[] arr = new String[]{"JJ", "DD", "MM", "GG", "AA"};
String dest = "BB";
boolean isFlag = true;
for(int i=0; i<arr.length; i++){
   if(dest.equals(arr[i])){
       System.out.println("下标为：" + i);
        isFlag = false;
        break;
    }
}
if(isFlag){
    System.out.println("查找失败！");
}

二分法查找

前提：所要查找的数组必须有序

int[] arr3 = new int[]{-99,-45,2,34,67,89,138,245,356};
int dest1 = -45;
int head = 0;//初始的首索引
int end = arr2.length - 1;//初始的末索引
boolean isFlag1 = true;
while(head <= end){
    int middle = (head + end) / 2;
    if(dest1 == arr3[middle]){
        System.out.println("下标为" + middle);
        isFlag1 = false;
        break;
     }else if(arr3[middle] > dest1){
         end = middle - 1;
     }else{
         head = middle + 1;
     }
if(isFlag1){
     System.out.println("查找失败！");
}

四、数组元素的排序算法

十大内部排序算法

冒泡排序

重复地走访过要排序地数列，一次比较两个元素，如果他们地顺序错误就把他们交换过来

public class Test05BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[]{42,56,-25,-69,156,88,50};
        //冒泡排序
        for(int i=0; i<arr.length-1; i++){
            for(int j=0; j<arr.length-1-i; j++){
                if(arr[j] >arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }

            }
        }
        for(int i=0; i<arr.length; i++){
            System.out.print(arr[i] + "  ");
        }
    }
}

快速排序

快速排序通常明显比同为O(nlogn)的其他算法更快，因此常被采用，而且快速排序采用了分治法的思想。是迄今为止所有内排序中速度最快的一种。冒泡排序的升级版，交换排序的一种。快速排序的时间复杂度为O(nlog(n))

数组工具类的使用

java.util.Array类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法

boolean equals(int[] a, int[] b)	判断两个数组是否相等
String toString(int[] a)	输出数组的信息
void fill(int[] a, int val)	将指定值填充到数组中
void sort(int[] a)	对数组进行排序
int binarySearch(int[] a,intkey)	对排序后的数组进行二分法检索指定的值

public class Test06Array {
    public static void main(String[] args) {
//        1.boolean equals(int[] a, int[] b)
        int[] arr1 = new int[]{1,2,3,4};
        int[] arr2 = new int[]{1,3,2,4};
        boolean isEquals = Arrays.equals(arr1, arr2);
        System.out.println(isEquals);//false
//        2.String toString(int[] a)
        System.out.println(Arrays.toString(arr1));//[1, 2, 3, 4]
//        3.void fill(int[] a, int val)
        Arrays.fill(arr1, 10);
        System.out.println(Arrays.toString(arr1));//[10, 10, 10, 10]
//        4.void sort(int[] a)
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));//[1, 2, 3, 4]
//        5.int binarySearch(int[] a,intkey)
        int[] arr3 = new int[]{-99,-45,2,34,67,89,138,245,356};
        int index = Arrays.binarySearch(arr3, 67);
        if(index >= 0){
            System.out.println(index);//4
        }else{
            System.out.println("未找到");
        }
    }
}

weixin_47940048

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java数组学习笔记

提示：[0,1)*90 ->[0,90) + 10 -> [10,100)->[10,99]i++){System.out.println("最大值" + max);System.out.println("最小值" + min);System.out.println("总和" + sum);System.out.println("平均值" + avg);
复制链接

扫一扫