java-数组/数组的遍历/反转/二维数组

数组:
相当于一个容器,存放了一组相同类型的数据(数据必须为同一类型)
* 数组存放的规则:是以下标(角标)来存放的,并且下标从0开始
*数组的声明规范:数据类型[] 数组名称 = 初始值;(数据类型指的是数组中存放的数据的类型)

ublic static void main(String[] args) {
    //所有的函数都在栈内存中,栈的特点是执行完毕,立即释放,函数一旦执行完毕就立即被系统释放,不需要手动管理
    int a = 10;
    //声明了一个长度为5的整型数组,⚠️数组的长度一旦声明,就不能改变
    //数组是在堆内存中开辟了一块连续的空间
//堆内存的特点:①有初始值(如果没有给初始值,系统会默认是0)
//           ②堆内存有内存地址,通过内存地址来访问
//           ③堆内存的垃圾回收机制
    //int[] array在栈内存中,存储的是数组在堆内存中的首地址
    int[] array = new int[5];//new代表在堆内存中开辟了一块空间
//    array = null;//讲数组置成空
//    System.out.println(array[0]);
    //NullPointerException访问了一个不存在的区域
    //在数组中取值,规则是: 数组名[角标];
//  ArrayIndexOutOfBoundsException,是数组越界的意思
    array[3] = 10;//根据下标来赋值
    System.out.println(array[3]);
}

数组的遍历(将数组中的数据全部输出一遍)
*只要是数组方面的问题都离不开数组的遍历

public static void main(String[] args) {
    //数据类型[] 数组名称 = new 数据类型[数组的长度];
//  int[] array = new int[5];
    //数组的定义方法二:直接声明出数组中保存的值(语法糖) 数据类型[] 数组名称 = new 数据类型[]{数组的元素}
    int[] array = new int[] {1,3,5,7,9};
//  System.out.println(array[1]);
    //打印数组中所有的值(遍历数组)
    //array.length,代表数组的长度
//  for (int i = 0; i < array.length; i++) 
//  {
//      System.out.println(array[i]);   
//  }
//  System.out.println(array.length);
    //将数组转换成字符串来输出
//
//  System.out.println(Arrays.toString(array));//系统方法可以直接输出一个数组
//随机10个数.随机的区间为[15,150],把这十个数放入数组中,打印最大值
    //声明一个数组
    int[] arr =new int[10];
    for (int i = 0; i < 10; i++) 
    {
        int num = (int)(Math.random()*(150-15+1)+15);
        arr[i] = num;   
    }
    int num = arr[0];
    //遍历数组寻找最大值
    for (int i = 0; i < arr.length; i++) 
    {
        num = (num>arr[i]) ? num : arr[i];
    }
    System.out.println(Arrays.toString(arr));
    System.out.println("最大值为:"+ num);
}

数组练习
1,根据索引找元素
2,根据元素找索引

public static void main(String[] args) {
        // 需求:封装一个传入数字1,返回1...
        System.out.println(name((int) (Math.random() * 8)));
        // 需求:定义一个数组,数组的值分别为3 6 11 22,在数组中查找11的位置
        int[] arr = new int[] { 3, 6, 11, 22, 11 };
        for (int i = 0; i < arr.length; i++) 
        { // 遍历数组
            if (arr[i] == 11)
            {
                System.out.println("元素在数组中的位置:" + i);
                break;// 找到索引后,立即停止循环
            }
        }
        System.out.println(find(arr, 111));//根据封装的函数来找下标
    }

    public static char name(int i) {
        char[] list = new char[] { '1', '2', '3', '4', '5', '6', '7' };
        return list[i - 1];
    }

    // // 封装一个函数,根据值来查找下标
    // public static int find(int[] array, int num)
    // {
    // //定义一个变量,保存下标
    // 注意:这里的初始值不能为0,因为当为0时,会与数组的下标正真为0时出现混淆,所以要定义为-1
    // int index = -1;
    // for (int i = 0; i < array.length; i++) //遍历数组
    // {
    // if (num == array[i])
    // {
    //// return i;// 返回下标
    // index = i;//保存查找出来的下标
    // break;
    // }
    // }
    // return index;//将查找到的下标返回,如果返回值为-1,则说明数组长度为0或者数组中没有这个元素
    // }
    // 封装一个函数,根据值来查找下标
    public static int find(int[] array, int num) {
        int index = -1;
        for (int i = 0; i < array.length; i++) {
            if (num == array[i]) {
                index = i;
                break;
            }

数组元素的反转
(把数组中的元素位置进行改变)

public static void main(String[] args) {
        int[] array = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        int num = array.length / 2;// 表示元素位置交换的次数
        for (int i = 0; i < num; i++) //
        {
            // 利用中间变量来进行两个数值的交换
            // 相当于array[i]与array[array.length-1-i]进行交换
            int temp = array[i];// 定义一个中间值来保存array[i]的原来值
            array[i] = array[array.length - 1 - i];
            array[array.length - 1 - i] = temp;
        }
        System.out.println(Arrays.toString(array));
        System.out.println();
        int a= 10;
        int b = 20;
        //⚠️⚠️⚠️
        //这一步的本质是给change函数中的a,b的两个变量赋值,与main函数中的a,b其实是没有关系的,本质上是值的传递
        //在change函数结束的时候,change函数则被系统释放,因为change函数是在栈内存中
        change(a, b);
        System.out.println("a="+a+","+"b="+b);
    }
    //需求:编写一个函数,交换两个数的值() 
public static void change(int num1,int num2)// 
{
    int temp = num1;
    num2 = num1;
    num1 = temp;
}

二维数组
定义:二维数组也是个容器,里面保存的是多个一维数组,并且是相同类型的一维数组 声明方式: 数据类型[][] 数组名称 = 初值;

public static void main(String[] args) {
        // 声明方式一:
        // 声明了一个有两个一维数组并且每个一维数组中是三个元素的二维数组
        // 注意:声明时需要把有几个一维数组(即二维数组的长度)声明出来,一维数组的长度可不声明
        int[][] array = new int[2][3];// 前面的数字代表二维数组的长度,后面的数字代表一维数组的长度
        System.out.println(array[0][0]);
        // 声明方式二:
        // 声明一个有三个一维数组并且每个一维数组中有四个元素的二维数组
        //也可以说是声明了一个三行四列的二维数组
        int[][] arr1 = new int[][] { 
            { 1, 2, 3, 5 }, 
            { 3, 5, 6, 8 }, 
            { 7, 8, 6, 7 }
            };
            //二维数组的遍历
            //二维数组的长度指的是有几个一维数组
            {
                for (int j = 0; j < arr1[i].length; j++) 
                {
                    System.out.print(arr1[i][j]);
                }
                System.out.println();
            }