java基础:进制详细介绍,进制快速转换,二维数组详解,循环嵌套应用,杨辉三角实现正倒直角正倒等腰三角,附练习案列

1.Debug模式

1.1 什么是Debug模式

是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序。

1.2 Debug介绍与操作流程

• 如何加断点

  • 选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可

• 如何运行加了断点的程序

  • 在代码区域右键Debug执行

• 看哪里

  • 看Debugger窗口

  • 看Console窗口

• 点哪里

  • 点Step Into (F7)这个箭头，也可以直接按F7

• 如何删除断点

  • 选择要删除的断点，单击鼠标左键即可

  • 如果是多个断点，可以每一个再点击一次。也可以一次性全部删除

2. 进制的介绍与书写格式

2.1 进制的介绍与书写格式

代码 :

public class Demo1 {
    /*
        十进制：Java中，数值默认都是10进制，不需要加任何修饰。
        二进制：数值前面以0b开头，b大小写都可以。
        八进制：数值前面以0开头。
        十六进制：数值前面以0x开头，x大小写都可以。
​
        注意: 书写的时候, 虽然加入了进制的标识, 但打印在控制台展示的都是十进制数据.
     */
    public static void main(String[] args) {
        System.out.println(10);
        System.out.println("二进制数据0b10的十进制表示为:" + 0b10);
        System.out.println("八进制数据010的十进制表示为:" + 010);
        System.out.println("十六进制数据0x10的十进制表示为:" + 0x10);
    }
}

2.2 任意进制到十进制的转换

 

 

2.3 进制转换-十进制到任意进制转换

2.3.1 : 十进制到二进制的转换

公式：除基取余使用源数据，不断的除以基数（几进制，基数就是几）得到余数，直到商为0，再将余数倒着拼起来即可。

需求：将十进制数字11，转换为2进制。

实现方式：源数据为11，使用11不断的除以基数，也就是2，直到商为0。

 

 

 

2.3.2 : 十进制到十六进制的转换

公式：除基取余使用源数据，不断的除以基数（几进制，基数就是几）得到余数，直到商为0，再将余数倒着拼起来即可。

需求：将十进制数字60，转换为16进制。

实现方式：源数据为60，使用60不断的除以基数，也就是16，直到商为0。

 

结论：十进制到任意进制的转换

公式：除基取余使用源数据，不断的除以基数（几进制，基数就是几）得到余数，直到商为0，再将余数倒着 拼起来即可

2.4 快速进制转换法

8421码：

8421码又称BCD码，是BCD代码中最常用的一种BCD： (Binary-Coded Decimal‎) 二进制码十进制数在这种编码方式中，每一位二进制值的1都是代表一个固定数值，把每一位的1代表的十进制数加起来得到的结果就是它所代表的十进制数。

 

 

 

2.5 原码反码补码

前言 : 计算机中的数据，都是以二进制补码的形式在运算，而补码则是通过反码和原码推算出来的

原码 :（可直观看出数据大小）

就是二进制定点表示法，即最高位为符号位，【0】表示正，【1】表示负，其余位表示数值的大小。

通过一个字节表示+7和-7，代码：byte b1 = 7; byte b2 = -7;一个字节等于8个比特位，也就是8个二进制位

0(符号位) 0000111

1(符号位) 0000111

反码 : 正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。

补码 : （数据以该状态进行运算）正数的补码与其原码相同；负数的补码是在其反码的末位加1。

 

 

 

 

2.6 位运算-基本位运算符

