Java - Java基础（一）

一、计算机基础知识

1、计算机简介
	第一台通用计算机: ENIAC
2、数据的存储和运算
	计算机中对于数据的存储和运算，都是通过二进制数据来完成
3、人机交互方式
	图形化界面
	DOS命令行
	    D: 切换盘符
	    dir 查看当前路径下的文件信息
	    cd 文件名 进入目录
	    cd .. 返回上级目录
	    cd / 返回盘符根目录
	    cls 清屏
	    exit 退出命令提示符窗口
	    win + r 命令行窗口界面
	    win + e 快速打开此电脑
	    set pathext 查看可省略后缀的文件
4、Path环境变量
	Path环境变量: 记录很多软件的完整路径
5、计算机语言
	介绍: 人与计算机沟通交流的表达方式
	    shutdown -s -t 300 5分钟后关闭计算机
	    shutdown -a 取消关机命令
	计算机语言的发展
	    机器语言
	        就是0/1代码，计算机只能识别0和1
	    汇编语言
	        就是将一串机器语言转化成英文单词
	    高级语言
	        使用普通英语进行编写代码，然后通过编译器翻译成类似于汇编语言的指令，之后再由计算机执行

二、Java介绍与环境搭建

1、Java背景

• Java语言是美国 Sun 公司(Stanford University Network) 在1995年推出的计算机语言，后被Oracle公司收购
• Java之父: 詹姆斯·高斯林(James Gosling)

2、Java介绍

1. JVM

• 它是 Java Virtual Machine 也就是 Java 虚拟机的缩写，它的职责是解释执行Java代码。我们写好的 Java 代码，并不能被直接运行，而是需要交给 JVM 来解释执行
• 很多公司都提供了 JVM 实现，最为知名的是 Oracle 提供的 JVM 实现

2. JRE

• JRE呢，是 Java runtime environment 的缩写，含义是 Java 的运行环境。Java 代码编写好了以后，不仅是需要 JVM 对它来进行解释，而且也需要一些基础功能的配合，这些基础功能呢，称之为核心类库（Core libraries），JVM 和核心类库加在一起，就构成了 JRE 这个运行环境

3. JDK

• JDK是 Java development kit 的缩写，含义是 Java 的开发环境。如果你不仅仅要运行 Java 程序，还想开发新的 Java 程序，那还需要借助一些开发工具，JRE 跟开发工具合在一起，就构成了JDK
  
• JDK 功能最全，包含了 JRE 和开发工具
• 其次是 JRE，包含了 JVM + 核心类库
• 最后是 JVM，负责解释执行我们的 Java 代码

3、JDK下载和安装

1. 下载和安装

1. 访问 oracle 官网 Oracle | Cloud Applications and Cloud Platform
   
2. 点击 Java 后进入下面的页面
   
3. 下载 解压版
   
4. 下载完毕后，解压到一个没有中文和空格的目录

2. 配置 Path

如何配置Path环境变量

• 右键此电脑 -> 高级系统设置 -> 环境变量 -> 系统变量 -> Path -> 新增
• JAVA_HOME: JDK的位置(D:\soft\Java\jdk-17.0.1)
• Path: %JAVA_HOME%\bin

检验是否安装成功

C:\Users\Lenovo>java -version
java version "17.0.2" 2022-01-18 LTS
Java(TM) SE Runtime Environment (build 17.0.2+8-LTS-86)
Java HotSpot(TM) 64-Bit Server VM (build 17.0.2+8-LTS-86, mixed mode, sharing)

4、第一个Java程序

public class HelloWorld {
	/*
		Java程序开发的三个步骤
		    编写代码
		        源文件
		    编译代码
		        javac xxx.java
		    运行代码
		        java xxx
		
		HelloWorld案例代码详解
		    public: 权限修饰符，限制类名称和文件名需要保持一致
		    class: 定义一个类，后面跟上的是类名称
		    static: 不用创建对象，因为main方法是静态的，所以测试类中其他方法也需要是静态的
		    void: 被JVM调用，不需要给JVM返回值
		    main: 一个通用的名称，虽然不是关键字，但是被JVM识别，程序执行时的入口，main方法也称为主方法
		    String[] args: 以前用于接收键盘录入数据的，现在没用
	*/
    public static void main(String[] args) {
        System.out.println("Hello World"); // 打印语句
    }
} 

三、基础语法

1、注释

概述
	注释是在程序指定位置添加的说明性信息
分类
	单行注释 
	    //
	多行注释
	    /*
	        内容
	    */
	文档注释(文档注释的内容是可以提取到一个程序说明文档中的)
	    /**
	        文档注释
	    */
注意事项
	注释内容不会参与编译和运行

// 通过class定义了一个类，类名称叫HelloWorld
public class HelloWorld {
	/*
        main方法，又称之为主方法
        这里是程序的入口，如果没有编写主方法，程序就不知道从哪里开始运行
     */
    public static void main(String[] args) {
        System.out.println("Hello World"); // 这是打印语句，也叫输出语句，可以打印双引号所包裹的内容
    }
}

2、关键字

概述
    被Java赋予了特定涵义的英文单词
注意事项
    Java中的关键字，已经被赋予了特殊的涵义，这些单词不允许使用

3、字面量

常用数据	生活中写法	程序中写法	说明
整数	666, -88	666, -88	写法一致
小数	13.14, -5.21	13.14, -5.21	写法一致
字符串	黑马程序员	“HelloWorld”, “黑马程序员”	程序中必须使用双引号
字符	A, 0，我	‘A’, ‘0’, ‘我’	程序中必须使用单引号，有且仅能一个字符
布尔值	真、假	true 、false	只有两个值: true: 代表真，false: 代表假
空值		null	一个特殊的值，空值

4、变量

public class VariableDemo1 {
    /*
        变量介绍: 内存中的存储空间, 空间中记录着经常发生改变的数据

        变量的定义格式:
    
                数据类型 变量名 = 数据值;

                数据类型 : 整数(int)
                
        使用变量
                根据变量名进行使用        
                    
        变量的注意事项 :

                1. 变量名不允许重复定义
    
                2. 一条语句, 可以定义出多个变量, 中间需要使用逗号分隔
    
                3. 变量在使用之前, 必须完成赋值
    
                4. 变量的作用域: 在自己所归属的大括号中                                                                                                                                                              
     */
    public static void main(String[] args) {
        int salary = 12000;
        // 使用变量: 根据变量的名字使用
        System.out.println(salary);

        salary = 15000;
        System.out.println(salary);


        // 1. 变量名不允许重复定义
        // int salary = 15000;

        System.out.println(salary);

        // 2. 一条语句, 可以定义出多个变量, 中间需要使用逗号分隔
        int a = 10, b = 20, c = 30;

        // 3. 变量在使用之前, 必须完成赋值
        int num;
        num = 10;
        System.out.println(num);             
    }
}

5、标识符

概述
    就是给类，方法，变量等起名字的符号
命名规则
    由数字、字母、下划线(_)和美元符($)组成
    不能以数字开头
    不能是关键字
    区分大小写
命名规范
    小驼峰命名法: 变量
        标识符是一个单词的时候，所有字母小写
        标识符由多个单词组成的时候，从第二个单词开始，首字母大写
    大驼峰命名法: 类
        标识符是一个单词的时候，首字母大写
        标识符由多个单词组成的时候，每个单词的首字母大写

6、数据类型

6.1、基本数据类型

说明: e+38表示是乘以10的38次方，e-45表示乘以10的负45次方

数据类型	关键字	取值范围	内存占用
整数	byte	-128~127	1
整数	short	-32768~32767	2
整数	int(默认)	-2147483648~2147483647(10位数)	4
整数	long	-9223372036854775808~9223372036854775807(19位)	8
浮点数	float	1.401298e-45到3.402823e+38	4
浮点数	double(默认)	4.9000000e-324到1.797693e+308	8
字符	char	0~65535	2
布尔	boolean	true, false	1

public class DataTypeDemo1 {
    /*
        数据类型

            1. 基本数据类型

                    整数
                            byte            1个字节          -128 ~ 127
                            short           2个字节
                            int             4个字节
                            long            8个字节
                    小数
                            float(单精度)    4个字节
                            double(双精度)   8个字节
                    字符
                            char            2个字节
                    布尔
                            boolean         1个字节


            2. 引用数据类型

        ---------------------------------------------------------------------

        使用思路 :
                    1. 整数类型 : 首选int, 如果发现int装不下了, 将类型换成long, 定义long类型变量需要加入L的标识

                    2. 小数类型 : 首选double, 非要用float类型, 需要加入F标识
     */
    public static void main(String[] args) {

        char gender = '男';

        boolean flag = true;

        char c = 97;
        System.out.println(c); // a
        
        // 姓名
        String name = "约翰尼 纯情阿绅";
        // 年龄
        int age = 18;
        // 性别
        char gender = '男';
        // 身高
        double height = 180.1;
        // 是否单身
        boolean flag = false;

        System.out.println(name);
        System.out.println(age);
        System.out.println(gender);
        System.out.println(height);
        System.out.println(flag);                                 
    }
}

四、运算符

1、算数运算符

public class OperatorDemo1 {
    /*
    	运算符: 对字面量或者变量进行操作的符号(+ - * / %)
    	表达式: 用运算符把字面量或者变量连接起来符合java语法的式子可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式
        算数运算符 :

            +
            -
            *
            ---------------------------
            / : 整数相除, 结果只能得到整数, 想要得到带有小数的结果, 需要有小数参与运算
            % : 取模, 作用是用来取余数的
		
		注意事项:
		    / 和 % 的区别: 两个数据做除法，/ 取结果的商，% 取结果的 余数
		    整数操作只能得到整数，要想得到小数，必须有浮点数参与运算
     */
    public static void main(String[] args) {
        System.out.println(5 / 2); // 2
        System.out.println(5.0 / 2); // 2.5
        System.out.println(5 / 2.0); // 2.5
        System.out.println(5.0 / 2.0); // 2.5

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

        System.out.println(5 % 2); // 5 / 2 = 2...1
        System.out.println(4 % 2); // 4 / 2 = 2...0
        System.out.println(3 % 2); // 1
        System.out.println(2 % 2); // 0
    }
}

1.1、字符串拼接

当 + 操作中，遇到了字符串，这时 + 就是字符串连接符，而不是算术运算符

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

        int a = 5;
        System.out.println("abc" + 'a'); // "abca"
        System.out.println("abc" + a); // "abc5"
        System.out.println(5 + a); // 10
        System.out.println("abc" + 5 + 'a'); // "abc5a"
        System.out.println(15 + "abc" + 15); // "15abc15"
        System.out.println(a + 'a'); // 102
        System.out.println(a + "" + 'a'); // "5a"
        System.out.println(a + 'a' + "itheima"); // "102itheima"
        System.out.println("itheima" + a + 'a'); // "itheima5a"
        System.out.println("itheima" + (a + 'a')); // "itheima102"
    }
}

2、自增自减运算符

符号	作用	说明
++	自增	变量自身的值加1
–	自减	变量自身的值减1

public class OperatorDemo2 {
    /*
        自增自减运算符 :
            ++ : 让变量自身的值 + 1
            -- : 让变量自身的值 - 1

        1. 单独使用 : 一句代码中, 只做++, 或者是--
            ++, -- 在变量的前面, 还是后面, 没有区别的

            int a = 10;
            ++a;
            System.out.println(a);   // 11

        2. 参与运算使用 :
            ++在前 : 先自增, 再操作

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

            -----------------------

            ++在后 : 先操作, 再自增
            	- 将该变量原本记录的值提取出来做操作, 然后变量再自增.
                                
        3. ++ 、-- 只能操作变量，不能操作常量                                
     */
    public static void main(String[] args) {

        int a = 10;
        int b = a++;    // b = 10, a = 11

        System.out.println("a=" + a);
        System.out.println("b=" + b);
    }
}

3、类型转换

3.1、隐式转换

public class TypeConversionDemo1 {
    /*
        类型转换 - 隐式转换

            介绍: 将取值范围小的数据或变量, 给取值范围大的变量赋值, 可以直接赋值
                    - 简单记: 小的给大的, 可以直接给

            取值范围从小到大

                    byte -> short -> int -> long -> float -> double

                    问题: float占用4个字节, 为什么放在了long(8个字节)的后面
                    解释: 虽然float占用4个字节, 但是 [取值范围] 要比8个字节的long 更大
                            - 小数的二进制存储形式, 更加节省内存
                            
            运算中的隐式转换
                取值范围小的数据，和取值范围大的数据进行运算，小的会先提升为大的之后，再进行运算
                
                byte、short、char 三种数据在运算的时候，都会提升为int，然后再进行运算                                                                            
     */
    public static void main(String[] args) {

        int a = 10;
        double b = a;
        System.out.println(a);      // 10
        System.out.println(b);      // 10.0

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

        long num1 = 123L;
        float num2 = num1;
        System.out.println(num2); // 123.0

        byte aa = 10;
        byte bb = 20;
        int cc = aa + bb;
    }
}

3.2、强制转换

public class TypeConversionDemo2 {
    /*
        类型转换 - 强制转换

            介绍 : 将取值范围大的数据或变量, 给取值范围小的变量赋值, 不允许直接赋值, 需要加入强转
            
            格式 : 目标数据类型 变量名 = (目标数据类型) 被强制转换的数据

            注意 : 强制转换 [有可能] 会出现精度损失
     */
    public static void main(String[] args) {

        double a = 12.3;
        int b = (int) a;
        System.out.println(b);

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

        int num1 = 10;
        byte num2 = (byte) num1;
        System.out.println(num2); // 10

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

        int num = 130;
        byte result = (byte)num;
        System.out.println(result);     // -126
    }
}

