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 空指针异常

原因：引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。
1. 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();

        }
    }
}