JavaSE第一阶段模块一

Java基础模块一

初识计算机和Java语言

计算机基本概念

计算机：用于高级计算，使用广泛的设备。主要组成：软件、硬件

常见主要硬件

CPU（中央处理器）、内存、硬盘、输入输出设备、主板、机箱和电源等辅助设备。

CPU

核心——计算机的运算和控制中心，所有运算都有CPU完成。解释计算机机器指令及处理计算机软件数据

内存

存储部件，暂存CPU中的运算数据，以及与硬盘等外部存储交换的数据

CPU可直接、高效的访问内存数据

容量小，无法永久存储，断电容易数据丢失

硬盘

主要存储部件，永久存放数据内容，容量大且断电不丢失

CPU不能直接访问，需先加载到内存中

1TB = 1024GB
1GB = 1024MB
1MB = 1024KB
1KB = 1024Byte（字节）

输入输出设备

输入：键盘

输出：键盘

常见主要软件

主要分为系统软件和应用软件

系统软件：Windows/Unix/Linux/IOS/Android

应用软件：Office

计算机体结构

应用软件/JAVA应用——>操作系统外壳（GUI/命令）——>操作系统内核——>硬件(由外到内)

计算机语言发展

第一代：机器语言——二进制代码

第二代：汇编语言——助记符，如ADD，SUB

第三代：高级语言——Java、C、C++、PHP、Python、Scala等

Java语言的发展

1995——Java发行——sun公司（后被Oracle收购）

1996——Java1.0

1999——Java1.2（JAVA SE\JAVA EE\JAVA ME）

… … …

2004——Tiger发布（JAVA5.0），Java登陆火星

2011——7月Oracle正式发布Java7.0

2014——3月19日，Oracle发布Java8.0正式版

2017——9月21日，Java9.0正式发布

2018——9月25日，Oracle官方发布Java11

Java SE——Java平台标准版，基础，包含了运行Java应用所需的基础环境和核心类库

Java EE——Java平台企业版，在Java SE基础上用于构建其业务及应用

Java ME——Java平台微型版（已淘汰）

开发工具下载与安装

一、官网下载：www.sun.com www.oracle.com

二、搜索下载：www.baidu.com www.sougou.com

JDK相关概念

bin——JDK工具命令

conf——JDK配置文件

include——平台的头文件

jmods——JDK各种模块

legal——JDK各模块授权文档

lib——JDK的补充jar包和源代码

JDK—Java开发工具包，目前主流版本JDK11

JRE—Java SE运行时环境，提供了运行Java应用程序的软件环境

javac.exe—编译器，用于将高级源代码翻译成字节码文件

java.exe—解释器，用于启动JVM对字节码文件进行解释执行

JDK包含了JRE，JRE包含了JVM

JDK——>编译器等工具、JRE——>运行类库、JVM

编写Java程序流程

Java开发常用工具

1.文本编辑器

2.记事本、Notepad++、Edit Plus、Ultra Edit

3.集成开发环境（IDE）

4.JBuilder、NetBeans、Eclipse、MyEclipse、IDEA

编写Java程序流程

1.新建文本文档，将扩展名改为——.java

2.使用记事本/Notepad++方式打开文件，编写Java代码后保存

3.启动dos命令窗口，并切换到.java文件所在路径

4.使用javac xxx.java进行编译，生成.class字节码文件

5.使用java xxx进行解释执行，打印结果

常见错误

错误：需要class，interface或enum =>通常都是class关键字拼写错误

错误：找不到符号 => 通常是因为单词拼写错误或Java中不支持这样的单词

错误：需要“;” => 通常是因为少写分号，加上英文分号即可

错误：非法字符：‘\uff1b’ => 通常是因为出现了中文标点符号，修改为英文版即可

错误：在类Xxx中找不到main方法，请将main方法定义为: => main写成了mian

Java11新特性之简化的编译执行

1.新建文本文档，将扩展名改为——.java

2.使用记事本/Notepad++方式打开文件，编写Java代码后保存

3.启动dos命令窗口，并切换到.java文件所在路径

4.使用java xxx.java 进行编译执行，打印最终结果（慎用）

常用快捷键和注释

1.快捷键

ctrl + s 保存 ctrl + c 复制 ctrl + v 粘贴 ctrl + a 全选 ctrl + x 剪切

ctrl + z 撤销 ctrl + f 搜索 ctrl + shift 切换输入法，使用shift进行中英文切换

windows + d 回到桌面 windows + e打开计算机 windows + l 锁屏

windows + r 打开运行，输入cmd启动dos窗口

windows + tab 切换任务 alt + tab 切换任务 ctrl + alt + delete 启动任务管理器

2.注释

——用于代码说明

基本分类

// 单行注释，从//开始，到本行结束，都是注释

/* */ 多行注释，从 / *开始，到 */结束，中间都是注释

/** */ 多行/文档注释，从/**开始，到 */结束，是一种支持提取的注释

多行注释不允许嵌套使用

环境变量的配置

通常情况下可执行文件只能在该文件所在路径中使用，为了该可执行文件可以在任意路径中使用，需要将文件所在的路径信息配置到环境变量Path中

跨平台原理

“一次编译，到处使用”。Java字节码文件可以通过不同平台上的 Java JVM 翻译为可执行机器指令，从而得以运行。

变量和数据类型

变量的基本概念

在需要程序中记录单个数据内容时，声明一个变量。声明变量本质是在内存中申请一个存储单元，且该存储单元中数据内容可以发生改变，故而称为“变量”。

更大的数据用数据类型来记录。

变量的声明方式

数据类型 变量名 = 初始值;——初始值可以省略，但是“;”不可以省略

变量使用注意事项

1.Java是强类型语言，使用变量之前先声明其数据类型

2.使用变量之前必须初始化

3.变量不能重复声明

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

            //1.声明一个变量并初始化    数据类型  变量名  =  初始值;
            int age= 18;
            //2.打印变量数值 + 字符串连接符  用于将两边的内容拼接/连接起来结果还是字符串
            System.out.println("age = "+age); //age = 18

            System.out.println("——————————————————————————————————————");
            //3.使用变量注意事项
            //3.1 使用变量之前需要声明
            //3.2 使用变量之前需要初始化
//        System.out.println("name = " + name);  //错误：找不到符号

//        String name;
//        System.out.println("name = " + name);   //错误：可能尚未初始哈办理name
            String name = "weiwei";
            System.out.println("name = " + name); //name = weiwei

            //3.3 变量不能重复声明
//        int age = 17;  //错误：已在方法main(String[])中定义/声了变量 age
        }
}

标识符命名法则（笔试）

1.由数字、字母、下划线以及美元符$等组成，数字不能开头

2.不能使用Java关键字

3.区分大小写，长度没有限制但不能过长

4.见名知意，支持中文不推荐使用

5.标识符可以给类/变量/属性/方法/包起名

变量通过键盘输入输出

//导入Java目录中的util目录的Scanner类
import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/12 14:55
 * @description  编程实现变量的输入输出
 */
public class VarIOTest {

    public static void main(String[] args) {

        //1.声明两个变量用于记录姓名和年龄
        String name;
        int age;

        //2.提示用户从键盘输入姓名和年龄并放入到变量中  变量随用随声明
        System.out.println("请输入您的姓名和年龄：");
        //创建一个扫描器来扫描键盘输入的内容     System.in代表键盘输入
        Scanner sc = new Scanner(System.in);
        //通过扫描器读取一个字符串数据放入变量name
        name = sc.next();
        //通过扫描器读取一个整数数据放入变量age
        age = sc.nextInt();
        //3.打印变量的值
//        System.out.println("name = " + name);
//        System.out.println("age = " + age);
        System.out.println("name = " +name + ", age = " + age);
    }
}

数据类型分类

1.基本数据类型（记住）

​ byte、short、int、long、float、double、boolean、char

2.引用数据类型（了解）

​ 数组、类、接口、枚举、标注

常用进制

1.日常使用的为十进制，逢十进一，权重：10^0、101、10^2、…

2.计算机底层采用0和1组成的二进制，逢二进一，权重：2^0、21、2^2、…

3.二进制最高位（最左边）用于代表符号位，若该位为0则是非负数，若该位为1则表示负数

4.八进制和十六进制都是二进制的简写

进制间的转换

1.正十进制转二进制

​ a.除二取余法，逆序排列（45----101101） 0b/0B可以作为二进制的前缀

​ b.拆分法，十进制整数拆分为若干个二进制权重的和，有该权重下面写1.否则写0

​ … 128 64 32 16 8 4 2 1

​ 0 0 1 0 1 1 0 1

​ 45 => 32+8+4+1

2.正二进制转换为十进制

​ a.加权法，二进制中每位数乘与相应权重再相加

3.负十进制转换为二进制

​ a.先将十进制绝对值转换位二进制，然后进行按位取反再加1

​ 负数的需要补码：按位取反，再加1

​ -45绝对值的二进制：0010 1101 => 按位取反：1101 0010 => 再加1:1101 0011

​ -45二进制：1101 0011

4.负二进制转换为十进制

​ a.先减1在按位取反，合并为十进制整数后添加负号

​ -45（1101 0011）=> 先减1： 1101 0010

​ =>按位取反：0010 1101

​ =>转为十进制：45

​ =>添加负号： -45

单个字节表示的整数范围（重中之重）

单个字节表示八位二进制，最大范围：-128（-2^8）~ 127（2^7-1）

整数类型

描述整数数据类型的有：byte、short、int、long，常用int

byte占用1个字节，范围：-128~127

short占用2个字节，范围：-2^15~215-1（-32768~32767）

int占用4个字节，范围：-2^31~231-1（-2147483648~2147483647）

long占用8个字节，范围：-2^63~263-1

