java基础学习

一，变量

变量：值一旦初始化，通过代码可以改变值

变量分类：

              局部变量：声明在方法中的变量。 注意事项:使用之前要初始化(赋值)

             成员变量：声明在类中方法外。

             静态变量：使用static修饰的变量，一般在类中方法外

                      声明格式：数据类型 变量名=值; "="是值赋给变量

             数据类型: 整数:int 小数:double 变量操作：1赋值 2改变变量值 声明常量

                     格式: final 数据类型 常量名 = 值;

二，基本数据类型：

1.8种基本数据类型

类型                                               大小                          范围
byte(字节整型)                        1byte (8bit)                     -2^7-2^7-1  -128-127(记住)
short(短整型)                           2byte (16bit)                  -2^15-2^15-1
int(整型)默认                            4byte (32bit)                   -2^31-2^31-1 -2147483648-2147483647
long(长整型)                             8byte (64bit)                  -2^63-2^63-1
float(单精度浮点型)                  4byte (32bit)                  -3.4E38-3.4E38
double(双精度浮点型)默认       8byte (64bit)                  -1.7E308-1.7E308
char (字符型)                            2byte (16bit)                 0-65535既可以表示整数，也可以表示字符
boolean(布尔型)                       1byte                           true,false
注:
1.String不是基本数据类型，是一个类，是引用数据类型。2.java中除了上述基本数据类型以外的类型都叫引用数据类型。

2.char类型： 能表示一个字符，也能表示整数(0-65535) ASC：48-57:表示字符0-9 65-90:表示字符A-Z 97-122:表示字符a-z

2.自动类型转换

自动类型转换：把小范围的数据类型的值赋给比他大的范围的类型，会发生自动类型转换
基本数据类型范围从小到大：byte->short->int->long->float->double

package Day1;
public class Demo5 {
    public static void main(String[] args) {
        int i = 10;

        //自动类型转换
        double d = i;
        float f = 5l;

        double d2 = 2.0;
        //大范围不能直接赋值给小范围
        int j = (int) d2;//强转
        byte c = (byte) d2;

        //多种类型的值在进行计算时，结果自动转换成范围最大的类型
        System.out.println(i + f + d2);//int + float + double
        float result = i+ f + 2l;//Alt + enter ->introduce local variable 自动生成表达式类型



    }
}

3 .强制类型转换

强制类型转换：把大范围的数据类型的值赋给比他小的范围的类型，使用强制手段
 基本数据类型范围从小到大：byte->short->int->long->float->double
 格式：小范围数据类型 变量名 = (小范围数据类型) 大范围类型的值或变量

package Day1;
public class Demo6 {
    public static void main(String[] args) {
        float f = 23;
        byte f2 = (byte)f;
        System.out.println(f2);

        //精度丢失
        double d = 3.2234;
        int i = (int)d;
        System.out.println(i);

        //内存溢出
        long l = 1000000000000l;
        int m = (int)l;
        System.out.println(m);
    }
}

三，运算符

1 .加减乘除

package Day1;
/*
除法：/
取余：%

 */
public class Demo7 {
    public static void main(String[] args) {
        int i = 5;
        int x = 2;
        double d = 2.0;
        System.out.println(i/x);//2 整型在做除法运算时，结果会去除小数部分，保留整数
        System.out.println(i/d);

        //取余结果，和被取余数符号一致
        System.out.println(i%x);//1
        int m = 10;
        int n = -4;
        System.out.println(m%n);
        //被取余数的绝对值小于取余数，取余结果就等于被取余数
        int a = 1;
        int g = 4;
        System.out.println(a%g);//1

        //判断奇偶数 偶数num%2 == 0  奇数 num%2 != 0
    }
}

2. ++:自增1    --:自减1

package Day1;
public class Demo8 {
    public static void main(String[] args) {
        int x = 5;
//        x++;
        x--;
        System.out.println(x);

        //前置自增自减：先自增自减在赋值。后置自增自减：先赋值后自增自减
        int s = 12;
        int r = s++;
        System.out.println(s);
        System.out.println(r);

        int c = 3;
        int s2 = ++c;
        System.out.println(c);
        System.out.println(s2);

    }
}

3.逻辑运算符

