【持续更新】Java入门教程

浏览数: 186

好了现在我们就要开始学习第三门的语言了，同时也是比较难的一门语言——Java。但是前面有我们的C语言和Python语言的一个基础学习的话，到Java这块的话自然而然的也不会太难。一样的本文章也是我的一个学习笔记，教程的来源是黑马程序员

一、Java的基础

1、基本输出

学编程还是得来一个Hello World的输出才算编程语言学习的开始：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

然后的话特别强调一下，我们创建的这个文件名字为：HelloWorld.java 问题来了为什么我们要强调这个东西，是因为文件的名字和代码中的类名称是存在关系的。如果你的类名称和文件名称不一样，代码将无法运行。（建议类名称首字母为小写，若由多个字母组合的，首字母均为大写）

诶那话说又回来了，什么是类啊？就是我们第一行代码：public class 这个作为一个公共类型的类为下面的代码内容起到了关键作用，那其他第二行这么多单词，到底是干什么用的？

而第二行的代码作用主要是整个程序的主办法入口。

然后Java同时也是对大小写比较敏感的，剩下的基础语法应该不需要给大家解释了，都基本差不多了。

2、代码注释

代码注释的话其实不用多讲，在IDEA中我们都直接用 Ctrl+/ 的组合直接快捷注释了。不过还是稍微看一下。

public class HelloWorld {
   /* 这是第一个Java程序
    * 它将输出 Hello World
    * 这是一个多行注释的示例
    */
    public static void main(String[] args){
       // 这是单行注释的示例
       /* 这个也是单行注释的示例 */
       System.out.println("Hello World"); 
    }
}

上面是菜鸟教程给的例子。

3、自变量分类

①自变量

自变量分类的话，之前学过编程的都接触过什么整型啊，浮点型之类的东西。然后这边给大家送上黑马程序员整理的关于Java的自变量分类。

那如何直接输出这些内容呢？请看示例代码：

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello World"); // 字符串
        System.out.println(114514); // 整数
        System.out.println(1.14514); // 小数
        System.out.println(-11); // 负数
        System.out.println(true); // 布尔类型
        System.out.println(null); // 空 输出不了null 可以转换成字符串输出
    }
}

②特殊字符

Ⅰ制表符

制表符的表达方式是什么？是”\t” 他究竟有什么作用？

在打印的时候，把前面字符串的长度补齐到8，或者8的整数倍。最少补1个空格，最多补8个空格

那如何使用呢？看示例代码：

public class Main {
    public static void main(String[] args) {
        System.out.println("name" + '\t' + "ZherKing");
        System.out.println("school" + '\t' + "XXX University");
    }
}

其输出的结果是：

然后给大家上总结：

然后通过 菜鸟教程给大家补充：

符号	字符含义
\n	换行 (0x0a)
\r	回车 (0x0d)
\f	换页符(0x0c)
\b	退格 (0x08)
\0	空字符 (0x0)
\s	空格 (0x20)
\t	制表符
\”	双引号
\’	单引号
\\	反斜杠
\ddd	八进制字符 (ddd)
\uxxxx	16进制Unicode字符 (xxxx)

4、变量

①如何实现

变量的话按照之前的编程语言的学习相比大家都了解了，不过不理解的话我还是随便拿了个图给你们（

接下来看示例代码：

public class Main {
    public static void main(String[] args) {
        int a = 5;
        System.out.println(a);
    }
}

a是一个变量名，作为整形存在，然后的话输出是可以直接调用a直接进行输出的，最终的输出结果是 5

②使用方式

Ⅰ基本计算

看示例代码：

public class Main {
    public static void main(String[] args) {
        int a = 5;
        int b = 5;
        System.out.println(a+b);
    }
}

还有更多的运算符这边作个补充（菜鸟教程）

操作符	描述	例子
+	加法 – 相加运算符两侧的值	A + B 等于 30
–	减法 – 左操作数减去右操作数	A – B 等于 -10
*	乘法 – 相乘操作符两侧的值	A * B等于200
/	除法 – 左操作数除以右操作数	B / A等于2
％	取余 – 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21（区别详见下文）
—	自减: 操作数的值减少1	B– 或 –B 等于 19（区别详见下文）

将运算符代入到实际代码中测试：

public class Test {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     int c = 25;
     int d = 25;
     System.out.println("a + b = " + (a + b) );
     System.out.println("a - b = " + (a - b) );
     System.out.println("a * b = " + (a * b) );
     System.out.println("b / a = " + (b / a) );
     System.out.println("b % a = " + (b % a) );
     System.out.println("c % a = " + (c % a) );
     System.out.println("a++   = " +  (a++) );
     System.out.println("a--   = " +  (a--) );
     // 查看  d++ 与 ++d 的不同
     System.out.println("d++   = " +  (d++) );
     System.out.println("++d   = " +  (++d) );
  }
}

输出结果：

a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++   = 10
a--   = 11
d++   = 25
++d   = 27

Ⅱ修改数据

查看示例代码：

public class Main {
    public static void main(String[] args) {
        int b = 5;
        System.out.println(b);
        b = 10;
        System.out.println(b);
    }
}

示例代码中 b 的数值从5改成了10。然后总结！

然后再来一些注意事项：

5、基本数据类型

①介绍

那如何进行使用这些数据类型呢？

public class Main {
    public static void main(String[] args) {
        byte a = 1;
        System.out.println(a);
        short b = 1;
        System.out.println(b);
        int c = 1;
        System.out.println(c);
        long d = 1;
        System.out.println(d);
        float e = 1;
        System.out.println(e);
        double f = 1;
        System.out.println(f);
        boolean g = true;
        System.out.println(g);
        char h = 'A';
        System.out.println(h);
    }
}

输出的结果：

1
1
1
1
1.0
1.0
true
A

上总结：

②练习题

示例代码：

public class Main {
    public static void main(String[] args) {
        String name = "真境";
        int age = 18;
        char gender = 'M';
        double height = 180.1;
        boolean flag = true;
        System.out.println(name);
        System.out.println(age);
        System.out.println(gender);
        System.out.println(height);
        System.out.println(flag);
    }
}

6、标识符

什么叫做标识符？标识符就是给类，方法，变量等取名字。

这些就是标识符的规范要求。

7、键盘录入（Scanner类的使用）

①基本的键盘录入

键盘录入的话根据我们之前学的编程的话，大家都知道比如说C语言的 scanf 和 Python 的 input 的语法。其作用就是代码程序通过用户输入的内容对某个变量进行复制。

然后的话给大家来一个示例代码：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int i = sc.nextInt();
        System.out.println(i);
    }
}

同时的话创建对象的同时是可以进行输入多个变量的：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个整数");
        int i = sc.nextInt();
        int j = sc.nextInt();
        System.out.println(i+j);
    }
}

②NextLine和Next的区别

首先的话这两个都是属于 Scanner 类里面的内容的。

