DW-CHEN的Java点滴记录-基础2-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_42795277/article/details/107734383

Java中的内存分配

栈内存：方法运行时进入的内存，局部变量都存放于这块内存中
堆内存：new出来的内容都会进入堆内存，并且会存在地址值
方法区：字节码文件(.class文件）加载时进入的内存
本地方法栈：调用操作系统相关资源
寄存器：交给CPU去使用

数组

数组静态初始化和动态初始化对比

动态初始化：手动指定数组长度，由系统给出默认初始化值
静态初始化：手动指定数组元素，系统会根据元素个数计算出数组长度
应用场景：
1.动态初始化：只明确元素个数，不明确具体值，推荐使用动态初始化
2.静态初始化：已经明确了具体操作数据，推荐直接静态初始化

代码

数组

package cn.cdw.demo;

/**
 * @author DW-CHEN
 * 数组
 */
public class Demo11 {
    public static void main(String[] args) {
        int[] arr1=new int[6];//动态初始化一个长度为6的数组
        //int[] arr2 = new int[]{1, 4, 2, 3, 8};//静态初始化数组
        int[] arr2={1, 4, 2, 3, 8};//静态初始化数组

        /**
         * [I@4554617c
         * @ : 表示分隔符
         * [ : 表示当前空间是一个数组类型
         * I : 表示当前容器中的数据类型是int类型
         * 4554617c ： 十六进制的内存地址
         */
        System.out.println("输出的是数字的内存地址为：" + arr1);
        System.out.println("数组未赋值，所以输出默认值为:"+arr1[0]);

        arr1[0]=10;//赋值
        System.out.println("赋值后数组索引0的数值为："+arr1[0]);
        System.out.println("静态初始化数组索引0的数值为："+arr2[0]);
    }
}

数组常见异常（ArrayIndexOutOfBoundsException，NullPointerException）

ArrayIndexOutOfBoundsException：索引越界异常，访问数组中不存在的索引对应的元素造成的索引越界问题
NullPointerException：空指针异常，访问的数组已经不再指向堆内存的数据，造成的空指针异常

package cn.cdw.demo;

/**
 * @author DW-CHEN
 * 数组常见异常：ArrayIndexOutOfBoundsException，java.lang.NullPointerException
 */
public class Demo12 {
    public static void main(String[] args) {
        int[] arr1 = new int[6];
        //System.out.println(arr1[6]);//java.lang.ArrayIndexOutOfBoundsException索引越界异常
        arr1 = null;//null表示空值，引用数据类型的默认值，表示不指向任何有效对象
        System.out.println(arr1[0]);//因为数组的内存地址指向为空，所以会报java.lang.NullPointerException空指针异常
    }
}

找出数组中的最大值

package cn.cdw.demo;

/**
 * @author DW-CHEN
 * 找出数组的最大值
 */
public class Demo13 {
    public static void main(String[] args) {
        int[] arr = {23, 25, 12, 55, 22, 11};
        int max = arr[0];//定义数组第一个值为最大值
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {//判断数组的中值与最大值的比较
                max = arr[i];
            }
        }
        System.out.println("该数组的最大值为："+max);
    }
}

键盘录入5的数据到数组中，然后求和

package cn.cdw.demo;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author DW-CHEN
 * 键盘录入5的数据到数组中，然后求和
 */
public class Demo14 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入五个数据,");

        Long[] arr = new Long[5];
        int sum = 0;
        for (int i = 0; i < 5; i++) {//键盘录入5个数据
            System.out.print("请输入第" + (i+1) + "个数据:");
            Long num=scanner.nextLong();
            arr[i]=num;//将录入的数据添加到数组
        }

        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];//计算总和
        }
        System.out.println("你输入的数组为:"+Arrays.toString(arr));
        System.out.println("数组总和为：" + sum);
    }
}

键盘录入一个数据去找数组中的数据，如果数组中有该数据则返回对于的索引，如果数组中没有该数据则返回-1

package cn.cdw.demo;

import java.util.Scanner;

/**
 * @author DW-CHEN
 * 键盘录入一个数据去找数组中的数据，如果数组中有该数据则返回对于的索引，如果数组中没有该数据则返回-1
 */
