java数组学习

白给是个技术活！

已于 2023-07-19 20:46:42 修改

阅读量95

点赞数 1

文章标签： java 学习

于 2023-07-18 17:18:14 首次发布

本文链接：https://blog.csdn.net/weixin_45812603/article/details/131790689

版权

数组

1 一维数组

1.1 概念

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

变量:在内存开辟一块空间。

数组:也是变量，在内存中开辟一串连续的空间。数组长度一旦确定，就不能修改

数组的常见概念：

数组名
下标(或索引)
元素
数组的长度

1.2 基本用法

数组的声明

 public static void arrTest1()
    {
        //方式1 声明数组变量并创建数组 此时没有分配内存空间
        int[] arry1 = null;
        System.out.println(arry1);//null
        //方式2 声明数组变量并创建数组 此时分配内存空间
        int[] arry2 = new int[5];//创建一个长度为5的int类型数组
        //方式3 声明数组变量并创建数组 此时分配内存空间
        int[] arry3 = new int[]{1, 2, 3, 4, 5};//创建一个长度为5的int类型数组,并赋值
        //方式4 声明数组变量并创建数组 此时分配内存空间
        int[] arry4 = {1, 2, 3, 4, 5};//创建一个长度为5的int类型数组,并赋值

        String[] strings = new String[3];
        strings[0] = "hello";
        strings = new String[4];
        //char数组的默认值是/u0000 int型为0
    }

1.3 内存结构

int[] arr1 = null;

此时内存状态：

int[] arr1 = new int[4]

此时内存状态：

int arr1 = new int[4];
arr1[0] = 10;
arr1[2] = 20;

String[] arr2 = new String[3];
arr2[1] = "刘杰"
arr2 =new String[5];

此时内存状态：

另一种情况内存状态：

1.4 数组实战

1.4.1 数组的读取

public static void arrTest2()
    {
        //读取数组
        int[] arry1 = new int[]{1, 2, 3, 4, 5};
        for (int i = 0; i < arry1.length; i++)
        {
            System.out.println(arry1[i]);
        }
    }

1.4.2 数组的默认值

public static void arrTest3()
    {
        //int型数组的默认值为0
        int[] arr1 = new int[4];
        System.out.println(arr1[0]);//默认值为0
        //char型数组的默认值为/u0000 为0
        char[] arr2 = new char[4];
        System.out.println(arr2[0]);//默认值为0
        //String型数组的默认值为null
        String[] arr3 = new String[4];
        System.out.println(arr3[0]);//默认值为null
        //boolean型数组的默认值为false
        boolean[] arr4 = new boolean[4];
        System.out.println(arr4[0]);//默认值为false
    }

1.4.3 求极值问题

 public static void arrTest4()
    {
        int[] arr = {12,456,98,468,90,67};
        int max = arr[0];
        int min = arr[0];
        for (int i = 0; i < arr.length; i++)
        {
            if (arr[i] > max)
            {
                max = arr[i];
            }
            else if (arr[i] < min)
            {
                min = arr[i];
            }

        }
        System.out.println("最大值为："+max);
        System.out.println("最小值为："+min);
    }

1.5 数组练习

从键盘读入学生成绩，找出最高分，并输出学生成绩等级。

提示：先读入学生人数，根据人数创建int 数组，存放学生成绩

成绩>=最高分-10 等级为’A’
成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’
其余等级为’D’

public static void arrTest5()
    {
        System.out.println("请输入学生人数：");
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        System.out.println("请输入"+num+"人成绩：");
        int[] arr = new int[num];
        for (int i = 0; i < arr.length; i++)
        {
            arr[i] = scanner.nextInt();
        }
        int max = 0;
        for (int i = 0; i < arr.length; i++)
        {
            max = arr[i];

            System.out.println(arr[i]);
        }
        System.out.println("最高分是："+max);

        for (int i = 0; i < arr.length ; i++) {
            if (arr[i] >= max-10)
            {
                System.out.println("student "+i+" score is"+arr[i]+" grade is "+'A');
            }
            else if (arr[i] >= max-20)
            {
                System.out.println("student "+i+" score is"+arr[i]+" grade is "+'B');
            }
            else if (arr[i] >= max-30)
            {
                System.out.println("student "+i+" score is"+arr[i]+" grade is "+'C');
            }
            else
            {
                System.out.println("student "+i+" score is"+arr[i]+" grade is "+'D');
            }

        }

    }

2. 二维数组

2.1 概念

对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组

语法格式

 public static void initTest() {
        //方式1
        int[][] arr = new int[][]{{5, 6, 9}, {8, 10, 14}, {6, 9, 20}};
        //方式2
        int[][] arr1 = new int[3][3];
        //方式3
        int[][] arr2 = new int[3][];
    }

2.2 二维数组的使用