在Java中直接写出的整数数据类型叫做直接量/字面值/常量，默认为int类型。若想表达更大的直接量，则可在直接量后面加上l或者L，一般用L

整数类型编程

/**
 * @auther weiwei
 * @date 2021/3/12 16:15
 * @description     编程实现整数类型的使用
 */
public class IntTest {
    public static void main(String[] args) {

        //1.声明一个byte类型的变量并初始化
        byte b1 = 25;
//        byte b1 = 250;      //错误：不兼容类型：从int转换到byte可能会有损失  250这样直接写出来的整数数据叫做直接量/常量/字面值  默认为int类型
        //2.打印变量的数值
        System.out.println("b1 = "+b1); //b1 = 25

        System.out.println("——————————————————————————————");
        //3.声明一个short类型的变量并初始化
        short s1 = 250;
//        short s1 = 250250;    //错误：不兼容的类型：从int转换到short可能会有损失
        System.out.println("s1 = " + s1);  //s1 = 250

        System.out.println("———————————————————————————————");
        //4.声明一个int类型的变量并初始化
        int i1 = 250250;
//        int i1 = 2502505006;  //错误：整数太大       默认为int类型，属于局自身已出错，无法表示
//        int i1 = 2502505006L;   //错误：不兼容数据类型：从long转换到int可能会有损失
        System.out.println("i1 = " + i1);

        System.out.println("———————————————————————————————");
        //5.声明一个long类型的变量并初始化,若描述避long类型还大的数据则使用java.math.BigInteger类型
        long g1 = 2502505006L;
        System.out.println("g1 = " + g1);  // g1 = 2502505006L
    }
}

浮点类型

描述小数的数据类型：float和double，推荐double

float占用4个字节，单精度浮点数，可表示7位有效数字，范围：-3.403E38~3.403E38

double占用8个字节，双精度浮点数，表示15位有效数字，范围：-1.798E308~1.798E308

Java中直接写出的小数叫直接量，默认为double类型，若想表达float则在小数后面加f或F

浮点类型编程使用

/**
 * @auther weiwei
 * @date 2021/3/12 17:04
 * @description
 */
public class DoubleTest {
    public static void main(String[] args) {

        //1.声明一个float类型变量初始化
//        float f1 = 3.1415926;     //错误：不兼容类型，从double转换为float可能会有损失
        float f1 = 3.1415926F;
        //2.打印变量数值
        System.out.println("f1 = " + f1); // f1 = 3.1415925  默认7位有效数字

        System.out.println("——————————————————————————————");
        //3.声明一个double类型的变量初始化
        double d1 = 3.1415926;
        System.out.println("d1 = " + d1);  //   d1 = 3.1415926    一般是15位有效数字

        System.out.println("——————————————————————————————");
        //4.笔试考点
        System.out.println(0.1 + 0.2);  //0.30000000000000004   运算时可能会有误差,若实现精确运算,则借助java.math.BigDecimal类型
    }
}

布尔类型

用于描述真假信息类型：boolean，数值只有true和false，所占大小没有明确规定

/**
 * @auther wewei
 * @date 2021/3/12 17:18
 * @description     编程实现布尔类型的使用
 */
public class BooleanTest {
    public static void main(String[] args) {
        //1.声明一个boolean类型办理初始化
        boolean b1 = true;
        //2.打印变量的数值
        System.out.println("b1 = " + b1);  // b1 = true

        System.out.println("——————————————————————————————————");
        //3.修改变量b1的数值   =  赋值运算符，用于将=右边的数据赋值给=左边的变量，覆盖变量中原来的数值
        b1 = false;
        System.out.println("b1 = " + b1);  // b1 = false

        System.out.println("——————————————————————————————————");
//        b1 = 1;   //错误：不兼容类型：int无法转换为boolean
    }
}

字符类型

用于描述单个字符的数据类型：char类型，如：‘a’，占用两个字节，范围：0~65535

掌握ASCII（美国标准信息交换代码）：‘0’ - 48 ‘A’ - 65 ‘a’ -97 空格 - 32 换行符 - 10

Unicode字符集

世界通用定长字符集，都是16位

转义字符

掌握：\ "---- " \ '---- ’ \ \ ---- \ \t----制表符 \n----换行符

/**
 * @auther weiwei
 * @date 2021/3/12 19:17
 * @description     编程实现字符类型的使用
 */
public class CharTest {
    public static void main(String[] args) {

        //1.声明一个char类型变量初始化
        char c1 = 'a';
        //2.打印变量数值
        System.out.println("c1 = " + c1);  //c1 = a
        System.out.println("对应的编号是：" + (int)c1); //表示将char类型的c1强制转换为int类型并打印  97

        System.out.println("——————————————————————————————");
        //3.声明一个char类型变量初始化
        char c2 = 98;
        System.out.println("c2 = " + c2);  //c2 = b
        System.out.println("对应的编号是：" + (int)c2);

        System.out.println("——————————————————————————————");
        //4.使用Unicode字符集来表示我的名字  小明  对应编号：\u5c0f\u660e
        char c3 = '\u5c0f';
        char c4 = '\u660e';
        System.out.println("最终结果是：" + c3 + c4);  //小明

        System.out.println("——————————————————————————————");
        //5.特殊字符使用      双引号本身两个含义：a.字符串开头和结尾标志     b.双引号自身      \转义就是转换原有的含义
        System.out.println("我想过过\"过过过过的生活！");  //   \"  - "
        System.out.println("我想过过\'过过过过的生活！");
        System.out.println("我想过过\\过过过过的生活！");
        System.out.println("我想过过\t过过过过的生活！");
        System.out.println("我想过过\n过过过过的生活！");
    }
}

自动类型转换

1.基本数据类型转换

​ a.自动类型转换：小转大

​ b.强制类型转换：大转小 目标类型 变量名 = （目标类型）源类型变量名

​ byte——>short(char)——>int——>long——>float——>double

​ 小——>大

/**
 * @auther weiwei
 * @date 2021/3/12 19:48
 * @description     编程实现基本数据类型之间转换的使用
 */
public class TransformTest {
    public static void main(String[] args) {

        //1.声明两个变量初始化
        byte b1 = 10;
        short s1 = 20;
        //打印变量的数值
        System.out.println("b1 = " + b1);  // b1 = 10
        System.out.println("s1 = " + s1);  // s1 = 20

        System.out.println("——————————————————————————————————");
        //3.实现自动类型转换的使用
        //表示变量b1的数值赋值给变量s1，并覆盖s1找那个原来的数值，byte到short的转化      小到大     自动转换
        s1 = b1;
        System.out.println("b1 = " + b1);  // b1 = 10
        System.out.println("s1 = " + s1);  // s1 = 10

        System.out.println("——————————————————————————————————");
        //4.实现强制类型转换的使用
        //表示变量s1的数值赋值给变量b1，并覆盖b1找那个原来的数值，short到byte的转化      大到小     强制转换
        //b1 = s1; 错误：不兼容，short转换到byte可能会有损失
        s1 = 128;
        b1 = (byte)s1;
        System.out.println("b1 = " + b1);  // b1 = 10   -128
        System.out.println("s1 = " + s1);  // s1 = 10   128
    }
}

运算符

算术运算符

1.加法运算符：+

2.减法运算符：-

3.乘法运算符：*

4.除法运算符：/

5.取模（取余）运算符：%

/**
 * @auther weiwei
 * @date 2021/3/13 15:05
 * @description     编程实现算术运算符的使用
 */
public class ArithmeticTest {
    public static void main(String[] args) {

        //1.声明两个int类型变量并初始化
//        int ia = 6, ib = 2;   //不推荐使用
        int ia = 6;             //推荐使用，提高代码可读性
        int ib = 2;
        System.out.println("ia = " + ia);   // ia = 6
        System.out.println("ib = " + ib);   // ib = 2

        System.out.println("————————————————————————————");
        //2.使用上述变量实现算术运算符的使用   +  -  *  /  %
        //表示声明变量ic来记录ia和ib的和
        int ic = ia + ib;
        System.out.println("ic = " + ic);  // ic = 8
        //其中ia+ib叫表达式  ia、ib叫做操作数   +叫做操作符/运算符
        System.out.println(ia + ib);    //8
        System.out.println(ia - ib);    //4
        System.out.println(ia * ib);    //12
        System.out.println(ia / ib);    //3
        System.out.println(ia % ib);    //0

        System.out.println("————————————————————————————");
        // 3.注意事项
        // 3.1 当两个整数相除时结果只保留整数部分，丢弃小数部分
        System.out.println(5/2);    // 2
        // 3.2 若希望保留小数部分如歌处理？
        // 处理方式一：使用强制类型转换将其中一个数转换为double类型在运算即可
        System.out.println((double)5/2);  // 2.5
        System.out.println(5/(double)2);  // 2.5
        System.out.println((double)5/(double)2);  // 2.5
        System.out.println((double)(5/2));  // 2.0
        // 处理方式二：让其中一个数乘以1.0(推荐)
        System.out.println(5*1.0 / 2);  // 2.5
        System.out.println(5.0 / 2);    // 2.5  ia.0 错误的表示

        System.out.println("————————————————————————————");
        // 3.3 0不能做除数
        //System.out.println(5 / 0);  //编译正常，运行发生java.lang.ArithmeticException（算术异常）: / by zero
        System.out.println(5 / 0.0);  // Infinity 无穷
        System.out.println(0 / 0.0);  // NaN  Not a Number
    }
}

算术运算符编程实现时间拆分

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/13 15:35
 * @description     编程实现使用算术运算符实现秒数的拆分
 */
