Java第四天
函数与数组
1.函数(方法)
定义：方法是一段能完成独立功能的代码块，我们只需要写一次方法，此方法就可以多次被调用，依次来提高代码的复用性。
静态方法区：在内存中专门存储静态方法的区域。
函数(方法)的语法：
//权限修饰符 或者为void 或为函数名 这两个统称为参数列表，也可有也可无
public static 返回值类型 方法名 (数据类型 参数名){
方法体;
//当返回值类型为void时，没有return 结果名;此段代码
return 结果名;
}
/*
*主方法(函数)
*/
public static void main(String[] args) {
方法体;
}
/*
*一般方法 无返回值(函数)
*/
public static void 方法名() {
方法体;
}
/*
*一般方法 有返回值(函数)
*/
public static 返回值类型 方法名() {
数据类型 结果名 = 初始值;
方法体;
return 结果名;
}
主方法调用一般方法的语法：
//当存在返回值类型时，变量用来存储return返回的结果名的值
//参数名也可有也可无
返回值类型 变量名 = 方法名(参数名1，参数名2，...);
//当返回值为void时
//参数名也可有也可无
方法名(参数名1，参数名2，...);
返回值类型：返回值类型是函数执行后要给调用者的数据类型，如果指定了数据类型就必须要有return语句，如果返回值类型为void则不用有return语句。
参数：调用者传递过来的数据的接受方式，参数可以有多个，也可没有。
实参：主函数调用时所传递的变量的值。
形参：方法中的参数。
②调用方法时是通过值传递的方式将实参的值传递给方法的形参
③Java语言中只有值传递。
④自定义方法的数据类型要与传递的值的数据类型一致
⑤当方法有返回值时，必须至少要有一个return语句被执行。
⑥return后的代码不能被访问！
2.方法的重载
定义：(overload)在一个类中有两个以上同名的方法，但是参数不同(参数的个数或类型不同),跟返回值无关。
目的：提高代码的可读性，节省命名的词。
public class OverloadExample {
public static void main(String[] args){
//实例化对象
OverloadExample overloadExample = new OverloadExample();
//使用对象调用方法，不打印返回值
overloadExample.example();
//使用对象调用方法，无返回值
overloadExample.example(1);
//使用对象调用方法，不打印返回值
overloadExample.example(1,"example3");
System.out.println();
//使用对象调用方法，打印返回值
System.out.println(overloadExample.example(1,"example3"));
System.out.println();
//使用对象调用方法，不打印返回值
overloadExample.example("example4",1);
System.out.println();
//使用对象调用方法，打印返回值
System.out.println(overloadExample.example("example4",1));
}
public int example(){
System.out.println("Example1");
return 1;
}
public void example(int a){
System.out.println("Example2");
}
//以下两个参数类型顺序不同
public String example(int a,String s){
System.out.println("Example3");
return "returnexample3";
}
public String example(String s,int a){
System.out.println("Example4");
return "returnexample4";
}
}
结果：
Example1
Example2
Example3
Example3
returnexample3
Example4
Example4
returnexample4
3.数组
定义：一组数据，一个数据的集合，其数值在堆中存储。
语法：
// 这里的整数是数组的长度
数据类型 [] 数组名 = new 数据类型[整数];
int [] arr = new int[3];
数据类型 [] 数组名 = new {数值1,数值2,数值3,...};
int [] arr = new {1,2,3,...};
数据类型 [] 数组名 = new 数据类型[]{数值1,数值2,数值3,...};
int [] arr = new int[]{1,2,3,...};
//获取数组长度的语法
数组名.length;
int a = 0;
a = arr.length;
/*当数组在方法的参数列表中时的语法
*作用：可将在此方法外定义的数组接收并传入到此方法中并使用
*注意：方法参数列表中的数据类型需要与数组的类型相同
*参数名可不与数组名相同*/
方法名(数据类型 [] 参数名){ }
public void example(int[] array){
方法体;
}
索引：(Index)索引指的是当前数组元素在数组中的位置，从0数起。
注意：①当一个数组长度为4时，最后一位数据的索引为3。
②注意数组越界报错(ArrayIndexOutofBoundsException)，在数组中索引<数组长度，否则就会报错。
在内存中的表现
在java中，内存被分为栈、堆，他们都是一块内存空间。
| 名称 | 特性 | 适合场景 | 举例 | 特点 |
|---|---|---|---|---|
| 栈 | 容量小，存取速度快 | 适合存储生命周期短的数据 | 变量(局部变量) | 先进后出，后进先出 |
| 堆 | 容量大，存取速度慢 | 适合存储生命周期长的数据 | 对象(实例) | - |
数组属于引用类型，在堆中存储。在堆中任何一个存储空间都有相对应的地址，一个数组有且仅有一个地址，地址一般为十六进制并带有符号。
定义数组时的内存过程
每当用户在定义一个数组时
①java会先在堆中开辟一块新的内存空间用来存储数组的数据，并给这个存储着数组数据的内存空间一个内存地址
②其次会在栈中也开辟一块新的内存空间用来存储上面的内存地址，并将这个存储着数组地址的内存空间命名为用户定义的数组名
使用数组时的内存过程
在使用数组时，
①java首先去栈中找到相对应数组名的内存空间
②再从此内存空间中获取到相对应的值(内存地址)
③然后获取堆中数组的数据，再将其调用。
遍历数组
定义：将指定结构的数据全部访问一遍。
public static void main(String[] args) {
//定义一个数组
int [] a = {15,2,3,45,5,6,7,78,7,0};
//调用遍历数组的方法，并将要遍历的数据传过去
printArray(a);
//定义一个遍历数组的方法
public static void printArray(int[] aa) {
for(int i = 0; i<aa.length;i++) {
//将遍历好的数组打印出来
System.out.print(aa[i]+"\t");
}
}
}
求数组的极值
步骤：
①在for循环结构外定义结果变量
②定义一个for循环结构(for循环内的计数器应从1开始，若从0开始等于第一个数值多一次与自身比较，无意义)
③在for循环结构内使用if语句将结果变量与数组的值比较
④在主方法内定义一个变量用来接收求出的极值
⑤调用相关方法
⑥将求出的极值打印出来
注意：更改if语句内的大小比较符即可变换求极大值或极小值
public static void main(String[] args) {
int [] a = {15,2,3,45,5,6,7,78,7,0};
//调用求极值的方法，并将要求极值的数组的数据传过去
int max = maxValue(a);
int min = minValue(a);
System.out.println("最大值"+max);
System.out.println("最小值"+min);
//最大值
public static int maxValue(int [] aa) {
//定义结果变量
int result = aa[0];
for(int i = 1; i<aa.length; i++ ) {
if(result < aa[i]) {
result = aa[i];
}
}
//返回求出的极值
return result;
}
//最小值
public static int minValue(int [] aa) {
//定义结果变量
int result = aa[0];
for(int i = 1; i<aa.length; i++ ) {
if(result > aa[i]) {
result = aa[i];
}
}
//返回求出的极值
return result;
}
对数组内的值排序
冒泡排序：将相邻的两个数逐个比较，如果前一个数比后一个小/大，那么互换位置，当第一轮比较完，最小/大值一定在末尾。
比较的轮数：数组名.length - 1;
每轮比较的次数：数组名.length - 轮数的计数器 - 1；
改变每轮比较的次数内的if语句内的比较符，即可更改排序顺序
public static void main(String[] args) {
int [] a = {15,2,3,45,5,6,7,78,7,0};
//打印原数组
printArray(a);
//打印换将
System.out.println();
//将数从小到大排序
min(a);
//将排序后的数组进行打印
printArray(a);
System.out.println();
//将数从大到小排序
max(a);
//将排序后的数组进行打印
printArray(a);
//冒泡排序 小到大
public static void min(int[] bb) {
for(int i = 0;i < bb.length-1;i++) {
for(int j = 0; j < bb.length -i -1; j++) {
if(bb[j] > bb[j+1]) {
int cc = bb[j+1];
bb[j+1] = bb[j];
bb[j] = cc;
}
}
}
}
//冒泡排序 大到小
public static void max(int[] bb) {
for(int i = 0;i < bb.length-1;i++) {
for(int j = 0; j < bb.length -i -1; j++) {
if(bb[j] < bb[j+1]) {
int cc = bb[j+1];
bb[j+1] = bb[j];
bb[j] = cc;
}
}
}
}
//遍历数组并将其打印
public static void printArray(int[] aa) {
for(int i = 0; i<aa.length;i++) {
System.out.print(aa[i]+"\t");
}
}
}
查找
一般查找
查找数组中指定一个数的索引(效率低)
public static void main(String[] args) {
int [] a = {15,2,3,45,5,6,7,78,7,0};
//定义一个变量用于接收目标数值的索引，并传入数组与目标数值
int result = index(a,2);
//打印目标数值的索引
System.out.println(result);
}
//定义一个查找的方法
public static int index(int[] aa,int num) {
int result = -1;
for(int i = 0;i <aa.length;i++) {
//使用if语句将目标值与数组内的值进行等值判断
if(aa[i] == num) {
result = i;
break;
}
}
return result;
}
二分法查找
要求：有序的数组
步骤：
①分别定义最小索引、最大索引、中间索引
②使用while语句将目标值与中间索引的值进行等值比较
③若目标值大于中间索引的值，将中间索引加一并赋值给最小索引，否则将中间索引减一赋给最大索引
④更新中间索引
⑤返回目标值的索引(也就是中间索引)
初始值：最小索引为0；最大索引：数组名.length - 1;中间索引：(最小索引+最大索引)/2。
public static void main(String[] args) {
int [] a = {15,2,3,45,5,6,7,78,7,0};
//先将数组进行排序
min(a);
//调用查找方法，并传入相关参数和接收目标索引
int result = index1(a,6);
//打印目标值的索引
System.out.println(result);
}
//冒泡排序 小到大
public static void min(int[] bb) {
for(int i = 0;i < bb.length-1;i++) {
for(int j = 0; j < bb.length -i -1; j++) {
if(bb[j] > bb[j+1]) {
int cc = bb[j+1];
bb[j+1] = bb[j];
bb[j] = cc;
}
}
}
}
//定义二分法查找的方法
public static int index1(int[] array,int aa) {
//定义最小索引
int minIndex = 0;
//定义最大索引
int maxIndex = array.length - 1;
//定义中间索引
int midIndex = (minIndex + maxIndex)/2;
while(array[midIndex] == aa) {
if(aa > array[midIndex]) {
minIndex = midIndex + 1;
}else {
maxIndex = midIndex - 1;
}
//更新中间索引
midIndex = (minIndex + maxIndex)/2;
}
return midIndex;
}
数组倒置
交换次数：数组名.length / 2; 末尾数值的索引：数组名.length - i -1;
步骤：
①第一层for循环内，计数器<数组名.length / 2;
②第二层for循环内，定义临时变量
public static void main(String[] args) {
int [] a = {15,2,3,45,5,6,7,78,7,0};
//打印原数组
printArray(a);
System.out.println();
//倒置数组
change(a);
System.out.println();
//打印倒置后的数组
printArray(a);
}
//定义一个倒置数组的方法
public static void change(int array[]) {
for(int i = 0;i < array.length / 2;i++) {
int temp = array[i];
array[i] = array[array.length - 1 - i];
array[array.length - 1 - i] = temp;
}
}
//定义一个打印数组的方法
public static void printArray(int[] array1) {
for(int i = 0; i<array1.length;i++) {
System.out.print(array1[i]+"\t");
}
}
二维数组
定义：二位数组就是集合中套集合(数组=集合)
注意：必须明确外围数组名！
整数1表示这个二维数组有多少个数组
整数2表示每一个一维数组的元素个数
定义语法：
// 两个整数都为数组的长度，整数1必须准确指定数值
数据类型 [][] 数组名 = new 数据类型[整数1][整数2];
数据类型 [][] 数组名 = {{值1，值2，值3}，{值4，值5，值6}...};
int [][] array1 = new int [3][4];
int [][] array2 ={{1,2,3},{4,5,6},{7,8,9}...}
赋值语法：
int [][] array = new int[3][4];
array[0][0] = 1;
array[0][1] = 2;
array[0][2] = 3;
array[0][3] = 4;
array[1][0] = 11;
array[1][1] = 22;
array[1][2] = 33;
array[1][3] = 44;
array[2][0] = 111;
array[2][1] = 222;
array[2][2] = 333;
array[2][3] = 444;
打印结果：
1 2 3 4
11 22 33 44
111 222 333 444
253
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