Ⅰnext():

1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next() 不能得到带有空格的字符串。

ⅡnextLine()：

1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。

主要的区别都在上面，其实最根本的用途就是通过哪一种方式来获取用户的输入。那具体的使用方法就是：

import java.util.Scanner;

public class scanner {
    public static void main(String[] args) {
    // next 和 nextLine 的基本用法
        Scanner sc1 = new Scanner(System.in);
        String a = sc1.next();
        String b = sc1.nextLine();
        System.out.println(a+b);
    }
}

不过的话使用 next 和 nextLine 这两个语法的话可能需要使用字符串才可以（IDE给的建议）

③hasNext语句

hasNext语法的话我个人认为可以说判断是否有输入东西，或者是说输入的东西是否是恰当的数据类型，比如说看以下语句：

import java.util.Scanner;

public class scanner {
    public static void main(String[] args) {
        Scanner sc2 = new Scanner(System.in);
        if (sc2.hasNext()){
            String c = sc2.next();
            System.out.println(c);
        }else{
            System.out.println("你好像什么都没输入啊？");
        }
        sc2.close();
        Scanner sc3 = new Scanner(System.in);
        if (sc3.hasNextLine()){
            String c = sc3.nextLine();
            System.out.println(c);
        }else{
            System.out.println("你好像什么都没输入啊？");
        }
        sc3.close();
    }
}

代码为了展示将 next 和 nextLine 整合在了一块，实际上这两个会冲突（你运行试试看？）然后的话判断的方式差别也是和前面的内容是一样的。那如何通过 hasNext 语句来判断是否是整形或者其他数据类型的输入呢？

通过 IDE 的联想的话可以看见 hasNext 语句的分支是非常多的，那随便拿个来作为例子：

import java.util.Scanner;

public class scanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        if (scanner.hasNextInt()){
            int n = scanner.nextInt();
            System.out.println(n);
        }else{
            System.out.println("你输入的好像不是整型啊？");
        }
    }
}

8、隐式转换和强制转换

①隐式转换

什么叫做隐式转换，其实说不用说是背这么一个专业词，看示例代码：

public class ImplicitConversion {
    public static void main(String[] args) {
        int a = 5;
        double b = 3.14;
        System.out.println(a + b);
    }
}

a是整型，b是双浮点型。那这两个加起来的结果是什么型？答案是双浮点型。因为他这样进行了一给隐式转换。

然后来几个练习题：

②强制转换

强制转换这个东西的话其实也很好理解，就是本来指定好的数据类型，直接强制转换成了指定的数据类型。

这个先不着急了解，后面的教程会继续说明。

9、算数运算符（补充）

①+运算符

②练习-数值拆分

题目：

示例代码：

import java.util.Scanner;
public class NumberBreaker {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入三位数字");
        int num = sc.nextInt();
        int ge = num % 10;
        int shi = num / 10 % 10;
        int bai = num / 100 % 10;
        System.out.println("个位数是" + ge);
        System.out.println("十位数是" + shi);
        System.out.println("百位数是" + bai);
    }
}

然后给大家来一个小结：

③运算符的补充（简便版）

当然的话这样子也可以更便捷的进行运算：

④运算符

⑤逻辑运算符+短路逻辑运算符

⑥三元运算符

三元运算符这个东西其实很好理解，看示例代码：

public class ThreeYuan {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        int c = a > b ? a:b;
        System.out.println(c);
    }
}

其中代码部分：int c = a > b ? a:b; 就是我们所说的三元运算符。当a > b 符合这个条件的时候，c就会被复制给：前面的数值，也就是 a。如果不符合 a > b 这个条件的话，就给c赋值上：后面的数值，也就是b。

这么说的话三元运算符其实也很好理解的了。

⑦运算符优先级

二、Java进阶

从这个教程开始的话就是Java的一个进阶了，不过其实不会太难。不要紧张。

1、if语句

if 语句作为一个条件语句，也可以算是一种分支结构

①if语句

首先的话 if 语句是一种条件语句，当条件判断合适的时候就会执行命令。如以下代码：

import java.util.Scanner;
public class ifline {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        sc.close();
        if (a>5){
            System.out.println("这个数字大于5");
        }
    }
}

前面的话就是通过用户输入的数字，后面的if语句就是进行判断这个数字是否大于5。如果大于5的话就是true，就会输出 “这个数字大于5” 这个提示。没错 if 语句同时也可以判断布尔的数据类型，当结果为 true的时候就会直接执行内容：

import java.util.Scanner;
public class ifline {
    public static void main(String[] args) {
        boolean isLight = true;
        if (isLight) System.out.println("灯亮了");
    }
}

顺带一提，如果当代码只有一行的时候 {} 是可以省略的。但是的话我建议都要带个 {}。以免后期写代码混淆。

②if-else语句

既然前面有大于5数值进行判断，那肯定有不符合条件判断的。示例代码：

import java.util.Scanner;
public class IfAndelse {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.close();
        if (n > 5) System.out.println("所输入的数值大于5");
        else System.out.println("所输入的数值并不大于5");
    }
}

那就是一个 if else 的一个语句，大家记得个语法就可以了。

③else if 语句

那如果有多重条件呢？那就看示例代码：

import java.util.Scanner;
public class ElseIf {
    public static void main(String[] args) {
        System.out.println("请输入你的成绩：");
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.close();
        if (n >= 90) System.out.println("你的成绩为优秀！");
        else if (n >= 80 && n < 90) System.out.println("你的成绩为一般！");
        else if (n < 80 && n >= 60) System.out.println("你的成绩有点落后了，请加油");
        else if (n < 60) System.out.println("你的成绩为不合格！");
        else System.out.println("你输入的数值无法判断");
    }
}

这是一个成绩判断的一个小代码，代码可以通过你输入的成绩来判定评分等级，大概看一看！也是比较好理解的一个语句。

2、switch语句

switch 语句也是 分支语句 的一种语法。和 if 语句有点相似，请看他的流程图（菜鸟教程）：

switch case 语句有如下规则：

1、switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。

2、switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。

3、case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。

4、当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。

5、当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。

6、switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。

那我们先看示例代码：

import java.util.Scanner;
public class SwitchWithCase {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char n = sc.next().charAt(0);
        switch (n) {
            case 'a':
                System.out.println("A");
                break;
            case 'b':
                System.out.println("B");
                break;
            case 'c':
                System.out.println("C");
                break;
            default:
                System.out.println("无法识别");
                break;
        }
    }
}

条件语句中还是在判断用户输入的字符，如果是 a 则输出 A 后直接 break; 跳出 switch 语句，如果没有 break 的话就会继续执行下面的代码块输入 B C 等内容 直到出现 break 或者语句结束为止。

default 的作用就是用作于不符合 case 的内容的一个默认输入内容，当你输入的内容非 a b c 的话就是输出default的内容。

3、循环语句

①while循环

while循环是一种最基本一个循环，其结构为：

while( 布尔表达式 ) {
  //循环内容
}

如果布尔表达式的值为 true 循环内容就会一直循环下去，直到布尔值为 false 才会终止。看示例代码：

public class WhileAndDoWhile {
    public static void main(String[] args) {
        int n = 10;
        while (n > 5){
            System.out.println("循环剩下" + (n - 5) + "次");
            n--;
        }
    }
}

如果你需要无限循环的话就是：

while (true) {}

这个代码就举了个例子就是循环的次数，当 n > 5 的时候布尔值就是true嘛然后就会开始执行 {} 里面的代码块，在输出内容的同时 n 也自减了 1 。最后不符合 n > 5 的条件，就结束的运行。

②do…while 循环

do while 循环和 while 循环不一样的地方就是，do while 循环就是先执行内容，在根据条件判断继续循环。总的来说就是先做在判断，while就是先判断再做。然后看示例代码：

public class WhileAndDoWhile {
    public static void main(String[] args) {
        int n = 10;
        do {
            System.out.println("循环剩下" + (n - 5) + "次");
            n--;
        } while (n > 5);
    }
}

就是先指定 do 的代码块的内容，然后再看 while 这边符合条件才继续 do。语法就是：

do {
       //代码语句
}while(布尔表达式);

③for循环

for循环这些东西其实和C语言非常相似，代码语法就是：

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

示例代码：

public class ForAndBreakContinue {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println("已经进行循环了" + i + "次");
        }
    }
}

输出的结果为：

已经进行循环了0次
已经进行循环了1次
已经进行循环了2次
已经进行循环了3次
已经进行循环了4次
已经进行循环了5次
已经进行循环了6次
已经进行循环了7次
已经进行循环了8次
已经进行循环了9次

示例代码中呢 for 循环第一个语句就是 设定为 i 为 0，第二个语句就是一个布尔表达式，如果 i 小于 10 的话 布尔值就是true，那他就会继续执行语句块，当每执行完一个代码块的话，就会进行 i++（自增）。因此他的顺序是：

当然这是基于符合条件，如果不符合呢？：

是的就是直接跳过了代码块。那其实这个也是很好理解的是吧！

④break和continue

Ⅰbreak语句

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。break 跳出最里层的循环，并且继续执行该循环下面的语句。其语法就是：

break;

那如果代入示例代码呢：

public class ForAndBreakContinue {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println("已经进行循环了" + i + "次");
            break;
        }
    }
}

输出的结果为：

已经进行循环了0次

是的当他第一次执行完这个代码块完后读取到了 break 这个循环直接结束了，就开始执行后面的内容了。所以你可以直接理解成 终止循环。

Ⅱcontinue

continue 这个东西其实也很好理解，continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。在 for 循环中，continue 语句使程序立即跳转到更新语句。在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

那就直接看示例代码：

public class ForAndBreakContinue {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if ( i == 5 ) continue;
            System.out.println("已经进行循环了" + i + "次");

        }
    }
}

输出内容：

已经进行循环了0次
已经进行循环了1次
已经进行循环了2次
已经进行循环了3次
已经进行循环了4次
已经进行循环了6次
已经进行循环了7次
已经进行循环了8次
已经进行循环了9次

没错如果当 i 等于 5的时候，直接执行 continue。那么这个第六次（循环从0开始因此这是第六次循环）的循环就直接跳过了，所以你会发现输出内容中少了个 ”已经进行循环了5次“ 这个内容。这就是continue的用法。

⑤小练习题

直接放答案：

public class FengServerPass {
    public static void main(String[] args) {
        for (int i = 1; i <= 100 ; i++) {
            if (i% 10 == 7 || i % 7 == 0 || i / 10 % 10 == 7) {
                System.out.println("过！");
                continue;
            }
            System.out.println(i);
        }
    }
}

4、数组

什么是数组？他是一种数据结构之一

①数组的定义

其实的话你会法西安数组定义的方式2 和C语言对数组定义的语法是一模一样的。然后的话初始化其实有两种方式，一个简写一个比较复杂，这个就是完整的格式：

简化格式：

示例代码如下：

public class ArrayDefine {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};
        int[] arr2 = {1,2,3,4,5};
    }
}

相较于第一个完整版，简化版看着更容易记下来，同时的话数组也可以同时存储多个数据类型：

public class ArrayDefine {
    public static void main(String[] args) {
        String[] name = {"LiMing","ZhangSan"};
        double[] height = {1.78,1.80};
    }
}

②数组的输出

我们数组存储了大量的数据，那我们现在如何把数组内的数组输出出来呢？如果说是直接输出数组名呢？

那如何正确的输出我需要的数组的内容呢？请看示例代码：

public class ArrayDefine {
    public static void main(String[] args) {
        int[] arr2 = {1,2,3,4,5};
        int number = arr2[0];
        System.out.println(number);
    }
}

最终的输出结果为：

其中呢我们调用了 arr2[0] 这是数组的第一个值（数组的顺序都是从0开始的）然后赋值在 number 然后输出，那这样的话就可以正确的输出我们想要输出的内容了。

其格式就是：

数组名[索引]

③数组的遍历

诶数组的遍历是什么？

那如果我们想要一口气输出数组内的每个数据呢？请看示例代码：

public class ArrayDefine {
    public static void main(String[] args) {
        int[] arr2 = {1,2,3,4,5};
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
    }
}

我们用的是for 循环，通过循环将数组的每一个数据，按照顺序输出。也就是索引从0到尾巴的一个过程，其中呢 arr2.length 就是代表数组的长度，和隔壁C语言的 sizeof 是一个意思。

④练习

Ⅰ遍历数组求和

参考答案：

public class ArrayDefine {
    public static void main(String[] args) {
        int[] arr2 = {1,2,3,4,5};
        int sum = 0;
        for (int i = 0; i < arr2.length; i++) {
            sum+=arr2[i];
        }
        System.out.println(sum);
    }
}

Ⅱ统计个数

参考答案：

public class ArrayDefine {
    public static void main(String[] args) {
        int[] arr2 = {1,2,3,4,5,6,7,8,9,10};
        int sum = 0;
        for (int i = 0; i < arr2.length; i++) {
            if (arr2[i] % 3 == 0) {
                sum++;
            }
        }
        System.out.println(sum);
    }
}

Ⅲ变化数据

参考答案：

public class ArrayDefine {
    public static void main(String[] args) {
        int[] arr2 = {1,2,3,4,5,6,7,8,9,10};
        int sum = 0;
        for (int i = 0; i < arr2.length; i++) {
            if (arr2[i] % 2 == 0) arr2[i] /= 2;
            else arr2[i] *= 2;
        }
        for (int i = 0; i < arr2.length; i++) System.out.print(arr2[i] + "\n");
    }
}

⑤数组动态初始化

那这个数组有什么作用呢？我们可以指定这个数组的长度。看示例代码：

public class ArrayDefine {
    public static void main(String[] args) {
        String[] arr3 = new String[50];
        arr3[0] = "ZhangSan";
        System.out.println(arr3[0]);
    }
}

这样的话我们就定义了 arr3 这个数组能存储 50 个数据，同时我们也可以调用数据来进行输出，那如果我现在没有定义 arr3[1] 的内容，会输出什么呢？答案是：null，他会输出他的默认初始值。

那静态和动态有什么区别呢？

补充个注意事项：

⑥练习 – 动态化

Ⅰ求最值

参考答案：

public class FIndTheMax {
    public static void main(String[] args) {
        int[] arr = {33,5,22,44,55};
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        System.out.println(max);
    }
}

Ⅱ遍历数组求和

参考答案：

import java.util.Random;

public class RadomNumber {
    public static void main(String[] args) {
        int[] arr = new int[10];
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) arr[i] = r.nextInt(100) + 1;
        int sum = 0;
        for (int i = 0; i < arr.length; i++) sum += arr[i];
        int average = sum / arr.length;
        int geshu = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < average) geshu++;
        }
        System.out.println("总和为：" + sum);
        System.out.println("平均数为：" + average);
        System.out.println("小于平均数的个数有：" + geshu + "个");
    }
}

Ⅲ交换数组中的数据

参考答案：

public class ExchangeArrData {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for (int i = 0,j = arr.length - 1; i < j; i++,j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        for (int i = 0; i < arr.length; i++) System.out.print(arr[i] + " ");
    }
}

Ⅳ打乱数据

参考答案：

import java.util.Random;

public class DisturbArrData {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        Random rand = new Random();
        for (int i = 0; i < arr.length; i++) {
            int index = rand.nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

5、Java的内存分配

6、方法

①介绍

什么叫做方法？

方法有什么作用呢？

比如说，我现在想打一把游戏，如果按照输出语句来游玩，就是图片上的过程，那如果我要打两把呢？难道我需要把所有内容再多打一遍吗？那这样的话是不是有点麻烦了？因此的话我们可以将这些代码直接打包下来，如图：

直接通过调用的方法调用两把游戏，是不是很熟悉，C语言的函数？Python的 def 方法？那有什么好处呢？

②定义和调用

那么了解方法之后，我们将了解如何进行定义和调用咯，那我们要如何定义他呢？首先的话我们要知道方法定义是：将所有的代码打包成一块，这个过程叫做方法。

那方法调用呢？方法调用就是：方法定义后并井不是直接运行的，需要手动调用才能执行，该过程称为方法调用。

好那么我们就向大家展示如何定义的：

然后的话我们将分成三个方法给大家讲解如何进行定义这个方法的：

Ⅰ最简单的

那就直接看这个代码：

public class ClassDefine {
    public static void Test(){
        System.out.println("Hello World");
    }
    public static void main(String[] args) {
        Test();
    }
}

然后我们将进一步的进行讲解这个代码内容，如下代码就是这个方法定义的框架：

public static void 方法名(){
        // 代码块
    }

那如何将这个方法调用呢？：

方法名();

然后给大家来一个注意事项：

这是一个看代码说结果的测试，其实很简单，只要从上往下读代码就可以了，不需要考虑太多的，输出的顺序我也画在图片上了，大家可以看看了解一下。

Ⅱ带参数的

为什么需要一个带参数的方法呢？你想想如果我自己写了一个计算的方法，但是他的值只能在方法中定义并不能收到主方法的定义，因此的话我们需要一个带参数的方法来接受主方法传入来的参数。

那么给大家来一个例子吧：

public class ClassDefine {
    public static void Test(int number){
        number++;
        System.out.println(number);
    }
    public static void main(String[] args) {
        Test(1);
    }
}

那么我给大家介绍一下这些代码：

public static void Test(参数类型 参数变量){
// 代码块
    }

那引用呢？

Test(参数值);

那你如果想要有多个值呢？用逗号分开：

public static void Test(int a, int b){
// 代码块
    }
Test(1, 2);

带参数和不带参数的区别：

Ⅲ带返回值的

带返回值啥意思啊？你想想哈我都对值进行传入参数了，那你还考虑什么，那肯定方法要吐出来一个数值是吧？那直接举个例子：

public class ClassDefine {
    public static int Test(int number){
        number++;
        return number;
    }
    public static void main(String[] args) {
        int a = Test(1);
        System.out.println(a);
    }
}

那么很明显的我们方法返回数值的时候用的是 return xxx; 在主方法中可以看出我们将返回值赋值给了 a 这个变量。这是一个流程：

上总结：

Ⅳ小总结

③方法的重载

Ⅰ介绍

什么是重载，为什么会有重载：

你可以想象，你在给方法进行命名的时候，会有一种情况，就是词穷了，我不知道要取什么名字，拼音大法又有点难堪，那么重载的作用就来了。他可以将所有的方法同一个命名。

那到底怎么实践呢？请看下列例子：

当我进行调用的时候，比如说 sum(1,2); 那我到底会用第一个方法还是第二个方法呢？其实很简单，答案是：第一个 为什么呢？因为第一个只需要两个参数，Java虚拟机会判断出来的。

这些是判断是否构成重载，要是参数个数一样的话可以判断数据类型的

Ⅱ练习

. 数组遍历

参考答案：

public class PrintArr {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]);
            }else System.out.print(arr[i] + ", ");
        }
        System.out.print("]");
    }
}

.. 数组最大值

参考答案：

public class AccordingClassToPrintTheArrMaxNumber {
    public static int PrintMax(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 void main(String[] args) {
        int[] arr = {1,4,2,3,6,1,4,8,0,10};
        int max = PrintMax(arr);
        System.out.println(max);
    }
}

… 判断是否存在

参考答案：

import java.util.Scanner;

public class FindItRealHave {
    public static boolean Find(int[] arr,int number){
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number){
                return true;
            }
        }
        return false;
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9};
        Scanner sc = new Scanner(System.in);
        int number = sc.nextInt();
        System.out.println(Find(arr,number));
    }
}

…. 复制数组

参考答案：

import java.util.Scanner;
public class CopyTheRangeOfTheArr {
    public static int[] CopyOfRange(int[] arr,int from,int to){
        int[] copyArr = new int[to - from];
        int index = 0;
        for(int i=from;i<to;i++){
            copyArr[index] = arr[i];
            index++;
        }
        return copyArr;
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        Scanner sc = new Scanner(System.in);
        int from = sc.nextInt();
        int to = sc.nextInt();
        int[] newarr = CopyOfRange(arr,from,to);
        for(int i=0;i < newarr.length ;i++) System.out.println(newarr[i]);
    }
}

④方法的内存

不是很想说什么= = 直接略过。

⑤方法值的传递

看上面的代码的话，其实 number 的数值是无法修改的，因为方法内修改的数值只有方法内有效，所以，传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值。

要修改的话还是得通过 return 来进行修改：

7、综合练习题

黑马程序员的题目，随缘做（不一定全部做完答案不是百分百是黑马程序员的，我自己写的（

①买飞机票

参考答案：

import java.util.Scanner;

public class BuyThePlaneTicket {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入飞机原价：");
        double Price = sc.nextInt();
        System.out.print("请输入购票月份：");
        int Month = sc.nextInt();
        System.out.println("请选择座位类型：");
        System.out.println("1. 头等舱");
        System.out.println("2. 经济舱");
        System.out.print("请输入对应数字(1、2)：");
        int Choice = sc.nextInt();
        if (Month >= 5 && Month <= 10) {
            switch (Choice) {
                case 1:
                    Price*=0.9;
                    break;
                case 2:
                    Price*=0.85;
                    break;
            }
        }else{
            switch (Choice) {
                case 1:
                    Price*=0.7;
                    break;
                case 2:
                    Price*=0.65;
                    break;
            }
        }
        System.out.println("飞机的价格为："+Price);
    }
}

②找质数

参考答案：

public class FindTheSuShu {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 101; i <= 200; i++) {
            boolean flag = true;
            for (int j = 2 ; j < i ; j++){
                if (i % j == 0){
                    flag = false;
                    break;
                }
            }
            if (flag){
                System.out.println(i + "是素数");
                sum++;
            }
        }
        System.out.println("素数一共有："+sum);
    }
}

③开发验证码

参考答案：

import java.util.Random;

public class TheRandomVerisity {
    public static void main(String[] args) {
        char[] chs = new char[52];
        for (int i = 0; i < chs.length; i++) {
            if (i <= 25) chs[i] = (char)(97 + i);
            else chs[i] = (char)(65 + i);
        }
        String result = "";
        Random rand = new Random();
        for (int i = 0 ; i < 4 ; i++){
            int randomIndex = rand.nextInt(chs.length);
            System.out.print(chs[randomIndex]);
        }
        int number = rand.nextInt(10);
        result += number;
        System.out.println(result);
    }

}

④数组元素的复制

参考答案：

public class CopyTheArr {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int[] arr2 = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr2[i] = arr[i];
        }
        for (int i = 0; i < arr2.length; i++) System.out.println(arr2[i]);
    }
}

⑤抢红包

参考答案：

import java.util.Random;
public class StoleTheRedPackage {
    public static void main(String[] args) {
        int[] arr = {288,388,588,1088};
        int[] newArr = new int[arr.length];
        Random r = new Random();
        for (int i = 0; i < 4; ) {
            int RandomIndex = r.nextInt(arr.length);
            int prize = arr[RandomIndex];
            boolean flag = contains(newArr, prize);
            if (!flag){
                newArr[i] = prize;
                i++;
            }
        }
        for (int i = 0; i < newArr.length; i++) System.out.println(newArr[i]);
    }
    public static boolean contains(int[] arr, int value) {
        for (int num : arr) {
            if (num == value) {
                return true;
            }
        }
        return false;
    }
}

⑥二维数组

二维数据这种东西其实很简单，你可以想象成一个表格，比如说一维数组是这样的：

二维数组就是这样的：

很好理解的，我就懒得写了，直接来一个黑马程序员的代码吧！

7、面向对象

①介绍

那怎么理解上面的面向对象呢？比如说

我现在要进行一个输出，我要找什么？能干活的东西，那就是System.out.print 嘛他能干活，这样就是面向对象，诶很好理解是吧，这有什么好处勒？

符合人类思维习惯，编程更简单，更好理解。

②类和对象

以一把手机为例子，他的类你可以分成几种，比如说手机型号、手机厂商什么的，那他的行为呢？可以接电话、打游戏，那就可以开始看一个示例代码了：

package com.mclzyun.blog;

public class PhoneClassTest {
    String Phone;
    String Name;
    String Price;
    public void Call(){
        System.out.println("电话");
    }
    public void Game(){
        System.out.println("游戏");
    }
}

你甚至可以理解成 Python 里面的包，确实这个东西的话分成了多个文件。但是的话在创建文件的时候需要注意一个问题，这个文件是要怎么个创建法，以IDE 为例子：

就是创建一个软件包，然后东西该丢进去都丢进去的那种。那如何创建这把手机的对象呢？：

package com.mclzyun.blog;

public class MxClass {
    public static void main(String[] args) {
        PhoneClassTest p = new PhoneClassTest();
    }
}

既然我成功调用他了是吧，那我肯定要进行输出数据以及修改对吧？那看下面的例子（带解释）：

package com.mclzyun.blog;

public class MxClass {
    public static void main(String[] args) {
        PhoneClassTest p = new PhoneClassTest();
        // 修改数据
        p.Name = "超级厉害的手机";
        // 输出数据
        System.out.println(p.Name);
        // 调用行为
        p.Call();
    }
}

当然我也可以基于这个创建第二个手机：

PhoneClassTest p2 = new PhoneClassTest();

同上一样的使用方式，就是这样。

③封装

封装到底是什么？对象代表什么，就得封装对应的数据，并提供数据对应的行为

那封装到底有什么好处？

良好的封装能够减少耦合。
隐藏信息，实现细节。
类内部的结构可以自由修改。
可以对成员变量进行更精确的控制。

其实说你可以和Python中的 Global 型一起联系起来，相比Python来说的话，Python需要额外的声明 Global 而 Java 需要额外声明谁是隐藏量。来个示例代码：

public class Person {
    private String name;
    private int age;
}

如示例代码的话，我们将 name 和 age 两个属性都转为私有化，这样的话name 和 age 两个属性的话只能本类访问

所以说我们在主办法中无法进行调用和修改数据

对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

public class Person{
    private String name;
    private int age;

    public int getAge(){
      return age;
    }

    public String getName(){
      return name;
    }

    public void setAge(int age){
      this.age = age;
    }

    public void setName(String name){
      this.name = name;
    }
}

不过封装的话其实没什么，你可以理解成数据加密的作用，下列的代码也能起到不错的作用：

④就近原则和This关键字

从上面的 setAge代码可以知道，原本已经私有化的 age 变量通过转换（变量a赋值）成功的输出了出去，那如果我不用变量a呢？直接改成 age = age 呢？其结果为 null。在了解之前我们需要去了解下什么是局部变量什么是成员变量？

这是成员变量和局部变量的区别

局部变量就是 method 里面的 age 变量，成员变量就是 method 外的 age。那进行下列的输出打印的话到底用谁？那就考虑到了我们说的 就近原则，想都不用想就是用局部变量

那如何用成员变量中的age呢？这时候我们就可以用 This 关键字了。

既然都知道 This 关键字了，那你可以这么修改成员变量

我们前面所说的 age = age 的结果是 null 也可以用 this 关键字了。

那来个总结吧！

⑤构造方法

构造方法这东西，我觉得和方法很像，就是有几个不一样的地方：

