0
点赞
收藏
分享

微信扫一扫

练习敲代码速度

墨香子儿 2023-09-21 阅读 48
java开发语言
加载失败

java——数组

1，数组概述

  1. 数组是一组数据的集合
  2. 数组作为一种引用类型
  3. 数组元素的类型可以是基本类型，也可以是引用类型，但同一个数组只能是同一种类型
  4. 数组作为对象，数组中的元素作为对象的属性，除此之外数组还包括一个成员属性 length，length 表示数组的长度
  5. 数组的长度在数组对象创建后就确定了，就无法再修改了
  6. 数组元素是有下标的，下标从 0 开始，也就是第一个元素的下标为 0，依次类推最后一个元素的下标为 n-1，我们可以通过数组的下标来访问数组的元素

2，一维数组

一维数组的定义

  - 格式一：数据类型[]  数组名;
  - 格式二：数据类型 数组名[];
/**
 * 数组的定义
 */
public class Demo01_Array {
    /*
        数组的定义：
            格式一：数据类型[] 数组名;
            格式二：数类型 数组名[];
     */
    public static void main(String[] args) {
        //1、数据类型[] 数组名;
        int[] arr1; //定义一个int类型的数组,起名为arr1

        //2、数据类型 数组名[];
        float arr2[]; //定义一个float类型的数组，起名为arr2
    }
}

一维数组的静态初始化

初始化：就是在内存中，为数组容器开辟空间，并将数据(元素)存放到容器中的过程
完整格式：数据类型 [ ]  数组名 = new 数据类型 [ ] {元素1,元素2,元素3,元素4....};
简化格式：数据类型 [ ]  数组名 = {元素1,元素2,元素3,元素4...};
/**
 * 数组的静态初始化
 */
public class Demo02_Array {
    /*
        数组的静态初始化：
            完整格式：数据类型[] 数组名 = new 数据类型[] {元素1,元素2,元素3,元素4...};
            简化格式：数据类型[] 数组名 = {元素1,元素2,元素3,元素4...};
     */
    public static void main(String[] args) {
        //1、数据类型[] 数组名 = new 数据类型[] {元素1,元素2,元素3,元素4...};
        //创建了一个int类型的数组，数组名叫做arr1，数组中存放了10,20,30,40，这四个元素
        int[] arr1 = new int[]{10,20,30,40};
        System.out.println(arr1);//打印输出数组在内存中的地址值

        //2、数据类型[] 数组名 = {元素1,元素2,元素3,元素4...};
        double[] arr2 = {2.55,3.55,4.55,5.55};
        System.out.println(arr2);

        //[I@1b6d3586:  表示int类型的数组在内存中的地址值  @符号之后的内容是十六进制的地址值
        //[D@4554617c:  表示double类型的数组在内存中的地址值
    }
}

一维数组动态初始化

- 动态初始化：初始化时只指定数组的长度，由系统为数组分配初始值
- 格式：数据类型 [ ]  数组名 = new 数据类型 [ 数组长度 ] ;
/**
 * 数组的动态初始化
 */
