Java基础第四部分

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]);
         }
         
     }
 }

 

常见异常

1. NullPointerException 空指针异常

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

   2. 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();
 ​
         }
     }
 }