然后看示例代码（不带参数的）：

public class CreatingMethod {
    public CreatingMethod(){
        System.out.println("Creating method");
    }
}

带参代码：

public class CreatingMethod {
    public CreatingMethod(String name,int age){
        System.out.println("Creating method");
    }
}

同样也是可以用 this 关键字的，然后看看注意事项：

Java 支持构造方法的重载，即可以在同一个类中定义多个构造方法，只要参数列表不同即可。例如：

public class Person {
    String name;
    int age;

    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }

    public Person(String name) {
        this.name = name;
        this.age = 0;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

创建对象时，Java 会根据传入的参数数量和类型自动选择匹配的构造方法：

Person p1 = new Person(); // 调用无参构造方法
Person p2 = new Person("Alice"); // 调用单参数构造方法
Person p3 = new Person("Bob", 30); // 调用双参数构造方法

上总结：

⑥练习题

Ⅰ对象数组1

参考答案：

mian文件：

package Shop;

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

        good g1 = new good("001",5,"Apple",2);
        good g2 = new good("002",4,"Banana",1);
        good g3 = new good("003",3,"Orange",1);
        arr[0] = g1;
        arr[1] = g2;
        arr[2] = g3;
        for (int i = 0; i < arr.length; i++) {
            good good = arr[i];
            System.out.println(good.getCount() + good.getName() + good.getId() + good.getPrice());
        }

    }
}

good 文件：

package Shop;

public class good {
    private String id;
    private String name;
    private int price;
    private int count;
    public good(){
    }

    public good(String id, int count, String name, int price) {
        this.id = id;
        this.count = count;
        this.name = name;
        this.price = price;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}

Ⅱ对象数组2

参考答案：

Phone：

package DuiXiang3;

public class Phone {
    private String brand;
    private int price;
    private String color;
    public Phone(String brand, int price, String color) {
        this.brand = brand;
        this.price = price;
        this.color = color;
    }
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

主函数：

package DuiXiang3;

public class PhoneTest {
    public static void main(String[] args) {
        Phone[] arr = new Phone[3];
        Phone p1 = new Phone("小米",1999,"White");
        Phone p2 = new Phone("Apple",8999,"Black");
        Phone p3 = new Phone("华为",7999,"Yellow");
        int averagePrice = (p1.getPrice() + p2.getPrice() + p3.getPrice()) / arr.length;
        System.out.println(averagePrice);
    }
}

8、字符串

①API

什么叫做API：

挺好理解的，直接调用别人写完的代码，你只需要知道如何使用即可。你要说常见的 API 的话，Scanner这些都算，当然还有很多很多的API：

当然你也不是一个一个就能记录进去的。所以当你不知道怎么写怎么使用的时候就可以直接看文档了：

所以大概总结一下：

②String（字符串）

Ⅰ引入

那么应用场景呢？：

比如说B站在登录的时候，需要用正确的用户名和用户输入的用户名进行字符串的比较。还有字符串的转换功能：

主要的学习内容：

Ⅱ概述

然后总结：

Ⅲ创建String对象

创建 String 对象有两种方式：

示例代码：

public class StringTEST {
    public static void main(String[] args) {
//        直接创建对象
        String s1 = "真境的博客";
        System.out.println(s1);
//        用new 的方式来 实际上是空参
        String s2 = new String();
        System.out.println("123" + s2);
//        不一定是空参 也可以传递对象
        String s3 = new String("123");
        System.out.println(s3);
//        非空参
        char[] chs = {'a', 'b', 'c'};
        String s4 = new String(chs);
        System.out.println(s4);
    }
}

数组的形式也可以：

内存分析就不写了。

Ⅳ字符串的比较

如果要说字符串比较的话简单的形式就是：

那如果我换成这个形式的话要如何进行字符串的比较呢？：

那我们要先知道 == 到底比较的是什么？：

那到底还有什么方法来比较字符串呢？：

直接看示例代码：

public class StringCompare {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";
        // 直接比较
        boolean result = str1.equals(str2);
        System.out.println(result);
        // 忽视大小写
        boolean result2= str1.equalsIgnoreCase(str2);
        System.out.println(result2);
    }
}

Ⅴ字符串长度

如何看字符串的长度，直接看菜鸟教程的例子：

public class StringDemo {
    public static void main(String args[]) {
        String site = "www.runoob.com";
        int len = site.length();
        System.out.println( "菜鸟教程网址长度 : " + len );
   }
}

输出的结果：

菜鸟教程网址长度 : 14

Ⅵ连接字符串

String 类提供了连接两个字符串的方法：

string1.concat(string2);

返回 string2 连接 string1 的新字符串。也可以对字符串常量使用 concat() 方法，如：

"我的名字是 ".concat("Runoob");

更常用的是使用’+’操作符来连接字符串，如：

"Hello," + " runoob" + "!"

结果如下:

"Hello, runoob!"

下面是一个例子:

public class StringDemo {
    public static void main(String args[]) {     
        String string1 = "菜鸟教程网址：";     
        System.out.println("1、" + string1 + "www.runoob.com");  
    }
}

以上实例编译运行结果如下：

1、菜鸟教程网址：www.runoob.com

③练习题

Ⅰ用户登录

参考答案：

import java.util.Scanner;

public class UserLogin {
    public static void main(String[] args) {
        String currentUser = "admin";
        String currentPassword = "123456";
        for (int i = 3; i > 0;) {
            Scanner scanner = new Scanner(System.in);
            System.out.println();
            System.out.println("请输入用户名");
            String user = scanner.nextLine();
            System.out.println("请输入密码：");
            String password = scanner.nextLine();
            if (currentUser.equals(user) && password.equals(currentPassword)){
                System.out.println("登录信息正确！已为您登录！");
            }else{
                i--;
                System.out.println("信息错误！你剩下" + i + "次机会");
                continue;
            }
        }
        System.out.println("三次输入错误！你的账户已冻结！");
    }
}

Ⅱ金额转换

参考答案：

import java.util.Scanner;

public class MoneyTurnToCN {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int money;
        while (true){
            System.out.println("请输入金额：");
            money = sc.nextInt();
            if (money <= 9999999 && money >= 0){
                break;
            }else{
                System.out.println("金额无效");
            }
        }
        String moneyStr = "";
        while (true){
            int ge = money % 10;
            String capitalNumber = getCapitalNumber(ge);
            moneyStr = moneyStr + capitalNumber;
            money = money / 10;
            if (money == 0){
                break;
            }
        }
        int count = 7 - moneyStr.length();
        for (int i = 0; i < count; i++){
            moneyStr = "零" + moneyStr;
        }
        System.out.println(moneyStr);
        String[] arr = {"佰","拾","万","仟","佰","拾","元"};
        String result = "";
        for (int i = 0; i < moneyStr.length(); i++){
            char c = moneyStr.charAt(i);
            result  = result + c + arr[i];
        }
        System.out.println(result);
    }
    public static String getCapitalNumber(int number){
        String[] arr = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
        return arr[number];
    }
}

