05.数组工具类_二维数组_方法的使用

第一章.数组工具类

1.数组工具类

1.1.System类

1.概述:java自带的类
2.特点:方法都是带static的
3.使用:
  类名直接点

方法	说明
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)	src:源数组,复制哪个数组中的元素 srcPos:从源数组的哪个索引开始复制 dest:目标数组,将元素复制到哪个数组中去 destPos:从目标数组的哪个索引开始粘贴 length:复制多少个元素

public class Demo01System {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] arr2 = new int[5];

        System.arraycopy(arr,0,arr2,0,3);

        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
    }
}

1.2.Arrays类

1.概述:java自带的类,是数组工具类
2.作用:操作数组
3.特点:方法都是带static的
4.使用:
  类名直接调用

方法	说明
String toString(数组)	按照[元素1,元素2…]格式打印
void sort(数组)	数组升序排序
int binarySearch(数组,要查找的元素)	二分查找,返回元素对应的索引
int[] copyOf(数组,新数组长度)	数组扩容,返回新数组

public class Demo02Arrays {
    public static void main(String[] args) {
        int[] arr = {5,4,3,2,1};
       //String toString(数组)          按照[元素1,元素2...]格式打印
        System.out.println(Arrays.toString(arr));
       //void sort(数组)                数组升序排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
       //int binarySearch(数组,要查找的元素) 返回元素对应的索引

        int[] arr2 = {1,2,3,4,5,6,7,8,9};
        int index = Arrays.binarySearch(arr2, 10);
        System.out.println(index);
       //int[] copyOf(数组,新数组长度),返回新数组
        int[] newArr = Arrays.copyOf(arr2, 20);
        System.out.println(Arrays.toString(newArr));
        arr2 = newArr;
        System.out.println(Arrays.toString(arr2));
    }
}

2.Hutool工具

1.概述:属于第三方工具
2.使用:
  如果使用第三方提供的技术或者工具,都需要在当前项目环境下,引入第三方环境(第三方提供的jar包)
3.什么是jar包:
  jar就是一个压缩包,里面装的都是一些工具类的class文件

官网：https://www.hutool.cn/

2.1.引入jar

怎么引入jar包: -> 相当于将jar解压
  a.在当前模块下,右键 -> new -> Directory -> 取名为lib或者libs
  b.对着lib或者libs右键 -> add as library -> level选择module -> 此时name栏会变成空的,不要管 -> 直接ok

2.2.ArrayUtil工具类

方法	说明
int max(数组)	返回数组最大值
int indexOf(数组,要查找的数据)	顺序查找,指定的数据在数组中的位置
reverse()	数组翻转

public class Demo03HuTool {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        //int max(数组)返回数组最大值
        System.out.println(ArrayUtil.max(arr));

        //int indexOf(数组,要查找的数据)顺序查找,指定的数据在数组中的位置
        System.out.println(ArrayUtil.indexOf(arr, 3));

        //reverse()数组翻转
        ArrayUtil.reverse(arr);
        
        //调用的是hutool的toString方法,不是Arrays中的
        System.out.println(ArrayUtil.toString(arr));
    }
}

第二章.二维数组

2.1二维数组的定义格式

1.动态初始化
  数据类型[][] 数组名 = new 数据类型[m][n]
  数据类型 数组名[][] = new 数据类型[m][n]
  数据类型[] 数组名[] = new 数据类型[m][n] 
    
  m:代表的是二维数组长度
  n:代表的是每一个一维数组的长度
      
  如果不指定n(代表没有指定一维数组长度),那么相当于一维数组没有被创建出来
      
2.静态初始化
  数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...}...}
  数据类型 数组名[][] = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...}...}
  数据类型[] 数组名[] = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...}...} 

public class Demo01TwoArray {
    public static void main(String[] args) {
        //动态初始化
        int[][] arr = new int[3][3];
        int[][] arr2 = new int[3][];
        //静态初始化
        String[][] arr3 = {{"孙悟空","猪八戒","唐僧"},{"熊大","熊二"},{"百变小樱魔术卡","铁甲小宝","蜻蜓队长"}};
    }
}

2.2获取二维数组长度

1.格式:
  数组名.length

public class Demo02TwoArray {
    public static void main(String[] args) {
        String[][] arr1 = {{"孙悟空","猪八戒","唐僧"},{"熊大","熊二"},{"百变小樱魔术卡","铁甲小宝","蜻蜓队长"}};
        System.out.println(arr1.length);
        System.out.println("========================");
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i].length);
        }
    }
}

2.3获取二维数组中的元素

