java_04-数组

java_04-数组

一维数组

package main.java.chapter3dir;

import java.lang.reflect.Array;

/**
 * 一、数组的概述
 * 1.数组的理解，数组（Array），是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
 * <p>
 * 2.数组相关概念
 * >数组名
 * >元素
 * >角标、下标、索引
 * >数组的长度：元素的个数
 * <p>
 * 3.数组的特点
 * 1）数组是有序排列的
 * 2）数组属于引用数据类型。数组的元素既可以是基本数据类型，也可以是引用数据类型。
 * 3）创建数组对象会在内存中开辟一整块连续的空间
 * 4）数组的长度一旦确定，就不能修改
 * <p>
 * 4.数组的分类
 * 1）按照维数：一维数组、二维数组。。
 * 2）按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组
 * <p>
 * 5.一维数组的使用
 * 1）一维数组的声明和初始化
 * 2）如何调用数组的指定位置的元素
 * 3）如何获取数组的长度
 * 4）如何遍历数组
 * 5）数组元素的默认初始值
 * 6）数组的内存解析
 */
public class Q1Array {
    public static void main(String[] args) {
        // 1.一维数组的声明和初始化？
        int num;    // 声明
        num = 10;   // 初始化
        int id = 1001;  // 什声明和初始化

        int[] nums;
        // 1.1 静态初始化：数组的初始化和数组的赋值操作同时进行
        nums = new int[]{1, 2, 3, 4};
        // 1.2 动态初始化：数组的初始化和数组元素的赋值操作分开进行
        int[] nums2 = new int[3];
        nums2[0] = 1;
        nums2[1] = 2;
        nums2[2] = 3;

        // 2.如何调用数组的指定位置的元素？// 通过索引方式调用（java中数组的索引从0开始到数组长度-1结束）。
        System.out.println(nums2[0]);

        // 3.如何获取数组的长度
        // 属性：length

        // 4.如何遍历数组
        System.out.println("---如何遍历数组---");
        System.out.println(nums2[0]);
        for (int i = 0; i < nums2.length; i++) {
            System.out.println(nums2[i]);
        }

        // 5.数组元素的初始化值
        /**
         * 数组元素的初始化值
         * > 整形: 0
         * > 浮点型: 0.0
         * > boolean: false
         * > char: 0 或 '\u0000' 而非'0'
         * > 引用数据类型 比如string: null
         *
         */

        System.out.println("---数组元素初始化值---");
        int[] int1 = new int[3];
        float[] float1 = new float[3];
        boolean[] boolean1 = new boolean[3];
        String[] stirng1 = new String[3];
        char[] char1 = new char[3];
        System.out.println(int1[0]);    // 0
        System.out.println(float1[0]);  // 0.0
        System.out.println(boolean1[0]);    // false
        System.out.println("aaaa" + char1[0] + "hhhh");   // aaaahhhh 0或'\u0000' 而非'0' 但是实际看到的效果是空格
        if (char1[0] == 0) {
            System.out.println("你好");
        }

        // 6. 数组的内存解析 见logic——note.ppt
        System.out.println(stirng1[0]); // null
        
    }

}

一维数组的内存解析

二维数组

大部分和一维数组相同，部分细节记录：

二维数组元素的初始化值（很重要）