package Day1;
/*
  移位：>>
  逻辑运算符：
  &&(短路逻辑与) ||(短路逻辑或) !(非)
  &逻辑与   |逻辑或
  在做短路逻辑与运算时，当第一个表达式为false时，后面的表达式不会执行
  在做短路逻辑或运算时，当第一个表达式为true时，后面的表达式不会执行


   */
public class Demo9 {
    public static void main(String[] args) {
        System.out.println(21>>2);//往右移n位，就除以2^n
        System.out.println(21<<2);//往左移n位，就乘以2^n

        int i = 10;
        boolean result = i > 5 && i < 20;//true && true
        boolean b = i > 6 && i < 8;//true && false 有假即假
        System.out.println(b);
        System.out.println(result);

        boolean b1 = i > 5 || i < 6;//有真即真
        System.out.println(b1);

        int score = 50;
        String s = score >= 60 ? "及格" : "不及格";
        System.out.println(s);

    }
}

4.  三元运算符

  三元运算符：
    格式：判断表达式?表达式1:表达式2; 

package day_01;

import java.util.Scanner;

public class ZuoYe {
    public static void main(String[] args) {
        //创建Scanner类对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入身高1:");
        //调用nextInt方法：接收从控制台输入的值
        int num1 = sc.nextInt();
        System.out.println("请输入身高2:");
        int num2 = sc.nextInt();
        System.out.println("请输入身高3:");
        int num3 = sc.nextInt();
        int max;
        //三元表达式嵌套
        max = (num1 > num2) ? (num1 > num3 ? num1 : num3) : (num2 > num3 ? num2 : num3);
        System.out.println("最大身高为:" + max);

    }
}

四，方法

1.静态方法函数

静态方法函数：把一个功能的代码单独提取出来放在一个模块里，要使用时去调用
格式：
权限修饰符 static 返回值类型 方法的名字(参数列表){

 return;
  }

返回值类型
  1. void:表示该方法没有返回值。return可以写可以不写
  2.可以使用基本数据类型，String类型. 如果声明了上述类型就必须使用return返回同类型的值

方法的调用：
  1.方法名(值);
  2.类名.方法名(值);
  3.通过当前类的对象.方法名(值);

package day_02;
public class MethodDemo01 {
    public static void main(String[] args) {
        /*add();
        MethodDemo01.add();
        new MethodDemo01().add();*/

        //在调用有返回值类型的方法时，可以声明一个和返回值类型相同的变量来接收方法返回值
        int i = sub();
        System.out.println(i);

        //也可以直接打印
        System.out.println(sub());

        double result = div(100.0, 5.0);
        System.out.println(result);
    }

    //声明一个没有返回值类型，无参的方法
    public static void add() {
        int a = 100;
        int b = 100;
        int i = a + b;
        System.out.println(i);
    }

    //声明一个返回值类型为int的无参方法，相减的功能sub
    public static int sub() {
        int a = 100;
        int b = 10;
        return a - b;
    }

    //声明一个返回值类型为double的有参方法，执行相除的功能
    public static double div(double num1, double num2) {
        return num1 / num2;
    }

}

2.重载

方法的重载：方法同名，参数不同。指参数类型和参数数量不同

package day_02;
public class MethodDemo02 {
    public static void test(int i, double d) {

        System.out.println(i + d);
    }

    public static void test(int i) {

        System.out.println(i);
    }

    public static void test(double i) {

        System.out.println(i);
    }

    public static void main(String[] args) {
        //调用重载方法：根据传递的参数值来分别调用不同的重载方法
        test(1);
        test(1.01);
        test(1,3);
    }
}

3 .练习

package day_02;

import java.util.Scanner;
/*
   练习：
      求一个圆柱的体积：V=S*h
       1.声明一个求底面积方法 getS(double r)
       2.声明一个求体积的方法 getV(double r,double h); 调用getS(r)获取底面积，再乘以h得到体积
  Math.PI : 表示π
 */
public class MethodTest01 {
    //求面积
    public static double getS(double r){
        double S = 3.14 * r *r;
        return S;
    }

    //求体积
    public static double getV(double r, double h){
        return getS(r) * h;

    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入圆柱的半径");
        double r = sc.nextDouble();
        System.out.println("请输入圆柱的高");
        double h = sc.nextDouble();
        double x = getV(r, h);
        System.out.println("圆柱体积是：" + x);
    }
}