package com.itheima.demo;
​
public class Demo2 {
    /*
        位运算:
​
            位运算符指的是二进制位的运算，先将十进制数转成二进制后再进行运算。
            在二进制位运算中，1表示true，0表示false。
​
             & 位与 : 遇false则false, 遇0则0
​
                        00000000 00000000 00000000 00000110     // 6的二进制
                     &  00000000 00000000 00000000 00000010     // 2的二进制
                    -----------------------------------------
                        00000000 00000000 00000000 00000010     // 结果: 2
​
             | 位或 : 遇true则true, 遇1则1
​
             ^ 位异或 : 相同为false, 不同为true
​
             ~ 取反 : 全部取反, 0变1, 1变0  (也包括符号位)
​
                    00000000 00000000 00000000 00000110         // 6的二进制补码
                  ~ 11111111 11111111 11111111 11111001
​
                  -                                   1         // -1求反码
                   ------------------------------------
                    11111111 11111111 11111111 11111000         // 反码推原码
​
                    10000000 00000000 00000000 00000111         // -7
     */
    public static void main(String[] args) {
        System.out.println(6 & 2);
        System.out.println(~6);
    }
}
​

 

2.7 位运算-位移运算符

位运算概述 : 位运算符指的是二进制位的运算，先将十进制数转成二进制后再进行运算。在二进制位运算中，1表示true，0表示false。

位运算符介绍 : 

 

 

 

代码 :

package com.itheima.demo;
​
public class Demo3 {
    /*
       位移运算符:
​
               << 有符号左移运算，二进制位向左移动, 左边符号位丢弃, 右边补齐0
                        运算规律: 向左移动几位, 就是乘以2的几次幂
​
                                12 << 2
​
                                (0)0000000 00000000 00000000 000011000  // 12的二进制
​
       -----------------------------------------------------------------------------
               >> 有符号右移运算，二进制位向右移动, 使用符号位进行补位
                        运算规律: 向右移动几位, 就是除以2的几次幂
​
                                000000000 00000000 00000000 0000001(1)  // 3的二进制
​
       -----------------------------------------------------------------------------
​
                >>> 无符号右移运算符,  无论符号位是0还是1，都补0
​
                                010000000 00000000 00000000 00000110  // -6的二进制
​
     */
    public static void main(String[] args) {
        System.out.println(12 << 1);  // 24
        System.out.println(12 << 2);  // 48
​
    }
}
​

package com.itheima.demo;
​
public class Demo4 {
    /*
        ^ 运算符的特点
​
                一个数, 被另外一个数, 异或两次, 该数本身不变
     */
    public static void main(String[] args) {
        System.out.println(10 ^ 5 ^ 10);
    }
}
​

3.基础练习

3.1 数据交换

案例需求

已知两个整数变量a = 10，b = 20，使用程序实现这两个变量的数据交换 最终输出a = 20，b = 10;

代码实现

package com.itheima.test;
​
public class Test1 {
    /*
        需求：已知两个整数变量a = 10，b = 20，使用程序实现这两个变量的数据交换
        最终输出a = 20，b = 10;
​
​
        思路：
        1. 定义一个三方变量temp，将a原本记录的值，交给temp记录 （a的值，不会丢了）
        2. 使用 a 变量记录 b 的值，（第一步交换完毕，b的值也丢不了了）
        3. 使用 b 变量记录 temp的值，也就是a原本的值 （交换完毕）
        4. 输出 a 和 b 变量即可
     */
    /*
        动态初始化格式：
​
            数据类型[][] 变量名 = new 数据类型[m][n];
            m表示这个二维数组，可以存放多少个一维数组
            n表示每一个一维数组，可以存放多少个元素
     */
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
​
        // 将a原本记录的值，交给temp记录 （a的值，不会丢了）
        int temp = a;
        // 用 a 变量记录 b 的值，（第一步交换完毕，b的值也丢不了了）
        a = b;
        // 使用 b 变量记录 temp的值，也就是a原本的值 （交换完毕）
        b = temp;
​
        // 输出 a 和 b 变量即可
        System.out.println("a=" + a);
        System.out.println("b=" + b);
    }
}

3.2 数组反转【应用】

案例需求 :

已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换，

交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素

实现步骤 :

1. 定义两个变量, start和end来表示开始和结束的指针.

2. 确定交换条件, start < end 允许交换

3. 循环中编写交换逻辑代码

4. 每一次交换完成, 改变两个指针所指向的索引 start++, end--

5. 循环结束后, 遍历数组并打印, 查看反转后的数组