3.3、进制

计算机中存储数据的单位: 字节
    每一个字节在计算机底层，都是以二进制的形式进行体现的
    
进制的分类
    二进制: 二进制数据使用0和1两个数码来表示。进位规则是"逢二进一"，借位规则是"借一当二"
    十进制: 由0、1、2、3、4、5、6、7、8、9进行表示。
逢十进一，借一当十。
    八进制：采用0，1，2，3，4，5，6，7八个数字，逢八进1
    十六进制：用数字0到9和字母A到F（或a~f）表示，其中: a~f 表示10~15，这些称作十六进制。
        【0】【1】【2】【3】【4】【5】【6】【7】【8】【9】【a】【b】【c】【d】【e】【f】
 
不同进制的书写
    十进制: 110
    二进制: 0b110
    八进制: 0110
    十六进制: 0x110
    
二进制转十进制

原码反码补码
    原码
        数据的二进制体现形式，一个字节由8个二进制位组成
        高位: 二进制数据中，最左侧的数据通过高位代表符号位
            0: 代表正数
            1: 代表负数 
            其余位，表示数值大小
        弊端: 遇到负数运算，会出现错误
    反码
        正数的反码与其原码相同
        负数的反码是对其原码逐位取反，但符号位除外
    补码
        正数的补码与其原码相同
        负数的补码是在其反码的末位加1

3.4、面试题

public class TypeConversionTest {
    /*
        类型转换面试题 : 下列代码是否存在错误, 如果有, 请指出说明, 并改正.

        byte b1 = 3;
        byte b2 = 4;
        byte b3 = b1 + b2;

        错误原因:
                    b1和b2是两个byte类型, 在运算的时候, 会提升为int类型
                    提升之后, 就是两个int在运算了, 运算的结果还是int.
                    将int类型的结果, 赋值给byte类型的变量, 属于大给小, 不能直接给.

                    byte b1 = 3;
                    byte b2 = 4;
                    byte b3 = (byte)(b1 + b2);

                    System.out.println(b3);

        byte b = 3 + 4;


        Java存在常量优化机制 : 在编译的时候 (javac) 就会将3和4这两个字面量进行运算.
                                产生的字节码文件 :  byte b = 7;
     */
    public static void main(String[] args) {
        byte b = 3 + 4;
        System.out.println(b);
    }
}

4、赋值运算符

符号	作用	说明
=	赋值	a=10，将10赋值给变量a
+=	加后赋值	a+=b，将a + b的值给a
-=	减后赋值	a-=b，将a - b的值给a
*=	乘后赋值	a*=b，将a × b的值给a
/=	除后赋值	a/=b，将a ÷ b的商给a
%=	取余后赋值	a%=b，将a ÷ b的余数给a

package com.itheima.operator;

public class OperatorDemo1 {
    /*
        赋值运算符 :

             1. 基本赋值运算符

                     = : 将等号右侧的数据, 赋值给左边的变量

                     int num = 10;

             2. 扩展赋值运算符

                     += : 将符号左右两边的数据, 做加法运算, 再将结果赋值给左边.
                     -= : 将符号左右两边的数据, 做减法运算, 再将结果赋值给左边.
                     *=
                     /=
                     %=

        ------------------------------------------------------------------------

        细节补充 :
                    扩展赋值运算符, 内部自带强转效果
     */
    public static void main(String[] args) {

        int num = 10;
        num -= 20;
        System.out.println(num);

        short s = 1;
        s += 1;     // s = (short)(s + 1);
        System.out.println(s);

        double a = 12.3;
        int b = 10;

        b += a;     // b = 22;
        System.out.println(b);      // 22
    }
}

5、关系运算符

符号	说明
==	a==b，判断a和b的值是否相等，成立为true，不成立为false
!=	a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>	a>b，判断a是否大于b，成立为true，不成立为false
>=	a>=b，判断a是否大于等于b，成立为true，不成立为false
<	a<b，判断a是否小于b，成立为true，不成立为false
<=	a<=b，判断a是否小于等于b，成立为true，不成立为false

package com.itheima.operator;

public class OperatorDemo2 {
    /*
        关系运算符 (比较运算符) :

            >
            >=
            <
            <=
            ==
            !=

        总结: 让数据之间做比较的符号, 返回true, false
        
        注意事项
        	关系运算符的结果都是 boolean 类型，要么是true，要么是false。
            千万不要把 == 误写成 =
     */
    public static void main(String[] args) {
        System.out.println(10 > 20);        // false
        System.out.println(10 >= 20);       // false
        System.out.println(10 < 20);        // true
        System.out.println(10 <= 20);       // true
        System.out.println(10 == 20);       // false
        System.out.println(10 != 20);       // true
    }
} 

6、逻辑运算符

符号	介绍	说明
&	逻辑与	并且, 遇 false 则 false
|	逻辑或	或者，遇 true 则 true
！	逻辑非	取反
^	逻辑异或	相同为 false，不同为 true
&&	短路与	作用和 & 相同，但是有短路效果
||	短路或	作用和 | 相同，但是有短路效果

package com.itheima.operator;

public class OperatorDemo4 {
    /*
        逻辑运算符 :

            1. 用于连接boolean类型的表达式, 或者是值
            2. 整合多个条件, 为一段整体的逻辑

        分类:

            &(与) : 并且, 遇false, 则false

                    场景: 范围性的判断查找
                    举例: 键盘录入一个学生成绩, 判断该成绩是否是90~100之间
                    伪代码: 不能运行, 仅供理解

                    int score = 95;

                    如果(score >= 90 & score <= 100){
                    }

            |(或) : 或者, 遇true, 则true

                    场景: 多个条件任选其一
                    举例: 键盘录入一个学生学号, 学号 3 5 12

                    int id = 3;

                    如果(id == 3 | id == 5 | id == 12){
                    }

            !(非) : 取反

                    场景: 对一段逻辑整体做取反操作
                    举例: 键盘录入一个学生学号, 学号除了 3 5 12 都要

                    如果(  ! (id == 3 | id == 5 | id == 12)  ){
                    }

            ^(异或) : 相同为false, 不同为true
            
        短路逻辑运算符 :

            & : 没有短路效果, 无论左边是true, false, 右边都要继续执行
            && : 具有短路效果, 左边为false, 右边不执行了
                    左边为true, 右边要继续执行
        
            | : 没有短路效果, 无论左边是true, false, 右边都要继续执行
            || : 具有短路效果, 左边为true, 右边不执行了
                    左边为false, 右边要继续执行
        
        ---------------------------------------------------
        
            常用的逻辑运算符:   &&  ||   !
     */
    public static void main(String[] args) {

        System.out.println(true & true);
        System.out.println(true & false);
        System.out.println(false & true);
        System.out.println(false & false);

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

        System.out.println(true | true);
        System.out.println(true | false);
        System.out.println(false | true);
        System.out.println(false | false);

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

        System.out.println(!true);
        System.out.println(!false);

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

        System.out.println(true ^ true);
        System.out.println(true ^ false);
        System.out.println(false ^ true);
        System.out.println(false ^ false);
        
        System.out.println("------------------------------");
        
        int x = 3;
        int y = 4;
                        // false
        boolean result = ++x > 5 && y-- < 4;
        
        System.out.println(x);          // 4
        System.out.println(y);          // 3
        System.out.println(result);     // false
    }
}