public class Demo05_Array {
    /*
        数组的动态初始化：初始化时只能指定数组的长度，由系统未数组分配初始值
        格式：数据类型[] 数组名 = new 数据类型[数组长度];

        数据类型的默认初始值：
            基本数据类型：
                整数：0
                浮点型：0.0
                布尔：false
                字符型：空白字符
            引用数据类型：null
     */
    public static void main(String[] args) {
        //数据类型[] 数组名 = new 数据类型[数组长度];
        int[] arr = new int[4];

        //获取数组的默认值
        System.out.println(arr[0]);//0
        System.out.println(arr[1]);//0
        System.out.println(arr[2]);//0
        System.out.println(arr[3]);//0

        //赋值操作
        arr[0] = 11;
        arr[1] = 22;
        arr[2] = 33;
        arr[3] = 44;

        //遍历数组，打印数据到控制台
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

数组初始化的区别和使用场景：
静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组长度。明确具体操作数据
动态初始化：手动指定数组长度，由系统默认初始化值。不明确具体数据，但明确数组长度

一维数组内存图

基本数据类型数据存储发生在栈内存中；引用类型数据存储，分两步，在堆中保存数据，在栈中保存数据的地址(堆地址)

在这里插入图片描述

3，二维数组

二维数组概述

二维数组：
	是一种结构较为特殊的数组，只是将数组中的每个元素变成了一维数组

二维数组静态初始化

初始化格式: 
	数据类型 [ ] [ ] 数组名 = new 数组类型 [ ] [ ] {{元素1,元素2},{元素1,元素2}...};
简化格式：
	数据类型 [ ] [ ] 数组名 = {{元素1,元素2},{元素1,元素2}...};
二维数组元素访问格式：
	格式：数组名[索引] [索引] ;

/**
 * 二维数组
 */
public class Demo01_Array {
    /*
        二维数组：
            也是一种容器，容器中存储的是一维数组
         格式：
            初始化格式:  数据类型 [] [] 数组名 = new 数组类型 [] [] {{元素1,元素2},{元素1,元素2}...};
            简化格式：数据类型 [] [] 数组名 = {{元素1,元素2},{元素1,元素2}...};
     */
    public static void main(String[] args) {
        //1、创建二维数组
        int[][] arr = {{1,2,3},{10,20,30}};
        //2、打印一维数组的地址值
        System.out.println(arr[0]);//
        //3、打印一维数组的中的元素
        System.out.println(arr[0][1]);
    }
}

二维数组动态初始化

格式：数据类型  [ ] [ ] 数组名 = new 数据类型 [ m ] [ n ];
m 表示当前二维数组中可以存放的一维数组个数，
n 表示每一个一维数组可以存放多少个元素
/**
 * 二维数组的动态初始化
 */
public class Demo03_Array {
    /*
        格式：数据类型  [ ] [ ] 数组名 = new 数据类型 [ m ] [ n ];
             m 表示当前二维数组中可以存放的一维数组个数，
             n 表示每一个一维数组可以存放多少个元素
     */
    public static void main(String[] args) {
        //创建一个二维数组，其可以存放2个一维数组，每个一维数组可以存放3个元素
        int[][] arr = new int[3][3];
        //给一维数组赋值
        arr[0] = new int[]{1, 2, 3};
        arr[1] = new int[]{11, 22, 33};
        //遍历二维数组，获取一维数组中的元素，并打印
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
            System.out.println(Arrays.toString(arr[i]));
        }
    }
}

4，数组常用方法

1，数组求和

public class Demo08 {
    /*
        求数组的偶数之和
        1、初始化数组
        2、定义求和变量
        3、遍历数组中每一个元素
        4、判断元素是否为偶数，是偶数进行求和赋值运算
        5、打印求和值
     */
    public static void main(String[] args) {
        //1、初始化数组
        int[] arr = {22,33,44,55,66};
        //2、定义求和变量
        int sum = 0;
        //3、遍历数组中每一个元素
        for (int i = 0; i < arr.length; i++) {
            //4、判断元素是否为偶数，是偶数进行求和赋值运算
            if (arr[i]%2==0){
                sum+=arr[i];
            }
        }
        //5、打印求和值
        System.out.println(sum);
    }
}

2，数组求最大值

public class Demo09 {
    /*
        求数组中的最大值
            1、定义数组
            2、定义最大值变量max，并将数组中的第一个元素赋值给变量max
            3、从索引1开始遍历数组，依次取出数组元素和max比较，
                大于max则赋值给max，小于max则继续比较
            4、输出打印数组中元素最大值
     */
    public static void main(String[] args) {
        int[] arr = {11,55,33,87,21};
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i]>max){
                max = arr[i];
            }
        }
        System.out.println(max);
    }
}

3，二维数组遍历

/**
 * 遍历二维数组
 */