五，条件判断与循环

1. 条件判断

1.1
if语句
  格式：
     1.  if(条件判断语句){
            代码;
         }
        条件判断语句:boolean类型。如果为true执行if语句块中的代码，否则不执行
     2. if(条件判断语句){
            代码1;
         }else{
          代码2;
          }
         如果条件判断为true执行代码1，否则执行代码2
     3.if(条件判断语句1){
            代码1;
         }else if(条件判断语句2){
          代码2;
          }
          .
          .
          .
          else{
           代码n;
          }

package day_02;
public class IfDemo01 {
    public static void main(String[] args) {
        int i = 10;
        if(i > 20){
            System.out.println("执行if语句代码");
        }
        System.out.println("gg");

        //两种相对立情况
        int score = 59;
        if(score >= 60){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }

        //多种情况
        //判断一个数>0是正数，<0是负数，=0什么也不是
        int num = 1;
        if(num > 0){
            System.out.println("正数");
        }else if(num < 0){
            System.out.println("负数");
        }else {
            System.out.println("为0");
        }

    }
}

1.2 .练习

package day_02;

import java.util.Scanner;

/*
  练习：
   判断一个数是否为偶数
 */
public class IfTest01 {
    public static void main(String[] args) {
        for(int i = 1; i < 10; i++){
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个数：");
            int x = sc.nextInt();
            if(x%2 == 0){
                System.out.println("这个数是偶数");
            }else {
                System.out.println("这个数是奇数");
            }
        }


    }
}

2 .循环 

循环：在满足一定条件下，重复执行一块代码
  循环四要素：
    1.初始化一个变量
    2.条件判断语句  作用：判断是否满足循环条件
    3.循环体
    4.步进表达式 作用：用来改变初始化变量值

2.1 while循环

  while循环
    格式：
        初始化一个变量
        while(条件判断语句){
           循环体;
           步进表达式;
        }

package day_02;
public class WhileDemo {
    public static void main(String[] args) {
        int i = 0;
        while (i < 10) {
            System.out.println("HelloWord");

            if (i == 5) {
                break;
            }
            i++;
        }
    }
}

2.2 do-while循环

 do-while循环：
  格式：
  初始化一个变量
    do{
    循环体
    步进表达式
     }while(条件判断语句);
  do-while和while区别：
    do-while先执行一次再判断，至少执行一次循环体
    while先判断，再执行循环体。

package day_02;

import java.util.Scanner;


public class DoWhileDemo {
    public static void main(String[] args) {
       int x = 0;
        do {
            System.out.println("HelloWord");
            x++;
        } while (x < 10);
    }
}

练习

    模拟输入密码。判断密码是否正确，如果输入不正确重复输入密码，直到输入正确位置
         .equals()字符串比较

package day_02;

import java.util.Scanner;


public class DoWhileDemo {
    public static void main(String[] args) {
  
        String password = "123456";
        System.out.println("请输入密码");
        //输入的密码
        String input = "";
        Scanner sc = new Scanner(System.in);
        do {
        input = sc.nextLine();
        System.out.println("密码错误，请重新输入");
        } while (!password.equals(input));
        System.out.println("密码输入正确");
    }
}

2.3 for循环

  for循环
    格式：
      for(1初始化一个变量;2条件判断语句;4步进表达式){
         3循环体;
      }
 

package day_02;

public class ForDemo {
    public static void main(String[] args) {
        //for的常用格式
        for(int x = 0; x < 10; x++){
            System.out.println("HelloWord");
        }
        //特殊格式
        int x = 0;
        for(; x < 10; ){
            System.out.println("HelloWord");
            x++;
        }

        //for死循环
        for(;;){

        }
    }
}

3 练习

3.1
  写一个（10以内）的猜数游戏，随机生成一个数，如果猜的数比该数小，打印猜小了，反之猜大了。如果一致打印猜对了！
随机生成一个数代码

package exercise.day_02;

import java.util.Random;
import java.util.Scanner;