代码实现 :

package com.itheima.test;
​
public class Test2 {
    /*
        需求：已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换，
          交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素。
​
        步骤:
              1. 定义两个变量, start和end来表示开始和结束的指针.
              2. 确定交换条件, start < end 允许交换
              3. 循环中编写交换逻辑代码
              4. 每一次交换完成, 改变两个指针所指向的索引 start++, end--
              5. 循环结束后, 遍历数组并打印, 查看反转后的数组
     */
    public static void main(String[] args) {
        int[] arr = {19, 28, 37, 46, 50};
        //  1. 定义两个变量, start和end来表示开始和结束的指针.
        int start = 0;
        int end = arr.length -1;
        //  2. 确定交换条件, start < end 允许交换
        // 4. 每一次交换完成, 改变两个指针所指向的索引 start++, end--
        // for(int start = 0, end = arr.length -1; start < end; start++, end--)
        for( ; start < end; start++, end--){
            // 3. 循环中编写交换逻辑代码
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
​
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}
​

3.3 二维数组概述

概述 : 二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组容器

3.4 二维数组动态初始化

动态初始化格式：
​
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组，可以存放多少个一维数组
n表示每一个一维数组，可以存放多少个元素

package com.itheima.demo;
​
public class Demo1Array {
    /*
        动态初始化格式：
​
            数据类型[][] 变量名 = new 数据类型[m][n];
            m表示这个二维数组，可以存放多少个一维数组
            n表示每一个一维数组，可以存放多少个元素
     */
    public static void main(String[] args) {
        // 数据类型[][] 变量名 = new 数据类型[m][n];
        int[][] arr = new int[3][3];
        /*
            [[I@10f87f48
​
            @ : 分隔符
            10f87f48 : 十六进制内存地址
            I : 数组中存储的数据类型
            [[ : 几个中括号就代表的是几维数组
         */
        System.out.println(arr);
​
        /*
            二维数组存储一维数组的时候, 存储的是一维数组的内存地址
         */
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
​
        System.out.println(arr[0][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[2][2]);
​
        // 向二维数组中存储元素
        arr[0][0] = 11;
        arr[0][1] = 22;
        arr[0][2] = 33;
​
        arr[1][0] = 11;
        arr[1][1] = 22;
        arr[1][2] = 33;
​
        arr[2][0] = 11;
        arr[2][1] = 22;
        arr[2][2] = 33;
​
        // 从二维数组中取出元素并打印
        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[0][2]);
        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[1][2]);
        System.out.println(arr[2][0]);
        System.out.println(arr[2][1]);
        System.out.println(arr[2][2]);
    }
}

3.5 二维数组访问元素的细节问题

问题 : 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ?

答 : 可以的

代码实现

package com.itheima.demo;
​
public class Demo2Array {
    /*
        问题: 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ?
        答 : 可以的
     */
    public static void main(String[] args) {
        int[] arr1 = {11,22,33};
        int[] arr2 = {44,55,66};
        int[] arr3 = {77,88,99,100};
​
        int[][] arr = new int[3][3];
​
        arr[2][3] = 100;
​
        arr[0] = arr1;
        arr[1] = arr2;
        arr[2] = arr3;
​
        System.out.println(arr[1][2]);
        System.out.println(arr[2][3]);
    }
}

3.6 二维数组静态初始化

完整格式 : 数据类型 变量名 = new 数据类型{ {元素1, 元素2...} , {元素1, 元素2...}

简化格式 : 数据类型 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};

代码实现 :

package com.itheima.demo;
​
public class Demo3Array {
    /*
        完整格式：数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...} ...};
​
        简化格式: 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};
     */
    public static void main(String[] args) {
        int[] arr1 = {11,22,33};
        int[] arr2 = {44,55,66};
​
        int[][] arr = {{11,22,33}, {44,55,66}};
        System.out.println(arr[0][2]);
​
        int[][] array = {arr1,arr2};
        System.out.println(array[0][2]);
    }
}
​

3.7 二维数组遍历

需求 :

已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}};