public class Demo15 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int[] arr = {10, 20, 30, 40, 50, 60};
        int index=-1;//默认查询的数据在数组中是不存在的

        System.out.print("请输入一个数字：");
        int num=scanner.nextInt();
        for (int i = 0; i < arr.length; i++) {
            if (num == arr[i]) {
                index=i;//数组中找到了，返回该值对应的索引
                break;
            }
        }
        System.out.println(index);
    }
}

评委打分：键盘录入6个数据并存储到数组，然后去掉一个最高分和一个最低分，最后求出平均分

package cn.cdw.demo;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author DW-CHEN
 * 评委打分：键盘录入6个数据并存储到数组，然后去掉一个最高分和一个最低分，最后求出平均分
 */
public class Demo16 {
    public static void main(String[] args) {
        int max=0;//最高分
        int min=0;//最低分
        int sum=0;//总和
        int avg=0;//平均分
        Scanner scanner = new Scanner(System.in);
        int[] arr = new int[6];

        for (int i = 0; i < 6; i++) {//键盘录入6个数据
            System.out.print("请第" + (i + 1) + "个评分：");
            int num=scanner.nextInt();
            if (num < 0 || num > 100) {//不在分数范围
                System.out.print("分数输入有误,请重新输入，");
                i--;//索引要回来到刚才的索引
                continue;
            }
            arr[i]=num;//添加到数组中
        }

        max = arr[0];
        for (int i = 0; i < arr.length; i++) {//找出最大值
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        min = arr[0];
        for (int i = 0; i < arr.length; i++) {//找出最小值
            if (arr[i] < min) {
                min = arr[i];
            }
        }

        for (int i = 0; i < arr.length; i++) {//求出总和
            sum = sum + arr[i];
        }

        avg = (sum - max - min) / 4;//求出除去最大值和最小值后的平均值
        System.out.println("录入的数组数据为：" + Arrays.toString(arr));
        System.out.println("最后得分为：" + avg);
    }
}

方法（method）

方法（method）就是一段具有独立功能的代码块，不调用就不执行（提高代码的复用性）

行参和实参

形参：全称形式参数，指方法定义中的参数
实参：全称实际参数，方法调用中的参数

方法重载

在同一个类中，定义了多个同名的方法，但每个方法具有不同的参数类型或参数个数，这些同名的方法就构成了重载关系
就是同一类中，方法名相同，参数不同的方法
- 参数不同：个数不同，类型不同，顺序不同
- 注意：判断方法之间是否是重载关系，只看方法名和参数，跟返回值无关！

代码

定义一个方法接收键盘录入的一个参数，判断它是奇数还是偶数

package cn.cdw.demo;

import java.util.Scanner;

/**
 * @author DW-CHEN
 * 定义一个方法接收键盘录入的一个参数，判断它是奇数还是偶数
 */
public class Demo17 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个数字：");
        int num=scanner.nextInt();
        method(num);//调用方法
    }

    public static void method(int i) {//判断是偶数还是奇数的方法
        if (i % 2 == 0) {
            System.out.println(i+"是偶数");
        }else {
            System.out.println(i+"是奇数");
        }
    }
}

定义一个方法输出n到m之间的所有偶数

package cn.cdw.demo;

import java.util.Scanner;

/**
 * @author DW-CHEN
 * 定义一个方法输出n到m之间的所有偶数
 */