7、三元运算符

package com.itheima.operator;

public class OperatorDemo6 {
    /*
        三元运算符 (三目运算符)

            格式:
                    判断条件 ? 值1 : 值2;

            执行流程
                    1. 执行判断条件, 看其返回结果是true, false
                    2. true : 值1就是最终结果
                    3. false : 值2就是最终结果

            需求: 求两个整数的最大值
     */
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;

        // hold?fish:palm;

        int max = num1 > num2 ? num1 : num2;

        System.out.println(max);    // 20
    }
}

8、运算符优先级

六、分支语句

1、if语句

package com.itheima.mif;

import java.util.Scanner;

public class IfDemo {
    /*
        if语句注意事项
        
	        if 语句中，如果大括号控制的是一条语句，大括号可以省略不写
	        if 语句的 () 和 {} 之间不要写分号
     */
    public static void main(String[] args) {
        ifTest1();
    }

    /*
        if语句的第一种格式:

                if(判断条件){
                    语句体;
                }

        执行流程:
                1. 执行判断条件, 看其返回结果是true, false
                2. true : 执行 {} 中的语句体
                3. false : 不执行 {} 中的语句体
     */
    public static void ifTest1(){
        System.out.println("开始");

        int age = 17;

        if(age >= 18) {
            System.out.println("可以上网吧!");
        }

        System.out.println("结束");
    }

    /*
        if语句的第二种格式 :

                if (判断条件) {
                    语句体1;
                } else {
                    语句体2;
                }

        执行流程:

                1. 执行判断条件看其返回结果是true, false
                2. true : 执行语句体1
                3. false : 执行语句体2
     */
    public static void ifTest2(){

        System.out.println("开始");

        int age = 17;

        if(age >= 18){
            System.out.println("可以上网吧");
        } else {
            System.out.println("您的年龄未满18岁, 不可以上网吧!");
        }

        System.out.println("结束");

    }

    /*
        if语句的第三种格式 :

                if(判断条件1){
                    语句体1;
                }else if (判断条件2) {
                    语句体2;
                }else if (判断条件3){
                    语句体3;
                }
                ...
                else {
                    语句体n+1;
                }

        执行流程:

                1. 执行判断条件1, 看其返回结果是true, false
                        true : 执行语句体1, 执行完毕后, 结束整个if语句.
                        false : 执行第二步
                2. 执行判断条件2, 看其返回结果是true, false
                        true : 执行语句体2, 执行完毕后, 结束整个if语句.
                        false : 执行第三步
                    ...
                3. 如果给出的所有条件, 都不成立, 将会执行最后的 else
     */
    public static void ifTest3(){
        // 需求: 键盘录入一个整数数值, 表示用户身份   1. 会员   2. 非会员  其他. 您的输入有误
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        int num = sc.nextInt();

        if(num == 1){
            System.out.println("会员身份");
        }else if(num == 2){
            System.out.println("非会员身份");
        }else{
            System.out.println("您的输入有误");
        }
    }
}

2、switch语句

package com.itheima.mswitch;

import java.util.Scanner;

public class SwitchDemo {
    public static void main(String[] args) {
        switchTest3();
    }

    /*
        switch语句格式 :

            switch (将要匹配的值) {
                case 值1:
                    语句体1;
                    break;
                case 值2:
                    语句体2;
                    break;
                case 值3:
                    语句体3;
                    break;
                ...
                default:
                    语句体n+1;
                    break;
            }

        执行流程:

            1. 拿着 () 中将要匹配的值, 跟case给出的选项, 逐个进行匹配
                    匹配成功, 执行对应的语句体, 再由break结束掉整个的switch语句

            2. 如果给出的所有case, 都匹配失败了, 将会执行最后的 default, 由break结束掉整个的switch语句

        需求: 键盘录入一个整数, 根据录入的数值, 程序打印出对应的星期

                1 ---> 星期一
                2 ---> 星期二
                ...
                7 ---> 星期日
                8 ---> 您的输入有误

     */
    public static void switchTest1(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        int week = sc.nextInt();

        switch (week) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期日");
                break;
            default:
                System.out.println("您的输入有误");
                break;
        }
    }

    /*
        switch语句注意事项 :

            1. case 后面的值不允许重复
            2. case 后面的值, 只能是字面量, 不能是变量
            3. switch () 中可以接收的类型

                        1). 基本数据类型: byte short char int
                        2). 引用数据类型: jdk5版本开始可以是枚举, jdk7版本开始可以是String字符串

            4. case穿透现象
     */
    public static void switchTest2(){
        
        String week = "1";

        switch (week) {
            case "1" :
                System.out.println("星期一");
                break;
            case "2" :
                System.out.println("星期二");
                break;
            case "3" :
                System.out.println("星期三");
                break;
            default:
                System.out.println("您的输入有误");
                break;
        }
    }

    /*
        switch语句的case穿透现象

        需求: 键盘录入一个数值, 1~5 : 输出工作日  6~7 : 输出休息日

        现象: 多个case中存在了重复的代码, 考虑使用case穿透来优化代码

        --------------------------------------

        jdk14版本开始, case后面允许编写多个数据, 多个数据中间使用逗号分隔
     */
    public static void switchTest3(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        int week = sc.nextInt();

        switch(week){
            case 1, 2, 3, 4, 5 -> System.out.println("工作日");
            case 6, 7 -> System.out.println("休息日");
            default -> System.out.println("您的输入有误");
        }
    }
}

七、循环语句

1、for循环

package com.itheima.loop;

public class ForDemo {
    public static void main(String[] args) {
        forTest2();
    }

    /*
        for循环语句格式 :

            for(初始化语句; 判断条件; 条件控制语句){
                循环体语句;
            }

        执行流程:
            1. 执行初始化语句, 在整个循环过程中, 只执行一次
            2. 执行判断条件, 看其返回结果是true, false
                    false : 循环结束
                    true : 执行第三步
            3. 执行循环体语句
            4. 执行条件控制语句
            5. 回到2继续...
     */
    public static void forTest1() {

        for (int i = 1; i <= 3; i++) {
            System.out.println("跑圈");
        }
    }