遍历该数组，取出所有元素并打印

步骤 :

1. 遍历二维数组，取出里面每一个一维数组

2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素

代码实现 :

package com.itheima.test;
​
public class Test1 {
    /*
        需求:
​
            已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}};
            遍历该数组，取出所有元素并打印
​
        步骤:
            1. 遍历二维数组，取出里面每一个一维数组
            2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素
     */
    public static void main(String[] args) {
        int[][] arr = {{11, 22, 33}, {33, 44, 55}};
​
        // 1. 遍历二维数组，取出里面每一个一维数组
        for (int i = 0; i < arr.length; i++) {
            //System.out.println(arr[i]);
            // 2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素
            //int[] temp = arr[i];
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
    }
}

3.8 二维数组求和

需求 :

某公司季度和月份统计的数据如下：单位(万元) 第一季度：22,66,44 第二季度：77,33,88 第三季度：25,45,65 第四季度：11,66,99

步骤 :

1. 定义求和变量，准备记录最终累加结果

2. 使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来

3. 遍历二维数组，获取所有元素，累加求和

4. 输出最终结果

代码实现 :

 

package com.itheima.test;

 

public class Test2 {
/*
需求:
某公司季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

 

步骤:
1. 定义求和变量，准备记录最终累加结果
2. 使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来
3. 遍历二维数组，获取所有元素，累加求和
4. 输出最终结果
*/
public static void main(String[] args) {
// 1. 定义求和变量，准备记录最终累加结果
int sum = 0;
// 2. 使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来
int[][] arr = { {22,66,44} , {77,33,88} , {25,45,65} , {11,66,99}};
// 3. 遍历二维数组，获取所有元素，累加求和
for (int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr[i].length; j++){
sum += arr[i][j];
}
}
// 4. 输出最终结果
System.out.println(sum);
}
}

 循环嵌套:

外层循环一次,内层循环一周;

day06课后作业题

代码题

1.训练案例1

1.1.训练描述

自定义一个方法，根据用户键盘录入的行和列，能打印出对应行对应列的矩形;

例如:

当用户希望打印3行5列打印出效果如下:

*****
*****
*****

当用户希望打印4行8列打印出效果如下:

********
********
********
********

1.2.操作步骤描述

打印这种有规则的图形,可以利用循环嵌套的思路实现,内循环负责打印一行中的元素,外循环负责打印行数;

public class Mrb1 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入行:");
        int a=sc.nextInt();
        System.out.println("请输入列:");
        int b=sc.nextInt();
        print(a,b);
    }
    public static void print(int a,int b){
        for (int i = 1; i <= a; i++) {
            for (int j = 1; j <= b; j++) {
                System.out.print("*");
            }
            System.out.println();
​
        }
    }
}
​

运行效果:

 

2. 训练案例2

2.1.训练描述

自定义一个方法，根据用户键盘录入的行，能打印出对应行的直角三角形形;

例如:

当用户希望打印3行的三角形效果如下:

*
**
***

当用户希望打印5行的三角形效果如下:

*
**
***
****
*****

2.2.操作步骤描述

打印这种有规则的图形,可以利用循环嵌套的思路实现,内循环负责打印一行中的元素,外循环负责打印行数;只不过本题比第一题比需要注意的是内循环时,每次循环的次数与外循环的变量有关,也就是说,外循环第一次循环,内循环就循环1次,外循环第2次循环,内循环就循环2次,...以此类推,直到打印出想要的图形;