public class Demo18 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入开始的数字：");
        int n= scanner.nextInt();
        System.out.print("请输入结束的数字：");
        int m=scanner.nextInt();

        method(n,m);//调用下面自己写好的方法
    }

    public static void method(int n, int m) {//打印出n到m之间的所有的偶数
        for (int i = n; i <= m; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

编写一个方法，对数组进行遍历。格式为：[1,31,12,45,3]

package cn.cdw.demo;

/**
 * @author DW-CHEN
 * 编写一个方法，对数组进行遍历。格式为：[1,31,12,45,3]
 */
public class Demo19 {
    public static void main(String[] args) {
        int[] arr = {12, 2, 1, 44, 16};
        arrToString(arr);//调用方法
        System.out.println("============================");
    }

    public static void arrToString(int[] arr) {//定义遍历数组方法
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {//数组的最后一个值
                System.out.println(arr[i]+"]");
            }else {
                System.out.print(arr[i] + ",");//不是最后一个
            }
        }
    }
}

编写一个方法找出数组中的最大值

package cn.cdw.demo;

/**
 * @author DW-CHEN
 * 编写一个方法找出数组中的最大值
 */
public class Demo20 {
    public static void main(String[] args) {
        int[] arr = {12, 2, 43, 56, 3, 22};
        int max = getMax(arr);
        System.out.println("该数组中最大值为：" + max);
    }

    public static int getMax(int[] arr) {//找出数组中最大值的方法
        int max=0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

定义一个方法，获取数组中的最大值和最小值

package cn.cdw.demo;

/**
 * @author DW-CHEN
 * 定义一个方法，获取数组中的最大值和最小值
 */
public class Demo21 {
    public static void main(String[] args) {
        int[] arr = {12, 43, 11, 54, 10};
        String str = getMaxAndMin(arr);//调用方法
        System.out.println(str);
    }

    public static String getMaxAndMin(int[] arr) {
        int max = arr[0];
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i]; //获取最大值
            }else {
                min = arr[i];//获取最小值
            }
        }
        return "最大值为：" + max + ",最小值为：" + min;
    }
}

数据交换：a=10,b=20。让a=20，b=10

package cn.cdw.demo;

/**
 * @author DW-CHEN
 * 数据交换：a=10,b=20。让a=20，b=10
 */
public class Demo22 {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        method1(a, b);
        method2(a, b);
    }

    public static void method1(int a, int b) {//借助第三方常量
        int temp=0;
        temp = a;
        a = b;
        b = temp;
        System.out.println("a=" + a + " b=" + b);
    }

    public static void method2(int a, int b) {//不借助第三方常量
        a = a^b;
        b = a^b;
        a = a^b;
        System.out.println("a=" + a + " b=" + b);
    }
}

数组反转

package cn.cdw.demo;

import java.util.Arrays;

/**
 * @author DW-CHEN
 * 数组反转
 * 例如：将[1,2,3,4,5]反转为[5,4,3,2,1]
 */
public class Demo23 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};

        int index=0;//定义开始索引
        int end=arr.length-1;//定义结束索引
        for (; index < end; index++, end--) {//每次循环交换完成时，改变两个指针的索引位置
            int temp=0;
            temp = arr[index];
            arr[index] = arr[end];
            arr[end] = temp;
        }
        System.out.println("反转后的数组结果为：" + Arrays.toString(arr));
    }
}

二维数组

二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组容器

代码

二维数组

package cn.cdw.demo;

/**
 * @author DW-CHEN
 * 二维数组
 */
public class Demo24 {
    public static void main(String[] args) {
        //int[][] arr = new int[3][2];//动态创建一个二维数组，3表示可以存储3个一维数组，2表示每个一维数组可以存储2个数据

        //arr[0][0]=12;
        //arr[0][1]=13;//向二位数组的第一个一维数组添加数据

        //arr[1][0]=22;
        //arr[1][1]=23;//向二维数组的第二个一个数组添加数据

        //arr[2][0]=32;
        //arr[2][1]=33;//向二维数组的第三个一个数组添加数据
        //int[] arr1 = {32, 33};
        //arr[2]=arr1;//静态初始化二维数组

        int[][] arr = {{12, 13}, {22, 23}};//静态初始化二维数组

        for (int i = 0; i < arr.length; i++) {//遍历
            for (int j = 0; j < arr[i].length; j++) {//获取到每个一维数组的数据
                System.out.print("二维数组的第"+(i+1)+"个一维数组的数据的第"+j+"个索引的数据为:"+arr[i][j]);
                System.out.println();//换行
            }
        }
    }
}

计算一年四个季度的总收入

package cn.cdw.demo;

/**
 * @author DW-CHEN
 * 二维数组之求和
 * 例如：计算一年四个季度的总收入
 * 设置每个季度为一个一维数组
 */
public class Demo25 {
    public static void main(String[] args) {
        int[][] arr={{100,84,90},{76,79,80},{84,60,80},{90,79,88}};
        int sum=0;

        for (int i = 0; i < arr.length; i++) {//遍历二维数组计算总和
            for (int j = 0; j < arr[i].length; j++) {
                sum += arr[i][j];
            }
        }
        System.out.println("四个季度的总收入为：" + sum);
    }
}