    /*
        for循环注意事项 :
            1. for循环 {} 中定义的变量, 在每一轮循环结束后, 都会从内存中释放
            2. for循环 () 中定义的变量, 在整个循环结束后, 会从内存中释放
            3. for循环 () 和 {} 之间不要写分号
     */
    public static void forTest2() {

        for (int i = 1; i <= 5; i++) {
            int num = 10;
            System.out.println("...");
        }
    }
}

2、while循环

package com.itheima.loop;

public class WhileDemo {
    public static void main(String[] args) {
        whileTest();
    }

    /*
        while循环格式:

            初始化语句;
            while(判断条件){
                循环体语句;
                条件控制语句;
            }

        执行流程:
            1. 执行初始化语句
            2. 执行判断条件, 看其返回结果是true, false
                    false : 循环结束
                    true : 进入第三步
            3. 执行循环体语句
            4. 执行条件控制语句
            5. 回到2继续
     */

    public static void whileTest() {

        int i = 1;
        while(i <= 5){
            System.out.println("黑马程序员");
            i++;
        }
    }
}

3、do…while循环

package com.itheima.loop;

public class DoWhileDemo {
    public static void main(String[] args) {
        doWhileTest();
    }

    /*
        do...while循环格式 :

            初始化语句;
            do {
                循环体语句;
                条件控制语句;
            }while(判断条件);

        执行流程 :
            1. 执行初始化语句
            2. 执行循环体语句
            3. 执行条件控制语句
            4. 执行判断条件, 看其返回结果是true, false
                    false : 循环结束
                    true : 回到第二步继续
                    
        特点 :
            无论判断条件是否满足，都至少执行一次循环体
     */

    public static void doWhileTest() {

        int i = 6;
        do {
            System.out.println("黑马程序员");
            i++;
        }while(i <= 5);
    }
}

4、三种循环的区别

package com.itheima.loop;

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

    }

    /*
        三种循环的区别 :
                for循环 和 while循环 (先判断后执行)
                do...while (先执行后判断)

        for 和 while 的区别
                for循环 : 用于控制循环的那个变量, 在循环结束后, 就会从内存中消失, 循环结束后, 不能继续使用
                while循环 : 用于控制循环的那个变量, 在循环结束后, 不会从内存中消失, 循环结束后, 可以继续使用
     */
    public static void method() {

        for(int i = 1; i <= 5; i++){

        }
        // System.out.println(i);

        int i = 1;
        while(i <= 5){
            System.out.println("...");
            i++;
        }

        System.out.println(i);
    }
}

5、循环嵌套

package com.itheima.test;

public class ForTest {
    
    /*
        介绍 :
                在循环语句中，继续出现循环语句
                
        特点 :
                外循环执行一次，内循环执行一圈
     */
    public static void main(String[] args) {

        printTriangle();

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

        print99();
    }

