05数组，十六进制 （获取一个数组中的最大值，数组元素反转，数组的排序（重要））

一、直接打印数组名称，得到的是数组对应的：内存地址哈希值。

二进制：01

十进制：0123456789

16进制：0123456789abcdef

重点

二、java中内存划分

栈（stack）：局部变量在栈中，方法运行必须在栈中，

堆（Heap）：new 出来的都在堆内存，堆内存中存储的时真正的数据

方法区：存储.class相关的信息，包含方法的信息

本地方法区：与操作系统相关

寄存器：与cpu相关

三、一个数组在java中的内存模型

数组注意点

1、数组的长度在程序运行期间不可变

2、新建一个数组最常用的方式是

例如：int [  ]  array = {1,2,3};

3、数组当做参数传递，传递的是内存地址

4、{}内可以写变量 sum,age

5、方法的局部变量也包括方法的参数

例如：int [  ] array1 = { sum ,age };

最重要的点一定要理解明白

int[] arr1 = {1,2,3,4,5};//001

int[] temp1 = arr1;

int[] temp2 = arr1;

temp1获取的是arr1的内存地址

temp2获取的是arr1的内存地址

tmep1，temp2，arr1都是通过数组在内存中的地址指向的堆内存中的数组

只要修改tmep1，temp2，arr1中的任意一个，数组都会改变

还有一个很重要的点

静态方法中要想使用成员变量，必须给成员变量添加static修饰

基础练习题

1，获取一个数组中的最大值

//获取最大值

​​​​​​

public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        int max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        System.out.println(max);

    }

2、数组元素反转

方法一：只一个数组，不能创建新数组

//数组元素反转

public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        for (int min = 0, max = array.length - 1; min < max; min++, max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

    }

方法二：使用一个新数组，来存储反转之后的数据

 public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        //新数组(默认数组元素都是0)
        int[] array1 = new int[array.length];
        //反转输出array
        for (int i = array.length - 1; i >= 0; i--) {
            //赋值给新数组array1
            array1[array1.length - 1 - i] = array[i];
        }
        //输出
        for (int j = 0; j < array1.length; j++) {
            System.out.println(array1[j]);
        }
    }

3、数组的排序（重要）

//推荐第一种（我自己的思路）

public static void main(String[] args) {
        //定义一个数组：
        int[] arr = {1, 3, 7, 6, 2};
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] < arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

//第二种（我自己的思路）

 public static void main(String[] args) {
        //定义一个数组：
        int[] arr = {1, 3, 7, 6, 2};
        //Arrays类只提供了默认升序排列，升序之后反转数组元素即可实现

        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        System.out.println("=============================");
        //数组反转
        for (int min = 0, max = arr.length - 1; min < max; min++, max--) {
            int temp = arr[min];
            arr[min] = arr[max];
            arr[max] = temp;
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }