Java基础第四部分

方法

​ 在java中，方法就是用来完成解决某件事情或实现某个功能的办法，方法实现的过程中，会包含很多条语句用于完成某些有意义的功能，其设计原则为一般一个 方法对应一个功能。其格式为：

​ 修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){

​ 执行语句

​ ………

​ return 返回值;

​ }

​ 修饰符：目前就用 public static。还有其他的修饰符。 ​ 返回值类型：就是功能结果的数据类型。当这个方法没有返回值的时候，返回值的类型为void；当这个方法有返回值的时候，返回值的类型根据返回的数据来确 定(如果有返回值，必须使用return)。 ​ 方法名：符合命名规则即可 ​ 参数：实际参数：就是实际参与运算的。形式参数；就是方法定义上的，用于接收实际参数的。 ​ 参数类型：就是参数的数据类型 ​ 参数名：就是变量名 ​ 方法体语句：就是完成功能的代码。 ​ return：结束方法的。 ​ 返回值：就是功能的结果，由return带给调用者

public class Demo01 { public static void main(String[] args) { int i = add(3, 4); System.out.println(i); } public static int add(int a, int b){ return a + b; } }

方法的参数

​ 方法的参数分为两种：形参和实参。形参代表方法定义上的，用于接收实际参数的参数。实参代表实际参与运算的参数。Java中方法的参数传递都是通过值传递 实现的，所谓值传递，就是将实际参数值的副本传入方法内，而参数本身不会受到任何影响。

public class Demo01 { public static void main(String[] args) { int c = 5; int d = 6; swap(c,d); System.out.println(c+"-------"+d); } public static void swap(int a, int b){ int temp = a; a = b; b = temp; System.out.println(a+"======="+b); } }

方法重载

​ 在Java方法的执行过程中，重载的概念是相当重要的。Java允许同一个类中定义多个同名的方法，只要形参列表不同即可。如果同一个类中包含了两个或两个以 上的方法名相同，但是形参列表不同(与返回值类型无关)，我们则成为方法重载。所谓的重载就是要求两同一不同：同一个类中方法名相同，参数列表不同。对 于方法其他部分(返回值类型，修饰符等)与重载没有任何关系。参数列表不同包括：A:参数个数不同。B:参数类型不同。C:参数的顺序不同(算重载,但是在开发中 不用)

public class Demo02 { public static void main(String[] args) { int c = add(1,2); double d = add(2.3,5); double e = add(3,1.5); int f =add(4,5,6); System.out.println(c); System.out.println(d); System.out.println(e); System.out.println(f); } public static int add(int a, int b){ return a + b; } public static double add(double a, int b){ return a + b; } public static double add(int a, double b){ return a + b; } public static int add(int a, int b,int c){ return a + b + c; } }

形参个数可变的方法

​ 形参个数可变表示允许为方法指定数量不确定的形参。如果在方法定义时，在最后一个形参的类型后加三个点(…)，则表明该形参可以接受多个参数值，多个参 数值被当成数组传入。

public class Demo03 { public static void main(String[] args) { paramChange(2,"test1","test2","test3"); } public static void paramChange(int a, String ...strings){ System.out.println(a); for (String string:strings){ System.out.println(string); } } }

递归

​ 递归算法是一种直接或间接地调用自身的算法。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解

​ 其一般形式为：