    /*
        需求: 在控制台使用 * 打印4行5列矩形

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

                System.out.println();   打印数据后, 有换行效果
                System.out.print();     打印数据后, 没有换行效果
     */
    public static void printRectangle() {

        // 外循环: 控制行数
        for (int i = 1; i <= 4; i++) {
            // 内循环: 控制列数
            for (int j = 1; j <= 5; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

    /*
        需求: 在控制台使用 * 打印5行的直角三角形

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

                ---------------

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

     */
    public static void printTriangle() {
        // 外循环: 控制行数
        for(int i = 1; i <= 5; i++){
            // 内循环: 控制列数
            for(int j = 1; j <= i; j++){
                System.out.print("*");
            }
            System.out.println();
        }

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

        // 外循环: 控制行数
        for(int i = 5; i >= 1; i--){
            // 内循环: 控制列数
            for(int j = 1; j <= i; j++){
                System.out.print("*");
            }
            System.out.println();
        }

    }

    /*
        需求: 在控制台打印出 99乘法表

            1*1=1
            1*2=2 2*2=4
            1*3=3 2*3=6 3*3=9
            1*4=4 2*4=8 3*4=12 4*4=16
            1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
            ...

        1. 9行9列的矩形
        2. 9行的直角三角形
        3. 99乘法表

        规律:
               乘号左侧数据 : 每一行都是从1开始, 逐个+1进行增长     --> j
               乘号右侧数据 : 在每一行中, 数据都是固定不变的        --> i
     */
    public static void print99(){
        for(int i = 1; i <= 9; i++){
            for(int j = 1; j <= i; j++){
                System.out.print(j + "*" + i + "=" + j*i + "\t");
            }
            System.out.println();
        }
    }
}

6、跳转控制语句

6.1、break

package com.itheima.control;

import java.util.Scanner;

public class BreakDemo {
    /*
        break : 结束循环, 结束switch语句

        注意事项 : 只能在循环, 或者是switch语句中进行使用
     */
    public static void main(String[] args) {
        login();
    }

    /*
        需求: 模拟用户登录, 一共给三次机会
                假设密码是123456
     */
    public static void login() {

        Scanner sc = new Scanner(System.in);

        for(int i = 1; i <= 3; i++){
            System.out.println("请输入密码:");
            int password = sc.nextInt();

            if (password == 123456) {
                System.out.println("登录成功!");
                break;
            } else {
                System.out.println("登录失败, 密码有误!");
            }
        }
    }
}

6.2、continue

package com.itheima.control;

public class ContinueDemo {
    /*
        continue : 跳过

        注意事项 : continue只能在循环中使用

        -------------------------------------

        break, continue的共同注意事项 :

                下面不允许写代码, 因为执行不到, 属于无效的代码.
     */
    public static void main(String[] args) {
        print();
    }

    public static void print(){

        for(int i = 1; i <= 80; i++){
            if(i == 3 || i == 7 || i == 14){
                continue;
            }
            System.out.println("第" + i + "名顾客持48小时核酸证明进入电影院...");
        }
    }
}

6.3、结束整个循环

package com.itheima.control;

import java.util.Scanner;

public class ControlDemo {

    /*
        无限循环(死循环)

            1. for(;;){}

            2. while(true){}

            3. do {} while(true);
     */
    public static void main(String[] args) {
        initMenu();
    }

    /*
        需求: 学生管理系统-菜单搭建
     */
    public static void initMenu() {
        Scanner sc = new Scanner(System.in);

        lo:  // 标号 : 给循环起名字
        while (true) {
            System.out.println("请输入您的选择: 1. 添加学生  2. 删除学生  3. 修改学生  4. 查看学生  5. 退出");
            int choice = sc.nextInt();

            switch (choice) {
                case 1:
                    System.out.println("添加学生逻辑执行...");
                    break;
                case 2:
                    System.out.println("删除学生逻辑执行...");
                    break;
                case 3:
                    System.out.println("修改学生逻辑执行...");
                    break;
                case 4:
                    System.out.println("查看学生逻辑执行...");
                    break;
                case 5:
                    System.out.println("感谢您的使用, 再见!");
                    break lo;
                default:
                    System.out.println("您的输入有误, 请检查!");
                    break;
            }
        }
    }
}

八、数组

1、静态初始化

package com.itheima.array1;

public class ArrayDemo1 {
    public static void main(String[] args) {
        arrayTest2();
    }

    /*
        数组介绍 : 数组指的是一种容器, 可以存储同种数据类型的多个值

        数组的使用场景 : 发现手里的数据有多个, 并且这多个数据还属于同一组数据, 就可以考虑使用数组容器进行维护.

        初始化 : 在内存中, 为数组容器开辟空间, 并将数据存入容器的过程.

        数组的定义格式 :

                1. 数据类型[] 数组名;

                2. 数据类型 数组名[];

                注意 : 这种定义格式, 定义出来的, 只是数组类型的变量而已, 内存中还没有创建出数组容器.
     */
    public static void arrayTest1() {
        int[] array;

        int array2[];

        // System.out.println(array);
        // System.out.println(array2);
    }

    /*
        数组的静态初始化格式 :

                1. 完整格式 :
                                数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3...};

                2. 简化格式 :
                                数据类型[] 数组名 = {元素1, 元素2, 元素3...};

        打印数组名 :

                [I@776ec8df

                @ : 分割符
                [ : 当前空间, 是数组类型的
                I : 当前数组类型, 是int类型
                776ec8df : 数组的十六进制内存地址
     */
    public static void arrayTest2() {
        int[] arr1 = {11, 22, 33};
        double[] arr2 = {11.1, 22.2, 33.3};

        System.out.println(arr1);
        System.out.println(arr2);
    }
}

2、元素访问

package com.itheima.array1;

public class ArrayDemo2 {
    public static void main(String[] args) {
        arrayTest();
    }

    /*
        数组元素访问格式 :

                数组名[索引];

                索引 : 数组容器中空间所对应的编号, 编号从0开始, 逐个+1增长
     */
    public static void arrayTest() {
        int[] arr = {11, 22, 33, 44, 55};

        // 取出数组中 22 元素, 打印在控制台
        System.out.println(arr[1]);

        // 判断数组中第一个元素, 是奇数还是偶数
        if (arr[0] % 2 == 0) {
            System.out.println(arr[0] + "是一个偶数");
        } else {
            System.out.println(arr[0] + "是一个奇数");
        }

        // 修改数组中第三个元素, 为 66
        arr[2] = 66;
        System.out.println(arr[2]);

        // 根据数组中第四个元素, 决定在控制台打印多少次HelloWorld
        for(int i = 1; i <= arr[3]; i++){
            System.out.println("HelloWorld");
        }
    }
}

3、数组遍历

package com.itheima.test;

public class ArrayTest1 {
    public static void main(String[] args) {
        getSum();
    }

    /*
        数组遍历 : 将数中的每一个(所有)的内容, 取出来进行操作

                数组名.length : 动态获取到数组的长度 (元素的个数)

        需求: 对数组中偶数元素做求和操作

        数组遍历的场景 : 如果要完成的需求, 是需要操作到数组中的 [每一个] 元素, 就需要对数组进行遍历操作
     */
    public static void getSum() {

        int[] arr = {11, 22, 33, 44, 55};

        // 1. 定义求和变量, 准备进行累加操作
        int sum = 0;
        // 2. 遍历数组, 获取到每一个元素，数组遍历快捷键 : 数组名.fori
        for (int i = 0; i < arr.length; i++) {
            // 3. 判断当前元素是否是偶数
            // i : 索引
            // arr[i] : 元素
            if(arr[i] % 2 == 0){
                // 4. 是的话, 进行累加求和
                sum += arr[i];
            }
        }
        // 5. 遍历结束后, 将求和结果打印
        System.out.println("偶数和为:" + sum);
    }
}

4、动态初始化

package com.itheima.array1;

public class ArrayDemo3 {
    public static void main(String[] args) {
        arrayTest();
    }

    /*
        数组的动态初始化 :

            在初始化的时候, 只需要指定数组的长度, 系统就会分配默认值(初始值)

            格式: 数据类型[] 数组名 = new 数据类型[长度];

            默认值的分类 :

                    整数 : 0
                    小数 : 0.0
                    布尔 : false
                    ---------------------------
                    字符 : '\u0000'       ---> Unicode字符  ---> 常见的体现是空白字符
                    引用数据类型 : null

                    引用数据类型 : 数组, 类, 接口

                    String : 类
     */
    public static void arrayTest() {

        String[] arr = new String[3];

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

5、两种初始化区别

package com.itheima.test;

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

public class ArrayTest3 {
    /*
        数组两种初始化的区别 :

            动态初始化: 手动指定长度, 系统分配默认初始化值
            静态初始化: 手动指定元素, 系统会根据元素的个数, 计算出数组的长度

        两种初始化的使用选择 :

            1. 静态初始化: 如果要操作的数据, 需求中已经明确给出了, 直接静态初始化
                            需求: 已知班级学生成绩为 100 100 90 20 100, 找出最高分
                            int[] arr = {100,100,90,20,100};

            2. 动态初始化: 只明确元素个数, 不明确具体数值
                            需求1: 键盘录入5个学生成绩, 找出最高分
                            需求2: 产生10个1~100之间的随机数, 找出最小值
     */
    public static void main(String[] args) {

        /*int[] arr = initArrayFromScanner();

        int max = getMax(arr);
        System.out.println("最大值为:" + max);*/


        int[] randomNums = initArrayFromRandom();

        int min = getMin(randomNums);
        System.out.println("最小值为:" + min);
    }

    private static int[] initArrayFromRandom() {
        Random r = new Random();
        int[] randomNums = new int[10];

        for (int i = 0; i < randomNums.length; i++) {
            randomNums[i] = r.nextInt(100) + 1;
            System.out.println(randomNums[i]);
        }
        return randomNums;
    }

    private static int[] initArrayFromScanner() {
        // ctrl + alt + M : 抽取方法的快捷键
        Scanner sc = new Scanner(System.in);
        System.out.println("键盘录入班级成绩, 请输入班级人数:");
        int count = sc.nextInt();
        int[] arr = new int[count];

        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i + 1) + "个");
            arr[i] = sc.nextInt();
        }
        return arr;
    }

    /**
     * 从数组中找出最大值
     */
    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

    /**
     * 从数组中找出最小值
     */
    public static int getMin(int[] arr) {
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }
}

6、内存图

九、二维数组

1、静态初始化与访问

package com.itheima.array2;

public class ArrayDemo1 {
    /*
        二维数组介绍 : 二维数组是一种容器，该容器用于存储一维数组

        使用场景 : 若操作的多组数据属于同一组数据，就可以考虑使用二维数组进行维护

        定义格式 :
                1.完整格式 : 
                        数据类型[][] 数组名 = new 数据类型[][] {{},{}}

                2. 简化格式
                        数据类型[][] 数组名 = {{}, {}}
                
        细节: 二维数组在存储一维数组的时候, 具体存储的是一维数组的地址值

        二维数组的元素访问格式 :

                数组名[m索引][n索引] :

                        m索引 : 指定访问哪一个一维数组
                        n索引 : 访问一维数组中的哪一个元素
     */
    public static void main(String[] args) {

        int[][] arr = {
                {11, 22, 33},
                {44, 55, 66}
        };

        System.out.println(arr);        // [[I@776ec8df

        System.out.println(arr[0]);     // [I@4eec7777
        System.out.println(arr[1]);     // [I@3b07d329

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

2、数组遍历

package com.itheima.test;

public class ArrayTest4 {
    /*
        二维数组的遍历操作

                1. 遍历二维数组, 获取到每一个一维数组
                2. 继续遍历一维数组, 获取到具体的元素
     */
    public static void main(String[] args) {
        int[][] arr = {
                {11, 22, 33},
                {33, 44, 55}
        };

        printArray(arr);

        int sum = getSum(arr);
        System.out.println("求和结果为:" + sum);
    }

    /**
     * 遍历并打印二维数组中元素
     * 已知一个二维数组 arr = { {11 , 22 , 33} , {33 , 44 , 55} };
     * 遍历该数组，取出所有元素并打印
     */
    public static void printArray(int[][] arr) {

        // 1. 遍历二维数组, 获取到每一个一维数组
        for (int i = 0; i < arr.length; i++) {
            // arr[i] : 每一个一维数组
            // 2. 继续遍历一维数组, 获取具体的元素
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
    }

    /**
     * 遍历二维数组并求和
     * 已知一个二维数组 arr = { {11 , 22 , 33} , {33 , 44 , 55} };
     * 对内部存储的元素累加求和，并将结果输出在控制台
     */
    public static int getSum(int[][] arr) {
        int sum = 0;

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum += arr[i][j];
            }
        }

        return sum;
    }
}

3、动态初始化

package com.itheima.array2;

public class ArrayDemo2 {
    /*
        二维数组动态初始化 :

            格式: 数据类型[][] 数组名 = new 数据类型[m][n];

                    m : 这个二维数组中, 可以存放多少个一维数组
                    n : 每一个一维数组中, 可以存放多少个元素
     */
    public static void main(String[] args) {

        // 问题: 能不能将提前创建好的一维数组, 直接存入二维数组中?
        // 回答: 可以
        int[] arr1 = {11, 22, 33};
        int[] arr2 = {44, 55, 66};

        int[][] arr = new int[2][3];

        arr[0] = arr1;
        arr[1] = arr2;

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

    private static void arrayTest1() {
        // 这个二维数组可以存储2个一维数组, 每一个一维数组中可以存放3个元素
        int[][] arr = new int[2][3];

        arr[0][0] = 11;
        arr[0][2] = 33;

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

4、内存图

十、案例

1、逢七跳过

package com.itheima.test;

public class Test1 {

    public static void main(String[] args) {
        knockSeven();
    }

    /*
        需求: 在控制台打印出 1~100 之间满足逢七过规则的数据

        分析:
                1. 通过循环获取到1~100之间的每一个数字
                2. 数值拆分, 拆分出个位和十位
                3. 根据规则加入if判断
                        if(ge == 7 || shi == 7 || i % 7 == 0)
                4. 打印出满足规则的数据
     */
    public static void knockSeven() {
        // 1. 通过循环获取到1~100之间的每一个数字
        for(int i = 1; i <= 100; i++){
            // 2. 数值拆分, 拆分出个位和十位
            int ge = i % 10;
            int shi = i / 10 % 10;
            // 3. 根据规则加入if判断
            if(ge == 7 || shi == 7 || i % 7 == 0){
                // 4. 打印出满足规则的数据
                System.out.println(i);
            }
        }
    }
}

2、数组元素求和

package com.itheima.test;

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

        int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};

        int evenNumberSum = getEvenNumberSum(arr);

        System.out.println(evenNumberSum);
    }

    /*
        需求 :
                有这样的一个数组，元素是 {68,27,95,88,171,996,51,210}
                求出该数组中满足要求的元素和
                要求是：求和的元素个位和十位都不能是7，并且只能是偶数
     */
    public static int getEvenNumberSum(int[] arr) {

        // 1. 定义求和变量
        int sum = 0;

        // 2. 遍历数组, 获取到内部的每一个元素
        for (int i = 0; i < arr.length; i++) {
            // arr[i] : 数组中的每一个元素
            // 3. 将每一个元素, 拆分出个位, 十位
            int ge = arr[i] % 10;
            int shi = arr[i] / 10 % 10;
            // 4. 判断
            if(ge != 7 && shi != 7 && arr[i] % 2 == 0){
                // 5. 求和
                sum += arr[i];
            }
        }

        return sum;
    }
}

3、判断两个数组是否相同

package com.itheima.test;

public class Test3 {
    /*
        == :
                1. 基本数据类型 : 比较数据值
                2. 引用数据类型 : 比较地址值
     */
    public static void main(String[] args) {
        int[] arr1 = {11, 22, 33};
        int[] arr2 = {11, 22, 33, 44};

        boolean result = checkArrayContent(arr1, arr2);

        System.out.println(result);
    }

    /*
        需求: 定义一个方法, 比较两个数组的内容是否相同
        要求: 长度, 内容, 顺序完全相同
     */
    public static boolean checkArrayContent(int[] arr1, int[] arr2) {
        // 1. 比较两个数组的长度
        if (arr1.length != arr2.length) {
            return false;
        }

        // 2. 比较两个数组的元素内容
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }

        // 3. 如果代码能够走到这里, 代表两个数组长度, 内容, 顺序完全相同
        return true;
    }
}

4、查找元素在数组中的索引

package com.itheima.test;

import java.util.Scanner;

public class Test4_1 {
    public static void main(String[] args) {
        int[] arr = {19, 28, 37, 46, 50};

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要查找的元素:");
        int num = sc.nextInt();

        int index = getIndex(num, arr);

        System.out.println(index);
    }

    /*
        需求:
            设计一个方法, 查找元素在数组中的索引位置

            查找元素, 在数组中第一次出现的索引位置.

            已知一个数组 arr = {19, 28, 37, 46, 50};
            键盘录入一个数据，查找该数据在数组中的索引。
            并在控制台输出找到的索引值。
            如果没有查找到，则输出-1
     */
    public static int getIndex(int num, int[] arr) {
        // 1. 假设要查找的元素, 在数组中就是不存在的
        int index = -1;
        // 2. 遍历数组, 获取内部的每一个元素
        for (int i = 0; i < arr.length; i++) {
            // 3. 比较
            if (arr[i] == num) {
                // 4. 找到了, 让index变量记录正确的索引位置
                index = i;
                break;
            }
        }

        return index;
    }
}

package com.itheima.test;

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

        int[] arr = {19, 28, 37, 46, 50, 19, 19};
                  // 0    1   2   3   4   5   6

        int[] results = getIndex(28, arr);

        if(results.length == 0){
            System.out.println("您要查找的元素, 在数组中不存在");
        } else {
            for (int i = 0; i < results.length; i++) {
                System.out.println(results[i]);
            }
        }
    }

