Java - Java基础（一）基础语法、运算符、分支循环语句、数组、二维数组

已于 2023-10-14 15:55:32 修改
阅读量418 收藏 7
点赞数
分类专栏： Java 文章标签： java
于 2023-07-26 23:54:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/siyu1216/article/details/131947268
版权

一、计算机基础知识

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

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

3. JDK

  • 是 Java development kit 的缩写，含义是 Java 的开发环境。如果你不仅仅要运行 Java 程序，还想开发新的 Java 程序，那还需要借助一些开发工具，JRE 跟开发工具合在一起，就构成了JDK

4.所属关系
在这里插入图片描述

  • 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, -88666, -88写法一致
小数13.14, -5.2113.14, -5.21写法一致
字符串黑马程序员“HelloWorld”, “黑马程序员”程序中必须使用双引号
字符A, 0，我‘A’, ‘0’, ‘我’程序中必须使用单引号，有且仅能一个字符
布尔值真、假true 、false只有两个值: true: 代表真，false: 代表假
空值null一个特殊的值，空值

4、变量

变量介绍: 内存中的存储空间, 空间中记录着经常发生改变的数据

 变量的定义格式:
         数据类型 变量名 = 数据值;
        	- 数据类型 : 整数(int)
         
 使用变量
         根据变量名进行使用        
             
 变量的注意事项 :
         1. 变量名不允许重复定义
         2. 一条语句, 可以定义出多个变量, 中间需要使用逗号分隔
         3. 变量在使用之前, 必须完成赋值
         4. 变量的作用域: 在自己所归属的大括号中

