2022-04-07 西安 javaSE(04) 方法可变参数、重载、递归，数组、冒泡排序、二分查找、动态操作，二维数组、jvm内存区域划分

方法

1、方法传递参数

形参是基本类型：

1.参数传递的内容是该基本类型的数据值。
  2.对形式参数的改变不会影响实际参数的数据值

形参是引用类型：
   1.参数传递的是地址值
   2.对形式参数地址值的改变不会影响实际参数的地址值（改栈里的值）

3.地址值不变，形参内容改变（数组）会影响实际参数地址值的内容。（改堆里的值）
    public static void main(String[] args) {int[] arr = new int[]{6, 3, 8, 2, 9, 1};System.out.println(arr);//[I@28d93b30printArray(arr);System.out.println(arr);//[I@28d93b30}public static void printArray(int[] arr) {arr = new int[9];System.out.println(arr);//[I@1b6d3586}

。。。是时候看清楚自己的斤两了，，这个str难搞哟

str=“change”;改的是地址值，并不是内容？222-08-06回访

    public static void main(String[] args) {String str = new String("world");char[] ch = new char[]{'h', 'e', 'l', 'l', 'o'};change(str, ch);System.out.println(str);System.out.println(String.valueOf(ch));}public static void change(String str, char[] arr) {str = "change";arr[0] = 'a';arr[1] = 'b';arr[2] = 'c';arr[3] = 'd';arr[4] = 'e';}

2、jdk1.5之后可变参数

调用方法时，传递的实参可以任意个数的传递（此时方法形参就是根据实参做一个静态初始化的数组）
格式：数据类型... 可变参数名
注意点：可变参数必须放在形参列表最后面，且最多只能含有一个可变参数

3、方法的重载

在同一个类中（或者子父类继承关系中），出现了方法名相同,形参列表不同的现象

形参列表必须不同（至少满足以下一点）

形参列表中的数据类型不同

形参列表中形参个数不同

形参列表中数据类型的顺序不同

4、方法的递归

递归含义：指代方法自身调用自身的一种现象，如直接递归：在方法A中调用方法A。

递归注意事项：
1.需要给递归设置结束的条件。否则，栈内存溢出
2.即使添加了结束条件，也不能让递归的层数过多（>10000）,否则还是会造成栈内存溢出

使用方法递归获取1到指定整数的累加和

//使用方法递归获取1到指定整数的累加和
public static int getValue(int num){int sum=0;for(int i=0;i<=sum;i++){sum=sum+i;}return sum;
}//使用递归
public static int getSum(int num){//1是确定的，得倒着加if(num==1){return 1  }return num+getSum(num-1)
}

斐波那契数列

    public static void main(String[] args) {for (int i = 1; i <=15 ; i++) {Long num = getNum(i);System.out.println("第"+i+"个月，兔子数为："+num);}}//使用递归public static Long getNum(int month){//添加限制条件if(month==1 || month==2){return 1L;}return getNum(month-1)+getNum(month-2);}//使用动态规划，因为递归的层数越多，执行效率越低。public static Long getNum(int month){//添加限制条件if(month==1 || month==2){return 1L;}//当前月兔子对数long temp=0;//上个月兔子对数long a=1;//上上个月月兔子对数long  b=1;for(int i=3;i<=month;i++){temp=a+b;//当前月b=a;//将上个月兔子的对数赋值给上上个月a=temp;//将当前月的兔子数赋值给上个月}return temp;}

打印结果

数组

存储同一种数据类型多个元素的固定容器。数组的数据类型：数据类型[]

1.数组一旦初始化，数组在内存中的长度固定不变。
2.数组中必须是同一种数据类型
3.数组中的元素必须是多个（>=2），如果初始化可以存储0个和1个元素的数组也不会编译
报错，只不过没有意义。

数组的声明（定义）

数据类型[] 数组名；（推荐）
数据类型数组名[];（不推荐）

1、数组的初始化分类

数组动态初始化:初始化数组的时候，只初始化数组的长度，不会初始化数组中具体的元素，好处是jvm可以直接获取到数组的长度。

//数据类型[] 数组名=new 数据类型[长度]；长度为0没有意义
//new:向jvm申请开辟内存空间。
int[] arr01=new int[3];//动态初始化

数组静态初始化：初始化数组的时候，不会初始化数组的长度，只会初始化数组中具体的元素，
jvm可以间接获取数组的长度。

//静态初始化标准版：数据类型[] 数组名=new 数据类型[] {元素1，元素2，...，元素n}
int[] arr02=new int[]{11，22，33};//静态初始化简化版 ：数据类型[] 数组名={元素1，元素2，...，元素n}
int[] arr03={11，22，33};//jvm会根据数组名前面的数据类型[] 隐式填充new 数据类型[].

数组声明和初始化注意事项

int[] arr03={11，22，'a'};//数组元素支持类型转换
int[] arr03={11,(int)3.14};
int[] arr03=new int[3]{11,22,33}；//动静结合的方式，不允许,编译报错
int[] arr04=new int[-3];//编译不报错，运行时期报错。.NegativeArraySizeException//数组静态初始化的简化版不可以先声明后初始化。动态版和静态标准版可以先生们后初始化
int[] arr07;
arr07={11,22,33};//会编译报错

数组的访问

获取数组长度：arr.length;字符串用length（），集合用size()
索引值是jvm对数组中的元素进行动态的数字编号，长度为0的数组不存在索引值。

1、Java中的数组是对象吗？
在较高的层面上，数组不是某类事物中的一个具体的个体，而是多个个体的集合。那么它应该不是对象。而在计算机的角度，数组也是一个内存块，和其他对象一样，封装了一些数据，可以访问属性，也可以调用方法。所以在Java中数组是对象
public class ExceptionTest {@Testpublic void testA() {int[] arr = {1, 2, 3};//访问数组的属性System.out.println(arr.length);//3//调用数组的方法System.out.println(arr.toString());//[I@5387f9e0}
}

2、String[]、Object[] 和 Object

解释：
数组类直接继承了Object，关于Object[]类型的引用能够指向String[]类型的对象，这种情况只能是Java语法之中的一个特例，并不是严格意义上的继承。也就是说，String[]不继承自Object[]，但是我可以允许你向上转型到Object[]，这种特性是赋予你的一项特权。
public class ExceptionTest {@Testpublic void testA() {String[] s = new String[5];//成立,说明可以用Object[]的引用来接收String[]的对象Object[] os = s;//String[] 的直接父类是 Object而不是Object[]，可是Object[]的引用明明可以指向String[]类型的对象,why?System.out.println(s.getClass().getSuperclass().getName());//java.lang.Object}
}

数组的应用

1、基础应用：不改变数组元素位置，进行查询操作。求和，求最值

Interesting examples：去掉一个最高分，去掉一个最低分。求8位评委的平均值

    public static void main(String[] args) {int[] arr01=new int[]{11,22,33,44,77,55,99,88,22,33};//评委打分//去掉一个最高分，去掉一个最低分。然后求平均值int sum=arr01[0];int max=arr01[0];int min=arr01[0];for (int i = 0; i < arr01.length; i++) {sum+=arr01[i];if(arr01[i]>max){max=arr01[i];}if(arr01[i]<min){min=arr01[i];}}System.out.println("选手最后得分"+(sum-max-min)*1.0/8);//选手最后得分48.125}

2、高级应用：对数组中元素索引位置进行改变，如反转，排序

1、数组反转

数组首尾对应的元素进行索引位置互换

        int[] arr01 = new int[]{11, 22, 33, 44,55,66};//数组反转int j = arr01.length-1;for (int i = 0; i < arr01.length/2 ; i++) {int temp = arr01[i];arr01[i] = arr01[j];arr01[j] = temp;j--;}System.out.print("反转后 [");for (int i = 0; i < arr01.length; i++) {if(i==arr01.length-1){System.out.println(arr01[i]+"]");}else{System.out.print(arr01[i]+", ");}}

2、数组的动态操作

    public static void main(String[] args) {int[] arr={11,22,33,44,55};int num=66;//待添加的元素int[] ints1 = add(arr, 66);printArray(ints1);//数组的动态扩容  [11, 22, 33, 44, 55, 66]int[] ints2 = insert(arr, 111, 1);printArray(ints2);//数组的动态插入 [11, 111, 22, 33, 44, 55]int[] ints3 = remove(arr, 1);printArray(ints3);// 数组的动态删除 [11, 33, 44, 55]}/*   数组的动态扩容：创建新数组，把待添加的元素存储到新数组最后一位*/public static int[] add(int[] oldArr,int num){int[] newArr=new int[oldArr.length+1];for(int i=0;i<oldArr.length;i++){newArr[i]=oldArr[i];}newArr[newArr.length-1]=num;return newArr;}/*    数组的动态插入：创建新数组，根据指定的索引位置把待添加的元素存储到新数组中。*/public static int[] insert(int[] oldArr,int num,int index){int[] newArr=new int[oldArr.length+1];//习惯复制长度短的数组for(int i=0;i<oldArr.length;i++){if(i<(index)){newArr[i]=oldArr[i];//等位复制}else if(i>=index){newArr[i+1]=oldArr[i]; //错位复制}}newArr[index]=num;return newArr;}/*    数组的动态删除：创建新数组，根据指定的索引位置复制数组中的元素*/public static int[] remove(int[] oldArr,int index){int[] newArr=new int[oldArr.length-1];//习惯复制长度短的数组for(int i=0;i<newArr.length;i++){if(i<(index)){newArr[i]=oldArr[i];//等位复制}else if(i>=index){newArr[i]=oldArr[i+1]; //错位复制}}return newArr;}public static void printArray(int[] arr){//非空校验if(arr==null){return;}//特殊实参判断if(arr.length==0){System.out.println("数组：[ ]");return;}System.out.print("数组: [");for (int i = 0; i < arr.length; i++) {if(i==arr.length-1){System.out.println(arr[i]+"]");}else{System.out.print(arr[i]+", ");}}}

3、二维数组

多维数组：数组当中的元素依然是数组

一维数组数据类型[] 数组名
二维数组数据类型[][] 数组名

二维数组的初始化
   动态初始化：
   格式1：初始化二维数组长度的同时，也初始化里面每一个一维数组的长度
数据类型[][] 数组名=new 数据类型[x][y]
int[][] arr01=new int[3][2];
   x：是二维数组的长度
   y:每个一维数组的长度
格式2：只初始化二维数组的长度，但不会初始化里面每一维数组的长度
数据类型[][] 数组名=new 数据类型[x][]
int[][] arr02=new int[3][];//一维数组给的3个null值

静态初始化
数据类型[][] 数组名=new 数据类型[][]{}

标准版： int[][] arr02=new int[][]{new int[]{11,22,33}，new int[]{44,55}，{66,77,88,99}}
静态初始化简化版最终版： int[][] arr06={{11,22,33},{44,55},{66,77,88,99}}

二维数组的遍历

//        二维数组元素的访问int[][] arr = {{11, 22, 33}, {44, 55}, {66, 77, 88, 99}};
//        遍历for (int i = 0; i < arr.length; i++) {for (int j = 0; j < arr[i].length; j++) {if (j == (arr[i].length - 1)) {System.out.println(arr[i][j]);} else {System.out.print(arr[i][j] + ",");}}}

基本算法

1、数组的冒泡排序

原理：将相邻俩个整数比较，较大值移动到右侧。

第一轮:从第一个元素开始比较,得到最大的值

第二轮:从第一个元素开始比较,得到第二大的值

..........每一轮之后要比较的元素个数会越来越少

 public static void main(String[] args) {int[] arr = new int[]{6, 3, 8, 2, 9, 1, 0, -4, 9};System.out.println("排序前"+ Arrays.toString(arr));//外层循环:一共需要多少轮比较arr.length-1轮for (int i = 1; i <=arr.length ; i++) {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;}}}System.out.println("排序后"+ Arrays.toString(arr));}

手写冒泡总结：

1.双层for循环，外层控制多少轮。数组长度-1轮。为方便内层循环，i=1开始

2.内层循环控制每一轮遍历过程中，比较相邻2个数，逆序则交换，记得j=0开始，j<arr.length-i

=========

数组冒泡排序的优化

将俩个相邻的整数进行比较，记录较大值的索引。当这轮结束后，交换。

public static void main(String[] args) {int[] arr = new int[]{6, 3, 8, 2, 9, 1, 0, -4, 9};System.out.println("排序前"+ Arrays.toString(arr));//外层循环，求最大值次数for (int count = 1; count < arr.length; count++) {//定义临时最大值索引int index = arr.length - count;//内层循环：求一次最大值需要比较的次数for (int i = 0; i < arr.length - count; i++) {if (arr[i] > arr[index]) {index = i;}}//如果索引发生了交换if (index != arr.length - count) {int temp = arr[arr.length - count];arr[arr.length - count] = arr[index];arr[index] = temp;}}System.out.println("排序后"+ Arrays.toString(arr));
}

2、二分查找（折半查找）

二分查找前提：待操作的数组必须是元素大小有序

查询指定元素在数组中出现的第一次索引

1. 设置查找（索引）区间：start= 0；end= arr.length-1；
2. 若查找区间[start, end]不存在，则查找失败；否则转步骤3
3. 取中间位middle = (start + end) / 2；比较 num 与 arr[middle]，有以下三种情况：
3.1 若 num < arr[middle]，则end= middle- 1；查找在左半区间进行，转步骤2；
3.2 若 num > arr[middle]，则start= middle+ 1；查找在右半区间进行，转步骤2；
3.3 若 num = arr[middle]，则查找成功，返回 mid 值；

public static void main(String[] args) {int[] arr = new int[]{1, 3, 7, 13, 15, 19, 32, 37, 56, 87, 91};//二分查找只能找有序的数组//声明要查找的数int num = 7;//对应在数组中索引位置是2//声明并初始化索引变量int index = -1;//指定索引范围变量int start = 0;int end = arr.length - 1;//声明中间索引变量int middle = (start + end) / 2;//数组长度为偶数、奇数都适用//不清楚循环次数，选择whilewhile (start <= end) {//num是要查找的数if (num > arr[middle]) {start = middle + 1;} else if (num < arr[middle]) {end = middle - 1;} else {index = middle;break;}middle = (start + end) / 2;}//打印要查找的数的索引System.out.println(index);
}

二分查找数组是倒序：

    public static void main(String[] args) {int[] arr = new int[]{91,54,33,31,25,21,17,13,5,2};//二分查找只能找有序的数组//声明要查找的数int num = 33;//索引是2//声明并初始化索引变量int index = -1;//指定索引范围变量int start = 0;int end = arr.length - 1;//声明中间索引变量int middle = (start + end) / 2;//数组长度为偶数、奇数都适用//不清楚循环次数，选择while//数组是倒序while (start <= end) {//num是要查找的数if (num > arr[middle]) {end = middle - 1;} else if (num < arr[middle]) {start = middle + 1;} else {index = middle;break;}middle = (start + end) / 2;}//打印要查找的数的索引System.out.println(index);}

手写二分查找总结

1.定义好 start，end确定要查找的数索引的范围，middle=start+end/2

2.因为不知道要找多少次，使用while循环。在循环里，使用if（）else if （）else，分别对应要找的num值大于中间值，小于中间值，等于中间值。这中间会涉及到start或者end的重新赋值

3.判断之后要重新设置中间值，且while循环条件死记 start<=end

坑人的题

  //method((byte)123);会调用第一个形参为short的方法  public static void method(short a) {System.out.println("short");//byte首先提升为shortreturn;}public static void method(int a) {System.out.println("int");return;}public static void method(Long a) {System.out.println("long");return;}-----------------------------------------------------------int[] arr=new int[10];System.out.println(arr[10]);//编译时不报错，运行时发生错误----------------------------------------------------------int[] arr1=new int[]{1,32};
int[] arr2=new int[]{'1',32};//数组元素支持类型转换
System.out.println(arr2[0]);//49