1.格式:
  数组名[i][j]
      
  i:代表的是一维数组在二维数组中的索引位置
  j:代表的是元素在一维数组中的索引位置

public class Demo03TwoArray {
    public static void main(String[] args) {
        String[][] arr1 = {{"孙悟空","猪八戒","唐僧"},{"熊大","熊二"},{"百变小樱魔术卡","铁甲小宝","蜻蜓队长"}};
        System.out.println(arr1[0][0]);
        System.out.println(arr1[1][1]);
        System.out.println(arr1[2][2]);
    }
}

2.4二维数组中存储元素

1.格式:
  数组名[i][j] = 值
      
  i:代表的是一维数组在二维数组中的索引位置
  j:代表的是元素在一维数组中的索引位置

public class Demo04TwoArray {
    public static void main(String[] args) {
        String[][] arr1 = new String[3][3];
        arr1[0][0] = "孙悟空";
        arr1[0][1] = "猪八戒";
        arr1[0][2] = "唐僧";

        arr1[1][0] = "熊大";
        arr1[1][1] = "熊二";
        arr1[1][2] = "百变小樱";

        arr1[2][0] = "铁甲小宝";
        arr1[2][1] = "蜻蜓队长";
        arr1[2][2] = "小懒猪";

        System.out.println(arr1[0][0]);
        System.out.println(arr1[0][1]);
        System.out.println(arr1[0][2]);
        System.out.println(arr1[1][0]);
        System.out.println(arr1[1][1]);
        System.out.println(arr1[1][2]);
        System.out.println(arr1[2][0]);
        System.out.println(arr1[2][1]);
        System.out.println(arr1[2][2]);

    }
}

2.5.二维数组的遍历

1.嵌套循环:
  外层循环遍历二维数组,将每一个一维数组获取出来
  内层循环遍历一维数组,将每一个元素获取出来

public class Demo05TwoArray {
    public static void main(String[] args) {
        String[][] arr1 = new String[3][3];
        arr1[0][0] = "孙悟空";
        arr1[0][1] = "猪八戒";
        arr1[0][2] = "唐僧";

        arr1[1][0] = "熊大";
        arr1[1][1] = "熊二";
        arr1[1][2] = "百变小樱";

        arr1[2][0] = "铁甲小宝";
        arr1[2][1] = "蜻蜓队长";
        arr1[2][2] = "小懒猪";

        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                System.out.println(arr1[i][j]);
            }
        }

    }
}

第三章.方法的使用

1.概述:拥有功能性代码的代码块,将来开发,一个按钮就应该对应一个功能,一个功能就应该定义一个方法
2.方法通用定义格式:
  修饰符 返回值类型 方法名(参数){
      方法体
      return 结果
  }

  无参无返回值方法
  有参无返回值方法
  无参有返回值方法
  有参有返回值方法

1.无参无返回值方法定义和调用

1.格式:
  public static void 方法名(){
      方法体
  }

2.注意:
  void:代表的是无返回值
      
3.调用:在其他方法中
  方法名();

定义一个方法,实现两个整数相加

public class Demo01Method {
    public static void main(String[] args) {
        method01();
        System.out.println("哈哈");
    }

    /**
     * 无参无返回值方法
     */
    public static void method01(){
        int a = 10;
        int b = 20;
        int sum = a+b;
        System.out.println(sum);
    }
}

1.方法之间不能嵌套

2.方法不调用不执行,main方法是jvm自动调用的

3.方法的执行顺序只和调用顺序有关

2.方法定义各部分解释

1.方法通用定义格式:
  修饰符 返回值类型 方法名(参数){
      方法体
      return 结果
  }

2.各部解释:
  a.修饰符:目前固定为public static
  b.返回值类型: 方法运行完毕,最终返回的结果的数据类型 
               void 和 return 结果不能共存的
     
               void:代表无返回值
               return 结果:代表有返回值
  c.方法名:见名知意
  d.参数:传递到方法内部执行的数据 -> 数据类型 变量名1,数据类型 变量名1...
  e.方法体:实现该方法的具体代码
  f.return 结果:方法最终返回的数据

3.有参数无返回值的方法定义和执行流程

1.格式:
  public static void 方法名(参数){
      方法体
  }
2.调用:
  方法名(具体的值)

定义一个方法,实现两个整数相加

public class Demo02Method {
    public static void main(String[] args) {
        method01(10,20);
        System.out.println("哈哈");
    }

    /**
     * 有参无返回值方法
     */
    public static void method01(int a,int b){
        int sum = a+b;
        System.out.println(sum);
    }
}

4.无参数有返回值定义以及执行流程

