Java基础方法和数组

转载

mob604756fd5175 2021-07-25 16:38:00

1:方法(掌握)
(2)格式
(3)两个明确
(6)方法的注意事项
需要明白方法的定义及调用、方法重载、可变参数、递归
2:数组(掌握)
(4)数组的初始化
(5)Java的内存分配
(7)数组的常见操作
3:二维数组(理解)
4:数组高级以及Arrays(掌握)
稀疏数组（理解）

1:方法(掌握)

1.方法：就是完成特定功能的代码块。

注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。

2.格式：

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
方法体语句;
return 返回值;
}

修饰符：目前就用 public static。后面再详细讲解其他修饰符
返回值类型：就是功能结果的数据类型
方法名：就是起了一个名字，方便我们调用该方法。
参数类型：就是参数的数据类型
参数名：就是变量
参数分类：
实参：实际参与运算的数据
形参：方法上定义的，用于接收实际参数的变量
方法体语句：就是完成功能的代码块
return：结束方法
返回值：就是功能的结果，由return带给调用者。

//比大小，选择两个数中较大的数值，此外，return还有中止的意思
public static int max(int num1,int num2){
int result = 0;  //给变量初始化

if(num1 == num2){
System.out.println("num1 == num2");
return 0;  //终止方法
    }
if(num1>num2){
result = num1;
    }else{
result = num2;
    }
return result;
}

两个明确
返回值类型：结果的数据类型
参数列表：参数的个数及对应的数据类型
方法调用
A:有明确返回值的方法 a:单独调用，没有意义 b:输出调用，不是很好，因为我可能需要不结果进行进一步的操作。但是讲课一般我就用了。 c:赋值调用，推荐方案 B:void类型修饰的方法 a:单独调用
案例
A:求和方案 B:获取两个数中的较大值 C:比较两个数据是否相同 D:获取三个数中的最大值 E:输出m行n列的星形 F:输出nn乘法表
方法的注意事项

方法不调用不执行
方法之间是平级关系，不能嵌套定义
方法定义的时候，参数是用，隔开的
方法在调用的时候，不用在传递数据类型
如果方法有明确的返回值类型，就必须有return语句返回。
Java是值传递，不是引用传递

方法重载在同一个类中，方法名相同，参数列表不同。与返回值无关。

方法名称必须相同
参数列表必须不同（个数不同、数据类型不同、参数排列顺序不同等）
方法的返回类型可以相同也可以不相同
仅仅返回类型不同不足以成为方法的重载

可变参数

jdk1.5开始，Java支持传递同类型的可变参数
格式：在方法声明中，在指定参数类型后加一个省略号(...)
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明
public static void printMax(double... numbers){ if(numbers.length == 0){ System.out.println("No argument passed"); return; } double result = numbers[0]; //排序 for(int i = 1; i < number.length; i++){ if(numbers[i] > result){ result = numbers[i]; } } System.out.println("The max value is"+ result); }

递归

简单来说方法是A方法调用B方法，递归就是，A方法调用A方法，自己调用自己
递归结构包括两个部分
递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
递归体：什么时候需要调用自身方法。
//计算n的阶乘 public static int f(int n){ if(n==1){ return 1; }else{ return n*f(n-1); } }

2:数组(掌握)

数组：存储同一种数据类型的多个元素的容器。即是相同类型数据的有序集合
特点：每一个元素都有编号，从0开始，最大编号是长度-1。编号的专业叫法：索引

其长度是确定的。数组一旦被创建,它的大小就是不可以改变的
其元素必须是相同类型不允许出现混合类型。
数组中的元素可以是任何数据类型,包括基本类型和引用类型。
数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

定义格式
A: 数据类型[] 数组名;
B: 数据类型数组名[];
（推荐是用A方式，B方法就忘了吧。但是要能看懂，这是C# C++的写法，为了让早期的程序员快速掌握)
数组的初始化
A:动态初始化只给长度，系统给出默认值举例：int[] arr = new int[3]; arr[1]=1; arr[2]=2; B:静态初始化给出值，系统决定长度举例：int[] arr = new int[]{1,2,3}; 简化版：int[] arr = {1,2,3};
Java的内存分配

A:栈存储局部变量 B:堆存储所有new出来的 C:方法区(面向对象部分详细讲解) D:本地方法区(系统相关) E:寄存器(CPU使用) 注意： a:局部变量在方法定义中或者方法声明上定义的变量。 b:栈内存和堆内存的区别栈：数据使用完毕，就消失。堆：每一个new出来的东西都有地址每一个变量都有默认值 byte,short,int,long 0 float,double 0.0 char '\u0000' boolean false 引用类型 null 数据使用完毕后，在垃圾回收器空闲的时候回收。
数组内存图
A:一个数组
B:二个数组
C:三个数组(两个栈变量指向同一个堆内存)
数组越界
ArryIndexOutOfBoundsException:数组下标越界异常！
数组的常见操作
A:遍历方式1： public static void printArray(int[] arr) { for(int x=0; x<arr.length; x++) { System.out.println(arr[x]); } } 方式2： public static void printArray(int[] arr) { System.out.print("["); for(int x=0; x<arr.length; x++) { if(x == arr.length-1) { System.out.println(arr[x]+"]"); }else { System.out.println(arr[x]+", "); } } } B:最值最大值： public static int getMax(int[] arr) { int max = arr[0]; for(int x=1; x<arr.length; x++) { if(arr[x] > max) { max = arr[x]; } } return max; } 最小值： public static int getMin(int[] arr) { int min = arr[0]; for(int x=1; x<arr.length; x++) { if(arr[x] < min) { min = arr[x]; } } return min; } C:逆序方式1： public static void reverse(int[] arr) { for(int x=0; x<arr.length/2; x++) { int temp = arr[x]; arr[x] = arr[arr.length-1-x]; arr[arr.length-1-x] = temp; } } 方式2： public static void reverse(int[] arr) { for(int start=0,end=arr.length-1; start<=end; start++,end--) { int temp = arr[start]; arr[start] = arr[end]; arr[end] = temp; } } public static int[] reverse(int[] arr){ int[] result = new int[arr.length]; //反转 for(int i=0,j=arr.length-1; i<arr.length; i++,j--){ result[j] = arr[i]; } return result; } D:查表给出一个已知的数组索引来得到相应的数组值 public static String getString(String[] strArray,int index) { return strArray[index]; } E:基本查找方式1： public static int getIndex(int[] arr,int value) { for(int x=0; x<arr.length; x++) { if(arr[x] == value) { return x; } } return -1; } 方式2： public static int getIndex(int[] arr,int value) { int index = -1; for(int x=0; x<arr.length; x++) { if(arr[x] == value) { index = x; break; } } return index; }

3:二维数组(理解)

元素是一维数组的数组。
格式：
A:数据类型[][] 数组名 = new 数据类型[m][n]; B:数据类型[][] 数组名 = new 数据类型[m][]; 数组名[0] = new 数据类型[n];等动态的分配空间 C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}}; D:数据类型[][] 数组名 = {{...},{...},{...}}; int[][] arr = {{1,2},{2，3},{3,4},{4,5}}; for(int i = 0; i < arr.length; i++){ for(int j = 0; j < arr[i].length; j++){ System.out.println(arr[i][j]); } }