package com.heima.meiri.day6;
​
import java.util.Scanner;
​
public class Mrb2 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int a =sc.nextInt();
        print(a);
    }
    public static void print(int a){
        for (int i = 1; i <=a; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
​

运行效果:

 

day06课后作业题

单选题

1.下列代码的运行结果是(C )

public static void main(String[] args) {
​
    int sum=0;  
​
    for (int i = 1; i < 3; i++) {
​
        for (int j = 1; j < 3; j++) {
​
            sum+=i*j;//1*1+1*2+2*1+2*2
​
        }
​
    }
​
    System.out.println("sum="+sum);
​
}

A.sum=3

B.sum=4

C.sum=9

D.sum=5

2.下列代码的运行结果是(B )

public static void main(String [] args){
​
    for (int i = 0; i < 1; i++) {
​
        System.out.println("执行语句1");
​
        for (int j = 0; j < 2; j++) {
            System.out.println("执行语句2");
        }
​
        System.out.println("执行语句3");
​
    }
​
}

A.没有输出结果

 

B.执行语句1

执行语句2

执行语句2

执行语句3

 

C.执行语句1

执行语句2

执行语句3

 

D.执行语句1

执行语句2

执行语句2

执行语句3

执行语句1

执行语句2

执行语句2

执行语句3

3:下面是有关数组反转的实现原理的描述，说法错误的是（ D）

A.数组反转过程中，会定义两个int类型的变量，分别保存数组的最大索引值和数组的最小索值

B.数组反转过程中，判断循环结束，其条件是保存数组的最大索引值的变量值小于等于保存数组的最小索引值的变量值

C.数组反转过程中，需要将对称索引位置的元素，进行数据交换

D.数组反转过程中，原始数组的数据和顺序不发生改变

4:下列代码的作用是对数组中的元素存储位置进行反转，如：原数组[1,2,3,4] 反转后的数组为：[4,3,2,1] ，横线处应该填写的代码是（C ）

public static void main(String[] args) {
​
    int arr[] = {1, 2, 3, 6, 8, 9};
​
    for (int min = 0, max = arr.length - 1;__________;  min++, max--) {
​
        int temp = arr[min];
​
        arr[min] = arr[max];
​
        arr[max] = temp;
​
    }
​
    for (int i = 0; i < arr.length; i++) {
​
        System.out.println(arr[i]);
​
    }
}

A.min > max

B.min >= max

C.min < max

D.min == max

多选题

5:代码如下，下列关于数组的反转描述正确的是（ABC D）

public static void main(String[] args) {
​
    int[] array = { 10, 20, 30, 40, 50 };
​
    for (int min = 0, max = array.length - 1; min < max; min++, max--) {
​
        int temp = array[min];
​
        array[min] = array[max];
​
        array[max] = temp;
​
    }
​
}

A.数组反转就是将数组中元素的顺序颠倒，要先找到数组中的最小索引和最大索引。最小索引：0，最大索引就是：array.length - 1，分别保存在两个int类型的变量中

B.如果数组中元素的个数是未知的，通过for循环拿到每个元素，但是要限制循环的次数，只要保证min记录的索引小于max记录的索引即可

C.每循环一次，就会对数组中元素进行一次交换。

D.每次交换数据之后，就会对min和max记录的值修改，小索引min需要加1，大索引max需要减1

代码题

1.扩展案例1

需求

请自定义一个方法,在方法中打印出九九乘法表,并在main方法中调用自定义的方法;

思路提示

1:九九乘法表是固定的格式,所以该方法无需设计参数和返回值;

2:打印九九乘法表的格式和打印直角三角形的形式几乎是一致的,仅仅是把打印的元素替换成乘法表的表达式即可;

3:每个表达式之间使用" "转义字符分隔,当一行表达式打印完之后可以执行换行的操作;

案例效果:

​
public class Kz1 {
    public static void main(String[] args) {
        print();
​
    }
​
    public static void print() {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i + "*" + j + "=" + i * j + "	");
            }
            System.out.println();
        }
    }
}

运行效果:

 

2.训练案例2

[ 五星难度-如果看完需求没思路不推荐花费大量时间研究,难度过高,仅供有兴趣的学生研究 ]

2.1.训练描述

假如一个班级中有3个小组,第一个小组中有3个人,第二个小组中有5个人,第三个小组中有2个人,请分别定义两个方法,一个方法使用代码随机给三个小组中的每个人保存一个1-100之间的随机数作为分数,另一个方法计算出每个小组内成绩的平均分;

2.2.操作步骤描述