public class ZuoYe01 {
    public static void main(String[] args) {
        //Random类，该类声明了一个nextInt(int bound)方法，用来生成一个指定范围随机整数
        //创建Random类对象
        Random r = new Random();
        int num = r.nextInt(11);
     /*   while (true){
            Scanner sc = new Scanner(System.in);
            System.out.println("输入你猜的数字");
            int x = sc.nextInt();
            if(x < num){
                System.out.println("你猜小了");
            }else if(x > num){
                System.out.println("你猜大了");
            }else {
                System.out.println("你猜对了");
                break;
            }
        }*/
        for(int i = 1; i <= 3; i++){
            Scanner sc = new Scanner(System.in);
            System.out.println("输入你猜的数字");
            int x = sc.nextInt();
            if(x < num){

                System.out.println("你猜小了");

            }else if(x > num){
                System.out.println("你猜大了");

            }else {
                System.out.println("你猜对了");
                break;
            } if(i==3){
                System.out.println("次数用完");

            }
        }

    }
}

3.2 
   输入一个年份
  判断平年还是闰年
    什么是闰年?
    条件1：能被4整除并且不能被100整除
    条件2：能被400整除
 

package exercise.day_02;

import java.util.Scanner;

public class ZuoYe02 {
    public static void main(String[] args) {
        while (true) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入年份  退出：0" );
            int year = sc.nextInt();

            if (year == 0){
                break;
            }
            if (year % 4 == 0 & year % 100 != 0 | year % 400 == 0) {
                System.out.println("是闰年");
            } else {
                System.out.println("是平年");
            }
        }
    }
}

3.3
   求1-100的和

package exercise.day_02;

public class ZuoYe03 {
    public static void main(String[] args) {
        int sum = 0;
        for(int x = 0; x <= 100; x++){
            sum = sum + x;
        }
        System.out.println(sum);
    }
}

3.4
  求1-100之间的偶数个数

package exercise.day_02;

public class ZuoYe04 {
    public static void main(String[] args) {
        int count = 0;
        for(int x = 0; x <= 100; x++){
            if(x%2 == 0){
                count++;
            }

        }
        System.out.println("偶数个数：" + count);
    }
}

3.5
   打印6x5的矩形
    *****
    *****
    *****
    *****
    *****
    *****

package exercise.day_02;

public class ZupYe05 {
    public static void main(String[] args) {
        //for循环嵌套
        for (int i = 0; i < 6; i++) { // 控制行数
            for (int j = 0; j < 5; j++) { //控制列数
                System.out.print("*"); //打印
            }
            //换行
            System.out.println();
        }
    }
}

4 .数组

4.1 定义
  数组：是一个存储数据的一种数据结构，是相同类型元素的集合，存储的是多个相同类型的数据
            通过下标去访问数组中的元素。下标从0开始，最大下标为(数组长度-1)

  数组的定义：
         格式1：数据类型[] 数组名 = new 数据类型[数组长度]; 或者 数据类型 数组名[] = new 数据类型[数组长度];
        格式2：数据类型[] 数组名 = new 数据类型[] {元素1,元素2,...};
       格式3：数据类型[] 数组名 = {元素1,元素2,...};

 数组的元素访问：
       格式：数组名[下标];
  数组元素赋值
     格式：数组名[下标] = 值;
  数组中不同类型的默认值
     int:0
     double:0.0
     String:null
     char:空字符
     boolean:false
 

package day_03;

public class ArrayDemo {
    public static void main(String[] args) {
      //声明一个存储整形的长度为4的数组
        int[] arr = new int[4];
        /*
        int: 表示该数组中只能存储int类型的值
        []:表示一个数组
        new:开辟一个空间，来村粗数组中的元素
        4：表示数组的长度
         */

        //赋值
        arr[0] = 1;
        arr[1] = 2;

        //访问数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
//        System.out.println(arr[4]);//ArrayIndexOutOfBoundsException:数组下标越界

        System.out.println("--------");

        //打印数组名 引用
//        System.out.println(arr);//[I@1e643faf


        //第二种声明格式
        double[] arr2 = new double[]{1.0,2.9,3.7};
        arr2[1] = 0.2;
        System.out.println(arr2[1]);
        //第三种声明格式
        int[] arr3 = {1,2,2};

        int[] arr4 = null;
//        System.out.println(arr4[0]);//NullPointerException:空指针异常
        arr4 = new  int[5];
    }
}

4.2 数组的遍历
  数组的遍历：一个个去获取到数组中的每个元素
  数组长度的获取：数组名.length

  方式：
     1.for循环遍历：不仅可以获取元素，也可以使用下标操作元素
     2.增强for循环遍历:单纯的在获取数组中元素

  Arrays：数组工具类
    方法：
     1.static toString(数组名); 返回指定数组的内容的字符串表示形式

     2.Arrays.sort()方法，把数组中的元素按照升序排序

package day_03;

import java.util.Arrays;

public class ArrayDemo02 {
    public static void main(String[] args) {
        //声明一个数组
        int[] arr = {2,3,56,7};

        //for循环遍历  快捷方式：arr.fori + enter
        for(int x = 0; x < arr.length; x++){
            System.out.println(arr[x]);
        }
        System.out.println("------------");
        //增强for   快捷方式：arr.for + enter
        for (int i : arr){
            System.out.println(i);
        }

       //查看数组元素
        System.out.println(Arrays.toString(arr));

        System.out.println("--------");

    }
}

 4.3  数组的复制：
      1.System.arrayCopy(原数组,原数组的起始下标,目标数组,目标数组的起始下标,复制长度)方法
      2.Arrays.copyOf()方法

package day_03;

import java.util.Arrays;

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] arr2 = new int[5];
        //System.arrayCopy()方法
        System.arraycopy(arr,0,arr2,0,5);
        System.out.println(Arrays.toString(arr2));

        //Arrays.copyOf()方法
        int[] arr3 = {1,2,3,4,5};
        /*
          参数：
          origin：要复制的数组
          newLength:新数组的长度
         */
        int[] arr4 = Arrays.copyOf(arr3, 5);
        System.out.println(Arrays.toString(arr4));

    }
}

4.4 练习
  练习1:声明一个整型数组，求数组中的所有数的平均值
  练习2：声明一个长度为5的整型数组，给数组每个元素随机赋值，倒序输出
  练习3：将数组数据调换

package day_03;

import java.util.Arrays;
import java.util.Random;

public class ArrayDemo03 {
    public static void main(String[] args) {
        getAvg(new int[]{1, 3, 4, 5, 6});
        System.out.println("--------");
        getNum();
        System.out.println("--------");
        getChange();
    }

    //练习1
    public static void getAvg(int[] arr) {
//        int[] arr1 = {22,45,65,76,88,67,1};
        double sum = 0;
        for (int i : arr) {
            sum += i;

        }
        double avg = sum / arr.length;
        System.out.println("平均值：" + avg);
    }

    //练习2
    public static void getNum() {
        Random r = new Random();
        int[] arr = new int[5];
        //赋值
        for (int i = 0; i < arr.length; i++) {
            int x = r.nextInt(101);
            arr[i] = x;
        }
        System.out.println(Arrays.toString(arr));

        //倒序输出 快捷：数组名.forr + enter
        for (int a = arr.length - 1; a >= 0; a--) {
            System.out.println(arr[a]);
        }
    }

    //练习3
    public static void getChange(){
        int[] arr = {1, 2, 3, 4, 5};
        for (int i = 0; i < arr.length; i++) {
            int temp = arr[0];
            arr[0] = arr[2];
            arr[2] = temp;
        }
        System.out.println(Arrays.toString(arr));
    }
}

练习4.模仿Arryas.toString（），写一个同样的方法。

练习5.将{36, 27, 42, 35, 19}从小到大排序。使用冒泡排序

 
练习6.定义一个数组，求出数组中的最大，最小值。

练习7.从控制台输入数字表示某个班级的学生人数，
创建一个表示该班级的学生姓名的数组，
并使用控制台输入学生姓名赋值给数组的每一个元素，
最后输出所有姓名。

package exercise.day_03;

import java.util.Arrays;
import java.util.Scanner;