public class ArithmeticTimeTest {
    public static void main(String[] args) {

        // 1.提示用户输入一个正整数的秒数并用变量记录
        System.out.println("请输入一个正整数的秒数： ");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();

        // 2.将正整数的秒数拆分为时分秒后并用变量记录
        // 3666秒 => 1小时1分钟6秒
        // 3666 / 3600 = 1 小时     3666 % 3600 = 66 /60 = 1 分钟   3666 % 60 = 6 秒钟
        int hour = num / 3600;        //拆分小时数
        int min = num % 3600 / 60;    //拆分分钟数
        int sec = num % 60;           //拆分秒数
        // 3.打印最终拆分结果
        System.out.println(num + "秒转换为" + hour + "小时" + min + "分" + sec + "秒");
    }
}

字符串连接运算符

1.+既可以作为字符串连接符，又可以作为加法运算

2.只要+两边的操作数有一个字符串类型，则该+就是字符串连接符，否则当做加法运算符处理

System.out.println(1 + 1 + 6);  // 8 int
System.out.println(1 + 1 + 6 + "");  // 8    字符串
System.out.println(1 + 1 + "" + 6);  // 26   字符串
System.out.println(1 + "" + 1 + 6);	 // 116  字符串
System.out.println("" + 1 + 1 + 6);  // 116  字符串
System.out.println("" + (1 + 1 + 6) );  // 8 字符串  

关系（比较）运算符

>  表示是否大于运算符		>=表示是否大于等于运算符
<  表示是否小于运算符		<=表示是否小于等于运算符
== 表示是否等于运算符		！=表示是否不等于运关系算符

关系运算符最终运算的表达式结果一定是boolean类型

/**
 * @auther weiwei
 * @date 2021/3/13 16:06
 * @description     编程实现关系运算符的使用
 */
public class RelationTest {
    public static void main(String[] args) {

        // 1.声明两个int类型的变量并初始化
        int a = 5;
        int b = 2;
        // 2.使用变量实现关系运算符的使用并打印结果
        boolean b1 = a > b;
        System.out.println("b1 = " + b1);   // b1 = true
        System.out.println(a > b);  // 是否大于       true
        System.out.println(a >= b); // 是否大于等于   true
        System.out.println(a < b);  // 是否小于       false
        System.out.println(a <= b); // 是否小于等于   false
        System.out.println(a == b); // 是否等于       false
        System.out.println(a != b); // 是否不等于     true
    }
}

编程实现关系运算符实现负数的判断

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/13 16:15
 * @description     编程使用关系运算符实现负数的判断
 */
public class RelationJudgeTest {
    public static void main(String[] args) {
        // 1.提示用户输入一个整数并用变量记录
        System.out.println("请输入一个整数： ");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();

        // 2.判断该整数是否为负数并打印
        boolean b1 = num < 0;
        System.out.println("b1 = " + b1);
        System.out.println(num);
    }
}

自增自减运算符

++ 表示自增运算符，当前变量自身数值加1

– 表示自减运算符，当前变量吱声数值减1

++ --前缀后缀区别：前缀——先用于结果后计算 后缀——先计算后得出结果

只能用于变量

/**
 * @auther weiwei
 * @date 2021/3/13 16:24
 * @description     编程实现自增自减运算符的使用
 */
public class SelfTest {
    public static void main(String[] args) {

        // 1.声明int变量并初始化
        int ia = 10;
        // 2.打印变量数值
        System.out.println("ia = " + ia);

        System.out.println("——————————————————————————");
        // 3.实现自增减运算符
        // 让变量ia自身数值加1，并覆盖该变量原来的数值
        ia++; // ia = ia + 1;
        System.out.println("ia = " + ia);
        ++ia;
        System.out.println("ia = " + ia);

        // 让变量ia自身数值减1，并覆盖该变量原来的数值
        ia--; // ia = ia + 1;
        System.out.println("ia = " + ia);
        --ia;
        System.out.println("ia = " + ia);

        System.out.println("——————————————————————————————");
        // 4.简单的变换（前缀后缀区别）
        // ia++这个整体叫做表达式    其中ia叫做操作数/变量    ia++和ia表示不同的含义，所占用内存空间不同

        // 后缀++表示让ia的数值作为整个表达式的最终结果，然后再让ia变量自身数值加1  “先打印再计算”
        System.out.println(ia++);           // 10
        System.out.println("ia = " + ia);   // 11
        // 前缀++表示线上自身数值加1，然后再让变量的数值作为整体表达式的结果   “先计算再打印”
        System.out.println(++ia);           // 12
        System.out.println("ia = " + ia);   // 12

        System.out.println("——————————————————————————————");
        // 5.笔试考点
        int ib = ia++;
        System.out.println("ib = " + ib);   // ib = 12
        System.out.println("ia = " + ia);   // ia = 13
        int ic = ++ia;
        System.out.println("ic = " + ic);   // ic = 14
        System.out.println("ia = " + ia);   // ia = 14

        //                  14      16
        System.out.println(ia++ + ++ia);    // 30
        System.out.println("ia = " + ia);   // 16
    }
}

逻辑运算符

&& 表示逻辑与运算符，相当于”并且“，同真为真，一假为假

|| 表示逻辑或运算符，相当于“或者”，一真为真，同假为假

！ 表示逻辑非运算符，相当于“取反”，真为假，假为真

逻辑运算符操作数均为boolean表达式

/**
 * @auther weiwei
 * @date 2021/3/13 16:55
 * @description     编程实现逻辑运算符的使用
 */
public class LogicTest {
    public static void main(String[] args) {

        // 1.声明两个boolean类型变量并初始化
        boolean b1 = true;
        boolean b2 = false;
        // 2.打印变量的数值
        System.out.println("b1 = " + b1); //b1 = true
        System.out.println("b2 = " + b2); //b2 = false

        System.out.println("——————————————————————————————");
        // 3.使用上述变量实现逻辑运算符的使用
        boolean b3 = b1 && b2;
        System.out.println("b3 = " + b3); // false
        System.out.println(b1 && b2);     // false  并且
        System.out.println(b1 || b2);     // true   或者
        System.out.println(!b1);          // false  取反
        System.out.println(!b2);          // true
    }
}

短路特性

逻辑与：若第一个表达式为假则结果为假，此时跳过第二个表达式

逻辑或：第一个为真则结果为真，跳过第二个

		int ia = 3;
        int ib = 5;
        // 低于逻辑与，第一个条件为假则整个表达式为假，跳过第二个条件
        boolean b4 = (++ia == 3) && (++ib == 5);
        System.out.println("b4 = " + b4);   // false
        System.out.println("ia = " + ia);   // 4
        System.out.println("ib = " + ib);   // 5

        //对于逻辑或，第一个条件为真则整个表达式为真，跳过第二个条件
        boolean b5 = (++ia == 5) || (++ib == 5);
        System.out.println("b5 = " + b5);   // true
        System.out.println("ia = " + ia);   // 5
        System.out.println("ib = " + ib);   // 5

判断三位数

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/13 19:04
 * @description     编程使用逻辑运算符判断三位数
 */
public class LogicJudgeTest {
    public static void main(String[] args) {

        // 1.提示用户输入一个正整数并用变量记录
        System.out.println("请输入一个正整数： ");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        // 2.使用逻辑运算符判断时否为三位数并打印     >= 100  <=999   &&
//        System.out.println(100 <= num <= 999);  // 错误：二元运算符'<='的操作类型错误
        // 逻辑运算符主要用于连接多个关系运算符作为最终运算的表达式，用于实现多条件的连接
        System.out.println(100 <= num && num <= 999);
    }
}

条件（三目）运算符

条件表达式 ？表达式1 ：表达式2

判断条件表达式是否成立，若成立则执行表达式1，否则执行表达式2

//使用三目运算符判断num是否为三位数
System.out.println((100 <= num && num <= 999) ? "是三位数":"不是三位数");

三目运算符查找最大值

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/13 19:18
 * @description     编程使用三目运算符查找最大值
 */
public class ThreeEyeTest {
    public static void main(String[] args) {

        // 1.提示用户输入两个整数并用变量表示
        System.out.println("请输入两个整数： ");
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();

        // 2.使用三目运算符找到最大值并打印
        int max = a > b ? a : b;
        System.out.println("最大值是：" + max);
    }
}

赋值运算符

= 将=右边的数据赋值给左边的变量，覆盖原来的数值

复合赋值运算符：+=、-=、*=、/=

/**
 * @auther weiwei
 * @date 2021/3/13 19:26
 * @description     赋值运算符使用
 */
public class AssignTest {
    public static void main(String[] args) {

        // 1.声明一个int类型变量并初始化
        int a = 3;
        // 2.打印变量的数值
        System.out.println("a = " + a); // a = 3

        System.out.println("————————————————————————————————————");
        // 3.简单赋值运算符
        // 表示将数据5赋值给变量a并覆盖变量a之前的值
        a = 5;
        System.out.println("a = " + a); // a =5
        // 下面代码是在打印表达式的结果
        System.out.println(a = 5);  // 5
        System.out.println("a = " + a); // a =5

        int b = a = 6;
        System.out.println("a = " + a); // a =6
        System.out.println("b = " + b); // a =6

        int c = b = a = 8;
        System.out.println("a = " + a); // a =8
        System.out.println("b = " + b); // a =8
        System.out.println("c = " + c); // a =8

        System.out.println("————————————————————————————————————");
        // 4.复合赋值运算符
        //a = a + 2;
        a+=2;       // 简化写法,从结果上来看是等价的
        System.out.println("a = " + a); // a = 10

        System.out.println("————————————————————————————————————");
        // 5.笔试考点1
        byte b1 = 10;
        System.out.println("b1 = " + b1);   // b1 = 10
//        b1 = b1 + 2;    // 不兼容类型：从int转换到byte肯能会有损失          byte + int 相加结果哈市int类型
//        b1 = b1 + (byte)2;    // 不兼容类型：从int转换到byte肯能会有损失    byte + byte 相加结果还是那天类型    编译器优化，避免相加超出范围高倍溢出
//        b1 = (byte)(b1 + 2);  //强制类型转换，将int类型转换到byte
        b1 += 2;    // 真正等价于b1 = (byte)(b1 + 2);
        System.out.println("b1 = " + b1);   // b1 = 12

        System.out.println("————————————————————————————————————");
        // 6.笔试考点2
        // a == 2;  -表示判断变量a的数值是否等于2
        // 2 == a;  -表示判断2是否等于变量a的数值，从结果上来说等价，推荐该方式
        // a = 2;   -表示将2赋值给变量a，覆盖变量a原来的数值
        // 2 = a;   -编译报错   错误：意外的类型
    }
}