1.在main方法中创建一个二维数组,二维数组中的第一个一维数组长度为3，二维数组中的第2个一维数组长度为5,二维数组中的第3个一维数组长度为2;

2.自定义第一个方法,参数是二维数组,无需返回值,在方法中,利用随机数,给二维数组中的每一个一位数组中的学生保存随机成绩;

3.自定义第二个方法,参数是二维数组,返回值是一维数组,在方法体中计算每个小组的平均分并分别保存到新的一维数组中,然后返回一维数组;(新的一维数组自己创建,长度为3,保存的是每一个小组的平均分)

package com.heima.meiri.day6;
​
import java.util.Random;
​
public class Kz02 {
    public static void main(String[] args) {
     int[][]arr=new int[][]{new int[3],new int[5],new int[2]};
     ran(arr);
     int[]avg=avg(arr);
        for (int i = 0; i < avg.length; i++) {
            System.out.println("第"+(i+1)+"组的平均分为:"+avg[i]);
        }
​
    }
    /*
    用循环嵌套给二维数组赋值随机数
     */
    public static void ran(int[][]nums){
        Random r=new Random();
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[i].length; j++) {
                nums[i][j]=r.nextInt(100)+1;
            }
        }
        /*
        循环遍历二维数组
         */
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[i].length; j++) {
                System.out.println(nums[i][j]);
            }
        }
​
    }
     /*
        求平均值,并将每组平均值存入一个新的数组;
         */
     public static int[] avg(int[][]arr){
         int[]avg=new int[3];
         for (int i = 0; i < arr.length; i++) {
              int sum=0;
             for (int j = 0; j < arr[i].length; j++) {
                 sum+=arr[i][j];
             }
            avg[i]=sum/arr[i].length;
​
         }
         return avg;
     }
​
}
​

运行效果:

 

 

3.训练案例3[超级变态难-主要是算法规则难]

3.1.训练描述

创建方法，打印出杨辉三角形（要求打印出10行）

                1
            1       1
        1       2       1
    1       3       3       1
1       4       6       4       1

3.2.操作步骤描述

1.每个数的计算方式,当前位置的元素,等于上一行左右两边的元素之和,具体看下图:

2.制表符（" "）的打印数量

可以利用循环嵌套的思路实现打印制表符的数量，具体规则如下：

第一行：4个" "

第二行：3个" "

第三行：2个" "

第四行：1个" "

第五行：没有

此外数字之间是两个" "。

代码实现:

package com.heima.Znd;

import java.util.Scanner;

public class day6_杨辉三角 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入行数:");
        int a=sc.nextInt();
        Yanghui(a);

    }
    public static void Yanghui(int a){
        int[][]arr=new int[a][a];
        for (int i = 0; i <arr.length; i++) {
            arr[i][0]=1;
            arr[i][i]=1;
           /* for (int j = 1; j <= i; j++) {
                if (i>=2){
                    arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
                }*/
            for (int j = 1; j <= i; j++) {
                arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
            }
            }

        System.out.println("直角三角形");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(arr[i][j]+"	");
            }
            System.out.println();
        }
        System.out.println("倒直角三角形");
        for (int i = arr.length-1; i >= 0; i--) {
            for (int j = 0; j <= i; j++) {
                System.out.print(arr[i][j]+"	");
            }
            System.out.println();
        }
        System.out.println("等腰三角行");
        for (int i = 0; i < arr.length; i++) {
            for (int k=0;k<arr[i].length-i;k++){
                System.out.print("	");
            }
            for (int j = 0; j <= i; j++) {
                System.out.print(arr[i][j]+"		");
            }
            System.out.println();
        }
        System.out.println("倒等腰三角");
        for (int i = arr.length-1; i >= 0; i--) {
            for (int k=0;k<arr[i].length-i;k++){
                System.out.print("	");
            }
            for (int j = 0; j <= i; j++) {
                System.out.print(arr[i][j]+"		");
            }
            System.out.println();
        }
    }
}

 

运行效果: