数组重点内容强调

最新推荐文章于 2024-09-15 19:46:31 发布

小白的含金量

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量894

点赞数 32

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/weixin_65278827/article/details/124108080

版权

JavaSE 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

数组基本用法

数组的遍历

for循环遍历

确确实实遍历数组每个元素，可以修改每个元素的值

for (int i = 0; i < array.length-1; i++) {
      array[i]....
}

for-each 增强型for循环

将数组中每个元素拷贝一份给整型i，不能修改元素的值

for(int i : array) {
  sum+=i;
}

数组作为方法的参数

内存

数组是接触的第一个引用数据类型

内存在JVM中的分布

要想理解引用类型，得先知道内存是啥，在JVM中，内存分为六大部分。

程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址

虚拟机栈(JVM Stack): 重点是存储局部变量表(当然也有其他信息). 我们刚才创建的 int[] arr 这样的存储地址的引用就是在这里保存

本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的

堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2, 3} )

方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域

运行时常量池(Runtime Constant Pool): 是方法区的一部分, 存放字面量(字符串常量)与符号引用. (注意从 JDK 1.7 开始, 运行时常量池在堆上)

今天我们只需要了解虚拟机栈区和堆区即可

栈区与堆区

栈区：遵循先进后出原则（LIFO），所有方法的调用，形参的创建，变量的创建全部在栈中进行，我们把这些数据进入栈中的过程叫做栈帧的入栈。方法结束时，临时变量和形参出栈销毁。

堆区：所有对象（new出来的）都在堆区中储存，数组对象，类的实例化对象，接口的对象。

理解引用类型

说白了，引用类型的特点就是存储的是地址。

内置类型传参

如果不是引用类型，如何在内存中存储呢？

附上一张此类型传参在栈中储存的过程

引用类型传参

存放地址，正因为如此，所以如果在方法中改变数组元素中的值，那么就算方法调用结束，这个地址中的元素的值依旧会保留改变之后的值。

一图流表示数组在栈堆上的储存

可以看出，如果我们在调用方法时不想破坏原数组元素，那么就在方法中新建数组，这样可以让新的数组存储另一块地址存储元素，当我们返回数组时相当于返回了存储的新地址。

二维数组传参

什么是二维数组

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组。

实际上就是，二维数组存放的地址也是几个地址，而这几个地址存放的则是元素。

public class Test11 {
    public static void main(String[] args) {
        int[][] arr = {
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11, 12}
        };
        for (int row = 0; row < arr.length; row++) {
            for (int col = 0; col < arr[row].length; col++) {
                System.out.printf(arr[row][col]+" "+"\t");
            }
            System.out.println();
        }
    }
}

二维数组在栈堆中的存储

数组的练习

二分查找

二分查找的作用就是比遍历更快速更高效

在一个有序数组中，给定一个值，在数组在查找该值对应元素的下标

正常写法

我们可以通过找出中间元素array[mid]，然后看给定值的大小，决定下一次比较的空间

代码部分

public class Test5 {
    public static void main(String[] args) {
        int[] array=new int[]{1,2,3,4,5,6,7};
        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int left=0;
        int right=array.length-1;
        int num = binarySearch(array,a);
        if(num!=-1) {
            System.out.println("找到了，下标是 "+num);
        }
        else {
            System.out.println("没找到");
        }
    }
     public static int binarySearch(int[] array,int a) {
        int left = 0;
        int right = array.length-1;
        while(left<=right) {
            int mid = (left+right)/2;
            if(array[mid] > a ) {
                right = mid-1;
            }
            else if(array[mid]<a) {
                left= mid+1;
            }
            else {
                return mid;
            }
        }
        return -1;
    }
}

递归写法

不难发现，二分查找有终止条件（数组已比完，左下标大于右下标）

从上图可以得知，可以把问题拆分为相同的小问题，且解决思路相同。

public static  int binarySearch(int[] array,int a,int left,int right) {
    if (left > right) {
        return -1;
    }
    int mid = (left + right) / 2;
    if (array[mid] == a) {
        return mid;
    }
    else if (array[mid] > a) {
        return binarySearch(array, a, left, mid-1);
    }
        return binarySearch(array, a, mid + 1, right);
}

冒泡排序

通过每趟排序，在数组元素之间两两比较，通过两个元素的交换，把大的元素放后面。

可以看出，当我第一趟排序时，有九个元素的时候，我需要分别把八组元素进行比较，比较八次

当我第二趟排序时，因为最大的元素已经放在了最后，所以只需要比较七次

又因为最后一趟的时候只剩下一个元素了，所以我们比较八趟就可以了。

public class Test3 {
    public static void main(String[] args) {
        int[] array=new int[]{5,1,2,3,4};
        isNumber(array);
        System.out.println(Arrays.toString(array));
    }
    public  static  void  isNumber(int[] array) {
         //比较趟数
        for (int i = 0; i < array.length-1; i++) {
            boolean finish = false;//创建布尔类型标记，此时假设不需要再排序
         //比较几组
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j]>array[j+1]) {
                    finish = true;//还是有乱序情况，需要排序
                    int tmp = array[j];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                }
            }
            if(finish==false) {
                break;
            }
        }
    }
}

数组逆序

从数组两端进行双下标交换

public static void main(String[] args) {
   int[] arr = {1, 2, 3, 4};
   reverse(arr);
   System.out.println(Arrays.toString(arr));
  }
public static void reverse(int[] arr) {
    int left = 0;
    int right = arr.length - 1;
    while (left < right) {
       int tmp = arr[left];
       arr[left] = arr[right];
       arr[right] = tmp;
       left++;
       right--;
  }
}

数组奇数偶数排序

将一个数组的偶数放在前边，奇数放在后边。

依旧采用双下标，从两端进行，左下标找到奇数停止，右下标找到偶数停止，然后交换。

然后开始下次寻找过程。

import java.util.Arrays;

/**
 * @author DELL
 * @date 2022-04-11 20:45
 */
public class Test11 {
    public static void main(String[] args) {
        int[] array= new int[]{2,5,8,7,9,4};
        System.out.println(Arrays.toString(array));
        reverse(array);
        System.out.println(Arrays.toString(array));
    }
    public static void reverse(int[] array) {
        int left=0;
        int right= array.length-1;
        while(left<right) {
            //左边遇到奇数停止
            while(left<right&&array[left]%2==0) {
                left++;
            }
            //右边遇到偶数停止
            while(left<right&&array[right]%2!=0) {
                right--;
            }
            int tmp = array[left];
            array[left]=array[right];
            array[right]=tmp;
            left++;
            right--;
        }
    }
}

运行结果