移位运算符（了解）

<< 左移运算符，二进制位向左移动，右边用0补充，左移一位相当于当前数值乘以2
>> 右移运算符，二进制位向右移动，左边使用符号位补充，右移一位相当于当前数值除以2
>>> 逻辑右移运算符，二进制位右移，左边使用0补充

/**
 * @auther weiwei
 * @date 2021/3/13 19:58
 * @description     编程实现一位运算符的使用
 */
public class MoveBitTest {
    public static void main(String[] args) {

        // 1.声明一个byte类型变量并初始化
        byte b1 = 13;
        // 2.打印变量的数值
        System.out.println("b1 = " + b1);

        System.out.println("——————————————————————————————");
        // 3.移位运算符的使用
        // 13的二进制是：0000 1101 => 左移一位结果：0001 1010 => 换位十进制整数是：26
        // byte b2 = b1 << 1;  //错误：不兼容类型，从byte转换为int可能会有损失     自动提升为int类型，32位
        byte b2 = (byte)(b1 << 1);
        System.out.println("b2 = " + b2);   // 26
        System.out.println(b1 << 1);    // 26   左移1位相当于当前数值乘以2
        System.out.println(b1 << 2);    // 52   左移1位相当于当前数值乘以4

        System.out.println("——————————————————————————————");
        System.out.println(b1 >> 1);    // 6    右移1位相当于当前数值除以2
        System.out.println(b1 >> 2);    // 3    右移1位相当于当前数值除以4

        System.out.println("——————————————————————————————");
        // 逻辑右移     对于非负数来说，逻辑右移和右移效果一致
        System.out.println(b1 >>> 2);   // 3
    }
}

位运算符（了解）

& 按位与运算符，按照二进制位进行与运算，同1位1，一0为0

|按位或运算符，按照二进制位进行或运算，一1为1，同0为0

~按位取反运算符，按照二进制位进行取反运算，1位0，0为1

^按位异或运算符，按照二进制位进行异或运算，同为0，不同为1

/**
 * @auther weiwei
 * @date 2021/3/13 20:17
 * @description     编程实现位运算符使用
 */
public class BitTest {
    public static void main(String[] args) {

        // 1.声明两个byte类型变量并初始化
        byte b1 = 11;
        byte b2 = 13;
        // 2.打印变量数值
        System.out.println("b1 = " + b1);   // b1 = 11
        System.out.println("b2 = " + b2);   // b2 = 13

        System.out.println("————————————————————————————————————");
        // 3.实现位运算符的使用
        // b1的二进制位：0000 1011
        // b2的二进制位：0000 1101
        System.out.println(b1 & b2);    //按位与：同1为1，一0为0     0000 1001 => 9
        System.out.println(b1 | b2);    //按位或：一1位一，同0为0    0000 1111 => 15
        System.out.println(b1 ^ b2);    //按位异或：同为0，不同为1   0000 0110 => 6
        System.out.println( ~ b1);      //按位取反：1为0,0为1       1111 0100 =>
        // 二进制1111 0100转十进制 => 先减1:1111 0011 => 按位取反 => 0000 1100 => 转为十进制：12 => 添加负号：-12
    }
}

运算符优先级

1.（）优先级极高

2.=优先级极低

3.无法确定优先级，则使用（）来确保即可

流程控制语句

if分支结构

if(条件表达式){ //成立执行语句代码块；不成立跳过

​ 语句代码块；

}

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/15 13:51
 * @description     编程使用if分支结构模拟网吧上网过程
 */
public class IfTest {
    public static void main(String[] args) {

        // 1.提示用户输入年龄信息并用变量记录
        System.out.println("请输入您的年龄:");
        Scanner sc = new Scanner(System.in);
        int age = sc.nextInt();
        // 2.使用if分支结构判断是否成年并给出相应提示
        if(age >= 18){
            System.out.println("祝您上网愉快！");
        }
        // 3.打印一句话
        System.out.println("美好的时光总是短暂的");
    }
}

两个数中寻找最大值的方式

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/15 14:01
 * @description     编程使用if分支结构查找两个整数中的最大值
 */
public class IfMaxTest {
    public static void main(String[] args) {

        // 1.提示用户输入两个整数并使用变量记录
        System.out.println("请输入两个整数：");
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        // 2.使用if分支结构找到最大值并打印
        
        // 方式一：使用两个if分支可以找到最大值
        /*
        if(a >= b){
            System.out.println("最大值是：" + a);
        }
        if(a < b){
            System.out.println("最大值是：" + b);
        }
        */
        
        // 方式二：假设第一个数为最大值并记录  推荐方式
        int max = a;
        if(b > max){
            max = b;
        }
        System.out.println("最大值是：" + max);
    }
}

if else分支结构

if（条件表达式）{ //条件成立执行代码块1

​ 代码块1；

}else{ //条件不成立执行代码块2

​ 代码块2；

}

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/15 14:17
 * @description     编程使用if else分支结构模拟考试成绩查询过程
 */
public class IfElseTest {
    public static void main(String[] args) {

        // 1.提示用户输入考试成绩并使用变量记录
        System.out.println("请输入您的考试成绩： ");
        Scanner sc = new Scanner(System.in);
        int score = sc.nextInt();

        // 2.使用if else分支结构判断考试成绩是否合格把那个给出相应的提示
        if(score >= 60){
            System.out.println("恭喜您考试通过！");
        }else{
            System.out.println("下学期来补考吧！");
        }
        // 3.打印一句话
        System.out.println("世界上最遥远的距离笔试生与死，而是你在if我在else，似乎一直相伴却又永远分离！");
    }
}

判断整数是负数还是非负数

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/15 14:27
 * @description     编程使用if else分支结构判断是否为负数和非负数
 */
public class IfElseJudgeTest {
    public static void main(String[] args) {

        // 1.提示用户输入一个整数并用变量记录
        System.out.println("请输入一个整数： ");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();

        // 2.使用if else分支结构判断负数和非负数并打印
        if(num < 0){
            System.out.println(num + "是负数");
        }else{
            //System.out.println(num + "是非负数");
            // 针对目前的非负数再次判断时正数还是零
            if(num > 0){
                System.out.println(num + "是正数！");
            }else{
                System.out.println(num + "是零！");
            }
        }
    }
}

if else if else分支结构

if(条件表达式1){ //表达式1成立执行代码块1

​ 代码块1；

}else if(条件表达式2){ //表达式1不成立，判断表达式2成立，执行代码块2

​ 代码块2；

}else{ //表达式2不成立，执行代码块n

​ 代码块n;

}

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/15 18:25
 * @description     编程实现if  else if     else分支结构的使用，来模拟购买火车票的过程
 */
public class IFelseifElseTest {
    public static void main(String[] args) {

        // 1.提示用户输入身份信息并用变量记录
        System.out.println("请输入您的身份信息： ");
        Scanner sc = new Scanner(System.in);
        String str = sc.next();

        // 2.使用if   else if   else分支结构判断身份信息并给出相应的提示
        // 判断“军人”是否等于str，是否与str的数值相等
        if("军人".equals(str)){
            System.out.println("请免费乘车！");
        }else if("学生".equals(str)){
            System.out.println("请购买半价票！");
        }else{
            System.out.println("请购买全价票！");
        }

        // 3.打印一句话
        System.out.println("坐上了火车！");
    }
}

个人所得税计算

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/15 18:39
 * @description     编程使用if  else if  else分支结构来计算个人所得税
 */
public class IfSalaryTest {
    public static void main(String[] args) {

        // 1.提示用户输入个人的薪水并用变量记录
        System.out.println("请输入您的薪水： ");
        Scanner sc = new Scanner(System.in);
        // 局部变量：作用范围是从声明开始一直到方法体结束
        int salary = sc.nextInt();

        // 2.使用if elseif else分支结构判断薪水所在的范围并计算对应个人所得税
        // 个人所得税公式：本月应纳税所得额 * 对应税率 - 速算扣除数

        double salaryPrice = 0.0;
        if(salary <= 5000){
            System.out.println("无需纳税");
        }else if(salary < 8000){
            // 块变量：作用范围是从声明开始直到当前语句块结束
            //double salaryPrice = (salary - 5000) *0.03;
            //salaryPrice = (salary - 5000) * 0.03;
            salaryPrice = (salary - 5000) * 0.03 - 0;
        }else if(salary <= 17000){
            //salaryPrice =(salary - 8000) * 0.1 +(8000 - 5000) * 0.03;
            salaryPrice =(salary - 5000) * 0.1 - 210;
        }else if(salary <= 30000){
            //salaryPrice =(salary - 17000) * 0.2 + (17000 - 8000)* 0.1 + (8000 - 5000) * 0.03;
            salaryPrice =(salary - 5000) * 0.2 - 1410;
        }
        // ...

        // 3.打印最终结果
        System.out.println("最终的个人所得税是： " + salaryPrice);
    }
}

出租车计费

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/15 19:04
 * @description     编程使用if  else if  else分支结构实现出租车计费系统的实现
 */