    /*
        需求: 设计一个方法, 查找元素在数组中的索引位置 (考虑重复元素问题)
        注意: return只能返回一个结果

        问题: 当一个方法运行结束后, 有多个结果需要返回, 怎么处理?
        回答: 可以将多个结果, 存入一个数组容器, 将数组返回.
     */
    public static int[] getIndex(int num, int[] arr) {
        // 1. 统计要查找的元素, 在数组中出现的个数
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == num){
                count++;
            }
        }
        // 2. 根据统计出来的个数, 创建数组容器
        int[] results = new int[count];

        int index = 0;

        // 3. 查找元素在数组中的索引, 将找到的索引, 存入数组容器
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == num){
                results[index] = i;
                index++;
            }
        }

        // 4. 将装满了索引的数组, 返回
        return results;
    }
}

5、数组元素反转

package com.itheima.demo;

public class SwapDemo1 {
    /*
        思路: 今后只要涉及到数据交换, 联想到第三方的变量

                int a = 10;
                int b = 20;

                int c = a;
                a = b;
                b = c;

                System.out.println("a=" + a);   // 20
                System.out.println("b=" + b);   // 10

        面试题: 实现两个变量的数据交换, 不允许定义第三方变量

        ^ 异或 :

                特点:
                        1. 相同为false, 不同为true
                        2. 一个数字, 被另外一个数字异或两次, 该数本身不变

        异或操作数值的运算过程 :

            1. 将需要运算的数据, 转换为二进制数据

                    0000 1010       10
                    0000 0101       5

            2. 将二进制数据的0当做为false, 1当做为true, 运算

                    0000 1010
                ^   0000 0101
            --------------------
                    0000 1111

            3. 将运算后的二进制数据, 转换为十进制
     */
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        a = a ^ b;  // a = 10 ^ 20;
        b = a ^ b;  // b = 10 ^ 20 ^ 20;            b = 10
        a = a ^ b;  // a = 10 ^ 20 ^ 10;            a = 20