public class VariableDemo1 {
    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、基本数据类型

数据类型关键字取值范围内存占用
整数byte-128~1271
整数short-32768~327672
整数int(默认)-2147483648~2147483647(10位数)4
整数long-9223372036854775808~9223372036854775807(19位)8
浮点数float1.401298e-45到3.402823e+384
浮点数double(默认)4.9000000e-324到1.797693e+3088
字符char0~655352
布尔booleantrue, false1
说明: e+38表示是乘以10的38次方，e-45表示乘以10的负45次方

数据类型
          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 class DataTypeDemo1 {
    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、算数运算符

运算符: 对字面量或者变量进行操作的符号(+ - * / %)
表达式: 用运算符把字面量或者变量连接起来符合java语法的式子可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式
算数运算符 :
    +
    -
    *
    ---------------------------
    / : 整数相除, 结果只能得到整数, 想要得到带有小数的结果, 需要有小数参与运算
    % : 取模, 作用是用来取余数的

注意事项:
    / 和 % 的区别: 两个数据做除法，/ 取结果的商，% 取结果的 余数
    整数操作只能得到整数，要想得到小数，必须有浮点数参与运算

public class OperatorDemo1 {
    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
自增自减运算符 :
    ++ : 让变量自身的值 + 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 class OperatorDemo2 {
    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、隐式转换

类型转换 - 隐式转换
	介绍: 将取值范围小的数据或变量, 给取值范围大的变量赋值, 可以直接赋值
	        - 简单记: 小的给大的, 可以直接给
	
	取值范围从小到大
	        byte -> short -> int -> long -> float -> double
	
	        问题: float占用4个字节, 为什么放在了long(8个字节)的后面
	        解释: 虽然float占用4个字节, 但是 [取值范围] 要比8个字节的long 更大
	                - 小数的二进制存储形式, 更加节省内存
	                
	运算中的隐式转换
	    取值范围小的数据，和取值范围大的数据进行运算，小的会先提升为大的之后，再进行运算
	    
	    byte、short、char 三种数据在运算的时候，都会提升为int，然后再进行运算

public class TypeConversionDemo1 {
    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
赋值运算符 :
	1. 基本赋值运算符
		= : 将等号右侧的数据, 赋值给左边的变量
			int num = 10;
	
	2. 扩展赋值运算符
	        += : 将符号左右两边的数据, 做加法运算, 再将结果赋值给左边.
	        -= : 将符号左右两边的数据, 做减法运算, 再将结果赋值给左边.
	        *=
	        /=
	        %=

细节补充 :
            扩展赋值运算符, 内部自带强转效果

package com.itheima.operator;

public class OperatorDemo1 {
    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
关系运算符 (比较运算符) :
	>
	>=
	<
	<=
	==
	!=

总结: 让数据之间做比较的符号, 返回true, false

注意事项
	1. 关系运算符的结果都是 boolean 类型，要么是true，要么是false。
	2. 千万不要把 == 误写成 =

package com.itheima.operator;

public class OperatorDemo2 {
    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
&&短路与作用和 & 相同，但是有短路效果
||短路或作用和 | 相同，但是有短路效果
逻辑运算符 :
    1. 用于连接boolean类型的表达式, 或者是值
    2. 整合多个条件, 为一段整体的逻辑

分类:
    &(与) : 并且, 遇false, 则false
            场景: 范围性的判断查找
            举例: 键盘录入一个学生成绩, 判断该成绩是否是90~100之间
            伪代码: 不能运行, 仅供理解
	            int score = 95;
	            if (score >= 90 & score <= 100) {
	            }

    |(或) : 或者, 遇true, 则true
            场景: 多个条件任选其一
            举例: 键盘录入一个学生学号, 学号 3 5 12
	            int id = 3;
	            if (id == 3 | id == 5 | id == 12) {
	            }

    !(非) : 取反
            场景: 对一段逻辑整体做取反操作
            举例: 键盘录入一个学生学号, 学号除了 3 5 12 都要
            	if id = 1;
	            if (  ! (id == 3 | id == 5 | id == 12)  ) {
	            }

    ^(异或) : 相同为false, 不同为true
    
短路逻辑运算符 :
    & : 没有短路效果, 无论左边是true, false, 右边都要继续执行
    && : 具有短路效果, 左边为false, 右边不执行了
            左边为true, 右边要继续执行

    | : 没有短路效果, 无论左边是true, false, 右边都要继续执行
    || : 具有短路效果, 左边为true, 右边不执行了
            左边为false, 右边要继续执行

常用的逻辑运算符:   &&  ||   !

package com.itheima.operator;

public class OperatorDemo4 {
    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、三元运算符

三元运算符 (三目运算符)
	格式:
	        判断条件 ? 值1 : 值2;
	
	执行流程
	        1. 执行判断条件, 看其返回结果是true, false
	        2. true : 值1就是最终结果
	        3. false : 值2就是最终结果

package com.itheima.operator;

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

        int max = num1 > num2 ? num1 : num2;
        System.out.println(max);    // 20
    }
}

8、运算符优先级

在这里插入图片描述

六、分支语句

1、if语句

if语句注意事项
	1, if 语句中，如果大括号控制的是一条语句，大括号可以省略不写
	2, if 语句的 () 和 {} 之间不要写分号

package com.itheima.mif;

import java.util.Scanner;

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

    /*
        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循环

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

执行流程:
    1. 执行初始化语句, 在整个循环过程中, 只执行一次
    2. 执行判断条件, 看其返回结果是true, false
            false : 循环结束
            true : 执行第三步
    3. 执行循环体语句
    4. 执行条件控制语句
    5. 回到2继续...
    
for循环注意事项 :
	1. for循环 {} 中定义的变量, 在每一轮循环结束后, 都会从内存中释放
	2. for循环 () 中定义的变量, 在整个循环结束后, 会从内存中释放
	3. for循环 () 和 {} 之间不要写分号

package com.itheima.loop;

public class ForDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            int num = 10;
            System.out.println("...");
        }
    }
}

2、while循环

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

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

package com.itheima.loop;

public class WhileDemo {
    public static void main(String[] args) {
        int i = 1;
        while(i <= 5){
            System.out.println("黑马程序员");
            i++;
        }
    }
}

3、do…while循环

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

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

package com.itheima.loop;

public class DoWhileDemo {
    public static void main(String[] args) {
        int i = 6;
        do {
            System.out.println("黑马程序员");
            i++;
        }while(i <= 5);
    }
}

4、三种循环的区别

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

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

package com.itheima.loop;

public class LoopDemo2 {
    public static void main(String[] args) {
		for(int i = 1; i <= 5; i++){

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

		System.out.println("------------------");
        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

break : 结束循环, 结束switch语句

注意事项 : 只能在循环, 或者是switch语句中进行使用

package com.itheima.control;

import java.util.Scanner;

public class BreakDemo {
    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

continue : 跳过

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

break, continue的共同注意事项 :
        下面不允许写代码, 因为执行不到, 属于无效的代码.

package com.itheima.control;

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

6.3、结束整个循环

无限循环(死循环)
	1. for(;;){}
	2. while(true){}
	3. do {} while(true);

package com.itheima.control;

import java.util.Scanner;

public class ControlDemo {
    public static void main(String[] args) {
        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、静态初始化

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

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

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

数组的定义格式 :
        1. 数据类型[] 数组名;
        2. 数据类型 数组名[];

        注意 : 这种定义格式, 定义出来的, 只是数组类型的变量而已, 内存中还没有创建出数组容器.

数组的静态初始化格式 :
        1. 完整格式 :
                        数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3...};
        2. 简化格式 :
                        数据类型[] 数组名 = {元素1, 元素2, 元素3...};

打印数组名 :
        [I@776ec8df
	        [ : 当前空间, 是数组类型的
	        I : 当前数组类型, 是int类型
	        @ : 分割符
	        776ec8df : 数组的十六进制内存地址

package com.itheima.array1;

public class ArrayDemo1 {
    public static void main(String[] args) {
        int[] array;
        int array2[];

        // System.out.println(array);
        // System.out.println(array2);
    
        int[] arr1 = {11, 22, 33};
        double[] arr2 = {11.1, 22.2, 33.3};

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

2、元素访问

数组元素访问格式 :
	数组名[索引];
		索引 : 数组容器中空间所对应的编号, 编号从0开始, 逐个+1增长

package com.itheima.array1;

public class ArrayDemo2 {
    public static void main(String[] args) {
        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、数组遍历

数组遍历 : 将数中的每一个(所有)的内容, 取出来进行操作
	数组名.length : 动态获取到数组的长度 (元素的个数)

package com.itheima.test;

public class ArrayTest1 {
    /*
        需求: 对数组中偶数元素做求和操作

        数组遍历的场景 : 如果要完成的需求, 是需要操作到数组中的 [每一个] 元素, 就需要对数组进行遍历操作
     */
    public static void main(String[] args) {
        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、动态初始化

数组的动态初始化 :
	在初始化的时候, 只需要指定数组的长度, 系统就会分配默认值(初始值)
	
	格式: 数据类型[] 数组名 = new 数据类型[长度];
	
	默认值的分类 :
	        整数 : 0
	        小数 : 0.0
	        布尔 : false
	        ---------------------------
	        字符 : '\u0000'       ---> Unicode字符  ---> 常见的体现是空白字符
	        引用数据类型 : null
	
	        引用数据类型 : 数组, 类, 接口
	
	        String : 类

package com.itheima.array1;

public class ArrayDemo3 {
    public static void main(String[] args) {
        String[] arr = new String[3];

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

5、两种初始化区别

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

两种初始化的使用选择 :
    1. 静态初始化: 如果要操作的数据, 需求中已经明确给出了, 直接静态初始化
                    需求: 已知班级学生成绩为 100 100 90 20 100, 找出最高分
                    int[] arr = {100,100,90,20,100};
    2. 动态初始化: 只明确元素个数, 不明确具体数值
                    需求1: 键盘录入5个学生成绩, 找出最高分
                    需求2: 产生10个1~100之间的随机数, 找出最小值

package com.itheima.test;

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

public class ArrayTest3 {
    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、静态初始化与访问

二维数组介绍 : 二维数组是一种容器，该容器用于存储一维数组

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

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

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

二维数组的元素访问格式 :
        数组名[m索引][n索引] :
                m索引 : 指定访问哪一个一维数组
                n索引 : 访问一维数组中的哪一个元素

package com.itheima.array2;

public class ArrayDemo1 {
    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、动态初始化

二维数组动态初始化 :
	格式: 数据类型[][] 数组名 = new 数据类型[m][n];
	       m : 这个二维数组中, 可以存放多少个一维数组
	       n : 每一个一维数组中, 可以存放多少个元素

package com.itheima.array2;

public class ArrayDemo2 {
    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 {
    /*
        需求: 在控制台打印出 1~100 之间满足逢七过规则的数据

        分析:
                1. 通过循环获取到1~100之间的每一个数字
                2. 数值拆分, 拆分出个位和十位
                3. 根据规则加入if判断
                        if(ge == 7 || shi == 7 || i % 7 == 0)
                4. 打印出满足规则的数据
     */
    public static void main(String[] args) {
        // 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;
    }
}
siyu1902
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java （计算机编程语言）
qiaoge66的博客
04-26 6294
走进JAVA Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。 Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等 。 程序举例: main方法，正如注释所
Java基础语法详尽教程
06-14
本文将深入讲解Java的基础语法，包括程序的结构、变量和数据类型、运算符、控制流程、数组和字符串、方法以及异常处理。 1. **Java程序的结构** Java程序由类（Class）构成，每个类包含成员变量（Fields）和方法...
Java
lyzgjy的博客
11-17 350
Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。 Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 。Java可以编写桌面应用程序...
Java基础
最新发布
05-25 460
抽象的，不是真实存在的第一次使用类内容时，通过CLASSPATH类路径找到字节码文件，将字节码文件中的内容加载到虚拟机中的过程，称之为类加载，通常情况下，类加载只会发生一次运行时异常：继承RuntimeException构造：无参构造+有参构造有参构造目的为给父类中声明的详细信息属性赋值非运行时异常：继承Exception内容：构造要求与运行时一致自定义类型必须实现java.io.Serializable接口，意为该类允许被序列化序列化：拆分对象信息的过程。
java
qq_41584674的博客
08-04 187
一个源文件只能有一个public类 一个源文件可以有多个非public类 源文件的名称应该和public类的类名一致， 如果一个类定义在某个包中，那么package语句应该在源文件的首行 如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该放在源文件中最前面 import语句对源文件中定义的所有类都有效，在同一源...
下载-Java基础教程%28语法入门%29.rar_Java语法
09-24
一维、二维及多维数组都是Java支持的。 7. **类与对象**：类是Java面向对象编程的基础，它定义了对象的属性（字段）和行为（方法）。对象是类的实例，通过new关键字创建。 8. **封装**：封装是隐藏对象的属性和...
java校企大一上班学期知识导图
02-15
Java中的数组可以是一维、二维或多维的，允许我们高效地处理批量数据。了解如何声明、初始化和操作数组，以及遍历数组的方法，是编程实践中必不可少的技能。 第三部分是“循环语句”，包括for、while和do-while循环...
java私塾面试题----JAVA基础1.rar
10-11
- 一维、二维数组的创建与操作。 - 数组遍历，数组作为方法参数传递。 7. **面向对象**： - 类与对象的概念，类的构造器。 - 继承（Inheritance）的实现，super关键字的使用。 - 多态（Polymorphism）的理解，...
Java-Homework
03-20
1. **基础语法**：包括变量、数据类型、运算符、流程控制（如if语句、for循环、while循环）、方法定义等。 2. **类与对象**：理解面向对象编程的基本概念，如封装、继承、多态，以及如何创建和使用类和对象。 3. *...
基于java记账管理系统 含源码、数据库、部署教程、论文、答辩ppt一条龙服务.zip
04-27
有部署问题可私信联系 ├── 【一定要读我】(关于java记账管理系统).txt ├── 截图 │   ├── 用户年收入.png │   ├── 用户注册(1).png │   ├── 用户注册.png │   ├── 用户财务月统计.png │   ├── 用户财务记录信息.png │   ├── 管理员用户信息.png │   └── 首页.png ├── 数据库文件 │   └── database.sql ├── 源代码 │   └── jizhang.zip └── 论文等资料 └── 论文等资料 ├── 基于java记账管理系统.ppt └── 基于java记账管理系统毕业论文.doc ├── 截图 │   ├── 用户年收入.png │   ├── 用户注册(1).png │   ├── 用户注册.png │   ├── 用户财务月统计.png │   ├── 用户财务记录信息.png │   ├── 管理员用户信息.png │   └── 首页.png ├── 数据库文
第2章Java编程基础教学课件.pptx
11-16
第2章的Java编程基础教学课件介绍了Java编程的基本语法、常量、变量、流程控制语句、方法以及数组的定义与使用。在这一章节中，学习者将掌握Java代码的基本格式、常量与变量的定义、运算符的使用、流程控制语句、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值