提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录
前言
课程链接：https://www.bilibili.com/video/BV1Cv411372m
我是在学完C++基础语法之后又学习的Java的语法，所以C++基础知识那一篇文档里的部分内容，为了节省时间在此篇就没有记录，可以结合C++基础知识的文档和此篇学习Java的基础语法。
一、java快速入门
1
2 java语言的产品是JDK（Java Development Kit ：Java开发者工具包) ，必须安装JDK才能使用Java语言。
3 JDK8 JDK11 JDK17是长期支持版，JDK8 yyds。
4 Java开发环境最重要的2个命令是什么？
javac 编译命令、 java 执行命令。
5 命令行窗口常用命令
Java开发环境最重要的2个命令是什么啊？
javac 编译命令、 java 执行命令。
6
7 
8 开发一个Java程序要经历哪些步骤？
编写、编译(javac)、运行(java)
9 Java代码编写有什么基本要求？
文件名称的后缀必须是java结尾。
文件名称必须与代码的类名称一致。
必须使用英文模式下的符号。
10 Hello World案例常见错误
11 jdk的组成
12 Path环境变量
Path环境变量用于记住程序路径，方便在命令行窗口的任意目录启动程序。
path环境变量的位置在：我的电脑 -> 属性 -> 高级系统设置 -> 高级 -> 环境变量。
13 path环境变量的配置
14 配置Java_home环境变量
二、IDEA开发工具的使用
1 之前的开发工具
文本编辑工具: 记事本 、 UltraEdit 、 EditPlus 、 TextPad 、 NotePad++、sublime…
存在的问题：编写代码时没有错误提醒、没有代码智能提示、需要自己进行编译、执行，功能不够强大。
2 集成开发环境（ IDE, Integrated Development Environment ）
把代码编写，编译，执行等多种功能综合到一起的开发工具，可以进行代码智能提示，错误提醒，项目管理等等。
常见Java的IDE工具有：Eclipse、MyEclipse、IntelliJ IDEA、Jbuilder、NetBeans等。
3 IDEA 下载
下载：https://www.jetbrains.com/idea/
安装：基本上是傻瓜式安装，建议修改安装路径（不要安装在有空格和中文的路径下）。
4 IDEA包括
project（项目、工程）
module（模块）
package（包）
class（类）
5 IDEA设置字体
6 快捷键
三、Java基础语法
1 多行注释
/*然后回车
2 文档注释
/**然后回车
文档注释可以自动提取到程序说明中去
3 形成class文件时，会自动删掉注释，有两点原因
注释是给程序员看的，形成class时会删掉
删掉注释可以较少代码的内存空间
4 注释快捷键
5 字面量
计算机是用来处理数据的，字面量就是告诉程序员：数据在程序中的书写格式。
6 常用数据类型
7 /t代表一个tab的缩进
8 main方法
输入main然后回车
9 输出方法
sout然后回车
或者psvm然后回车
或者先输入内容然后加上“.sout”
10 数据在计算机底层存储的最小单位是字节
11 ASCⅡ码
a：97
A：65
0：48
12 图片是由无数个像素点组成的，每个像素点的数据：0~255×255×255表示
13 十进制转二进制
14 
15 
16 
17 
18 java里字符串类型“String”，S要大写
19 关键字
20 
四、类型转换、常用运算符
1 自动类型转换
类型范围小的变量，可以直接赋值给类型范围大的变量，如byte类型变量可以直接赋值给int型变量
2
3 强制类型转换
4
5 两个整数相除，想得到小数，而且不更改对方的数据，如：3除以2
3×1.0÷2
6
7 自增自减拓展运算
8 
9 逻辑运算符
C++中逻辑运算符
java中逻辑运算符单与单或，双与双或都可以使用，开发中一般用双与双或
10 
11
12 案例知识：键盘录入技术
五、程序流程控制、Random类
1
2
3
4 System.out,printfln（）；//自带换行
去掉ln就不换行了
5
6 for循环中，控制循环的变量只在循环中可以使用，while循环中，控制循环的变量在循环后还可以继续使用
7
8
9
六、数组
1 数组定义（和C++中有区别）。
也可以：数据类型 数组名【】 = {}
2 数组是引用类型。
3 输出数组长度
4 数组动态初始化
5
6
7 for循环遍历整个数组：数组名.fori
8 结束整个循环
9
10
把数组a赋值给数组b，实际上是把数组a的地址赋值给数组b
11
12
13 Debug工具
七、方法（类似于C++中的函数）
1
2 ctrl + alt + T，再选择for：将一段代码写成for循环
3 如果方法不需要返回结果，返回值类型必须申明成void（无返回值）, 此时方法内部不可以使用return返回数据
4 方法与方法之间是平级关系，不能嵌套定义
5 数组作为形参的方法举例
6 方法的调用过程
方法是放在方法区中的，被调用的时候，需要进入到栈内存中运行
方法中的局部变量也在栈内存中
7 基本类型和引用类型在方法中的传递
数组是引用类型，虽然也是值传递，但是传的是地址，如果在方法中修改数组中的数据，那么在main方法中的数组就被修改了
8 方法重载
同一个类中，出现多个方法名称相同，但是形参列表是不同的，那么这些方法就是重载方法。
9 方法重载的好处
可读性好，方法名称相同提示是同一类型的功能，通过形参不同实现功能差异化的选择，这是一种专业的代码设计。
程序员可以少记很多API
10 方法重载的要求
同一个类中，多个方法的名称相同，形参列表不同，其他无所谓。
形参列表不同：形参的个数、类型、顺序不同。不关心形参的名称。
11 return的单独使用
return比break和continue要强，可以直接干掉某个方法
12 return单独使用举例：解决除法中除数为0的问题
八、编程思维训练
1 案例一：买飞机票
需求：机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。
package com.itheima;
import java.util.Scanner;
/**
需求：机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。
*/
public class Test1 {
public static void main(String[] args) {
// 3、录入购买信息，调用方法得到最终结果
Scanner sc = new Scanner(System.in);
System.out.println("机票原价：");
double price = sc.nextDouble();
System.out.println("月份：");
int month = sc.nextInt();
System.out.println("仓位类型（头等舱、经济舱）：");
String type = sc.next();
double rs = calc(price, month, type);
System.out.println("您当前购买机票的价格是：" + rs);
}
/**
1、定义一个方法：形参（原价、月份、头等舱经济舱） 返回值类型申明：double
*/
public static double calc(double money, int month, String type){
// 2、判断月份是淡季还是旺季
if(month >= 5 && month <= 10){
// 旺季
switch (type){
case "经济舱":
money *= 0.85;
break;
case "头等舱":
money *= 0.9;
break;
default:
System.out.println("您输入的仓位不正确~~");
money = -1; // 当前无法计算价格了！
}
}else if(month == 11 || month == 12 || month >= 1 && month <= 4){
switch (type){
case "经济舱":
money *= 0.65;
break;
case "头等舱":
money *= 0.7;
break;
default:
System.out.println("您输入的仓位不正确~~");
money = -1; // 当前无法计算价格了！
}
}else {
System.out.println("月份有问题");
money = -1;
}
return money;
}
}
2 案例二：找素数
package com.itheima;
/**
需求：找出101-200之间的素数输出：
素数是什么：如果除了1和它本身以外，不能被其他正整数整除，就叫素数。
*/
public class Test2 {
public static void main(String[] args) {
// 1、定义一个循环，找到101-200之间的全部数据
for (int i = 101; i <= 200 ; i++) {
// i = 101 102 103 ... 199 200
// 信号位：标记
boolean flag = true; // 一开始认为当前数据是素数。
// 2、判断当前遍历的这个数据是否是素数
for (int j = 2; j < i / 2; j++) {
if(i % j == 0){
flag = false; // 假设失败了，i不是素数
break; // 没有必要继续判定下去了！
}
}
// 3、根据判定的结果选择是否输出这个数据，是素数则输出
if(flag){
System.out.print(i + "\t");
}
}
}
}
3 案例三：生成验证码
package com.itheima;
import java.util.Random;
/**
需求：定义方法实现随机产生一个5位的验证码，每位可能是数字、大写字母、小写字母。
*/
public class Test3 {
public static void main(String[] args) {
// 4、调用获取验证码的方法得到一个随机的验证码
String code = createCode(8);
System.out.println("随机验证码：" + code);
}
/**
1、定义一个方法返回一个随机验证码：是否需要返回值类型申明？String 是否需要申明形参：int n
*/
public static String createCode(int n){
// 3、定义一个字符串变量记录生成的随机字符
String code = "";
Random r = new Random();
// 2、定义一个for循环，循环n次，依次生成随机字符
for (int i = 0; i < n; i++) {
// i = 0 1 2 3 4
// 3、生成一个随机字符：英文大写 小写 数字 (0 1 2)
int type = r.nextInt(3); // 0 1 2
switch (type){
case 0:
// 大写字符（A 65 - Z 65+25） (0 - 25) + 65
char ch = (char) (r.nextInt(26) + 65);
code += ch;
break;
case 1:
// 小写字符（a 97 - z 97+25） (0 - 25) + 97
char ch1 = (char) (r.nextInt(26) + 97);
code += ch1;
break;
case 2:
// 数字字符
code += r.nextInt(10); // 0 - 9
break;
}
}
return code;
}
}
4 案例四：数组元素的复制
package com.itheima;
/**
需求：把一个数组中的元素复制到另一个新数组中去。
*/
public class Test4 {
public static void main(String[] args) {
int[] arr1 = {11, 22, 33, 44};
// int[] arr2 = arr1; // 没有完成了数组复制。
int[] arr2 = new int[arr1.length];
copy(arr1 , arr2);
printArray(arr1);
printArray(arr2);
}
public static void printArray(int[] arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
}
System.out.println("]");
}
public static void copy(int[] arr1, int[] arr2){
// 正式完成元素的复制
for (int i = 0; i < arr1.length; i++) {
arr2[i] = arr1[i];
}
}
}
5 案例五：评委打分案例
package com.itheima;
import java.util.Scanner;
/**
需求：在唱歌比赛中，有6名评委给选手打分，分数范围是[0 - 100]之间的整数。
选手的最后得分为：去掉最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。
*/
public class Test5 {
public static void main(String[] args) {
// 1、定义一个动态初始化的数组，用于后期录入6个评委的分数
int[] scores = new int[6];
// 2、录入6个评委的分数
Scanner sc = new Scanner(System.in);
for (int i = 0; i < scores.length; i++) {
System.out.println("请您输入第" + (i + 1) +"个评委的打分：");
int score = sc.nextInt();
// 3、把这个分数存入到数组的对应位置处
scores[i] = score;
}
// 3、遍历数组中的每个数据，找出最大值 最小值 总分
// int max = scores[0] , min = scores[0] , sum = 0;
int max = scores[0] ;
int min = scores[0] ;
int sum = 0;
for (int i = 0; i < scores.length; i++) {
if(scores[i] > max){
// 替换最大值变量存储的数据
max = scores[i];
}
if(scores[i] < min){
// 替换最小值变量存储的数据
min = scores[i];
}
// 统计总分
sum += scores[i];
}
System.out.println("最高分是：" + max);
System.out.println("最低分是：" + min);
// 4、统计平均分即可
double result = (sum - max - min) * 1.0 / (scores.length - 2);
System.out.println("选手最终得分是：" + result);
}
}
6 案例六：数字加密
package com.itheima;
/**
需求：某系统的数字密码，比如1983，采用加密方式进行传输，规则如下：先得到每位数，
然后每位数都加上5再对10求余，最后将所有数字反转，得到一串新数。
*/
public class Test6 {
public static void main(String[] args) {
// 1、定义一个数组存储需要加密的数据
int[] arr = new int[]{1, 9, 8, 3};
// 2、遍历数组中的每个数据，按照规则进行修改
for (int i = 0; i < arr.length; i++) {
arr[i] = (arr[i] + 5) % 10;
}
// 3、把数组中的元素进行反转操作。
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
// 交换 i 和 j位置处的值，即可反转
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
// 4、遍历数组中的每个元素输出即可
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]);
}
}
}
7 案例七：模拟双色球（拓展）
package com.itheima;
import java.util.Random;
import java.util.Scanner;
/**
需求：双色球模拟
*/
public class Test8 {
public static void main(String[] args) {
// 1、随机6个红球号码（1-33，不能重复），随机一个蓝球号码（1-16），可以采用数组装起来作为中奖号码
int[] luckNumbers = createLuckNumber();
// printArray(luckNumbers);
// 2、录入用户选中的号码
int[] userNumbers = userInputNumbers();
// 3、判断中奖情况
judge(luckNumbers, userNumbers);
}
public static void judge(int[] luckNumbers, int[] userNumbers ){
// 判断是否中奖了。
// luckNumbers = [12, 23, 8, 16, 15, 32, 9]
// userNumbers = [23, 13, 18, 6, 8, 33, 10]
// 1、定义2个变量分别存储红球命中的个数，以及蓝球命中的个数。
int redHitNumbers = 0;
int blueHitNumbers = 0;
// 2、判断红球命中了几个，开始统计
for (int i = 0; i < userNumbers.length - 1; i++) {
for (int j = 0; j < luckNumbers.length - 1; j++) {
// 每次找到了相等了，意味着当前号码命中了
if(userNumbers[i] == luckNumbers[j]){
redHitNumbers ++ ;
break;
}
}
}
// 蓝球号码是否命中了
blueHitNumbers = luckNumbers[6] == userNumbers[6] ? 1 : 0;
System.out.println("中奖号码是：" );
printArray(luckNumbers);
System.out.println("您投注号码是：" );
printArray(userNumbers);
System.out.println("您命中了几个红球：" + redHitNumbers);
System.out.println("您是否命中蓝球：" + ( blueHitNumbers == 1 ? "是": "否" ) );
// 判断中奖情况了
if(blueHitNumbers == 1 && redHitNumbers < 3){
System.out.println("恭喜您，中了5元小奖！");
}else if(blueHitNumbers == 1 && redHitNumbers == 3
|| blueHitNumbers == 0 && redHitNumbers == 4){
System.out.println("恭喜您，中了10元小奖！");
}else if(blueHitNumbers == 1 && redHitNumbers == 4
|| blueHitNumbers == 0 && redHitNumbers == 5){
System.out.println("恭喜您，中了200元！");
}else if(blueHitNumbers == 1 && redHitNumbers == 5){
System.out.println("恭喜您，中了3000元大奖！");
}else if(blueHitNumbers == 0 && redHitNumbers == 6){
System.out.println("恭喜您，中了500万超级大奖！");
}else if(blueHitNumbers == 1 && redHitNumbers == 6){
System.out.println("恭喜您，中了1000万巨奖！可以开始享受人生，诗和远方！！");
}else {
System.out.println("感谢您为福利事业做出的突出贡献！！");
}
}
public static int[] userInputNumbers(){
// a、动态初始化一个数组，长度为7
int[] numbers = new int[7];
Scanner sc = new Scanner(System.in);
for (int i = 0; i < numbers.length - 1; i++) {
System.out.println("请您输入第"+(i + 1)+"个红球号码（1-33、不重复）：");
int data = sc.nextInt();
numbers[i] = data;
}
// b、录入一个蓝球号码
System.out.println("请您输入一个蓝球号码（1-16）：");
int data = sc.nextInt();
numbers[numbers.length - 1] = data;
return numbers;
}
public static void printArray(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static int[] createLuckNumber(){
// a、定义一个动态初始化的数组，存储7个数字
int[] numbers = new int[7]; // [12, 23, 0, 0, 0, 0, | 0]
// i
// b、遍历数组，为每个位置生成对应的号码。(注意：遍历前6个位置，生成6个不重复的红球号码，范围是1-33)
Random r = new Random();
for (int i = 0; i < numbers.length - 1; i++) {
// 为当前位置找出一个不重复的1-33之间的数字
while (true) {
int data = r.nextInt(33) + 1; // 1-33 ====> (0-32) + 1
// c、注意：必须判断当前随机的这个号码之前是否出现过，出现过要重新随机一个，直到不重复为止，才可以存入数组中去。
// 定义一个flag变量，默认认为data是没有重复的
boolean flag = true;
for (int j = 0; j < i; j++) {
if(numbers[j] == data) {
// data当前这个数据之前出现过，不能用
flag = false;
break;
}
}
if(flag) {
// data这个数据之前没有出现过，可以使用了
numbers[i] = data;
break;
}
}
}
// d、为第7个位置生成一个1-16的号码作为蓝球号码
numbers[numbers.length - 1] = r.nextInt(16) + 1;
return numbers;
}
}
九、面向对象基础
1 类：是对象共同特征的描述；
对象：是真实存在的具体实例。
2
3 定义类的注意事项
4 对象在内存中的运行机制
5 面向对象编程训练：模拟购物车模块
package com.xia.hello;
public class Goods {
int id; //编号
String name; //名称
double price; //价格
int buyNum; //购买数量
}
package com.xia.hello;
import java.util.Scanner;
public class shopCar {
public static void main(String[] args) {
//1、定义商品类，用于后期创建商品对象
//2、定义购物车对象，用一个数组对象表示
Goods[] shopCar = new Goods[100];
//3、搭建操作架构
while (true) {
System.out.println("请您选择如下命令进行操作：");
System.out.println("添加商品到购物车：add");
System.out.println("查询商品到购物车：query");
System.out.println("修改商品购买数量：update");
System.out.println("结算商品购买金额：pay");
Scanner sc = new Scanner(System.in);
System.out.println("请您输入命令：");
String command = sc.next();
switch (command){
case "add":
//添加商品到购物车
addGoods(shopCar, sc);
break;
case "query":
//查询商品到购物车
queryGoods(shopCar);
break;
case "update":
//修改商品购买数量
updateGoods(shopCar, sc);
break;
case "pay":
//结算商品购买金额
payGoods(shopCar);
break;
default:
System.out.println("您输入的输入有误，请重新输入！");
break;
}
}
}
public static void payGoods(Goods[] shopCar) {
queryGoods(shopCar);
double sum = 0;
for (int i = 0; i < shopCar.length; i++) {
Goods g = shopCar[i];
if (g != null){
sum += (g.price * g.buyNum);
}else{
break;
}
}
System.out.println("商品的总金额为：" + sum);
}
public static void updateGoods(Goods[] shopCar, Scanner sc) {
while (true) {
System.out.println("请输入商品的id：");
int id = sc.nextInt();
Goods g = getGoodsById(shopCar, id);
if (g == null){
System.out.println("您没有购买该商品！");
}else{
System.out.println("请输入" + g.name + "的数量：");
g.buyNum = sc.nextInt();
System.out.println("修改成功！");
queryGoods(shopCar);
break;
}
}
}
public static Goods getGoodsById(Goods[] shopCar, int id){
for (int i = 0; i < shopCar.length; i++) {
Goods g = shopCar[i];
if (g != null) {
if (g.id == id){
return g;
}
}else{
return null;
}
}
return null;
}
public static void queryGoods(Goods[] shopCar) {
System.out.println("------------查询商品信息如下-------------");
System.out.println("编号\t\t名称\t\t\t价格\t\t\t购买数量");
for (int i = 0; i < shopCar.length; i++) {
Goods g = shopCar[i];
if (g != null){
System.out.println(g.id + "\t\t" + g.name + "\t\t\t" + g.price + "\t\t\t" + g.buyNum);
}else{
break;
}
}
}
public static void addGoods(Goods[] shopCar, Scanner sc) {
//1、录入用户输入的购买商品信息
System.out.println("请输入商品的编号：");
int id = sc.nextInt();
System.out.println("请输入商品的名称：");
String name = sc.next();
System.out.println("请输入商品的价格：");
double price = sc.nextDouble();
System.out.println("请输入商品的数量：");
int buyNum = sc.nextInt();
//2、把这些商品信息封装成一个商品对象
Goods g = new Goods();
g.id = id;
g.name = name;
g.price = price;
g.buyNum = buyNum;
//3、把这个商品对象放到数组中去
for (int i = 0; i < shopCar.length; i++) {
if(shopCar[i] == null){
shopCar[i] = g;
break;
}
}
System.out.println("您的商品：" + g.name + "添加成功！");
}
}
6 构造器
7 构造器注意事项
8 this关键字
第一种命名里面的n和p没有实际含义，在开发中显得不专业
第二种三个name意义相同，会把输入的name给自己赋值并返回，这样成员变量还是默认值，初始化失败
9 this关键字的使用
10 封装
11 理解封装的好处
12 进行更好的封装
13 JavaBean
可以理解成实体类，其对象可以用于在程序中封装数据
14 标准JavaBean须满足的要求
15 形成get和set方法
右键—Generate—Getter and Setter—按住shift键全选成员变量—ok
虽然形成的方法不包括检验，但是一般程序在后台会控制变量的值使它不至于出错，只是需要Get和Set方法的风格
16 无参构造器比有参构造器用的多，因为有时候一开始不能确定数据，可以先建立一个空对象，有数据的时候再添加
17 成员变量和局部变量的区别
十、常用API(String、ArrayList)
1 API（Application Programming Interface，应用程序编程接口）
2 ArrayList
3 
4 String其实常被称为不可变字符串类型，它的对象在创建后不能被更改。
一开始，name指向“传智”，然后“传智”和“教育”做运算形成一个新的字符串，然后让name指向，形成“传智教育中心”的过程类似。
所以看起来是改变了，其实只是指向发生了变化，字符串本身没有被改变。
5 创建字符串方式
常用String构造器是后面两种，第三种可以字符数组自动连接形成字符串，第四种把字节数组内容转成字符然后连接成字符串
6 两种命名方式的区别
字符串常量池中只存储一份可以节省存储空间，因为一个项目中某个字符串可能出现多次
7 String面试题
s2这行代码创建两个对象，s1这行代码不创建新对象
s3不是双引号创建的，是通过运算得出的，存放在堆内存，s1是存放在字符串常量池中的，所以地址不一样
编译时‘a’, ‘b’, ‘c’, 已经是确定的了（字面量），直接转成“abc”可以结成提高性能，上面那题编译的时候不知道s2是多少，因此不能直接合起来
8 字符串比较的API
9 Strin常用API
判断字符串中时候包含某个字符串
判断是否以某个字符串为开头
10 String案例：开发验证码
package com.itheima.string;
import java.util.Random;
/**
练习题：使用String完成随机生成5位的验证码。
*/
public class StringExec6 {
public static void main(String[] args) {
// 1、定义可能出现的字符信息
String datas = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
// 2、循环5次，每次生成一个随机的索引，提取对应的字符连接起来即可
String code = "";
Random r = new Random();
for (int i = 0; i < 5; i++) {
// 随机一个索引
int index = r.nextInt(datas.length());
char c = datas.charAt(index);
code += c;
}
// 3、输出字符串变量即可
System.out.println(code);
}
}
11 String案例：模拟用户登录
package com.itheima.string;
import java.util.Scanner;
public class StringAPIEqualsDemo4 {
public static void main(String[] args) {
// 1、正确登录名和密码
String okName = "itheima";
String okPassword = "123456";
// 2、请您输入登录名称和密码
Scanner sc = new Scanner(System.in);
System.out.println("登录名称：");
String name = sc.next();
System.out.println("登录密码：");
String password = sc.next();
// 3、判断用户输入的登录名称和密码与正确的内容是否相等。
if(okName.equals(name ) && okPassword.equals(password)){
System.out.println("登录成功！");
}else {
System.out.println("用户名或者密码错误了！");
}
// 4、忽略大小写比较内容的Api: 一般用于比较验证码这样的业务逻辑
String sysCode = "23AdFh";
String code1 = "23aDfH";
System.out.println(sysCode.equals(code1)); // false
System.out.println(sysCode.equalsIgnoreCase(code1)); // true
}
}
12 String案例：手机号码屏蔽
package com.itheima.string;
import java.util.Scanner;
/**
练习题：手机号码屏蔽
*/
public class StringExec8 {
public static void main(String[] args) {
// 1、键盘录入一个手机号码
Scanner sc = new Scanner(System.in);
System.out.println("请您输入您的手机号码：");
String tel = sc.next();
// 2、截取号码的前三位，后四位 18665666520
String before = tel.substring(0, 3); // 0 1 2
String after = tel.substring(7); // 从索引7开始截取到手机号码的末尾
String s = before + "****" + after;
System.out.println(s);
}
}
13 集合：集合是和数组类似，也是一种容器，用于装数据
特点：大小不固定，启动后可以动态变化，类型也可以选择不固定
集合非常适合元素个数不确定，且要进行增删操作的业务场景
14 ArrayList集合
ArrayList是集合的一种，它支持索引
15 ArrayList的无参构造器
16 ArrayList添加元素
第二种插入之后，后面的元素会自动往后移动一个位置
17 统一ArrayList集合操作的元素类型：用泛型
语法格式
规定类型为字符串
规定类型为整数
如果想存所有类型，要加Object
以后用ArrayList都要用泛型
18 ArrayList常用API
19 ArrayList案例：遍历并删除元素
package com.itheima.arraylist;
import java.util.ArrayList;
/**
案例：从集合中遍历元素且删除。
*/
public class ArrayListTest4 {
public static void main(String[] args) {
// 1、创建集合对象：存入学生成绩(98,77,66,89,79,50,100)
ArrayList<Integer> scores = new ArrayList<>();
scores.add(98);
scores.add(77);
scores.add(66);
scores.add(89);
scores.add(79);
scores.add(50);
scores.add(100);
System.out.println(scores);
// [98, 77, 66, 89, 79, 50, 100]
// [98, 66, 89, 50, 100]
// i
// 1、遍历集合中的每个元素
// for (int i = 0; i < scores.size(); i++) {
// int score = scores.get(i);
// // 2、判断这个分数是否低于80分，如果低于则从集合中删除它
// if(score < 80){
// scores.remove(i);
// }
// }
// System.out.println(scores);
// [98, 77, 66, 89, 79, 50, 100]
// [98, 89, 100]
// i
for (int i = scores.size() - 1; i >= 0 ; i--) {
int score = scores.get(i);
// 2、判断这个分数是否低于80分，如果低于则从集合中删除它
if(score < 80){
scores.remove(i);
}
}
System.out.println(scores);
}
}
按照正常思维的会有bug，因为每次删除一个元素，后面的元素就会往前移动一个位置，所以会漏掉一些需要删除的元素，因此两种解决方案，一种是删除之后i减减，另一种是从后往前遍历
20 ArrayList案例：存储自定义类型
package com.itheima.arraylist;
public class Movie {
private String name;
private double score;
private String actor;
public Movie() {
}
public Movie(String name, double score, String actor) {
this.name = name;
this.score = score;
this.actor = actor;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public String getActor() {
return actor;
}
public void setActor(String actor) {
this.actor = actor;
}
}
package com.itheima.arraylist;
import java.util.ArrayList;
/**
案例：集合存储自定义元素并遍历。
需求：定义电影类（名称，分值，演员），创建3个电影对象，代表三部影片，存入集合中并遍历。
《肖生克的救赎》, 9.7 , 罗宾斯
《霸王别姬》, 9.6 , 张国荣、张丰毅
《阿甘正传》, 9.5 , 汤姆.汉克斯
*/
public class ArrayListTest5{
public static void main(String[] args) {
// 1、定义一个电影类：Movie
// 2、定义一个ArrayList集合存储这些影片对象。
ArrayList<Movie> movies = new ArrayList<>();
// 3、创建影片对象封装电影数据，把对象加入到集合中去。
// Movie m1 = new Movie("《肖生克的救赎》", 9.7 , "罗宾斯");
// movies.add(m1);
movies.add(new Movie("《肖生克的救赎》", 9.7 , "罗宾斯"));
movies.add(new Movie("《霸王别姬》", 9.6 , "张国荣、张丰毅"));
movies.add(new Movie("《阿甘正传》", 9.5 , "汤姆.汉克斯"));
System.out.println(movies);
// 4、遍历集合中的影片对象并展示出来
for (int i = 0; i < movies.size(); i++) {
Movie movie = movies.get(i);
System.out.println("片名：" + movie.getName());
System.out.println("评分：" + movie.getScore());
System.out.println("主演：" + movie.getActor());
}
}
}
21 ArrayList案例：元素搜索
package com.itheima.arraylist;
public class Student {
private String studyId;
private String name;
private int age;
private String className;
public Student() {
}
public Student(String studyId, String name, int age, String className) {
this.studyId = studyId;
this.name = name;
this.age = age;
this.className = className;
}
public String getStudyId() {
return studyId;
}
public void setStudyId(String studyId) {
this.studyId = studyId;
}
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 getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
}
package com.itheima.arraylist;
import java.util.ArrayList;
import java.util.Scanner;
/**
案例：学生信息系统：展示数据，并按照学号完成搜索
学生类信息（学号，姓名，性别，班级）
测试数据：
"20180302","叶孤城",23,"护理一班"
"20180303","东方不败",23,"推拿二班"
"20180304","西门吹雪",26,"中药学四班"
"20180305","梅超风",26,"神经科2班"
*/
public class ArrayListTest6 {
public static void main(String[] args) {
// 1、定义一个学生类，后期用于创建对象封装学生数据
// 2、定义一个集合对象用于装学生对象
ArrayList<Student> students = new ArrayList<>();
students.add(new Student("20180302","叶孤城",23,"护理一班"));
students.add(new Student("20180303","东方不败",23,"推拿二班"));
students.add(new Student( "20180304","西门吹雪",26,"中药学四班"));
students.add(new Student( "20180305","梅超风",26,"神经科2班"));
System.out.println("学号\t\t名称\t年龄\t\t班级");
// 3、遍历集合中的每个学生对象并展示其数据
for (int i = 0; i < students.size(); i++) {
Student s = students.get(i);
System.out.println(s.getStudyId() +"\t\t" + s.getName()+"\t\t"
+ s.getAge() +"\t\t" + s.getClassName());
}
// 4、让用户不断的输入学号，可以搜索出该学生对象信息并展示出来（独立成方法）
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请您输入要查询的学生的学号：");
String id = sc.next();
Student s = getStudentByStudyId(students, id);
// 判断学号是否存在
if(s == null){
System.out.println("查无此人！");
}else {
// 找到了该学生对象了，信息如下
System.out.println(s.getStudyId() +"\t\t" + s.getName()+"\t\t"
+ s.getAge() +"\t\t" + s.getClassName());
}
}
}
/**
根据学号，去集合中找出学生对象并返回。
* @param students
* @param studyId
* @return
*/
public static Student getStudentByStudyId(ArrayList<Student> students, String studyId){
for (int i = 0; i < students.size(); i++) {
Student s = students.get(i);
if(s.getStudyId().equals(studyId)){
return s;
}
}
return null; // 查无此学号！
}
}
看代码主要先看注释中每一步的思路，有了思路，剩下的就是基础知识的组合。
22
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