针对于初始化方式一：比如：int[ ][ ] arr = new int[4][3]
外层元素的初始化值为：地址值。 arr[0] 返回[I@15db9742，arr 返回[[I@6d06d69c。原因参见内存解析
内层元素的初始化值为：与一维数组初始化情况相同。 arr[0][0] 返回0
针对于初始化方式二：比如：int[ ][ ] arr = new int[4][ ];
外层元素的初始化值为：null。arr[0] 返回null
内层元素的初始化值为：不能调用，否则报空指针异常

二维数组的内存解析

数组的常见算法

冒泡排序done见java_05-面向对象01

Arrays工具类的使用

Q6ArrayUtil.java

package main.java.chapter5dir;

import java.lang.reflect.Array;

/**
 * 自定义数组的工具类
 *
 * 目的：熟悉方法是否返回和返回值类型
 */
public class Q6ArrayUtil {


    // 求数组的最大值
    public int getMax(int[] arr1){
        int maxNum = 0;
        for(int i = 0; i < arr1.length; i++){
            if(arr1[i] > maxNum){
                maxNum = arr1[i];
            }
        }
        return maxNum;
    }

    // 求数组的最小值
    public int getMin(int[] arr1){
        int minNum = 0;
        for(int i = 0; i < arr1.length; i++){
            if(arr1[i] < minNum){
                minNum = arr1[i];
            }
        }
        return minNum;
    }

    // 求数组的总和
    public int getSum(int[] arr1){
        int sum = 0;
        for(int i = 0; i < arr1.length; i++){
            sum += arr1[i];
        }
        return sum;
    }

    // 求数组的平均值
    public double getAvg(int[] arr1){
        if(arr1.length>0) {
            return (double) getSum(arr1) / arr1.length;
        }
        return 0.0;
    }


    // 反转数组
    public void reserve(int[] arr1){
        int tmp;
        for(int i = 0; i < arr1.length/2; i++){
            tmp = arr1[i];
            arr1[i] = arr1[arr1.length-1-i];
            arr1[arr1.length-1-i] = tmp;
        }
    }

    // 复制数组
    /**
     * 数组的复制
     * @param arr1 源数组
     * @param arr2 目标数组
     */
    public void copy(int[] arr1, int[] arr2){
        for(int i = 0; i < arr2.length; i++){
            arr2[i] = arr1[i];
        }
    }

    // 数组排序 升序
    public void sort(int[] arr1){
        //  冒泡排序
        for(int i = 0; i < arr1.length; i++){
            int tmp ;
            for(int j = 0; j < arr1.length - 1 - i; j++){
                if(arr1[j + 1] < arr1[j]){
                   tmp = arr1[j];
                   arr1[j] = arr1[j+1];
                   arr1[j+1] = tmp;
                }
            }
        }

    }

    // 遍历打印数组
    public void bianli(int[] arr1){
        String strArr = "[";
        for(int i = 0; i < arr1.length; i++){
            if(i != arr1.length-1 ){
                strArr += (arr1[i] + ","); // 注意：双引号"" 和 括号 debug发现
            } else {
                strArr += arr1[i];
            }
        }
        strArr += "]";
        System.out.println(strArr);

    }

    // 查找指定元素

    /**
     * 查找数组中第n位元素
     * @param arr1 数组
     * @param arg 第N位
     * @return
     */
    public int search(int[] arr1,int arg){
        for(int i = 0; i < arr1.length; i++){
            if(i == arg-1){
                return arr1[i];
            }
        }
        return 0;
    }
}

Q6ArrayUtilTest.java

package main.java.chapter5dir;


import javax.sound.midi.Soundbank;

public class Q6ArrayUtilTest {
    public static void main(String[] args) {
        // 测试数据
        int[] arr = new int[]{7,8,9,1};
        Q6ArrayUtil arrUtil = new Q6ArrayUtil();

        System.out.println("最大值：" + arrUtil.getMax(arr)); // 9

        System.out.println("最小值：" + arrUtil.getMin(arr)); // 0

        System.out.println("数组的总和：" + arrUtil.getSum(arr)); // 25

        System.out.println("数组的平均值：" + arrUtil.getAvg(arr)); //<double> 6.25

        int[] arr2 = new int[]{7,8,9,1,5};
        System.out.println("反转数组前：");
        arrUtil.bianli(arr2); // [7,8,9,1,5]
        System.out.println("反转数组后：");
        arrUtil.reserve(arr2);
        arrUtil.bianli(arr2); // [5,1,9,8,7]

        // 数组的复制 arr3复制arr  区别于地址的复制
        int[] arr3 = new int[arr.length];
        arrUtil.copy(arr,arr3);
        System.out.println("复制数组返回结果：");
        arrUtil.bianli(arr3);   // [7,8,9,1]


        //排序
        int[] arr4 = new int[]{6,8,9,1,9,1,0,7,5};
        System.out.println("升序前：");
        arrUtil.bianli(arr4);  //   [6,8,9,1,9,1,0,7,5]
        System.out.println("升序后：");
        arrUtil.sort(arr4); // [0,1,1,5,6,7,8,9,9]
        arrUtil.bianli(arr4);

        System.out.println(arrUtil.search(arr,3)); // 9

    }

}

数组的常见异常

---

已更新发布