public class Demo02_Array {
    /*
        遍历二维数组：先遍历出一个一个的一维数组，再将一维数组中存储的每个元素遍历出来
     */
    public static void main(String[] args) {
        int[][] arr = new int[][]{{111,222,333},{10,20,30},{100,200,300}};
        //1、遍历二维数组，获取每一个一维数组
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
            System.out.println(Arrays.toString(arr[i]));
        }
    }
}

5，数组常见问题

1，索引越界

/**
 * 数组异常
 */
public class Demo06_ArrayEcxeption {
    /*
        数组索引越界异常：ArrayIndexOutOfBoundsException
            即当访问数组中不存在的索引，引发的异常
     */
    public static void main(String[] args) {
        int[] arr1 = {11,22,33,44};

        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println(arr1[5]);
    }
}

在这里插入图片描述

2，空指针异常

/**
 * 空指针异常：
 */
public class Demo07_ArrayEcxeption {
    /*
        空指针异常：
            当引用数据类型被赋值为null之后，地址的消失，再继续访问堆内存数据，会引发空指针异常
     */
    public static void main(String[] args) {
        //创建数组
        int[] arr1 = {10,20,30};
        //引用变量arr1赋值为null
        arr1 = null;
        System.out.println(arr1[1]);
    }
}

在这里插入图片描述

6，数组的排序和查找

冒泡排序，选择排序；二分法（折半法）查找

7，Arrays工具类

在这里插入图片描述

public class ArraysMethod01 {
    public static void main(String[] args) {       
        //使用sort方法将数组按照默认规则排序(从小到大)
        int[] arr = {112,3,4,56,67,1};
        Arrays.sort(arr);
        int[] arr = { 1, 2, 3, 4, 5 };  
        // 直接输出为内存地址[I@139a55
        System.out.println(arr.toString());  
        //使用toString方法返回数组内容的字符串表示形式
        System.out.println(Arrays.toString(arr));

        //使用sort方法将数组按照定制规则排序
        Integer array[] = {1, -1, 7, 0, 89};
        Arrays.sort(arr, new Comparator(){
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                return i2 - i1;
            }
        });
        //输出排序后的数组中的内容
        System.out.println(Arrays.toString(array));

        //测试binarySearch方法
        Integer[] arr = {1, 2, 90, 123, 567};
        // 如果数组中不存在该元素，就返回 return -(low + 1); 
        int index = Arrays.binarySearch(arr, 567);
        System.out.println("index=" + index);

        //测试copyOf方法
        Integer[] newArr = Arrays.copyOf(arr, arr.length);
        System.out.println(Arrays.toString(newArr));

        //测试fill方法 
        Integer[] num = new Integer[]{9,3,2};
        //使用99去填充num数组，可以理解成是替换数组中原来所有的元素
        Arrays.fill(num, 99);
        System.out.println(Arrays.toString(num));

        //测试equals方法
        Integer[] arr2 = {1, 2, 90, 123};
        //比较两个数组元素内容是否完全一致,一样返回true否则返回false
        boolean equals = Arrays.equals(arr, arr2);
        System.out.println("equals=" + equals);//false

        //测试asList方法
        //将一组值转成一个List集合,asList编译类型是List(接口)
        List asList = Arrays.asList(2,3,4,5,6,1);
        System.out.println("asList=" + asList);
        // asList 运行类型 java.util.Arrays#ArrayList, 是Arrays类的静态内部类
        System.out.println("asList的运行类型" + asList.getClass());
    }
}
举报

相关推荐

蓝桥杯敲代码

蓝桥杯java数据结构算法

python作业代码敲写

python

java面试需要敲代码

解决方案编写代码Java后端开发

敲代码常用快捷键

spring bootspringjava

我们敲代码的不懂这个

项目实战springideJava编程语言

Java敲代码时抛出的错误

构造函数赋值显式Linux系统/运维

python代码敲写英雄联盟排列

python

“敲代码”学编程的正确方式

编程源码视频编程语言阅读程序

java学习笔记四--多敲代码

java开发语言后端

Java代码基本知识(手敲总结）

父类字符串java系统/运维
0 条评论
加载失败