public static void main(String[] args) {
//1、声明二维数组
//1.1 声明数组的同时开辟空间：数据类型[][] 数组名称=new 数据类型[行][列];
int[][] nns=new int[3][4];
//列的值：可以有：所有的行的列的个数相同，相当于矩形
// 可以省略，每一行都是null,需要自己去开辟空间--了解
//1.2 先声明数组再开辟空间
int[][] nns2;
nns=new int[3][4];
//1.3 声明数组的同时赋初值：行列的长度由赋值的个数决定了
int[][] nns3=new int[][] {{1,2},{3,4},{5,6}};
//1.4
int[][] nns4 = new int[3][];
nns4[0] = new int[] {1,2};
System.out.println(Arrays.toString(nns4));
System.out.println(Arrays.toString(nns4[0]));
//2、赋值
//使用循环赋值
for(int i=0;i<nns.length;i++) {
for(int j=0;j<nns[i].length;j++) {
nns[i][j]=i+j+4;
}
}
//3、取值
for(int i=0;i<nns3.length;i++) {
for(int j=0;j<nns3[i].length;j++) {
System.out.print(nns3[i][j]+" ");
}
    System.out.println();
}
}

2.3 内存结构

2.4 练习

基本都跟循环打交道；一维数组数组一重循环；2维数组数组2重循环；

基本离不开坐标问题；一维数组一个下标索引；二维数组一定就是两个坐标（横纵坐标）

 /*
     * 二维数组练习：
     * 数组中常见的异常： NullPointerException异常 空指针异常
     * ArrayIndexOutOfBoundsException 数组下标越界
     */
    public static void arryDemo()
    {
        //1、计算3个班级所有学生的平均分：每个班级有n个人，要求先输出各个班级的自己的平均分
        double[][] arr = new double[3][];
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < arr.length; i++) {
            double sum = 0;
            System.out.println("请输入" + (i + 1) + "班人数：");
            int n = scanner.nextInt();
            arr[i] = new double[n];
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println("请输入" + (i + 1) + "班第" + (j + 1) + "个同学的成绩：");
                arr[i][j] = scanner.nextDouble();
                sum += arr[i][j];
            }
            double average = sum / arr[i].length;
            System.out.println("第" + (i + 1) + "个班级的平均分为" + average);
        }
    }

3. 数组中常见算法

数组复制

 //数组复制
    public static void arrCopy()
    {
        String[] arr = {"小白","小黄","小黑"};
        String[] arr2 = new String[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arr2[i] = arr[i];
            System.out.println(arr2[i]);
        }
    }

数组反转

//数组反转
    public static void arrReversal()
    {
        String[] arr = {"小白","小黄","小黑"};
        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.println(arr[i]);

        }
    }

二分查找

//二分查找
    public static void binarySearch()
    {
        int[] arr = {1,3,5,8,10,13,16,32};
        System.out.println("请输入你要查找的数");
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        int head = 0;//初始化的首索引
        int end = arr.length-1;//初始化的末索引
        boolean isok = true;
        while (head <= end)
        {
            int i = (head+end)/2;
            if (num > arr[i])
            {
                head = i+1;
            }
            else if (num < arr[i])
            {
                end = i-1;

            }
            else if (num == arr[i])
            {
                System.out.println("找到了指定元素位置为"+i);
                isok = false;
                break;
            }
        }
        if (isok)
        {
            System.out.println("对不起没有找到");
        }

    }

冒泡排序

//冒泡排序
    public static void bubbleSort()
    {
        int[] arr = {50,80,100,89};
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                if (arr[i] > arr[j])
                {
                    int temp = 0;
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(+arr[i]+" ");

        }
    }

3.1 Arrys工具类

 //Arrys工具类的使用
    public static void arrysTole() {
      //1.boolean equals(int[] a,int[] b):判断两个数组是否相等
        int[] arr1 = new int[]{1, 2, 3, 4};
        int[] arr2 = new int[]{1, 2, 3, 4};
        boolean isEquals = Arrays.equals(arr1, arr2);
        System.out.println(isEquals);
        
      //2.String toString(int[] a):输出数组信息。
        System.out.println(Arrays.toString(arr1));
        
      //3.void fill(int[] a,int val):将指定值填充到数组之中。
        Arrays.fill(arr1, 10);
        System.out.println(Arrays.toString(arr1));
        
      //4.void sort(int[] a):对数组进行排序。
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));
        
      //5.int binarySearch(int[] a,int key)：二分查找 int key为要查找的数
        int[] arr3 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
        int index = Arrays.binarySearch(arr3, 210);
        if (index >= 0) {
            System.out.println(index);
        } else {
            System.out.println("未找到");
        }
    }

4. 总结

方法、局部变量、成员变量在程序运行时在内存中的情况：

public static void f1() {
int i = 1;
i = 11;
int[] arr = new int[4];
arr[1] = 2;
f2();
}
public static void f2() {
int i = 2;
char a = 'a';
}
public static void main(String[] args) {
int i = 3;
f1();
char a = 'b';
}