public class IfTaxiTest {
    public static void main(String[] args) {

        // 1.提示用户输入公里数和等待的秒数
        System.out.println("请输入公里数和等待的秒数： ");
        Scanner sc = new Scanner(System.in);
        int km = sc.nextInt();
        int sec = sc.nextInt();

        // 2.根据公里数计算对应里程费并用变量记录
        int kmPrice = 0;
        if(km <= 3){
            kmPrice = 13;
        }else if(km <= 15){
            kmPrice = 13 + (km - 3) * 2;
        }else{
            kmPrice = 13 + (15 -3) * 2 + (km - 15) * 3;
        }
        // 3、根据等待的秒数来计算对应的等待费并用变量记录
        int secPeice = sec / 150;

        // 4.计算总费用并打印
        int sumPrice = kmPrice + secPeice;
        System.out.println("本次出租车的总费用是: " + sumPrice);
    }
}

判断考试成绩所在等级并打印

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/15 19:15
 * @description     编程使用if  else if  else分支结构判断考试成绩所在等级
 */
public class IfScoreTest {
    public static void main(String[] args) {

        // 1.提示用户输入考试成绩并用变量记录
        System.out.println("请输入您的考试成绩： ");
        Scanner sc = new Scanner(System.in);
        int score = sc.nextInt();
        // 2.使用if  else if  else分支结构判断所在等级并打印
        if(score >= 90 && score <= 100){
            System.out.println("等级A");
        }else if(score >= 80){
            System.out.println("等级B");
        }else if(score >= 70){
            System.out.println("等级C");
        }else if(score >= 60){
            System.out.println("等级D");
        }else{
            System.out.println("等级E");
        }
    }
}

switch case分支结构

switch(变量/表达式){ //判断表达式是否匹配字面值1，匹配执行代码块1，执行break跳出当前结构

​ case 字面值1：代码块1；

​ break；

​ case 字面值2：代码块2； //表达式与字面值1不匹配，判断是否匹配字面值2，匹配执行代码块2，break跳出当前结构

​ break；

​ …

​ default：代码块n； //表达式与字面值2不匹配，执行代码块n

}

switch()中支持的数据类型有：byte、short、char、以及int类型，从JDK1.5开始支持枚举类型，从JDK1.7开始支持String类型

考试成绩等级判断

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/16 19:39
 * @description     编程使用switch case分支结构实现考试成绩等级判断
 */
public class SwitchScoreTest {
    public static void main(String[] args) {

        // 1.提示用户输入考试成绩并用变量记录
        System.out.println("请输入您的成绩： ");
        Scanner sc = new Scanner(System.in);
        int score = sc.nextInt();
        // 2.使用switch case分支结构实现考试成绩等级判断
        switch(score / 10){
            case 10 :
//                System.out.println("等级A");
//                break;
            case 9:
                System.out.println("等级A");      //上一个case没有break跳出，下一个case穿透
                break;
            case 8:
                System.out.println("等级B");
                break;
            case 7:
                System.out.println("等级C");
                break;
            case 6:
                System.out.println("等级D");
                break;
            default :
                System.out.println("等级E");
                //break;
        }
    }
}

字符界面

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/16 19:59
 * @description     编程使用switch case分支结构来模拟菜单的效果
 */
public class SwitchMenuTest {
    public static void main(String[] args) {

        // 1.绘制字符界面
        System.out.println("        欢迎来到拉勾教育");
        System.out.println("--------------------------------");
        System.out.println(" [1]学员系统    ");
        System.out.println(" [2]管理员系统");
        System.out.println("[0]退出管理系统");
        System.out.println("--------------------------------");
        System.out.println("请选择要进入的系统： ");
        Scanner sc = new Scanner(System.in);
        int choose = sc.nextInt();

        // 2.使用switch case分支结构模拟用户的选择并给出提示
        switch(choose){
            case 1:
                System.out.println("正在进入学员系统...");
                break;
            case 2:
                System.out.println("正在进入管理员系统...");
                break;
            case 0:
                System.out.println("谢谢使用，下次再见！");
                break;
            default:
                System.out.println("输入错误，请重新选择");
        }
    }
}

循环结构

重复执行一段代码

for循环

for(初始化表达式；条件表达式；修改初始值表达式){

​ 循环体；

}

/**
 * @auther weiwei
 * @date 2021/3/16 20:12
 * @description     编程实现for循环的使用，模拟玩游戏的过程
 */
public class ForTest {
    public static void main(String[] args) throws InterruptedException {

        for(int i = 1; i < 10; i++){
            System.out.println("今晚吃鸡，大吉大利，正在进行第" + i + "场游戏...");
            Thread.sleep(5000); //  表示模拟睡眠五秒的效果     调用线程休眠
            System.out.println("本场游戏结束！\n\n\n");
        }

        System.out.println("该休息了，不然明天要迟到了！");
    }
}

for循环打印奇数

/**
 * @auther weiwei
 * @date 2021/3/16 20:21
 * @description     编程使用for循环实现1~100之间所有奇数的打印
 */
public class ForNumTest {
    public static void main(String[] args) {

        // 1.使用for循环打印1~100之间的所有整数
        // 方式一：根据奇数的概念进行打印
        for (int i = 1; i <= 100; i++) {
            // 若当前i的值是奇数则打印，否则不打印       奇数是不能被2整除的数，即对2取余的结果不为0
            if(i % 2 != 0){
                System.out.println("i = " + i);
            }
        }

        System.out.println("----------------------------------");
        // 方式二：根据等差数列的概念来打印
        for (int i = 1; i <= 100; i += 2) {
            System.out.println("i = " + i);
        }

        System.out.println("----------------------------------");
        // 方式三：根据通项公式规则来打印
        for (int i = 1; i <= 50; i++) {
            System.out.println("i = " + (2 * i - 1));
        }
    }
}

for循环实现累加

/**
 * @auther weiwei
 * @date 2021/3/16 20:32
 * @description     编程使用for循环实现1~10000之间左右整数的累加和
 */
public class ForSumTest {
    public static void main(String[] args) {

        // 2.声明一个变量记录累加的结果
        int sum = 0;

        // 1.使用for循环打印1~10000之间的所有整数
        for (int i = 1; i <=10000 ; i++) {
            // 打印后不换行
            //System.out.print(i + " ");
            // 将所有i的值都累加到sum中
            sum = sum + i;
        }
        // 专门用于换行
        //System.out.println();

        // 3.打印最终的结果
        System.out.println("sum = " + sum);
    }
}

for循环水仙花数打印

//“水仙花数”即一个整数满足其值等于各个数位的立方和
//例如153 = 1^3+5^3+3^3

/**
 * @auther weiwei
 * @date 2021/3/16 20:44
 * @description     编程使用for循环打印三位数中所有的水仙花数
 */
public class ForWaterTest {
    public static void main(String[] args) {

        // 1.使用for循环打印所有的三位数
        for (int i = 100; i <= 999; i++) {

            // 3.拆分三位数中各个数位上的数字
            // 123 / 100 =1;    123 % 100 => 23 / 10 = 2;   123 % 10 = 3;
            int a = i / 100;        //拆分百分位
            int b = i % 100 / 10;   //拆分十位数
            int c = i % 10;         //拆分个位数

            // 2.针对每个三位数都要判断该数是否为水仙花数，若是则打印，否则不打印
            if(a*a*a + b*b*b + c*c*c == i){
                System.out.println("i = " + i);
            }
        }
    }
}

猜数字游戏

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

/**
 * @auther weiwei
 * @date 2021/3/17 19:26
 * @description     编程使用for循环实现猜数字游戏
 */
public class ForGuessTest {
    public static void main(String[] args) {

        // 1.随机是哪个从1~100之间的整数并用变量记录
        Random ra = new Random();
        int temp = ra.nextInt(100) + 1;
        //System.out.println("temp = " + temp);

        // 4.声明一个int类型变量来统计用户猜测的次数
        int count = 0;
        for(;;){    //无限循环
                    // 2.提示用户输入1~100之间猜测的整数并用变量记录
                    System.out.println("请输入1~100之间猜测的整数： ");
                    Scanner sc = new Scanner(System.in);
                    int num = sc.nextInt();
                    count++;

                    // 3.使用用户输入的整数与随机数之间比较大小并给出对应提示
                    if(num > temp){
                        System.out.println("猜大了，再小一点！");
                    }else if(num < temp){
                        System.out.println("猜小了，再大一点！");
                    }else{
                        System.out.println("恭喜您猜对了，游戏结束！");
                        break;
                    }
        }

        if(1 == count){
            System.out.println("你果然是个大咖！");
        }else if(count <= 6){
            System.out.println("水平不错，继续加油！");
        }else{
            System.out.println("你还可以再多玩几次游戏！");
        }
    }
}

continue关键字

用在循环体中，用于提前结束本次循环开始下一次循环

/**
 * @auther weiwei
 * @date 2021/3/16 20:59
 * @description     编程实现continue关键字的使用
 */
public class ContinueTest {
    public static void main(String[] args) {

        // 1.使用for循环打印1~20之间的所有整数
        for (int i = 1; i <= 20; i++) {
            // 若遇到5的倍数则跳过不打印，转而打印下一个数
            if(0 == i % 5){
                continue;   //提前结束本次循环，继续下一次循环，直接执行i++
            }
            System.out.println("i = " + i);
        }
    }
}

break关键字(多看几遍)

应用退出当前语句块，break用在循环体中用于退出循环

若要退出外层循环体，需要使用标号的方式

outer: for（…）{

​ for（）{

​ break outer；

​ }

}

for（；；）-这种没有条件的循环叫做无限循环，即“死循环”

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/16 21:07
 * @description     编程使用for循环和break关键字来模拟聊天的过程
 */