4:数组高级以及Arrays(掌握)

排序
A:冒泡排序 (相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。同理，其他的元素就可以排好。) /* 1、比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置 2、每一次比较，都会产生出一个最大或者最小的数字 3、下一轮则可以少一次排序 4、依次循环，直到结束 */ public static void bubbleSort(int[] arr) { //临时变量 int temp = 0; //外层循环，判断我们这个要走多少次 for(int x=0; x<arr.length-1; x++) { //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置， y < arr.length-1-x for(int y=0; y<arr.length-1-x; y++) { if(arr[y] > arr[y+1]) { temp = arr[y]; arr[y] = arr[y+1]; arr[y+1] = temp; } } } } B:选择排序把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。同理，其他的元素就可以排好。 public static void selectSort(int[] arr) { for(int x=0; x<arr.length-1; x++) { for(int y=x+1; y<arr.length; y++) { if(arr[y] < arr[x]) { int temp = arr[x]; arr[x] = arr[y]; arr[y] = temp; } } } }
查找A:基本查找针对数组无序的情况 public static int getIndex(int[] arr,int value) { int index = -1; for(int x=0; x<arr.length; x++) { if(arr[x] == value) { index = x; break; } } return index; } B:二分查找(折半查找) 针对数组有序的情况(千万不要先排序，在查找) public static int binarySearch(int[] arr,int value) { int min = 0; int max = arr.length-1; int mid = (min+max)/2; while(arr[mid] != value) { if(arr[mid] > value) { max = mid - 1; }else if(arr[mid] < value) { min = mid + 1; } if(min > max) { return -1; } mid = (min+max)/2; } return mid; }

Arrays工具类
A:是针对数组进行操作的工具类。包括排序和查找等功能。 B:要掌握的方法(自己补齐方法) 把数组转成字符串：public static String toString(int[] a) 排序：public static void sort(int[] a) 二分查找：public static int binarySearch(int[] a,int key)
稀疏数组（理解）
当一个数组中大部分元素为0,或者为同一值的数组时,可以使用稀疏数组来保存该数组稀疏数组的处理方式是:
◆在第一行中，记录数组一共有几行几列,有多少个不同值
◆在后面几行，把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模
如下图:左边是原始数组,右边是稀疏数组

//1、创建一个二维数组 11*11   0：代表没有棋子  1：黑棋 2：白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 1;
//输出原始数组
System.out.println("输出原始数组");
for(int[] ints : array1){
for(int anInt : ints){
System.out.print(anInt+"\t");
    }
System.out.println();
}

System.out.println("========");
//转换为稀疏数组保存
//获取有效值的个数
int sum = 0;
for(int i = 0; i < 11; i++){
for(int j = 0; j < 11; j++){
if(array1[i][j] != 0){
sum++;
        }
    }
}
System.out.println("有效值的个数："+ sum);

//2.创建一个稀疏数组的数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组，将非零的值，存放在稀疏数组中
int count = 0;
for(int i = 0; i < array1.length; i++){
for(int j = 0; j < array[i].length; j++){
if(array[i][j]!=0){
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
        }
    }
}
//输出稀疏数组
System.out.println("稀疏数组");
for(int i = 0; i < array2.length; i++){
System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
}

System.out.println("========");
System.out.println("还原矩阵");
//1、读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];   //这里的array2前两个存储的是行列
//2、给其中的元素还原它的值
for(int i = 1; i < array2.length; i++){
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//3、打印
System.out.println("输出还原的数组");
for(int[] ints : array3){
for(int anInt : ints){
System.out.print(anInt+"\t");
    }
System.out.println();
}