1.格式:
  public static 返回值类型 方法名(){
      方法体
      return 结果
  }
2.调用:方法的返回值返回给了调用处(哪里调用给哪里)
  a.赋值调用: 数据类型 变量名 = 方法名() -> 推荐使用
  b.打印调用: sout(方法名())  -> 不推荐使用   

定义一个方法,实现两个整数相加,将结果返回

public class Demo03Method {
    public static void main(String[] args) {
        //赋值调用
        int result = method01();
        System.out.println(result);

        //打印调用
        System.out.println(method01());
    }

    /**
     * 有参无返回值方法
     */
    public static int method01(){
        int a = 10;
        int b = 20;
        int sum = a+b;
        return sum;
    }
}

5.有参数有返回值定义以及执行流程

1.格式:
  public static 返回值类型 方法名(参数){
      方法体
      return 结果
  }
2.调用:
  a.赋值调用: 数据类型 变量名 = 方法名(具体的值) -> 推荐使用
  b.打印调用: sout(方法名(具体的值))  -> 不推荐使用  

定义一个方法,实现两个整数相加,将结果返回

public class Demo04Method {
    public static void main(String[] args) {
        int result = method01(10, 20);
        System.out.println(result);
    }
    public static int method01(int a,int b){
        int sum = a+b;
        return sum;
    }
}

6.形参和实参的区别

1.形参:在定义方法的时候,只是形式上定义的参数,此时还没有具体的值
2.实参:在调用方法的时候,给形参赋予的具体的值

作为初学者:

1.先定义,再调用

2.没有返回值的-> 直接调用-> 方法名()

3.有返回值的 -> 赋值调用 -> 数据类型 变量名 = 方法名()

7.参数和返回值的使用时机

1.总结:总的来说,开发中定义的方法基本上都是带参带返回值的方法
====================================================
1.参数的使用时机:当想将方法A中的数据传递到方法B中做操作,方法B在定义的时候就需要带参数,等着接收方法A中的数据
2.返回值的使用时机:方法A调用方法B之后,需要方法B的结果,然后拿到方法B的结果在A中做其他操作,此时方法B就需要将自己的结果返回出去 

public class Demo05Method {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int result = method(a, b);
        if (result > 10){
            System.out.println("结果大于10");
        }else{
            System.out.println("结果不大于10");
        }
    }
    public static int method(int a,int b){
        return a+b;
    }
}

8.方法注意事项终极版

1.方法不调用不执行
2.方法之间不能嵌套
3.方法的执行顺序只和调用顺序有关系
4.void不能和[return 值]共存,但是void能和[return]共存
  a.void:代表没有返回值
  b.return 值:代表有返回值,先将结果返回,然后结束方法
  c.return:仅仅代表结束方法,不代表有返回值
5.一个方法中不能return多个值 
6.调用方法时,需要看看有没有这个方法,否则会报错      

第五章.方法的重载(Overload)

1.需求:定义三个方法,分别计算两个整数相加,三个整数相加,四个整数相加

public class Demo01OverLoad {
    public static void main(String[] args) {
        sum(1,2);
        sum(1,2,3);
        sum(1,2,3,4);
    }

    public static void sum(int a,int b){
        System.out.println(a+b);
    }
    public static void sum(int a,int b,int c){
        System.out.println(a+b+c);
    }
    public static void sum(int a,int b,int c,int d){
        System.out.println(a+b+c+d);
    }
}

按住ctrl不放鼠标点击方法名,对象,变量名变成"小手"的时候,单击 -> 会跳到我们调用的位置

1.重载方法:方法名相同,参数列表不同的方法
2.什么叫做参数列表不同:
  参数个数不同
  参数类型不同
  参数类型的顺序不同
      
3.和什么无关
  a.和参数名无关
  b.和返回值无关

public class Demo01OverLoad {
    public static void main(String[] args) {
        sum(1,2);
        sum(1,2,3);
        sum(1,2,3,4);
    }

    public static void sum(int a,int b){
        System.out.println(a+b);
    }

/*    public static int sum(int a,int b){
       return a+b;
    }*/

/*    public static void sum(int x,int y){
        System.out.println(x+y);
    }*/
    public static void sum(int a,int b,int c){
        System.out.println(a+b+c);
    }
    public static void sum(int a,int b,int c,int d){
        System.out.println(a+b+c+d);
    }
}

public static void open(){}
public static void open(int a){}
static void open(int a,int b){}
public static void open(double a,int b){}
public static void open(int a,double b){}
public void open(int i,double d){}
public static void OPEN(){}
public static void open(int i,int j){}

使用场景:功能一样,但是实现细节不一样