public class Zy {
    public static void main(String[] args) {

//        int[] arr = {};
//        getArr(arr);
        test();
//       getSort();
//        getNum();
//        getName();

    }
//4
    public static void getArr(int[] arr){
        if(arr.length == 0){
        System.out.println("数组为空");
    }
       else {
            for (int i = 0; i < arr.length; i++) {
                if (i == arr.length-1){
                    System.out.print(arr[i] + "]");
                }else if(i == 0){
                    System.out.print( "[" + arr[i] + ",");
                }else {
                    System.out.print(arr[i] + ",");
                }
            }
        }


    }

    /*冒泡排序:数组中相邻的两个元素比较，如果前者大于后者，交换位置。
    1.数组中的元素两两比较，需要比较数组的长度-1次。
    2.每次比较完，会确定一个最大值。下一次比较次数-1。
    3.排序次数为数组长度-1
    冒泡排序分解*/

//5
    public static void getSort(){
        int[] arr = {36, 27, 42, 35, 19};
        for (int i = 0; i < arr.length-1; i++) {//表示排序次数
            for (int x = 0; x < arr.length-1-i; x++) {//表示比较次数
                if(arr[x] > arr[x+1]){
                    //交换位置
                    int temp = arr[x];
                    arr[x] = arr[x+1];
                    arr[x+1] = temp;
                }
            }
        }
        System.out.println("排序后：" + Arrays.toString(arr));
    }

    //Arrays.sort()方法，把数组中的元素按照升序排序
    public static void test(){
        int[] arr = {12,52,69,78};
        //排序
        Arrays.sort(arr);
        getArr(arr);
    }

//6
    public static void getNum(){
        int[] arr = {36, 27, 42, 35, 19};
        //初始化最大值，最小值
        int max = arr[0];
        int min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max){
                max = arr[i];
            }
            if (arr[i] < min){
                min = arr[i];
            }
        }
        System.out.println("最大值是" + max);
        System.out.println("最小值是" + min);
    }

//7
    public static void getName(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生人数");
        /*
          next和nextLine的区别
          1.next不接受空格，遇到空格读取结束
          2.调用next方法时，通过控制台输入字符串，使用enter键('\n')结束
          3.在next方法下，使用nextLine方法时，该方法会识别到enter(''\n)符，所以会自动结束
         */
        int num = sc.nextInt();
        String[] arr = new String[num];
        for (int i = 0; i < arr.length; i++) {
            Scanner s = new Scanner(System.in);
            System.out.println("请输入第"+(i+1) + "个学生姓名");
            String name = s.nextLine();
            arr[i] = name;
        }
        System.out.println(Arrays.toString(arr));
    }

}

4.5 二维数组

   二维数组：数组里存储的元素是数组
   二维数组的声明：
     1.数据类型[][] 数组名 = new 数据类型[一维数组的个数(行)][一维数组长度(列)];
     2.数据类型[][] 数组名 = new 数据类型[一维数组的个数][];
     3.数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2},{元素3},{元素4,元素5}};
     4.数据类型[][] 数组名 = {元素1,元素2},{元素3},{元素4,元素5}};
 

package day_04;

import java.util.Arrays;

public class DoubleArrayDemo {
    public static void main(String[] args) {
        //格式1
        int[][] arr = new int[2][4];
        //赋值
        arr[0][1] = 10;
        System.out.println(arr[0][0]);
        System.out.println("--------");

        //格式2
        double[][] arr2 = new double[3][];
        System.out.println(arr2[0]);//null
        //赋值
        arr2[0] = new double[2];
        arr2[1] = new double[4];
        arr2[2] = new double[3];
        System.out.println(arr2[0]);//[D@6e8dacdf
        System.out.println("--------");

        //格式3
        int[][] arr3 = new int[][]{{1,2,3},{67,87}};
        System.out.println(arr3[0][1]);
        System.out.println("--------");

        //格式4
        String[][] arr4 = {{"hello","java","word"},{"gg"},{"cq","wq"}};
        System.out.println(arr4[1][0]);
        System.out.println("--------");

        //二维数组的遍历
        for (int i = 0; i < arr4.length; i++) {
            //得到二维数组每一个一维数组
            String[] s = arr4[i];
            //遍历每一个一维数组
            for (int i1 = 0; i1 < s.length; i1++) {
                System.out.println(s[i1]);
            }

        }
        System.out.println("--------");

        for (int[] s : arr3) {
            for (int i : s) {
                System.out.println(i);
            }
        }

    }
}