④StringBuilder

Ⅰ学习

StringBuilder是啥？为什么要学他？：

这样的话你会发现运行速度非常的慢，那有什么高效的方法吗？有的肯定有的那就是StringBuilder：

常用方法：

示例代码：

public class StringBuilderDemo {
    public static void main(String[] args) {
// 创建对象
        StringBuilder s1 = new StringBuilder();
// 对象中添加内容 可以无限添加
        s1.append("Hello");
// 以拼接的形式输出。
        System.out.println(s1);
    }
}

你也可以对这些字符进行反转：

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder s1 = new StringBuilder();
        s1.append("Hello");
        s1.reverse();
        System.out.println(s1);
    }
}

输出的结果：

olleH

也可以输出长度：

sb.length();

还可以把他变成普通的字符串并赋值在 str 上：

String str = s1.toString();

然后给大家介绍一个链式编程：

import java.util.Scanner;

public class StringBuilderDemo {
    public static void main(String[] args) {
        int len = getString().substring(0, 10).replace("A","Q").length();
    }
    public static String getString(){
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        return str;
    }
}

int len 后面的部分都是从左往右的顺序进行运行程序，先传入参数到函数中，然后 substring 是意思就是从索引 0 开始提取字符到 10，后面的 replace 就是把A换成Q，最后输出长度，赋值给 len 函数。

Ⅱ练习

参考答案：

import java.util.Scanner;

public class DuiChengString {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        String result = new StringBuilder().append(str).reverse().toString();
        if (str.equals(result)) {
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
    }
}

⑤Stringjoiner

Ⅰ学习

这又是做什么的？我们可以先看以下的代码：

这个代码的意思就是集合数组前后用 [] 包围住，中间用逗号进行空格。看起来比较麻烦，那么有什么更方便的办法吗？有的！那就是Stringjoiner

然后给大家看个概述：

构造方法：

成员方法：

示例代码：

import java.util.StringJoiner;

public class StringjoinerDemo {
    public static void main(String[] args) {
        StringJoiner joiner = new StringJoiner(",");
        joiner.add("a");
        joiner.add("b");
        joiner.add("c");
        System.out.println(joiner.toString());
    }
}

StringJoiner joiner = new StringJoiner(“,”); 还是先创建对象 但是后面每添加的内容都是用 , 来隔开因此你可以知道 add 这个参数就是添加字符串并且用 , 隔开最终的输入结果为：

a,b,c

再多介绍个参数：

StringJoiner joiner = new StringJoiner(",","[","]");

看 IDE 给的标注，不难发现 [ 是前缀 ] 是后缀没错的，最终的输出结果会被 [] 给包围住的

上总结：

Ⅱ练习

参考答案：

import java.util.Scanner;

public class RomanNumberChange {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str;
        while(true){
            System.out.println("请输入字符串：");
            String s = sc.nextLine();
            boolean flag = checkStr(s);
            if(flag){
                break;
            }else{
                System.out.println("当前字符不符合规范。");
                continue;
            }
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            int number = c - 48;
            String s = changRoman(number);
            sb.append(s);
        }
        System.out.println(sb.toString());
    }
    public static String changRoman(int number){
        String[] arr = {"","Ⅰ","Ⅱ","Ⅲ","Ⅳ","Ⅴ","Ⅵ","Ⅶ","Ⅷ","Ⅸ"};
        return arr[number];
    }
    public static boolean checkStr(String str) {
        if(str.length() > 9){
            return false;
        }
        for(int i = 0; i < str.length(); i++){
            char c = str.charAt(i);
            if (c < '0' || c > '9') {
                return false;
            }
        }
        return true;
    }
}

9、ArrayList集合

①基本介绍

集合是干什么用的？当你想同时存储多个元素的时候集合就产生作用了，那集合和数组之间到底有什么区别呢？：

成员方法：

这个对应的包装类等等就可以用得上。

②使用

Ⅰ基础

下面的部分我们将由菜鸟教程来协助，如何为该集合添加元素：

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>(); // 创建对象 看见包装类了吗 String 是后面的不是前面的
        list.add("真境"); // 添加内容
        list.add("博客");
        System.out.println(list);
    }
}

最终的输出结果为：

[真境, 博客] // 自带方框

先介绍下这个创建对象的格式：

ArrayList<E> objectName =new ArrayList<>();　 // 初始化

E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。
objectName: 对象名。

那如何进行访问指定的元素呢？：

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("真境");
        list.add("博客");
        System.out.println(list.get(1)); // 通过 get 函数获取第二个元素 （数组索引从 0 开始）
    }
}

那如何修改元素呢？：

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("真境");
        list.add("博客");
        list.set(1,"Blog"); // 修改 第二个 博客 更改为 Blog
        System.out.println(list.get(1));
    }
}

那删除元素呢？：

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("真境");
        list.add("博客");
        list.remove(1); // 通过 remove 函数 删除索引为1的元素
        System.out.println(list);
    }
}

最终的结果：

[真境]

那怎么计算元素数量呢？：

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("真境");
        list.add("博客");
        System.out.println(list.size());
    }
}

最终的输出结果为：2

Ⅱ补充

如何迭代数组列表呢？：

import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        for (int i = 0; i < sites.size(); i++) {
            System.out.println(sites.get(i));
        }
    }
}

输出结果：

Google
Runoob
Taobao
Weibo

for-each的方法也行：

import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        for (String i : sites) {
            System.out.println(i);
        }
    }
}

排序呢？Collections 类也是一个非常有用的类，位于 java.util 包中，提供的 sort() 方法可以对字符或数字列表进行排序。

以下实例对字母进行排序：

import java.util.ArrayList;
import java.util.Collections;  // 引入 Collections 类

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Taobao");
        sites.add("Wiki");
        sites.add("Runoob");
        sites.add("Weibo");
        sites.add("Google");
        Collections.sort(sites);  // 字母排序
        for (String i : sites) {
            System.out.println(i);
        }
    }
}

输出结果：

Google
Runoob
Taobao
Weibo
Wiki

对数字排序：

import java.util.ArrayList;
import java.util.Collections;  // 引入 Collections 类

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<Integer> myNumbers = new ArrayList<Integer>();
        myNumbers.add(33);
        myNumbers.add(15);
        myNumbers.add(20);
        myNumbers.add(34);
        myNumbers.add(8);
        myNumbers.add(12);

        Collections.sort(myNumbers);  // 数字排序

        for (int i : myNumbers) {
            System.out.println(i);
        }
    }
}

输出结果为：

③练习

Ⅰ添加学生对象并遍历

参考答案：

main：

package ArrayListStudentInformation;

import java.util.ArrayList;