​ func( mode){ if(endCondition){ //递归出口 ​ end; ​ }else{ ​ func(mode_small) //调用本身，递归 } ​ }

public class Demo05 { public static void main(String[] args) { test(5); } public static void test(int a){ if(a==0){ System.out.println(a); }else { test(--a); } } }

数组

一维数组

​ 所谓的数组指的就是一组相关类型的变量集合，并且这些变量可以按照统一的方式进行操作,数组本身属于引用数据类型. 数组的最大好处就是能都给存储进来的 元素自动进行编号. 注意编号是从0开始。方便操作这些数据

数组的定义

格式1：

​ 元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

​ 示例：int[] arr = new int[5];

格式2：

​ 元素类型[] 数组名 = new 元素类型[]{元素，元素，……};

​ int[] arr = new int[]{3,5,1,7};

​ int[] arr = {3,5,1,7};

数组的初始化

初始化方式1：不使用运算符new

​ int[] arr = { 1, 2, 3, 4, 5 };

​ int[] arr2 = new int[] { 1, 2, 3, 4, 5 };

初始化方式2：

​ int[] arr3=new int[3];

​ arr3[0]=1;

​ arr3[1]=5;

​ arr3[2]=6;

数组的遍历

​ 数组中有一个属性可以获取到数组中元素的个数,也就是数组的长度. 数组名.length

public class Demo01 { public static void main(String[] args) { //int arrays1[] ,不建议这样写 //两种静态初始化 int[] arr1 = { 1, 2, 3}; //不能分开写 int[] arr2= new int[] { 1, 2, 3 }; //动态初始化 int[] arr3=new int[3]; arr3[0]=1; arr3[1]=2; arr3[2]=3; for (int i = 0; i < arr3.length; i++) { System.out.println(arr3[i]); } } }

常见异常

NullPointerException 空指针异常

原因： 引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。

ArrayIndexOutOfBoundsException 索引值越界

原因：访问了不存在的索引值。

总结

二维数组

​ 实质就是存储是一维数组。

​ 数组定义：

​ 数组类型 数组名 = new [数组类型一维数组的个数] [每一个一维数组中元素的个数];

public class Demo02 { public static void main(String[] args) { int m = 0; //静态初始化 int[][] arrays0 = new int[][]{{12, 13, 14, 15}, {16, 17, 18, 19}, {20, 21, 22, 23}, {24, 25, 26, 27}}; int[][] arrays = new int[3][4]; //动态初始化 for (int i = 0; i < arrays.length; i++) { for (int j = 0; j < arrays[i].length; j++) { arrays[i][j] = (m++); } } //输出arrays for (int i = 0; i < arrays.length; i++) { System.out.println(" \t"); for (int j = 0; j < arrays[i].length; j++) { System.out.print(arrays[i][j] + " "); } System.out.println(" \t"); } System.out.println("===================="); //输出arrays0 for (int i = 0; i < arrays0.length; i++) { System.out.println(" \t"); for (int j = 0; j < arrays0[i].length; j++) { System.out.print(arrays0[i][j] + " "); } System.out.println(" \t"); } } }

Arrays工具类

数组转换字符串

public class Demo03 { public static void main(String[] args) { int[] array = new int[]{1,2,6,8,9}; System.out.println("转换前："+array); //转换字符串 String str = Arrays.toString(array); System.out.println("转换后的字符串："+str); } }

对数组进行升序排列

public class Demo04 { public static void main(String[] args) { int[] array = new int[]{15,6,21,8,3}; System.out.println("原数组："+Arrays.toString(array)); //转换字符串 Arrays.sort(array); System.out.println("排序后的数组："+Arrays.toString(array)); } }

所有元素赋特定值

public class Demo05 { public static void main(String[] args) { int[] array = new int[]{15,6,21,8,3}; System.out.println("原数组："+Arrays.toString(array)); //所有元素赋特定值 Arrays.fill(array,10); System.out.println("排序后的数组："+Arrays.toString(array)); } }

判断数组是否相等

public class Demo06 { public static void main(String[] args) { int[] array0 = new int[]{15,6,21,8,3}; int[] array1 = new int[]{15,6,21,8,3}; int[] array2 = new int[]{11,25,2,81,9}; boolean boo=Arrays.equals(array0,array1); boolean boo2=Arrays.equals(array1, array2); System.out.println("array0:"+Arrays.toString(array0)); System.out.println("array1:"+Arrays.toString(array1)); System.out.println("array2:"+Arrays.toString(array2)); System.out.println("array0与array1是否相等？"+boo); System.out.println("array1与array2是否相等？"+boo2); } }

对数组复制

public class Demo07 { public static void main(String[] args) { int[] array = new int[]{15,6,21,8,3}; System.out.println("array："+Arrays.toString(array)); //把数组复制成特定长度的数组 int array1[]=Arrays.copyOf(array,array.length); System.out.println("array1："+Arrays.toString(array1)); } }

查询数组下标

public class Demo08 { public static void main(String[] args) { int[] array = new int[]{15,6,21,8,3}; //查询数组下标 int i=Arrays.binarySearch(array, 21); System.out.println("数组array第5个数字下标是："+i); } }

数组转换成集合

public class Demo09 { public static void main(String[] args) { int[] array = new int[]{15,6,21,8,3}; //数组转换成字符串 String str = Arrays.toString(array); //字符串转换成集合 List<String> list = Arrays.asList(str); for (int i = 0; i < list.size(); i++) { System.out.println("转换后的List集合："+list.get(i)); } } }

稀疏数组

当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组，稀疏数组的处理方法是：

​ .记录数组一共有几行几列，有多少个不同的值

​ .把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

​ 即第一行第一列记录记录原始数组行数，第一行第二列记录原始数组列数，第一行第三列总共有多少个值，第二行记录第一个有效数据，第三行记录第二个有效 数据

public class Demo10 { public static void main(String[] args) { //创建一个二维数组，11行11列 //0-无子，1-黑子，2-白子 int[][] array = new int[11][11]; array[1][2] = 1; array[2][3] = 2; //统计非0子的个数 int sum = 0; System.out.println("=========原数组为："); //输出原始二维数组 for (int i = 0; i < array.length; i++) { for (int j = 0; j <array[i].length ; j++) { if (array[i][j]!=0){ sum++; } System.out.print(array[i][j]+" "); } System.out.println(); } //创建稀疏数组 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 < array.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] = array[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]); } //还原稀疏数组 int[][] array3 = new int[array2[0][0]][array2[0][1]]; for (int i = 1; i <array2.length ; i++) { array3[array2[i][0]][array2[i][1]] = array2[i][2]; } System.out.println("=========还原后数组为："); //还原稀疏数组 for (int i = 0; i < array3.length; i++) { for (int j = 0; j <array3[i].length ; j++) { System.out.print(array3[i][j]+" "); } System.out.println(); } } }

​