public class BreakTest {
    public static void main(String[] args) {

        // 5.声明一个boolean类型的变量作为发送方的标志
        boolean flag = true;

        // 4.使用无限循环来模拟不断地聊天
        for(;;){
                    // 1.提示用户输入要发送的聊天内容并用变量记录
                    System.out.println("请"+ (flag ? "张三" : "李四") +"输入要发送的聊天内容： ");
                    Scanner sc = new Scanner(System.in);
                    String str = sc.next();

                    // 2.判断用户输入的内容时否为“bye”，若是则聊天结束
                    if("bye".equals(str)){
                        System.out.println("聊天结束！");
                        break;  // 用于跳出当前循环
                    }
                    // 3.若不是则打印用户输入的聊天内容
                    //else{
                        //System.out.println("聊天内容是： " + str);
                    //}
                    System.out.println((flag ? "张三说： " : "李四说： ") + str + "\n\n\n");
                    flag = !flag;
    }
        //...
    }
}

双重for循环–多行多列

for(初始化表达式1；条件表达式1；修改初始化值表达式1){

​ for(初始化表达式2；条件表达式2；修改初始化值表达式2){

​ 循环体；

​ }

}

/**
 * @auther weiwei
 * @date 2021/3/17 19:45
 * @description     编程实现双重for循环的使用
 */
public class ForForTest {
    public static void main(String[] args) {

        // 1.使用for循环打印5行字符串内容“厉害了我的哥！”
        for (int i = 1; i <= 5; i++) {
            System.out.println("厉害了我的哥！");
        }

        System.out.println("-------------------------------");
        // 2.使用for循环打印5列字符串内容“厉害了我的哥！”
        for (int i = 1; i <= 5; i++) {
            System.out.print("厉害了我的哥！");
        }
        System.out.println();

        System.out.println("-------------------------------");
        // 2.使用for循环打印5行5列字符串内容“厉害了我的哥！”
        // 外层循环控制打印的行数
        for (int i = 1; i <= 5; i++) {
            // 内层循环控制打印的列数
            for (int j = 1; j <= 5; j++) {
                System.out.print("厉害了我的哥！");
            }
            System.out.println();
        }
    }
}

星星图案打印

/**
 * @auther weiwei
 * @date 2021/3/17 20:01
 * @description     使用双重for循环打印星星图案
 */