public class Demo {
    public static void main(String[] args) {
        ArrayList<Information> list = new ArrayList<>();
        Information s1 = new Information("ZS",18);
        Information s2 = new Information("LS",19);
        Information s3 = new Information("WW",20);
        list.add(s1);
        list.add(s2);
        list.add(s3);
        for (int i = 0; i < 2; i++) {
            Information information = list.get(i);
            System.out.println(information.getStudentName()+information.getAge());
        }
    }
}

Information：

package ArrayListStudentInformation;

public class Information {
    private String studentName;
    private int age;
    public Information(String studentName, int age) {
        this.studentName = studentName;
        this.age = age;
    }

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Ⅱ查找用户是否存在

main：

package FindTheStudentIsAvailable;

import java.util.ArrayList;

public class TheMain {
    public static void main(String[] args) {
        ArrayList<TheStudentArrayList> list = new ArrayList<>();
        TheStudentArrayList s1 = new TheStudentArrayList(1, "ZS", "123456");
        TheStudentArrayList s2 = new TheStudentArrayList(2, "LS", "aaa456");
        TheStudentArrayList s3 = new TheStudentArrayList(3, "WW", "aaa123");
        list.add(s1);
        list.add(s2);
        list.add(s3);

        boolean flag = Contains(list,1);
        System.out.println(flag);
    }

    public static boolean Contains(ArrayList<TheStudentArrayList> list, int id) {
        for (int i = 0; i < 2; i++) {
            TheStudentArrayList temp = list.get(i);
            int uid = temp.getId();
            if (uid == id) {
                return true;
            }
        }
        return false;
    }
}

TheStudentArrayList：

package FindTheStudentIsAvailable;

public class TheStudentArrayList {
    private int id;
    private String username;
    private String password;
    public TheStudentArrayList(int id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

Ⅲ添加手机对象并返回数据

main：

package BaseAPhoneListReturnThePrice;

import java.util.ArrayList;

public class TheMain {
    public static void main(String[] args) {
        ArrayList<Phone> phoneList = new ArrayList<Phone>();
        Phone p1 = new Phone("小米",1000);
        Phone p2 = new Phone("苹果",8000);
        Phone p3 = new Phone("锤子",2999);
        phoneList.add(p1);
        phoneList.add(p2);
        phoneList.add(p3);
        ArrayList<Phone> PriceLow = SelectPhone(phoneList);
        for (int i = 0; i < PriceLow.size(); i++) {
            Phone p = PriceLow.get(i);
            int price = p.getPrice();
            String LowPriceName = p.getPhone();
            System.out.println(LowPriceName + " " + price);
        }
    }
    public static ArrayList<Phone> SelectPhone(ArrayList<Phone> phoneList){
        ArrayList<Phone> ReturnPhone = new ArrayList<Phone>();
        for (int i = 0; i < phoneList.size(); i++) {
            Phone p = phoneList.get(i);
            int price = p.getPrice();
            if (price < 3000) {
                ReturnPhone.add(p);
            }
        }
        return ReturnPhone;
        
    }
}

Phone：

package BaseAPhoneListReturnThePrice;

public class Phone {
    private String phone;
    private int price;
    public Phone(String phone, int price) {
        this.phone = phone;
        this.price = price;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
}

④学生管理系统

main：

package TheStudentInformationSystem;

import java.util.ArrayList;
import java.util.Scanner;

public class main {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<Student>();
        while (true) {
            System.out.println("-----欢迎来到学生管理系统-----");
            System.out.println("1：添加学生");
            System.out.println("2：删除学生");
            System.out.println("3：修改学生");
            System.out.println("4：查询学生");
            System.out.println("0：退出");
            System.out.println("请输入您的选择：");
            Scanner sc = new Scanner(System.in);
            String chose = sc.nextLine();
            switch (chose) {
                case "1" -> addStudent(students);
                case "2" -> delStudent(students);
                case "3" -> modifyStudent(students);
                case "4" -> searchStudent(students);
                case "0" -> {
                    System.out.println("退出");
                    System.exit(0);
                }
                default -> System.out.println("非法字符，请重试！");
            }
        }
    }
    public static void addStudent(ArrayList<Student> students){
        Student s = new Student();
        Scanner sc = new Scanner(System.in);
        int newID = 0;
        while (true){
            System.out.println("请输入学生ID：");
            newID = Integer.parseInt(sc.nextLine());
            boolean flag = contains(students, String.valueOf(newID));
            if (flag) {
                System.out.println("此ID已存在！请重新输入！");
            }else{
                s.setId(newID);
                students.add(s);
                break;
            }
        }

        System.out.println("请输入学生姓名：");
        s.setName(sc.next());
        System.out.println("请输入学生年龄：");
        s.setAge(sc.nextInt());
        System.out.println("请输入学生家庭住址：");
        s.setAddress(sc.next());
        students.add(s);
        System.out.println("添加信息成功！");
    }
    public static void delStudent(ArrayList<Student> students){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要删除的ID：");
        String id = sc.next();
        int index = getIndex(students, id);
        if (index >= 0){
            students.remove(index);
            System.out.println("ID为" + id + "的学生已经删除");
        }else{
            System.out.println("未找到该学生！");
        }
    }
    public static void modifyStudent(ArrayList<Student> students){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入需要修改的学生ID：");
        String id = sc.next();
        int index = getIndex(students, id);
        if (index == -1){
            System.out.println("修改的学生ID不存在，请重新再试！");
            return;
        }
        Student s = students.get(index);
        System.out.println("请输入修改的学生ID：");
        s.setName(sc.next());
        System.out.println("请输入修改学生的年龄：");
        s.setAge(sc.nextInt());
        System.out.println("请输入修改学生的地址：");
        s.setAddress(sc.next());
        students.set(index, s);
        System.out.println("修改信息成功！");

    }
    public static void searchStudent(ArrayList<Student> students){
        if (students.isEmpty()){
            System.out.println("无法查询该学生信息，请更换名称后再试");
        }
        System.out.println("id\t\t姓名\t年龄\t家庭住址");
        for (int i = 0; i < students.size(); i++) {
            Student student = students.get(i);
            System.out.println(student.getId() + "\t" + student.getAge() + "\t" + student.getName() + student.getAddress());
        }
    }
    public static boolean contains(ArrayList<Student> students, String id){
//        for (int i = 0; i < students.size(); i++) {
//            Student student = students.get(i);
//            String sid = String.valueOf(student.getId());
//            if (id.equals(sid)){
//                return true;
//            }
//        }
//        return false;
        return getIndex(students, id) >= 0;
    }
    public static int getIndex(ArrayList<Student> students, String id){
        for (int i = 0; i < students.size(); i++) {
            Student student = students.get(i);
            String sid = String.valueOf(student.getId());
            if (id.equals(sid)){
                return i;
            }
        }
        return -1;
    }

}

Student：

package TheStudentInformationSystem;

public class Student {
    private int id;
    private String name;
    private int age;
    private String address;


    public Student(int id, String name, int age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public Student() {

    }


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}