        System.out.println("a=" + a);   // 20
        System.out.println("b=" + b);   // 10
    }
}

package com.itheima.test;

public class Test5 {
    /*
        已知一个数组 arr = {11, 22, 33, 44, 55}; 用程序实现把数组中的元素值交换，
        交换后的数组 arr = {55, 44, 33, 22, 11}; 并在控制台输出交换后的数组元素。

        1. 确定好谁跟谁换

                第一个和倒数第一个 :  arr[0]  arr[arr.length-1-0]
                第二个和倒数第二个 :  arr[1]  arr[arr.length-1-1]
                第三个和倒数第三个 :  arr[2]  arr[arr.length-1-2]
                ...

                arr[i]  arr[arr.length-1-i]

        2. 定义三方变量, 套入公式
     */
    public static void main(String[] args) {

        int[] arr = {11, 22, 33, 44, 55};

        reverseArray2(arr);

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

    private static void reverseArray2(int[] arr) {
        for(int start = 0, end = arr.length - 1; start < end; start++, end--){
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
    }

    private static void reverseArray1(int[] arr) {
        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
    }
}

6、评委打分

package com.itheima.test;

import java.util.Scanner;

public class Test6 {
    /*
        需求:
              在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
              选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值

              1. 基本实现 (不考虑分数校验)
              2. 校验键盘录入的分数是否是0~100之间
              3. 抽取方法
     */
    public static void main(String[] args) {

        int[] arr = initData();

        int sum = getSum(arr);

        int max = getMax(arr);

        int min = getMin(arr);

        // 5. 求平均分 (总和 - 最大值 - 最小值) / 4
        double avg = ((sum - max - min) * 1.0) / (arr.length - 2);

        System.out.println("选手的最后得分为:" + avg);
    }

    /**
     * 数组中找最小值
     */
    private static int getMin(int[] arr) {
        // 4. 求最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }

    /**
     * 数组中找最大值
     */
    private static int getMax(int[] arr) {
        // 3. 求最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

    /**
     * 数组求和
     */
    private static int getSum(int[] arr) {
        // 2. 求和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }

    /**
     * 此方法用于键盘录入6个评委的分数
     */
    private static int[] initData() {
        int[] arr = new int[6];

        // 1. 键盘录入6个评委的打分
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入6个评委的打分:");

        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i + 1) + "位评委的打分:");
            int score = sc.nextInt();
            // 判断成绩是否正确
            if (score >= 0 && score <= 100) {
                arr[i] = score;
            } else {
                System.out.println("您的分数输入有误, 请检查是否是0~100之间的");
                i--;
            }
        }
        return arr;
    }
}

7、随机产生验证码

package com.itheima.test;

import java.util.Random;

public class Test7 {
    /*
        需求: 请从26个英文字母（大小写都包含），以及数字0-9中，随机产生一个5位的字符串验证码并打印在控制台
        效果: uYq8I，3r4Zj

        注意事项: 打印字符类型数组名, 不会看到地址值, 而是元素的内容
     */
    public static void main(String[] args) {

        char[] chs = getContents();

        String checkCode = getCheckCode(chs);

        System.out.println("产生的验证码为:" + checkCode);
    }

    private static String getCheckCode(char[] chs) {
        Random r = new Random();

        String checkCode = "";

        for(int i = 1; i <= 5; i++){
            int randomIndex = r.nextInt(chs.length);
            checkCode += chs[randomIndex];
        }
        return checkCode;
    }

    private static char[] getContents() {
        char[] chs = new char[26 + 26 + 10];

        int index = 0;

        for(char c = 'a'; c <= 'z'; c++){
            chs[index] = c;
            index++;
        }

        for(char c = 'A'; c <= 'Z'; c++){
            chs[index] = c;
            index++;
        }

        for(char c = '0'; c <= '9'; c++){
            chs[index] = c;
            index++;
        }
        return chs;
    }
}