public class ForForStarTest {
    public static void main(String[] args) {

        // 1.打印第一个星星图案--五行五列
        // 外层循环控制打印的行数
        for (int i = 1; i <= 5; i++) {
            // 内层循环控制打印的列数
            for (int j = 1; j <= 5; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println("---------------------------");
        // 2.打印第二个星星图案
        for (int i = 1; i <= 5; i++) {
                for (int j = 1; j <= i; j++) {      //当前行的列数与当前行的行数是相等关系
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println("---------------------------");
        // 3.打印第三个星星图案
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= 6 - i; j++) {      //当前行的列数与当前行的行数相加等于6
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println("---------------------------");
        // 3.打印第四个星星图案
        for (int i = 1; i <= 5; i++) {
            for (int j = 0; j <= 5-i; j++) {
                System.out.print(" ");
            }
            for (int j = 1; j <= 2*i - 1; j++) {      //当前行的列数与当前行的行数为 2*i-1 的关系
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

九九乘法表打印

/**
 * @auther weiwei
 * @date 2021/3/17 20:17
 * @description     使用双重for循环打印九九乘法表
 */
public class ForForTableTest {
    public static void main(String[] args) {

        // 1.使用外层for循环控制打印行数，一共9行
        outer:for (int i = 1; i <= 9; i++) {
            // 2.使用内层for循环控制打印列数，最多九列，规律是：与当前行所在的行数相等
            for (int j = 1; j <= i; j++) {
                // 3.使用两个循环变量来拼接等式
                System.out.print(j + "*" + i + "=" + j*i + " ");
                // 4.当打印完毕6*6 = 36后结束打印
                if(6 == j){
                    //break;  // 主要用于跳出循环，但该关键字只能跳出当前所在的循环
                    break outer;    // 可以跳出外层for循环
                }
            }
            System.out.println();
        }
    }
}

素(质)数打印

/**
 * @auther weiwei
 * @date 2021/3/17 20:34
 * @description     编程使用双重for循环打印2~100之间的所有素数
 */
public class ForForPrimeTest {
    public static void main(String[] args) {

        // 1.使用双重for循环打印2~100之间的所有整数
        for (int i = 2; i <= 100; i++) {

            // 3.声明一个boolean类型的变量作为是否为素数的标记
            boolean flag = true;
            // 2.针对每一个当前的整数都要判断是否为素数，若是素数则打印，否则 不打印
            // 判断每一个数是素数的方法：若该数不能被2到它本身 - 1之间的所有整数整除，则证明该数是素数
            // 使用内层for循环控制2到该数自身 - 1之间的范围
            //for (int j = 2; j < i; j++) {
            // 只需要判断2到该数的平方根即可，因为除数的增大商必然减小，会造成重复的判断
            for(int j = 2; j <= Math.sqrt(i); j++){
                // 使用当前数除以该循环中的每个数并判断是否可以整除，只要找到一个可以长出的数，则证明该数不是素数
                if(0 == i % j){
                    flag = false;
                    break;  //跳出当前所在的内存循环，不需要继续除以下一个整数
                }
            }
            // 只能打印素数
            if(flag == true){
                System.out.println("i = " + i);
            }
        }
    }
}

while循环

while(条件表达式){ // 判断条件表达式是否成立，成立则执行循环体，不成立循环结束

​ 循环体；

}

/**
 * @auther weiwei
 * @date 2021/3/17 20:55
 * @description     编程实现while循环的使用
 */
public class WhileTest {
    public static void main(String[] args) {

        // 1.使用for训话打印1~10之间的所有整数
        // 在()或者{}中声明的变量叫做块变量
        for (int i = 1; i <= 10; i++) {
            System.out.println("i = " + i);
        }

        System.out.println("------------------------");
        // 2.使用while循环打印1~10之间的所有整数
        int i = 1;
        while(i <= 10){
            System.out.println("i = " + i);
            i++;
        }
    }
}

调和数列的累加和

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/17 21:01
 * @description     编程使用while循环实现调和数列（1/1+1/2+1/3+...+1/n）的累加和并打印
 */
public class WhileSumTest {
    public static void main(String[] args) {

        // 1.提示用户输入一个整数并用变量记录
        System.out.println("请输入一个整数： ");
        Scanner sc= new Scanner(System.in);
        int num = sc.nextInt();
        // 2.使用while循环计算调和数列的和并使用变量记录
        double sum = 0.0;
        /*
        for (int i = 1; i <= num; i++) {
            sum += 1.0/i;
        }
         */
        int i = 1;
        while(i <= num){
            sum += 1.0/i;
            i++;
        }
        // 3.计算打印结果
        System.out.println("最终结果是： " + sum);
    }
}

while循环和for循环的比较

1.两者完全可以互换，首先推荐for循环

2.while循环更适用于明确循环条件但不明确循环次数的场合中

3.for循环更适于明确循环次数和范围的场合中

4.while（true）等价于for（；；）都表示无限循环

while循环实现反向输出

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/17 21:19
 * @description     编程使用while循环实现任意正整数的反向输出
 */
public class WhileReverseTest {
    public static void main(String[] args) {

        // 1.提示用户输入一个正整数并使用变量记录
        System.out.println("请输入一个正整数： ");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        // 2.使用while循环进行拆分并打印
        /*
        while(num > 0){
            System.out.print(num % 10);   //拆分个位数
            num /= 10;  //丢弃个位数
        }
         */

        // 2.使用while循环拆分整数中的每个数字并记录到变量中
        int res = 0;
        int temp = num; //指定变量作为num的替身
        while(temp > 0){
            res = res*10 + temp % 10;   //3     32      321
            temp /= 10;                 //12    1       0
        }
        // 3.打印逆序后的结果
        System.out.println(num + "逆序后的结果是： " + res);
    }
}

dowhile循环（熟悉）

至少执行一次循环体

do{ //执行循环体，判断条件表达式是否成立，成立则执行循环体，不成立则循环结束

​ 循环体

}while(条件表达式);

/**
 * @auther weiwei
 * @date 2021/3/17 21:32
 * @description     编程实现do while循环的使用
 */
public class DoWhileTest {
    public static void main(String[] args) {

        // 1.使用for训话打印1~10之间的所有整数
        // 在()或者{}中声明的变量叫做块变量
        for (int i = 1; i <= 10; i++) {
            System.out.println("i = " + i);
        }

        System.out.println("------------------------");
        // 2.使用while循环打印1~10之间的所有整数
        //int i = 1;
        int i = 11;
        while(i <= 10){
            System.out.println("i = " + i);
            i++;
        }

        System.out.println("------------------------");
        // 3.使用do while循环打印1~10之间的所有整数
        //i = 1;
        i = 11;
        do{
            System.out.println("i = " + i);
            i++;
        }while(i <= 10);
    }
}

模拟任务检查

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/17 21:40
 * @description     编程使用do while循环来模拟学习效果检查
 */
public class DoWhileCheckTest {
    public static void main(String[] args) throws InterruptedException {

        String msg = null;      //空
        do{
            System.out.println("正在疯狂学习中...");
            Thread.sleep(5000); //模拟5秒钟
            System.out.println("是否合格？ （Y/N）");
            Scanner sc = new Scanner(System.in);
            msg = sc.next();
        }while(!"Y".equals(msg));

        System.out.println("恭喜任务合格！");
        
        System.out.println("-----------------------------------");
        // 笔试考点
        int i = 1;
        while(i <= 10000);{
            System.out.println("I Love You !");
            i++;
        }
    }
}

循环笔试考点

 int i = 1;
while(i <= 10000){
    ;   // 空语句，啥也不干，可以用于延时
}
{
    System.out.println("I Love You !");
    i++;
}

数组以及应用

一维数组

概念

记录多个类型相同的数据，声明一个一维数组即可，本质是在内存上申请一段连续的存储单元；数组是相同数据类型的多个元素的容器，元素按现行排列，在Java中体现为引用数据类型。

声明方式

1.数据类型 [] 数组名称 = new 数据类型[数组长度]；

2.调用数组的length属性可以获取数组长度

3.通过下标访问数组中的元素，下标从0开始，对于长度为n的数组，下标范围是：0~n-1

数组声明、初始化使用

基本类型的数组，元素初始值：

byte 、short、char、int、long为：0

float和double为：0.0

boolean为：false

初始化方式：数据类型[] 数组名称 = {初始值1，初始值2，…}；

/**
 * @auther weiwei
 * @date 2021/3/18 15:37
 * @description     编程实现一维数组的声明和使用
 */
public class ArrayTest {
    public static void main(String[] args) {

        // 1.声明一个长度为2元素类型为int的一维数组
        // 数据类型[] 数组名称 = new 数据类型[数组长度];
        //int arr1[] = new int[2];    // 两种方式从结果上来说时一样的，不推荐使用
        // int num = 2;               // 声明一个初始值为2的变量

        int[] arr1 = new int[2];      // 推荐该方式，更容易与变量的声明区分，提高了代码可读性

        // 2.打印一位数组的长度以及每个元素的数值
        System.out.println("数组的长度是： " + arr1.length);   // 2    下标从0~1
        System.out.println("下标为0的元素是： " + arr1[0]);    // 0 默认值
        System.out.println("下标为1的元素是： " + arr1[1]);    // 0
        //System.out.println("下标为2的元素是： " + arr1[2]);    // 超过数组长度，ArrayIndexOutOfBoundsException数组下标越界异常

        System.out.println("-----------------------------------");
        // 3.使用for循环打印数组中所有元素
        for (int i = 0; i <= arr1.length-1; i++) {
            System.out.println("下标为" + i + "的元素是： " + arr1[i]); //全是0
        }

        System.out.println("-----------------------------------");
        // 4.声明一个长度为5元素类型为double类型的数组
        double[] arr2 = new double [5];
        // 打印数组中的所有元素
        for (int i = 0; i <= arr2.length-1; i++) {
            System.out.println("下标为" + i + "的元素是： " + arr2[i]); //全是0.0
        }

        System.out.println("-----------------------------------");
        // 5.声明数组的同时就对数组中元素初始化      静态方式简化版
        char[] arr3 = {'a','b','c','d'};
        // 打印数组中的所有元素值
        for (int i = 0; i <= arr3.length-1; i++) {
            System.out.println("下标为" + i + "的元素是： " + arr3[i]); // a b c d
        }

        System.out.println("-----------------------------------");
        // 6.特殊写法     静态方式
        boolean[] arr4 = new boolean[]{true,true,false,false};
        for (int i = 0; i <= arr4.length-1; i++) {
            System.out.println("下标为" + i + "的元素是： " + arr4[i]); // true true false false
        }
    }

内存分析

栈——用于存放程序运行过程中的所有局部变量（方法体中直接声明）

堆——用于存储使用new关键字创建的数组的对象

基本数据类型：直接放置数值

引用数据类型：放置堆区的内存地址

数组增删改查

/**
 * @auther weiwei
 * @date 2021/3/18 16:17
 * @description     编程实现一维数组的增删改查
 */
public class ArrayOpTest {
    public static void main(String[] args) {

        // 1.声明一个长度为5的int类型一维数组————声明
        int[] arr = new int[5];
        // 打印数组中所有元素的数值
        for (int i = 0; i <= arr.length-1; i++) {
            System.out.print(arr[i] + " ");     // 全是默认值0
        }
        System.out.println();

        System.out.println("-------------------------------------");
        // 2.将数据11 22 33 44依次对数组中前四个元素赋值————赋值
        /*
        arr[0] = 11;
        arr[1] = 22;
        arr[2] = 33;
        arr[3] = 44;
         */
        for (int i = 0; i <= arr.length-1; i++) {
            arr[i] = (i+1)*11;
        }
        // 打印数组中的所有元素
        for (int i = 0; i <= arr.length-1; i++) {
            System.out.print(arr[i] + " ");     // 11 22 33 44 0
        }
        System.out.println();

        System.out.println("-------------------------------------");
        // 3.将元素55插入到下标为0的位置，原有元素向后移动————插入
        /*
        arr[4] = arr[3];
        arr[3] = arr[2];
        arr[2] = arr[1];
        arr[1] = arr[0];
        arr[0] = 55;
         */
        for (int i = arr.length-1; i > 0; i--) {
            arr[i] = arr[i-1];
        }
        arr[0] = 55;
        // 打印数组中所有元素的值
        for (int i = 0; i <= arr.length-1; i++) {
            System.out.print(arr[i] + " ");     // 55 11 22 33 44
        }
        System.out.println();

        System.out.println("-------------------------------------");
        // 4.将元素55从数组中删除，删除方式为后续元素向前移动，最后位置置为0————删除
        for (int i = 0; i < arr.length-1; i++) {
            arr[i] = arr[i+1];
        }
        arr[4] = 0;
        // 打印数组中所有元素
        for (int i = 0; i <= arr.length-1; i++) {
            System.out.print(arr[i] + " ");     // 11 22 33 44 0
        }
        System.out.println();

        System.out.println("-------------------------------------");
        // 5.查找数组中是否存在元素22，若存在则修改为220————查改
        for (int i = 0; i <= arr.length-1; i++) {
            if(22 == arr[i]){
                arr[i] = 220;
                break;      //只要找到第一个22就修改后结束循环
            }
        }
        // 打印数组中所有元素
        for (int i = 0; i <= arr.length-1; i++) {
            System.out.print(arr[i] + " ");     // 11 220 33 44 0
        }
        System.out.println();
    }
}

一维数组优缺点

优点：

可直接通过下标（或索引）访问指定位置的元素，速度很快

缺点

1.要求索引元素类型相同

2.要求内幕才能空间必须连续，并且长度一旦确定就不能修改

3.增加或删除元素时可能移动大量元素，效率低

一维数组之间元素拷贝

/**
 * @auther weiwei
 * @date 2021/3/18 17:00
 * @description     编程实现数组之间元素的拷贝
 */
public class ArrayCopyTest {
    public static void main(String[] args) {

        // 1.声明一个初始值为11,22,33,44,55的一维数组
        int[] arr = {11,22,33,44,55};
        // 打印数组所有元素
        System.out.println("第一个数组中的元素有： ");
        for (int i = 0; i <= arr.length-1; i++) {
            System.out.print(arr[i]+ " ");      // 11 22 33 44 55
        }
        System.out.println();

        System.out.println("------------------------------------");
        // 2.声明一个长度为3的int类型一维数组
        int[] brr = new int[3];
        // 打印数组中所有元素
        System.out.println("第二个数组中的元素有： ");
        for (int i = 0; i <= brr.length-1; i++) {
            System.out.print(brr[i]+ " ");      // 0 0 0
        }
        System.out.println();

        System.out.println("------------------------------------");
        // 3.将第一个数组中的中间三个元素赋值到第二个数组中
        /*
        brr[0] = arr[1];
        brr[1] = arr[2];
        brr[2] = arr[3];
         */
        /*
        for (int i = 0; i < brr.length; i++) {
            brr[i] = arr[i+1];
        }
         */

        // 直接使用Java官方提供的拷贝功能
        // 表示将数组arr中下标自从1开始的三个元素拷贝到数组brr中下标从0开始的位置
        System.arraycopy(arr,1,brr,0,3);

        // 打印数组中所有元素
        System.out.println("第二个数组中的元素有： ");
        for (int i = 0; i <= brr.length-1; i++) {
            System.out.print(brr[i]+ " ");      // 22 33 44
        }
        System.out.println();
    }
}

笔试考点

	// 4.笔试考点
    // 表示将变量arr的数值赋值给变量brr，覆盖变量brr原来的数值
    // 数组名arr的内存空间中存放的是数据在堆中的内存地址信息，赋值后让brr变量中存放了arr所指向堆区的内存地址
	// 也就是让brr和arr指向了同一块堆区空间，本质上就是改变了指向
    brr = arr;
    // 打印数组中所有元素
    System.out.println("第二个数组中的元素有： ");
    for (int i = 0; i <= brr.length-1; i++) {
        System.out.print(brr[i]+ " ");      // 22 33 44
    }
    System.out.println();

统计数字次数

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/19 15:56
 * @description     编程使用数组实现正整数中每个数字出现次数的统计
 */
public class ArrayCountTest {
    public static void main(String[] args) {

        // 1.提示用户输入一个正整数并用变量记录
        System.out.println("请输入一个正整数： ");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        // 2.准备一个长度为10的int类型一维数组，默认值为0
        int[] arr = new int[10];
        // 3.拆分正整数中的每个数字并统计到数组中
        int temp = num;
        while(temp > 0){
            arr[temp%10]++;         //  temp%10得到的是数组下标
            temp /= 10;             //  temp/10得到的是数组下标对应的值（即数字出现次数）
        }
        // 4.打印统计结果
        for (int i = 0; i <= arr.length-1; i++) {
            System.out.println("数字" + i + "出现了" + arr[i] + "次！");
        }
    }
}

学生考试成绩的录入、计算和打印

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/19 16:19
 * @description     编程使用数组记录学生考试成绩并打印
 */
public class ArrayScoreTest {
    public static void main(String[] args) {

        // 1.提示用户输入学生人数并用变量记录
        System.out.println("请输入学生人数： ");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        // 2.根据学生人数来声明对应长度的数组负责记录学生成绩
        // 变长数组：指变量可以作为数组的长度，而不是数组长度可以发生改变
        int[] scores = new int[num];
        // 3.提示用户输入每个学生的考试成绩并记录在一维数组中
        for (int i = 0; i < num; i++) {
            System.out.println("请输入第" + (i+1) + "个学生的成绩：");
            scores[i] = sc.nextInt();
        }
        // 4.打印所有学生成绩
        for (int i = 0; i <= scores.length-1; i++) {
            System.out.print(scores[i] + " ");
        }
        System.out.println();

        System.out.println("-----------------------------");
        // 5.计算本班学生成绩的总分以及平均分并用变量记录
        int sum = 0;
        for (int i = 0; i < num; i++) {
            sum += scores[i];
        }
        double avg = sum*1.0 / num;
        // 打印最终计算结果
        System.out.println("本班学生总成绩为：" + sum + "," + "平均分是：" + avg);
    }
}

数组工具类

java.util.Arrays类——实现数组重元素的遍历、查找、排序等

static String toString(int[] a)	输出数组中的内容
static void fill(int[] a,int val)	将参数指定元素赋值给数组中所有元素
static boolean equals(boolean[] a,boolean[] a2)	判断两个数组元素内容和次序是否相同
static void sort(int[] a)	对数组中的元素进行从小到大排序
static int binarySearch(int[] a,int key)	从数组中查找参数指定元素所在的位置

工具类打印、填充和比较

import java.util.Arrays;

/**
 * @auther weiwei
 * @date 2021/3/19 16:50
 * @description     编程实现数组工具类的使用
 */
public class ArraysTest {
    public static void main(String[] args) {

        // 1.声明一个初始值为10、20、30、40、50的一维数组
        int[] arr1 = {10,20,30,40,50};
        // 2.使用原始方式打印数组中的所有元素，打印方式为：[10, 20, 30, 40, 50]
        System.out.print("第一个数组中的元素有： [");
        for (int i = 0; i <= arr1.length-1; i++) {
            // 当打印的元素是最后一个元素时，则直接打印元素本身即可
            if(arr1.length-1 == i){
                System.out.print(arr1[i]);
            }else{
                // 否则打印元素后打印逗号加空格
                System.out.print(arr1[i] + ", ");
            }
        }
        System.out.println("]");

        System.out.println("----------------------------------");
        // 3.使用数组工具类实现数组中所有元素的打印
        System.out.println("第一个数组中的元素有： " + Arrays.toString(arr1)); // [10, 20, 30, 40, 50]

        System.out.println("----------------------------------");
        // 4.声明一个长度为5的int类型一位数组
        int[] arr2 = new int[5];
        System.out.println("第二个数组中的元素有： " + Arrays.toString(arr2)); // [0, 0, 0, 0, 0]
        // 使用数组工具类中的fill方法实现数组中元素的填充并打印
        // 使用10来填充arr2中的所有元素，即给数组中的每个元素赋值为10
        Arrays.fill(arr2,10);
        System.out.println("第二个数组中的元素有： " + Arrays.toString(arr2)); // [10, 10, 10, 10, 10]

        System.out.println("----------------------------------");
        /// 5.声明一个长度为5的int类型一位数组并初始化
        int[] arr3 = new int[5];
        Arrays.fill(arr3,10);
        System.out.println("第三个数组中的元素有： " + Arrays.toString(arr3)); // [10, 10, 10, 10, 10]
        // 判断该数组是否与上述数组相等并打印,相同打印true，否则打印false
        System.out.println(Arrays.equals(arr2,arr3));       // true
        // 修改arr3中的元素
        arr3[4] = 20;
        System.out.println("第三个数组中的元素有： " + Arrays.toString(arr3)); // [10, 10, 10, 10, 20]
        System.out.println(Arrays.equals(arr2,arr3));       // false    要求内容要相同
        arr2[3] = 20;
        System.out.println("第二个数组中的元素有： " + Arrays.toString(arr3)); // [10, 10, 10, 20, 10]
        System.out.println(Arrays.equals(arr2,arr3));       // false    要求顺序要相同
    }
    

排序和查找（二分法查找）

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

/**
 * @auther weiwei
 * @date 2021/3/19 16:19
 * @description     编程使用数组记录学生考试成绩并打印
 */
public class ArrayScoreTest {
    public static void main(String[] args) {

        // 1.提示用户输入学生人数并用变量记录
        System.out.println("请输入学生人数： ");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        // 2.根据学生人数来声明对应长度的数组负责记录学生成绩
        // 变长数组：指变量可以作为数组的长度，而不是数组长度可以发生改变
        int[] scores = new int[num];
        // 3.提示用户输入每个学生的考试成绩并记录在一维数组中
        for (int i = 0; i < num; i++) {
            System.out.println("请输入第" + (i+1) + "个学生的成绩：");
            scores[i] = sc.nextInt();
        }
        // 4.打印所有学生成绩
        for (int i = 0; i <= scores.length-1; i++) {
            System.out.print(scores[i] + " ");
        }
        System.out.println();

        System.out.println("-----------------------------");
        // 5.计算本班学生成绩的总分以及平均分并用变量记录
        int sum = 0;
        for (int i = 0; i < num; i++) {
            sum += scores[i];
        }
        double avg = sum*1.0 / num;
        // 打印最终计算结果
        System.out.println("本班学生总成绩为：" + sum + "," + "平均分是：" + avg);

        System.out.println("-----------------------------");
        // 6.查找本班所有学生考试成绩中的最低分和最高分并打印
        System.out.println("原始的考试成绩是：" + Arrays.toString(scores));
        // 调用工具类中的排序方法对所有考试成绩进行从小到大排序
        Arrays.sort(scores);
        System.out.println("排序后的考试成绩是：" + Arrays.toString(scores));
        System.out.println("最低分是：" + scores[0] + "最高分是：" + scores[num-1]);

        System.out.println("-----------------------------");
        // 从数组中查找指定元素所在下标位置
        System.out.println("59分在数组中的下标位置是：" + Arrays.binarySearch(scores,59));
        System.out.println("60分在数组中的下标位置是：" + Arrays.binarySearch(scores,60));
    }
}

二维数组

本质上是多个一位数组组合在一起的数组，二维数组中每个元素是一个一位数组，一维数组中的元素才是数据内容。

声明、初始化和使用

数据类型[] [] 数组名称 = new 数据类型[行数] [列数];

数据类型[] [] 数组名称 = {{元素1，元素2，…},{},…};

/**
 * @auther weiwei
 * @date 2021/3/19 19:37
 * @description     编程实现二维数组的声明和使用
 */
public class ArrayArrayTest {
    public static void main(String[] args) {

        // 1.声明一个2行3列的int类型二维数组
        int[][] arr1 = new int[2][3];
        // 打印数组中的每个元素
        // 使用外层for循环控制打印行数
        for (int i = 0; i <= arr1.length-1; i++) {
            // 使用内层for循环控制打印的列数
            for (int j = 0; j <= arr1[i].length-1; j++) {
                System.out.print(arr1[i][j] + " ");     // 全是0
            }
            System.out.println();
        }

        System.out.println("------------------------------");
        // 2.实现二维数组中元素的赋值
        int cnt = 1;
        // 使用外层for循环控制打印行数
        for (int i = 0; i <= arr1.length-1; i++) {
            // 使用内层for循环控制打印的列数
            for (int j = 0; j <= arr1[i].length-1; j++) {
                arr1[i][j] = cnt++;
            }
        }
        // 使用外层for循环控制打印行数
        for (int i = 0; i <= arr1.length-1; i++) {
            // 使用内层for循环控制打印的列数
            for (int j = 0; j <= arr1[i].length-1; j++) {
                System.out.print(arr1[i][j] + " ");     // 全是0
            }
            System.out.println();
        }

        System.out.println("------------------------------");
        // 3.二维数组元素的初始化操作
        int[][] arr2 = {{11,22,33,44},{55,66,77,88}};
        // 使用外层for循环控制打印行数
        for (int i = 0; i <= arr2.length-1; i++) {
            // 使用内层for循环控制打印的列数
            for (int j = 0; j <= arr2[i].length-1; j++) {
                System.out.print(arr2[i][j] + " ");     // 11 22 33 44     55 66 77 88 
            }
            System.out.println();
        }

        System.out.println("------------------------------");
        // 4.考点
        int[][] arr3 = new int[3][];    //3行未知列的二维数组
        arr3[0] = new int[3];           // 第一行3列
        arr3[1] = new int[4];           // 第二行4列
        arr3[2] = new int[5];           // 第三行5列
    }
}

杨辉三角

import java.util.Scanner;

/**
 * @auther weiwei
 * @date 2021/3/19 19:57
 * @description     编程使用二维数组实现杨慧三角的生成和遍历
 */
public class ArrayArrayTriangleTest {
    public static void main(String[] args) {

        // 1.提示用户输入一个行数并用变量记录
        System.out.println("请输入一个行数： ");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();

        // 2根据用户输入的行数来声明对应的二维数组
        int[][] arr = new int[num][];

        // 3.针对二维数组中的每个元素进行初始化，使用双重for循环
        // 使用外层for循环控制二维数组的行下标
        for (int i = 0; i <= num-1; i++) {
            //针对二维数组中的每一行进行内存空间的申请
            arr[i] = new int[i+1];

            // 使用内层for循环控制二维数组的列下标
            for (int j = 0; j <= i; j++) {
                // 当列下标为0或者列下标与当前行的行下标相等时，则对应位置的元素就是1
                if(0 == j || i==j){
                    arr[i][j] = 1;
                }else{
                    // 否则对应位置的元素就是上一行当前列的元素加上上一行前一列的元素
                    arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
                }
            }
        }
        // 4.打印最终生成的结果
        for (int i = 0; i <= num-1; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}