第一讲 - 第八讲
计算机的基本概念 & Java语言的发展历程
第九讲
软件的安装路径中不要有中文， 否则可能出现莫名其妙的问题
第十讲
<1>java文件的后缀为.java
<2>查看代码的软件: npp, UltraEdit 等等
<3>JDK - Java Development Kit (开发工具包)
<4> JDK, JRE 和 JVM之间的关系
第十一讲 - 第十三讲
<1>Java开发的常用工具 - 文本编辑器 / 集成开发环境
<2>使用文本编辑器编写java代码
1.新建文件, 修改文件扩展名为.java, 并保存
2.编写代码
注释的规范:
3.启动DOS窗口, 切换到.java所在的路径 4. 使用 javac xxx.java 进行编译
-
使用 java xxx 进行运行
<3>编程规范
遇见左花括号: 空一行, 并且缩进
第十四讲
<1>
第十五讲 环境变量
为了使得可执行文件可以在任意路径下运行，需要配置环境变量
配置JAVA_HOME, 便于后续更换JDK版本以及学习JavaEE
第十六讲 跨平台原理
第十七讲 总结
<1> 计算机的体系结构 (常识)
<2> Java语言的概述 (常识)
<3> 开发环境的搭建和使用 (重点)
JDK, JRE, javac.exe， java.exe,编写java程序的流程， 快捷键和注释，
环境变量的配置， 跨平台原理
第一阶段 模块一 任务二: 变量和数据类型
第一讲：变量的基本概念
第二讲：变量的声明和使用
第三讲：变量使用的注意事项
<1>不能重复声明
<2>尽量初始化
第四讲：标识符(变量)的命名法则 (笔试)
<1>由数字，字母，下划线以及$等组成，其中数字不能开头
<2>不能使用Java语言的关键字
<3>名称不宜过长
<4>尽量做到见名知意, 支持中文但不推荐使用
<5>标识符可以给类/变量/属性/方法/包 起名字
第五讲：变量输入输出的案例实现
import java.util.Scanner; public class Demo { public static void main(String[] args) { // 1. 声明两个变量用于记录姓名和年龄信息 String name; int age; // 2. 提示用户输入年龄和姓名 System.out.println("请输入您的姓名和年龄信息:"); // 创建一个扫描器来扫描键盘输入的内容, System.in代表键盘键入 Scanner sc = new Scanner (System.in); // 通过扫描器读取一个字符串数据放入变量name中 name = sc.next(); // 通过扫描器读取一个整数数据放入变量age中 age = sc.nextInt(); // 3. 打印变量的数值 System.out.println("name = " + name); System.out.println("age = " + age); } }
第六讲: 变量输入输出案例的优化和手册介绍
<1>变量 随使用，随声明 (不用的时候, 不需要声明)
<2>尽可能减少重复的代码
import java.util.Scanner; public class Demo { public static void main(String[] args) { // 1. 提示用户输入年龄和姓名 System.out.println("请输入您的姓名和年龄信息:"); // 创建一个扫描器来扫描键盘输入的内容, System.in代表键盘键入 Scanner sc = new Scanner (System.in); // 通过扫描器读取一个字符串数据放入变量name中 String name = sc.next(); // 通过扫描器读取一个整数数据放入变量age中 int age = sc.nextInt(); // 2. 打印变量的数值 System.out.println("name = " + name + ", age = " + age); } }
<3> Java官方提供的手册
帮助文档路径: 第一阶段任务一模块一 Java编程基础 1任务一 初识计算机和Java语言 3_软件
第七讲: 数据类型的分类
在Java语言中数据类型主要分为两大类:
<1>基本数据类型（记住）
byte, short, int, long, float, double, boolean, char
<2>引用数据类型（了解）
数组，类，接口，枚举，标注
第八讲: 常用的进制
第九讲 - 第十讲:：正十进制转化为二进制的方式
第十一讲：正二进制转化为十进制的方式
第十二讲：负十进制转化为二进制的方式
第十三讲：负二进制转化为十进制的方式
先减1，再按位取反，合并为10进制数后，添加负号。
第十四讲：单个字节(8 bits)所能表示的整数范围（重中之重）
第十五讲 - 第十七讲：整数类型的概念 & 整数类型的编程使用
<1>Java语言中描述整数数据的类型有: byte, short, int, long, 推荐使用int 类型
<2>其中byte类型在内存空间中占1个字节, 表示范围是: -2^7 ~ 2^7-1
其中short类型在内存空间中占2个字节, 表示范围是: -2^15 ~ 2^15-1
其中int类型在内存空间中占4个字节, 表示范围是: -2^31 ~ 2^31-1
其中long类型在内存空间中占8个字节, 表示范围是: -2^63 ~ 2^63-1
<3>java.math.BigInteger类型, 用来描述比long类型还大的数据
第十八讲: 整数类型的笔试考点
<1>请问下面的代码是否有错误?
int i2 = 25; byte b2 = i2; // - 答: 错误。 不兼容的类型：从int转换到byte可能 （现在 或 未来）会有损失 // 由于i2 是变量, 随时可以发生改变, 因此， 代码不能通过编译 System.out.println("b2 = " + b2);
第十九讲：浮点类型
<1> 用于描述小数的类型: float 和 double， 推荐使用double 类型
<2> float类型占 4 个字节, 叫做 单精度浮点数 ，可以表示 7 位有效数字，
范围：-3.403E38 ~ 3.403E38 （E38 = 10^38）
<3> double 类型占 8 个字节, 叫做 双精度浮点数 ，可以表示 15 位有效数字，
范围：-1.798E308 ~ 1.798E308
第二十讲：浮点类型的编程使用
// 1.声明一个float类型的变量并初始化 //float f1 = 3.1415926; // 错误: 不兼容的类型: 从double转换到float可能会有损失 小数数据叫做直接量，默认为double类型 float f1 = 3.1415926f; // 2.打印变量的数值 System.out.println("f1 = " + f1); // output: f1 = 3.1415925 (一般是7位有效数字) System.out.println("----------------------------------------------------"); // 3.声明一个double类型的变量并初始化 double d1 = 3.1415926; System.out.println("d1 = " + d1); // d1 = 3.1415926 （一般是15位有效数字） System.out.println("----------------------------------------------------"); // 4.笔试考点 System.out.println(0.1 + 0.2); // 0.30000000000000004 运算时可能会有误差，若希望实现精确运算则借助java.math.BigDecimal类型
第二十一讲：布尔类型的概念和编程使用
<1>在Java中，用于描述真假的类型为boolean, 只有true 和 false 两个值 (没有0和1之分)
第二十二讲：字符类型的概念
<1>用于描述单个字符的数据类型: char类型。 如：'a', '中'...
<2>char占 2 个字节, 并且没有符号位，表示的范围为： 0 ~ 65535
<3>计算机只识别0和1, 对于字符'a'这样的图案不满足该规则，为了使得该数据能够储存起来就可以给该数据指定一个编号，然后将编号储存起来即可，该编号就叫做ASCII
第二十三讲：字符类型和编号的使用
<1>要求掌握的ASCII有:
'0' - 48 'A' - 65 'a' - 97 空格 - 32 换行符 - 10
第二十四讲：Unicode字符集的概念和使用
<1>Java中，使用Unicode字符集，来对图案进行编号。
<2>Unicode是世界通用的定长字符集，所有的字符都是16位
<3>示例
// 使用Unicode 字符集来表示 奇点 （u5947u70b9） char c1 = 'u5947'; char c2 = 'u70b9'; System.out.println("最终的结果是:" + c1 + c2); //最终的结果是:奇点
第二十五讲：转义字符的概念和使用
<1>双引号本身有 2 个含义： a. 字符串的开头和结尾标志 b. 双引号自身
<2> 转义就是转换原有的含义
第二十六讲：自动类型转换的概念和使用
<1>自动类型转换： 从小类型到大类型 的转换
第二十七讲：强制类型转换的概念和使用
<1>强制类型转化：从大类型到小类型 的转换
目标类型 变量名 = (目标类型) 被转换的变量
<2 >例子：强转一个超出范围的数
short s1 = 128; // 0000 0000 1000 0000 byte b1 = 0; // 0000 0000 b1 = (byte)s1; // b1: 1000 0000 System.out.println(b1); // 1000 0000 => -128 // 故：强转有风险，操作需谨慎！
第二十八讲：任务总结
<1>变量（重中之重）
变量的概念，变量的声明方式，标识符的命名法则，变量的输入输出等
<2>数据类型
基本数据类型：byte，short，int，long，float，double，boolean，char
常见的进制：十进制，二进制，十进制和二进制之间的转换方式，单个字节表示 的整数范围
数据类型之间的转换：自动类型转换 和 强制类型转换
常用的ASCII以及转义字符
第一阶段 模块一 任务三: 运算符
第一讲- 第二讲：算术运算符的概念和使用
第三讲：算术运算符实现时间拆分
// 1.提示用户输入一个正整数的秒数并使用变量记录
System.out.println("请输入一个正整数的秒数：");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
// 2.将正整数的秒数拆分为时分秒后并使用变量记录
// 3666秒 => 1小时1分钟6秒钟
// 3666 / 3600 = 1 小时 3666 % 3600 = 66 / 60 = 1 分钟 3666 % 60 = 6 秒钟
int hour = num / 3600; // 拆分小时数
int min = num % 3600 / 60; // 拆分分钟数
int sec = num % 60; // 拆分秒数
// 3.打印最终的拆分结果
System.out.println(num + "秒转换为" + hour + "小时" + min + "分钟" + sec + "秒钟");
System.out.println("---------------------------");
// 4.+既可以作为字符串连接符，又可以作为加法运算符
第四讲：字符串连接符的概念和使用
<1>+ 既可以作为 字符串连接符，又可以作为加法运算符
<2>例子
// 只要 + 两边的操作数中有一个操作数是字符串类型，则该+就被当做字符串连接符处理，否则当做加法运算符处理： System.out.println(hour + min + sec); // 8 整数8 System.out.println(hour + min + sec + ""); // 8 字符串8 System.out.println(hour + min + "" + sec); // 26字符串26 System.out.println(hour + "" + min + sec); // 116 字符串116 System.out.println("" + hour + min + sec); // 116 字符串116 System.out.println("" + (hour + min + sec));// 8 字符串8
第五讲 - 第六讲：关系运算符的概念和使用
<1> > < == >= <= !=
<2>返回值只有 true与 false
第七讲 - 第九讲：自增减运算符的概念和使用
<1>++：自增1 --：自减1
<2>前后++的区别(例子)：
int ia = 10; //后++表示先让变量ia的数值作为整个表达式的最终结果， //然后再让ia变量自身的数值加1 System.out.println(ia++); // 10 System.out.println("ia = " + ia); // 11 // 前++表示先让变量自身的数值加1， //后再让变量的数值作为整个表达式的结果 System.out.println(++ia); // 12 System.out.println("ia = " + ia); // 12 // 笔试考点 int ib = ia++; System.out.println("ib = " + ib);// 12 System.out.println("ia = " + ia); // 13 int ic = ++ia; System.out.println("ic = " + ic); // 14 System.out.println("ia = " + ia); // 14 // 14 + 16 System.out.println(ia++ + ++ia); // 30 System.out.println("ia = " + ia); // 16`
第十讲：逻辑运算符的概念和使用
<1>&&表示逻辑与运算符，相当于“并且“，同真为真，一假为假。
<2>||表示逻辑或运算符，相当于“或者“，一真为真，同假为假。
<3>!表示逻辑非运算符，相当于“取反”，真为假，假为真。
<4>逻辑运算符的操作数均为boolean表达式。
第十一讲：逻辑运算符的短路特性（例子）
// 测试一下短路特性 int ia = 3; int ib = 5; // 对于逻辑与运算符来说，若第一个条件为假则整个表达式为假， // 此时跳过第二个表达式不执行 boolean b4 = (++ia == 3) && (++ib == 5); System.out.println("b4 = " + b4); // false System.out.println("ia = " + ia); // 4 System.out.println("ib = " + ib); // 5 // 对于逻辑或运算符来说，若第一个条件为真则整个表达式为真， // 此时跳过第二个表达式不执行 boolean b5 = (++ia == 5) || (++ib == 5); System.out.println("b5 = " + b5); // true System.out.println("ia = " + ia); // 5 System.out.println("ib = " + ib); // 5
第十二讲：使用逻辑运算符，判断一个数是否为三位数
第十三讲 - 第十四讲: 条件/三目运算符
<1> 条件表达式？表达式1：表达式2
第十五讲 - 第十七讲：赋值运算符
<1> 笔试考点一
byte b1 = 10; b1 = b1 + 2; // 错误：不兼容的类型： 从int到byte可能会有损失 // byte + int = int b1 = b1 + (byte) 2; // 依然错误：不兼容的类型： 从int到byte可能会有损失 // byte + byte = int ==> 这属于编译器的优化 b1 = (byte)(b1 + 2); // 正确: 强制类型转换, 将int类型转换为byte b1 += 2; // 正确: 真正等价于 b1 = (byte)(b1 + 2), 而不是 b1 = (b1 + 2)
<2> 笔试考点二
//提问：以下四个的区别是什么？ //ia == 2; 表示判断变量ia的数值是否等于2 //2 == ia; //表示判断2是否等于变量ia的数值，从结果上来说等价， //但是，推荐该方式，避免少写一个 = 的问题发生 //ia = 2; 表示将2赋值给变量ia，覆盖变量ia原来的数值 //2 = ia; 编译报错。 错误：意外的类型
第十八讲：移位运算符的概念（了解）
<1> << 左移运算符，用于将数据的二进制位向左移动，右边使用0补充
>> 右移运算符，用于将数据的二进制位向右移动，左边使用符号位补充
(如果是负数，用1补充)
<2> >>>表示逻辑右移运算符（无符号右移运算符），用于将数据的二进制位向右移动，左边使用0补充
第十九讲：移位运算符的使用（了解 ）
// 编程实现移位运算符的使用 // 1. 声明一个byte类型的变量并初始化 byte b1 = 13; // 13 ==> 0000 1101 System.out.println("b1 = " + b1); // 13 // 2. 移位运算符的使用 byte b2 = (byte) (b1 << 1); // 0001 1010 ==> 26 System.out.println("b2 = " + b2); // 26 左移一位相当于当前整数的数值*2 System.out.println(b1 << 2); // 52 左移两位相当于当前整数的数值*4 System.out.println(b1 >> 1); // 6 右移一位相当于当前整数的数值/2 System.out.println(b1 >> 2); // 3 右移两位相当于当前整数的数值/4
第二十讲：位运算符（了解）
<1> &表示按位与运算符，按照二进制位进行与运算，同1为1，一0为0
<2> |表示按位或运算符，按照二进制进行或运算，一1为1，同0为0
<3> ~表示 按位取反
<4> ^表示按位异或，相同为0，不相同为1
第二十一讲：位运算符的使用
// 编程实现位运算符的使用 // 1. 声明两个byte类型的变量并初始化 byte b1 = 11; // 11 ==> 0000 1011 byte b2 = 13; // 13 ==> 0000 1101 // 2. 位运算符的使用 System.out.println(b1 & b2); // 0000 1001 ==> 9 System.out.println(b1 | b2); // 0000 1111 ==> 15 System.out.println(b1 ^ b2); // 0000 0110 ==> 6 System.out.println(~ b1); // 1111 0100 ==> 负数的二进制转十进制, 先减1: 1111 0011 ==> 按位取反: 0000 1100 // ==> 转为10进制: 12 ==> 添加负号: -12
第二十二讲：运算符的优先级
<1>
<2>
（）的优先级极高
= 的优先级极低
当无法确定优先级时，可以用（）来确保
第二十三讲：任务总结 - 运算符
算数运算符 + - * / %
字符串连接符 + 关系运算符 > >= < <= == !=
自增减运算符 ++ --
逻辑运算符 && || !
条件运算符 ？：
赋值运算符 = += -= *= ...
移位运算符 << >> >>>
位运算符 & | ^ ~
运算符的优先级
第一阶段 模块一 任务四：流程控制
第一讲：分支结构的概念
第二讲：if分支结构的概念和使用
第三讲- 第四讲：if分支结构查找最大值的方式
第五讲：if else分支结构的概念和使用
第六讲：if else分支结构判断负数和非负数
第七讲：if else if else 分支结构判断负数和非负数
第八讲 - 第九讲： 个人所得税的计算方式
第十讲：出租车计费系统的实现
第十一讲：if分支结构实现等级判断
第十二讲：switch case分支结构的概念
第十三讲：switch case 实现等级判断
第十四讲：switch case 实现字符界面
第十五讲：循环结构的概念
第十六讲：for循环的概念和使用
第十七讲：for循环打印奇数
第十八讲：for循环实现累加和
第十九讲：for循环实现水仙花数的打印
// 打印三位数中所有的水仙花数 for (int i = 100; i <=999 ; i++) { // 以拆分123为例: // 123 / 100 = 1; // 123 % 100 ==> 23 / 10 ==> 2 // 123 % 10 = 3 int ia = i / 100; // 拆分百位数 int ib = i % 100 / 10; // 拆分十位数 int ic = i % 10; // 拆分个位数 if(ia*ia*ia + ib*ib*ib + ic*ic*ic == i){ System.out.println(" i = " + i); } }
第二十讲：continue 关键字
<1>continue语句用在循环体中，用于结束本次循环而开始下一次循环
<2>例如：使用for循环打印1~20之间的所有整数，若遇到5的倍数则跳过不打印
第二十一讲 - 第二十二讲： break关键字模拟聊天
<1>
// 5.声明一个boolean类型的变量作为发送方的标志 boolean flag = true; // 4.使用无限循环来模拟不断地聊天 for(;;) { // 1.提示用户输入要发送的聊天内容并使用变量记录 System.out.println("请" + (flag? "张三": "李四") +"输入要发送的聊天内容："); Scanner sc = new Scanner(System.in); String str = sc.next(); // 2.判断用户输入的内容是否为"bye"，若是则聊天结束 if("bye".equals(str)) { System.out.println("聊天结束！"); break; // 用于跳出当前循环 } // 3.若不是则打印用户输入的聊天内容 //else { //System.out.println("聊天内容是：" + str); //} System.out.println((flag? "张三说：": "李四说：") + str + " "); flag = !flag; }
<2> 如果要退出外层循环体，需要使用标号的方式
outer: for(...){ for(...){ break outer; } }
第二十三讲 - 第二十四讲：猜数字游戏
// 1.随机生成1 ~ 100之间的整数并使用变量记录 Random ra = new Random(); int temp = ra.nextInt(100) + 1; //System.out.println("temp = " + temp); // 4.声明一个int类型的变量来统计用户猜测的次数 int cnt = 0; for(;;) { // 2.提示用户输入1 ~ 100之间猜测的整数并使用变量记录 System.out.println("请输入1 ~ 100之间猜测的整数："); Scanner sc = new Scanner(System.in); int num = sc.nextInt(); cnt++; // 3.使用用户输入的整数与随机数之间比较大小并给出对应的提示 if(num > temp) { System.out.println("猜大了，再小一点吧！"); } else if(num < temp) { System.out.println("猜小了，再大一点吧！"); } else { System.out.println("恭喜您猜对了，游戏结束！"); break; } } if(1 == cnt) { System.out.println("你果然是个大咖！"); } else if(cnt <= 6) { System.out.println("水平不错，继续加油哦！"); } else { System.out.println("你还可以多玩几次游戏！"); }
第二十五讲 - 第二十六讲：双重for循环的由来
第二十七讲：各种星星图案的打印
<1>
// 外层循环主要用于控制打印的行数 for(int i = 1; i <= 5; i++) { // 内层循环主要用于控制打印的列数 也就是当前行的列数与当前行的行数是相等关系 for(int j = 1; j <= i; j++) { System.out.print("*"); } System.out.println(); }
<2>
// 外层循环主要用于控制打印的行数 for(int i = 1; i <= 5; i++) { // 内层循环主要用于控制打印的列数 也就是当前行的列数与当前行的行数相加为6的关系 for(int j = 1; j <= 6-i; j++) { System.out.print("*"); } System.out.println(); }
<3>
for(int i = 1; i <= 5; i++) { // 控制空格的个数 for(int j = 1; j <= 5-i; j++) { System.out.print(" "); } // 内层循环主要用于控制打印的列数 也就是当前行的列数与当前行的行数为 2*i-1 的关系 for(int j = 1; j <= 2*i-1; j++) { System.out.print("*"); } System.out.println(); }
第二十八讲：九九乘法表的打印
// 1.使用外层for循环控制打印的行数，一共9行 outer:for(int i = 1; i <= 9; i++) { // 2.使用内层for循环控制打印的列数，最多9列，规律是：与当前行所在的行数相等 for(int j = 1; j <= i; j++) { // 3.使用两个循环变量来拼接等式 System.out.print(j + "*" + i + "=" + j*i + " "); // 4.当打印完毕6*6 = 36后结束整个打印 if(6 == j) { //break; // 主要用于跳出循环，但该关键字只能跳出当前所在的循环 break outer; // 表示可以跳出外层for循环 } } System.out.println(); }
第二十九讲 - 第三十讲：素数（质数）打印的实现
// 1.使用for循环打印2 ~ 100之间的所有整数 for(int i = 2; i <= 100; i++) { // 3.声明一个boolean类型的变量作为是否为素数的标记 boolean flag = true; // 2.针对每一个当前的整数都要判断是否为素数，若是素数则打印，否则不打印 // 判断一个数是否为素数的方法是：若该数不能被2到它本身-1之间的所有整数整除时，则证明该数是素数 // 使用内层for循环用于控制2到该数自身-1之间的范围 //for(int j = 2; j < i; j++) { // 只需要判断2到该数的平方根即可，因为随着除数的增大商必然减小，会造成重复的判断 for(int j = 2; j <= Math.sqrt(i); j++) { // 使用当前数除以该循环中的每个数据并判断是否可以整除，只要找到一个可以整除的数据，则证明该数不是素数 if(0 == i % j) { flag = false; break; // 跳出当前所在的内层循环，也就是不需要再继续除以下一个整数 } } // 只可以打印素数 if(flag) { System.out.println("i = " + i); } }
第三十一讲 - 第三十三讲：while循环
<1> while循环和for循环比较
1. while循环和for循环完全可以互换，推荐使用for循环 2. while循环更适合于明确循环条件，但不明确循环次数的场合中 3. for循环更适合于明确循环次数或范围的场合中
第三十四讲：while循环实现数字的反向输出
提示用户输入一个任意位数的正整数，然后反向输出
<1>思路：
<2>代码
// 1.提示用户输入一个正整数并使用变量记录 123 System.out.println("请输入一个正整数："); Scanner sc = new Scanner(System.in); int num = sc.nextInt(); // 2.使用while循环进行拆分并打印 //while(num > 0) { //System.out.print(num % 10); // 拆分个位数 //num /= 10; // 丢弃个位数 //} // 2.使用while循环拆分整数中的每个数字并记录到变量中 int res = 0; int temp = num; // 指定变量作为num的替身 while(temp > 0) { res = res*10 + temp % 10; // 3 32 321 temp /= 10; // 12 1 0 } // 3.打印逆序后的结果 System.out.println(num + "逆序后的结果是：" + res
第三十六讲：do while循环（熟悉）
do{
循环体;
}while(条件表达式);
第三十七讲：循环的笔试考点
// 典故： 十动然拒 笔试考点：有没有分号 int i = 1; while(i <= 10000); { System.out.println("I Love You !"); i++; } ============== 等价于 =================== while(i <= 10000) { ; // 空语句，啥也不干，可以用于延时 } { System.out.println("I Love You !"); i++; }
第三十八讲：任务总结
<1>分支结构
if分支结构，if else 分支结构，if else if else 分支结构，switch case 分支结构
<2>循环结构
for循环，break和continue关键字，双重for循环，while循环，do while循环
第一阶段 模块一 任务五：数组以及应用
第一讲：一维数组的基本概念
第二讲：一维数组的声明方式
<1>数据类型[] 数组名称 = new 数据类型[数组的长度];
<2>调用数组的length属性可以获取数组的长度
<3>通过下标访问数组的每一个元素
第三讲：一维数组的使用
<1>
int arr[] = new int [2]; // 不推荐使用
int []arr = new int[2]; // 推荐使用，因为它更容易与变量的声明区分，提高了可读性
第四讲：一维数组的初始化
<1>可以在数组声明的同时进行初始化 （静态方式的简化写法）：
数据类型[] 数组名称 = {初始值1，初始值2，...};
<2>特殊的写法（静态方式）
boolean[] arr = new boolean[]{true,true,false,false};
第五讲：内存结构分析
<1> 栈区： 栈用于存放 程序运行过程中 所有的 局部变量。
一个运行的Java程序，从开始到结束，会有多次变量的声明
<2>堆区：JVM会在其内存空间中，开辟一个称为“堆”的储存空间，
这部分空间用于存储使用new关键字创建的数组和对象。
第六讲 - 第九讲：一维数组的增删改查
// 1.声明一个长度为5元素类型为int类型的一维数组 int[] arr = new int[5]; // 打印数组中所有元素的数值 System.out.print("数组中的元素有："); for(int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); // 全是默认值0 } System.out.println(); System.out.println("------------------------------------"); // 2.将数据11 22 33 44依次对数组中前四个元素赋值 /* arr[0] = 11; arr[1] = 22; arr[2] = 33; arr[3] = 44; */ for(int i = 0; i < arr.length-1; i++) { arr[i] = (i+1)*11; } // 打印数组中所有元素的数值 System.out.print("数组中的元素有："); for(int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); // 11 22 33 44 0 } System.out.println(); System.out.println("--------------------------------------"); // 3.将数据55插入到下标为0的位置，原有元素向后移动 /* arr[4] = arr[3]; arr[3] = arr[2]; arr[2] = arr[1]; arr[1] = arr[0]; arr[0] = 55; */ for(int i = arr.length-1; i > 0; i--) { arr[i] = arr[i-1]; } arr[0] = 55; // 打印数组中所有元素的数值 System.out.print("数组中的元素有："); for(int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); // 55 11 22 33 44 } System.out.println(); System.out.println("---------------------------------------"); // 4.将数据55从数组中删除，删除方式为后续元素向前移动，最后一个位置置为0 /* arr[0] = arr[1]; arr[1] = arr[2]; arr[2] = arr[3]; arr[3] = arr[4]; */ for(int i = 0; i < arr.length-1; i++) { arr[i] = arr[i+1]; } arr[4] = 0; // 打印数组中所有元素的数值 System.out.print("数组中的元素有："); for(int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); // 11 22 33 44 0 } System.out.println(); System.out.println("-----------------------------------------"); // 5.查找数组中是否有元素22，若有则修改为220 for(int i = 0; i < arr.length; i++) { if(22 == arr[i]) { arr[i] = 220; } } // 打印数组中所有元素的数值 System.out.print("数组中的元素有："); for(int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); // 11 220 33 44 0 } System.out.println();
第十讲：一维数组的优缺点
<1>可以直接通过下标（或索引）的方式访问指定位置的元素，速度很快
<2>数组要求所有元素的种类相同
<3>数组要求内存空间必须连续，且长度一旦确定就不能修改
<4>增加和删除元素时可能移动大量元素，效率低
第十一讲 - 第十二讲：一维数组之间元素的拷贝
// 实现：数组之间元素的拷贝 // 1. 初始化数组arr int[] arr = {11,22,33,44,55}; // 2. 声明一个长度为3的int 数组 int[] arr2 = new int[3]; // 3. 将arr1中，中间三个元素，赋给arr2 //for (int i = 0; i <arr2.length ; i++) { // arr2[i] = arr[i+1]; //} // 可以直接使用JAVA官方提供的拷贝功能 // 表示将数组arr中下标从1开始的3个元素拷贝到数组arr2中下标从0开始的位置 System.arraycopy(arr,1,arr2,0,3); for (int i = 0; i <arr2.length ; i++) { System.out.print(arr2[i]+" "); } System.out.println();
第十三讲：一维数组之间的拷贝 - 笔试考点
int[] arr = {11,22,33,44,55}; int[] arr2 = new int[3]; arr2 = arr; // 笔试考点 // 表示将变量arr的数值赋值给变量arr2，覆盖变量arr2中原来的数值 // 数组名arr的内存空间中存放的是数据在堆区中的内存地址信息，赋值后让arr2变量中存放了arr所指向堆区的内存地址 // 也就是让arr2和arr指向了同一块堆区空间，有本质上就是改变指向而已 for (int i = 0; i <arr2.length ; i++) { System.out.print(arr2[i]+" "); // 11 22 33 44 55 } System.out.println();
第十四讲 - 第十五讲：
统计用户输入任意一个正整数中每个数字出现的次数并打印
如： 123123 ==> 1出现2次，2出现2次，3出现2次
// 1.提示用户输入一个正整数并使用变量记录 System.out.println("请输入一个正整数："); Scanner sc = new Scanner(System.in); int num = sc.nextInt(); // 2.准备一个长度为10元素类型int类型的一维数组，默认值为0 int[] arr = new int[10]; // 3.拆分正整数中的每个数字并统计到一维数组中 int temp = num; while(temp > 0) { arr[temp%10]++; temp /= 10; } // 4.打印最终的统计结果 for(int i = 0; i < arr.length; i++) { if(arr[i] > 0) { System.out.println("数字" + i + "出现了" + arr[i] + "次！"); } }
第十六讲：数组实现学生考试成绩的录取和打印
第十七讲：数组实现学生成绩总分和平均分的计算
// 1.提示用户输入学生的人数并使用变量记录 System.out.println("请输入学生的人数："); Scanner sc = new Scanner(System.in); int num = sc.nextInt(); // 2.根据学生的人数来声明对应长度的数组负责记录学生的考试成绩 // 变长数组 ： 主要指变量可以作为数组的长度，但绝不是数组的长度可以发生改变 int[] scores = new int[num]; // 3.提示用户输入每个学生的考试成绩并记录一维数组中 for(int i = 0; i < num; i++) { System.out.println("请输入第" + (i+1) + "个学生的考试成绩："); scores[i] = sc.nextInt(); } // 4.打印所有学生的考试成绩 System.out.print("本班学生的考试成绩分别是："); for(int i = 0; i < scores.length; i++) { System.out.print(scores[i] + " "); } System.out.println(); System.out.println("----------------------------------------------"); // 5.计算本班级学生的总分以及平均分并使用变量记录 int sum = 0; for(int i = 0; i < scores.length; i++) { sum += scores[i]; } double avg = sum*1.0 / num; // 打印最终的计算结果 System.out.println("本班级学生的总分是：" + sum + "，平均分是：" + avg); System.out.println("----------------------------------------------"); // 6.查找本班所有学生考试成绩中的最低分和最高分并打印出来 System.out.println("原始的考试成绩是：" + Arrays.toString(scores)); // 调用工具类中的排序方法对所有考试成绩进行从小到大的排序 Arrays.sort(scores); System.out.println("排序后的考试成绩是：" + Arrays.toString(scores)); System.out.println("最低分是：" + scores[0] + "，最高分是：" + scores[num-1]); System.out.println("----------------------------------------------"); // 从数组中查找指定元素所在的下标位置 System.out.println("59分在数组中的下标位置是：" + Arrays.binarySearch(scores, 59)); System.out.println("60分在数组中的下标位置是：" + Arrays.binarySearch(scores, 60));
第十八讲 - 第二十讲：数组工具类的概念和常用方法
<1>数组工具类的概念：
java.util.Arrays类可以实现对数组中元素的遍历，查找，排序等操作
<2>常用方法如下:
第二十一讲 - 第二十三讲： 二维数组
<1>声明方式：
数据类型 [] [] 变量名 = new 数据类型 [行数] [列数]；
在二维数组中，变量名.length代表行数，
变量名[0].length代表第一行的列数。
<2> 二维数组的遍历：
int[][] arr2 = {{11, 22, 33, 44}, {55, 66, 77, 88}}; // 使用外层for循环控制打印的行数 for(int i = 0; i < arr2.length; i++) { // 使用内层for循环控制打印的列数 for(int j = 0; j < arr2[i].length; j++) { System.out.print(arr2[i][j] + " "); // 11 22 33 44 55 66 77 88 } System.out.println(); }
<3>考点： 可以设置每一行的列数不同的二维数组
// 声明一个，行数为3，但暂时不知道是多少列的二维数组 int [][] arr = new int [3][]; // 声明第一行为3列 arr[0] = new int[3]; // 声明第二行为4列 arr[1] = new int[4]; // 声明第三行为5列 arr[2] = new int[5];
第二十四讲：二维数组实现杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
<1> 每一行的列数与当前的行数相同
<2> 每一行两侧的值均为1
<3> 每一行中间的数的数值 = 上面的数的数值 + 左上的数的数值
<4>代码实现：
// 1.提示用户输入一个行数并使用变量记录 System.out.println("请输入一个行数："); Scanner sc = new Scanner(System.in); int num = sc.nextInt(); // 2.根据用户输入的行数来声明对应的二维数组 int[][] arr = new int[num][]; // 3.针对二维数组中的每个元素进行初始化，使用双重for循环 // 使用外层for循环控制二维数组的行下标 for(int i = 0; i < num; i++) { // 针对二维数组中的每一行进行内存空间的申请 arr[i] = new int[i+1]; // 使用内层for循环控制二维数组的列下标 for(int j = 0; j <= i; j++) { // 当列下标为0或者列下标与当前行的行下标相等时，则对应位置的元素就是1 if(0 == j || i == j) { arr[i][j] = 1; } else { // 否则对应位置的元素就是上一行当前列的元素加上上一行前一列的元素 arr[i][j] = arr[i-1][j] + arr[i-1][j-1]; } } } // 4.打印最终生成的结果 for(int i = 0; i < num; i++) { for(int j = 0; j <= i; j++) { System.out.print(arr[i][j] + " "); } System.out.println(); }
第二十五讲：任务总结
<1>一维数组
基本概念，两种声明方式，增删改查操作，优缺点，数组工具类等
<2>二维数组
