Java数组——学习笔记（4）

数组：存储同种数据类型的内存区域。

使用数组，不需要定义大量变量，实现业务功能简单。

一、定义数组

1、静态初始化数组：定义的时候给赋值

package com.laogao.practice;

public class JavaPractice {
    public static void main(String[] args) {
//      数组
//        格式
        String[] s1=new String[]{"a","b","c"};
//        简化写法
        String[] s2={"a","b","c"};

        System.out.println(s1);//数组名中存储的是首个内容地址，数组是引用类型
        //引用类型里存的是地址，基本数据类型里是数据

    }
}

运行结果如下：

（1）数组的访问：索引从0开始，length记录数组长度

package com.laogao.practice;

public class JavaPractice {
    public static void main(String[] args) {
//      数组
        String[] s1=new String[]{"a","b","c"};
        //获取内容
        System.out.println(s1[1]);//b
        //获取长度
        System.out.println(s1.length);//3
        //修改内容
        s1[1]="hhh";
        System.out.println(s1[1]);//hhh
    }
}

（2）注意事项

最大索引(length-1),前提length不为0

a、定义格式，推荐写法："数据类型[] 数组名"，也可以写成"数据类型 数组名[]"

b、什么类型数组就放什么类型数据，否则会报错

c、定义完成后，长度、类型就不可变了

2、动态初始化数组：定义类型和长度，不赋值

package com.laogao.practice;

public class JavaPractice {
    public static void main(String[] args) {
//      动态初始化数组
        //先定义
        String[] s1=new String[3];//默认值时null
        double[] d1=new double[3];//默认值0.0
        //后赋值
        s1[0]="小明";
        s1[1]="小白";
        s1[2]="小红";
        System.out.println(s1[0]);//小明
        System.out.println(d1[0]);//0.0
    }
}

 区别：已经知道要存什么用静态初始化，不清楚存哪些用动态初始化。

注意：动态和静态两种方式不可混用，如下格式会报错:

int[] i1= new int[5]{1,2,3,4,5};//报错
int[] i1= new int[]{1,2,3,4,5};//静态
int[] i1= new int[5];//动态

 （1）动态初始化元素默认值规则（面试）

byte、short、int、char、long类型数组元素的值默认都是0

float、double类型数组元素的默认值时0.0

boolean类型数组元素的默认值说false、String类型数组元素的默认值时null

二、操作数组元素-->获取、修改

遍历数组-->一个一个的访问数据元素

package com.laogao.practice;

public class JavaPractice {
    public static void main(String[] args) {
//      遍历数组
        String[] s1=new String[3];
        s1[0]="小明";
        s1[1]="小白";
        s1[2]="小红";
        //遍历数组快捷代码：s1.fori
        for (int i = 0; i < s1.length; i++) {
            System.out.println(s1[i]);//快捷代码s1[i].sout
        }
    }
}

编写代码的快捷键，太爱了~哇哈哈

三、解决实际问题

案例1：数组元素求和

package com.laogao.practice;

public class JavaPractice {
    public static void main(String[] args) {
//        案例1：数组元素求和
        int[] nums={5,8,9,4,2};
        int sum=0;
        for (int i = 0; i < nums.length; i++) {
            sum+=nums[i];
        }
        System.out.println(sum);//28

    }
}

案例2：数组求最值

package com.laogao.practice;

public class JavaPractice {
    public static void main(String[] args) {
//        案例2：数组元素最值
        int[] nums={5,8,9,4,2};
        int max=nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (nums[i]>max){
                max= nums[i];
            }
        }
        System.out.println(max);//9

    }
}

案例3：猜数字游戏

package com.laogao.practice;

import java.util.Random;
import java.util.Scanner;

public class JavaPractice {
    public static void main(String[] args) {
//        案例3：猜数字
        //第一步：获得随机生成的数字
        int[] nums =new int[5];//存储随机生成的5个数字
        Random random=new Random();
        for (int i = 0; i < nums.length; i++) {
            nums[i]=random.nextInt(20)+1;//0~20之间的随机数
        }

        //第二步：用户输入猜测的数字
        Scanner scanner=new Scanner(System.in);
        OUT://外部循环out标签
        while (true){
            System.out.println("输入1~20之间的随机整数：");
            int guessData=scanner.nextInt();

            //和数组中的数值进行比较
            for (int i = 0; i < nums.length; i++) {
                if (nums[i]==guessData){
                    System.out.println("恭喜，猜对了");
                    break OUT;//跳出整个循环，结束外部while循环
                }
            }
            System.out.print("再猜一次~");

        }

        //第三步：打印数组内容
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i]+"\t");
        }

    }
}

案例4：随机排名

package com.laogao.practice;

import java.util.Random;
import java.util.Scanner;

public class JavaPractice {
    public static void main(String[] args) {
//        案例4：随机排名
        Scanner scanner = new Scanner(System.in);
        int[]info=new int[5];
        for (int i=0;i< info.length;i++) {
            System.out.println("请输入用户id：");
            info[i]=scanner.nextInt();
        }
        //打乱顺序,将索引i的数据与随意的索引数据交换位置
        int temp;
        Random random=new Random();
        for (int i = 0; i < info.length; i++) {
            int j=random.nextInt(info.length);//随机生成一个数组长度内的索引j
            temp = info[j];
            info[j]=info[i];
            info[i]=temp;
        }

        //输出打乱后的排序
        for (int i = 0; i < info.length; i++) {
            System.out.print(info[i]+"\t");
        }

    }
}

案例5：数组排序（面试）

冒泡排序：小的往前，大的往后（就像气泡，轻的往上飘，重的往下沉）

ｎ个数值，需要比较n-1轮

package com.laogao.practice;


public class JavaPractice {
    public static void main(String[] args) {
//        案例5：数组排序
        int[] arr={5,9,8,7,6,1};
        for (int i = 1; i < arr.length; i++) {//比较arr.length-1轮
            for (int j = 0; j < arr.length-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.println(arr[i]);
        }


    }
}

选择排序、快速排序、插入排序

搜索相关技术：二分搜索、分块搜索、哈希表查找

四、数组内存原理

1、Java内存分配、数组内存图

方法区：编译类会放到方法区

栈：将main方法提取到栈中运行，开辟区域代表变量，像int型变量值就直接存在这个区域中，数组这种引用变量，值会存入堆内存，栈中存储的是堆中对应的地址

堆：new出来的对象放在堆内存，开辟一个存储数组值和长度的空间

（本地方法栈、寄存区）

2、两个变量指向同一个数组

package com.laogao.practice;


public class JavaPractice {
    public static void main(String[] args) {
//        变量指向同一个数组
        int[]arr1={1,2,5,8};
        int[]arr2=arr1;//将地址赋给arr2

        System.out.println(arr2[0]);//1
        System.out.println(arr2[1]);//2
        System.out.println(arr2[2]);//5

        arr2[0]=8;
        System.out.println(arr1[0]);//8
    }
}

五、注意事项

1、数组索引越界：超过最大索引，ArrayIndexOutOfBoundsException。

2、若数组长度为空（null），则报错NullPointerException

六、Debug工具的使用，断点调试工具

1、添加断点

2、debug启动