1.开发环境搭建
1.1 JDK,JRE,JVM 的关系：
JDK : JER + 开发工具集（例如Javac编译工具等）
JRE : JVM + Java SE 标准类库
1.2 JDK的下载和安装
下载： 官网，github
https://www.oracle.com/index.html
链接：https://pan.baidu.com/s/1LPfM6qlup2_2aIy6ZJLg6w
提取码：8888
安装：傻瓜式安装，JDK，JRE
注意：安装软件的路径不能包含中文，空格)
新版windows10系统有可能出现JDK8点完安装，页面直接消失不见，有可能是输入法导致的，切换输入法变成系统默认输入法即可
1.3 如何配置
新版windows和以前有点小区别，需要在我的电脑右键选择->属性->关于->高级系统设置->环境变量设置
2.关键字和标识符
2.1 Java中的关键字的使用
定义：被Java语言赋予特殊的含义，用作专门用途的字符串（单词）
特点：关键字中字母都为小写
2.2 具体的关键字
2.3 保留字现在Java版本还没有使用，但以后的版本可能会作为关键字使用
具体的保留字：goto，const
注意：自己命名的标识符都要避免使用这些保留字
2,.4 标识符的使用
定义：凡是自己可以起名字的地方就叫标识符
涉及的结构：包名，类名，接口名，方法名，常量名
规则：（必须遵守，否则，编译不通过）
>由26个英文字母大小写，0~9，_或 $ 组成
>数字不可以开头
>不可以使用关键字和保留字，但可以包含保留字和关键字
>Java中严格区分大小写，长度无限制
>标识符不能包含空格
规范：（可以不遵守，不影响编译和运行，但是要求遵守）
>包名：多单词组成时所有字母都是小写：xxxyyyzzz
>类名，接口名：多单词组成，所有单词首字母大写：XxxYyyZzz
>变量名，方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
注意点：
>在起名字时，为了提高代码阅读性，要尽量实现 "见名知意" 的意义
3.变量的使用
3.1 按数据类型分类
1.整型：byte（1字节=8bit）\ short（2字节）\ int（4字节）\ long（8字节）
①：byte范围：-128 ~ 127之内
②：声明long类型变量，必须以 l 或者 L 结尾
③：通常定义变量时，使用 int 型
④：整型的常量：默认的类型是 int 类型
2.浮点型：float （4字节） / double （8字节）
①：浮点型，表示带有小数点的数值
②：float表示数据的范围比 long 还要大
③：定义float变量时，变量要以 f 或者 F 结尾
④：通常,定义浮点型变量时，使用double类型
⑤：浮点型的常量，默认的类型是 double
3.字符型 char （1字符=2字节）
①：定义char型变量，通常使用一堆 ’ ’ (英文输入法下的单引号)，内部只能使用一个字符
②：表示方式 1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
4.布尔型 boolean
①：只能取两个值： true 和 false
②：常常在条件判断时，循环结构中使用
3.2 按声明位置分为
3.3 定义变量的格式
数据类型 变量名=变量值；
或
数据类型 变量名； 变量名 = 变量值；
3.4 变量使用的注意点
①：变量必须先声明，后使用
②：变量都定义在其作用域内，在作用域内，它是有效的，换句话说，出了作用域，他就无效了
③：同一个作用域内，不可以声明两个同名的变量
3.5基本数据类型间的变量运算规则 （除boolean之外的其他7中类型）
自动类型转换：从小到大
byte，char，short—>int----->long---->float—>double
特别之处：当byte，char，short三种类型在做变量类型运算的时候，结果都是int类型
说明：此时所指的容量大小指的是，表示数的大小，比如：float容量要大于long的容量
强制类型转换：从大到小-自动类型提升的逆运算
①：需要使用强转符 （）
②：由高精度向低精度转化可能存在损失精度
String与8种基本数据类型的运算
①：String属于引用类型，翻译过来就是 字符串
②：声明String类型的变量时，使用一对双引号（英语输入法下）" "
③：String可以和8种基础类型做运算，且只能是连接运算：+
④：运算结果让然是String类型
避免：
String str=123; // 编译错误
String str1=“123”;
int i=(int) str1;//编译错误
4.计算机中的进制
4.1 编程中涉及的进制和表示方式
二进制(binary)：0,1，满2进一，以0b或者0B开头
十进制(decimal):0~9，满10进一，正常生活中使用
八进制(octal):0~7，满8进一，以数据0开头表示
十六进制(hex):0~9及A-F,满16进一，以0X或0x开头，此处的A-F不区分大小写
如：0x21AF+1=0x21B0
4.2 二进制在计算机中的使用
计算机底层的存储方式：所有数字在计算机底层都是以二进制形式存在
二进制数据存储的方式：所有的数值，不管正负，底层都以补码的方式存在
原码，反码，补码的说明：
正数：三码合一
负数：
原码：直接将一个数值转化为二进制数，最高位是符号位
负数的反码：是对原码按位取反，知识最高位（符号位）确定是1
负数的补码：在其反码的基础上+1
5.运算符
5.1 算数运算符
算数运算符有：
＋（加），-（减），*（乘） ，/（除） ,%（取模），（前++）++，（后加加）++，（前- -）-，（后- - ）-，（正）+，（负）-
代码
//除号：/
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2;
System.out.println(result1);//2
// %:取余运算
//结果的符号与被模数的符号相同
//开发中，经常使用%来判断能否被除尽的情况。
int m1 = 12;
int n1 = 5;
System.out.println("m1 % n1 = " + m1 % n1);
int m2 = -12;
int n2 = 5;
System.out.println("m2 % n2 = " + m2 % n2);
int m3 = 12;
int n3 = -5;
System.out.println("m3 % n3 = " + m3 % n3);
int m4 = -12;
int n4 = -5;
System.out.println("m4 % n4 = " + m4 % n4);
//(前)++ :先自增1，后运算
//(后)++ :先运算，后自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + ",b1 = " + b1);
int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + ",b2 = " + b2);
int a3 = 10;
++a3;//a3++;
int b3 = a3;
//(前)-- :先自减1，后运算
//(后)-- :先运算，后自减1
int a4 = 10;
int b4 = a4--;//int b4 = --a4;
System.out.println("a4 = " + a4 + ",b4 = " + b4);
特别说明的
(前)++ :先自增1，后运算
(后)++ :先运算，后自增1
(前)-- :先自减1，后运算
(后)-- :先运算，后自减1
连接符：+：只能使用在String与其他数据类型变量之间使用。
5.2 赋值运算符：= += -= *= /= %=
int i2,j2;
//连续赋值
i2 = j2 = 10;
//***************
int i3 = 10,j3 = 20;
int num1 = 10;
num1 += 2;//num1 = num1 + 2;
System.out.println(num1);//12
int num2 = 12;
num2 %= 5;//num2 = num2 % 5;
System.out.println(num2);
short s1 = 10;
//s1 = s1 + 2;//编译失败
s1 += 2;//结论：不会改变变量本身的数据类型
System.out.println(s1);
特别说明
如果希望变量实现+2的操作，有几种方法？(前提：int num = 10;)
num = num + 2;
num += 2; (推荐)
如果希望变量实现+1的操作，有几种方法？(前提：int num = 10;)
num = num + 1;
num++;
num++; (推荐)
5.3 比较运算符
>（关系运算符）: == != > < >= <= instanceof
int i = 10;
int j = 20;
System.out.println(i == j);//false
System.out.println(i = j);//20
boolean b1 = true;
boolean b2 = false;
System.out.println(b2 == b1);//false
System.out.println(b2 = b1);//true
特别说明
比较运算符的结果是boolean类型
> < >= <= :只能使用在数值类型的数据之间
== 和 !=: 不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间
Account acct1 = new Account(1000);
Account acct2 = new Account(1000);
boolean b1 = (acct1 == acct2);//比较两个Account是否是同一个账户。
boolean b2 = (acct1 != acct2);//
5.4 .逻辑运算符
& && | || ! ^
//区分& 与 &&
//相同点1：& 与 && 的运算结果相同
//相同点2：当符号左边是true时，二者都会执行符号右边的运算
//不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
//开发中，推荐使用&&
boolean b1 = true;
b1 = false;
int num1 = 10;
if(b1 & (num1++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num1 = " + num1);
boolean b2 = true;
b2 = false;
int num2 = 10;
if(b2 && (num2++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num2 = " + num2);
// 区分：| 与 ||
//相同点1：| 与 || 的运算结果相同
//相同点2：当符号左边是false时，二者都会执行符号右边的运算
//不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
//开发中，推荐使用||
boolean b3 = false;
b3 = true;
int num3 = 10;
if(b3 | (num3++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num3 = " + num3);
boolean b4 = false;
b4 = true;
int num4 = 10;
if(b4 || (num4++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num4 = " + num4);
特别说明
逻辑运算符操作的都是boolean类型的变量。而且结果也是boolean类型
5.5 位运算符
<< >> >>> & | ^ ~
int i = 21;
i = -21;
System.out.println("i << 2 :" + (i << 2));
System.out.println("i << 3 :" + (i << 3));
System.out.println("i << 27 :" + (i << 27));
int m = 12;
int n = 5;
System.out.println("m & n :" + (m & n));
System.out.println("m | n :" + (m | n));
System.out.println("m ^ n :" + (m ^ n));
//【面试题】 你能否写出最高效的2 * 8的实现方式？
//答案：2 << 3 或 8 << 1
特别说明
位运算符操作的都是整型的数据
<< ：在一定范围内，每向左移1位，相当于 * 2
>> :在一定范围内，每向右移1位，相当于 / 2
5.5 三元运算符
(条件表达式)? 表达式1 : 表达式2
public static void main(String[] args) {
int a = 10;
int b = 9;
System.out.println(a > b ? a : b);
}
特别说明
条件表达式的结果为boolean类型
根据条件表达式真或假，决定执行表达式1，还是表达式2.
如果表达式为true，则执行表达式1。
如果表达式为false，则执行表达式2。
表达式1 和表达式2要求是一致的。
三元运算符可以嵌套使用
凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立。
如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
6.流程控制
6.1 分支结构
- 1.if-else条件判断结构
结构一：
if（条件表达式）{
执行表达式
}
结构二：（二选一）
if（条件表达式你）{
执行表达式一
}else{
执行表达式二
}
结构二:（n选一）
if（条件表达式）{
执行表达式一
}else if（条件表达式）{
执行表达式二
}else if（条件表达式）{
执行表达式三
}
......
else{
执行表达式N
}
6.2 说明
1. else 结构是可选的
2. 针对于条件表达式
3. if -else 之间是可以循环嵌套的
4. 如果if-else 结构中执行语句只有一行时，对应的一对{ }是可以省略的，但是不建议省略
- 如果多个表达式之间是互斥关系，或没有交集的关系，哪个在上面做判断没有关系，无所谓
- 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面，否则，范围小的就没有机会执行了
- 如果多个表达式之间是包含的关系，通常情况下，需要将范围小的声明在范围大的上面，否则，范围小的就没有机会执行了
6.3 switch-case选择结构
switch(表达式){
case 常量一:
执行语句一
break;
case 常量二:
执行语句二:
break;
......
default:
执行语句n
break;
}
6.4说明
- 根据switch表达式中的值，依次匹配各个case中的常量，一旦匹配成功，则进入相应的case中，调用其执行语句，当调用完执行语句后，继续向下执行其他case语句，直到遇到break语句或者switch-case末尾结束为止；
- break，可以使用在switch-case中，表示一旦使用执行到此关键字，就跳出switch-case结构
- switch语句，只能使用如下6种数据类型之一
byte，short，char，int，枚举类（Enum jdk1.5新增),String（jdk7.0新增） - case之后只能声明常量，不能声明范围
- break关键字是可选的，
- default：相当于if -else 中的else结构
default：结构是可选的，而且位置是灵活的 - 如果switch-case中多个case执行语句相同，则可以考虑合并执行语句
- break在switch-case语句中是可选的
练习：
/*
break和continue关键字的使用
使用范围 循环中使用的作用(不同点) 相同点
break: switch-case
循环结构中 结束当前循环 关键字后面不能声明执行语句
continue: 循环结构中 结束当次循环 关键字后面不能声明执行语句
*/
class BreakContinueTest {
public static void main(String[] args) {
for(int i = 1;i <= 10;i++){
if(i % 4 == 0){
break;//123
//continue;//123567910
//System.out.println("今晚迪丽热巴要约我！！！");
}
System.out.print(i);
}
System.out.println("\n");
//******************************
label:for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break;//默认跳出包裹此关键字最近的一层循环。
//continue;
//break label;//结束指定标识的一层循环结构
continue label;//结束指定标识的一层循环结构当次循环
}
System.out.print(j);
}
System.out.println();
}
}
}
7.循环结构
7.1循环结构的四要素
-
初始化条件
-
循环条件 ------>是boolean类型
-
循环体
-
迭代条件
说明：通常情况下，循环结束都是因为2中循环条件返回false了
7.2 三种循环结构
7.2.1 for 循环结构
for（①;②;④）{
③;
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - … - ④
class ForTest {
public static void main(String[] args) {
/*
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
*/
for(int i = 1;i <= 5;i++){//i:1,2,3,4,5
System.out.println("Hello World!");
}
//i:在for循环内有效。出了for循环就失效了。
//System.out.println(i);
//练习：
int num = 1;
for(System.out.print('a');num <= 3;System.out.print('c'),num++){
System.out.print('b');
}
//输出结果：abcbcbc
System.out.println();
//例题：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
int sum = 0;//记录所有偶数的和
int count = 0;//记录偶数的个数
for(int i = 1;i <= 100;i++){
if(i % 2 == 0){
System.out.println(i);
sum += i;
count++;
}
//System.out.println("总和为：" + sum);
}
System.out.println("总和为：" + sum);
System.out.println("个数为：" + count);
}
}
7.2.2 while循环结构
①
while(②){
③;
④;
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ② - ③ - ④ - …②
说明：写while循环千万不要忘记丢了迭代条件，一旦丢了，就可能导致死循环
for 和 while 循环总结：
- 开发中，基本上我们都会从for 和while中选择，实现循环结构
- for 循环和 while 循环是可以相互转化的;
区别：for 循环和 while 循环的初始条件部分的作用范围不同 - 我们写程序，需要注意，避免出现死循环的出现
练习：
/*
While 循环的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件
二、while循环的结构
①
while(②){
③;
④;
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
说明：
1.写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
2.我们写程序，要避免出现死循环。
3.for循环和while循环是可以相互转换的！
区别：for循环和while循环的初始化条件部分的作用范围不同。
算法：有限性。
*/
class WhileTest{
public static void main(String[] args) {
//遍历100以内的所有偶数
int i = 1;
while(i <= 100){
if(i % 2 == 0){
System.out.println(i);
}
i++;
}
//出了while循环以后，仍可以调用。
System.out.println(i);//101
}
}
7.2.3 do - while 循环
①
do{
③;
④;
}while(②);
执行过程：① - ③ - ④ - ② - ③ - ④ - … - ②
说明：
- do -while循环至少会执行一次循环体；
- 开发中，for 和 while循环能多一点，较少使用do - while循环
- 无限循环结构：while(true) / for( ; ; )
练习：
/*
do-while循环的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件
二、do-while循环结构：
①
do{
③;
④;
}while(②);
执行过程：① - ③ - ④ - ② - ③ - ④ - ... - ②
说明：
1.do-while循环至少会执行一次循环体！
2.开发中，使用for和while更多一些。较少使用do-while
*/
class DoWhileTest {
public static void main(String[] args) {
//遍历100以内的偶数,并计算所有偶数的和及偶数的个数
int num = 1;
int sum = 0;//记录总和
int count = 0;//记录个数
do{
if(num % 2 == 0){
System.out.println(num);
sum += num;
count++;
}
num++;
}while(num <= 100);
System.out.println("总和为：" + sum);
System.out.println("个数为：" + count);
//*************体会do-while至少执行一次循环体***************
int number1 = 10;
while(number1 > 10){
System.out.println("hello:while");
number1--;
}
int number2 = 10;
do{
System.out.println("hello:do-while");
number2--;
}while(number2 > 10);
}
}
总结：如何结束一个循环结构
方式一：当循环条件是false的时候
方式二：在循环体中，执行break;
7.2.4 嵌套循环
嵌套循环，将一个循环A声明在循环B中，就构成了嵌套循环，
内层循环A
外层循环B
说明
- 内层循环结构遍历一遍，相当于外层循环执行一次
- 假设外层循环执行m次，内层循环执行n次，此时内层循环一共执行了 m * n 次
- 外层循环控制行数，内层循环控制列数
/*
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环
2.
外层循环：循环结构B
内层循环：循环结构A
3. 说明
① 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次
4. 技巧：
外层循环控制行数，内层循环控制列数
*/
class ForForTest {
public static void main(String[] args) {
//******
//System.out.println("******");
for(int i = 1;i <= 6;i++){
System.out.print('*');
}
System.out.println("\n");
/*
******
******
******
******
*/
for(int j = 1;j <= 4;j++ ){
for(int i = 1;i <= 6;i++){
System.out.print('*');
}
System.out.println();
}
/* i(行号) j(*的个数)
* 1 1
** 2 2
*** 3 3
**** 4 4
***** 5 5
*/
for(int i = 1;i <= 5;i++){//控制行数
for(int j = 1;j <= i;j++){//控制列数
System.out.print("*");
}
System.out.println();
}
/* i(行号) j(*的个数) 规律：i + j = 5 换句话说：j = 5 - i;
**** 1 4
*** 2 3
** 3 2
* 4 1
*/
for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 5 - i;j++){
System.out.print("*");
}
System.out.println();
}
/*
*
**
***
****
*****
****
***
**
*
*/
//略
/*
----*
---* *
--* * *
-* * * *
* * * * *
* * * *
* * *
* *
*
*/
//上半部分
//下半部分
}
}
/*
题目：
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
说明：
1. 不在循环条件部分限制次数的结构：for(;;) 或 while(true)
2. 结束循环有几种方式？
方式一：循环条件部分返回false
方式二：在循环体中，执行break
*/
import java.util.Scanner;
class ForWhileTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int positiveNumber = 0;//记录正数的个数
int negativeNumber = 0;//记录负数的个数
for(;;){//while(true){
int number = scan.nextInt();
//判断number的正负情况
if(number > 0){
positiveNumber++;
}else if(number < 0){
negativeNumber++;
}else{
//一旦执行break，跳出循环
break;
}
}
System.out.println("输入的正数个数为：" + positiveNumber);
System.out.println("输入的负数个数为：" + negativeNumber);
}
}
/*
嵌套循环的应用1：
九九乘法表
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
。。。
9 * 1 = 9 。。。 9 * 9 = 81
*/
class NineNineTable {
public static void main(String[] args) {
for(int i = 1;i <= 9;i++){
for(int j = 1;j <= i;j++){
System.out.print(i + " * " + j + " = " + (i * j) + " ");
}
System.out.println();
}
}
}
/*
100以内的所有质数的输出。
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。
最小的质数是：2
*/
class PrimeNumberTest {
public static void main(String[] args) {
boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
for(int i = 2;i <= 100;i++){//遍历100以内的自然数
for(int j = 2;j < i;j++){//j:被i去除
if(i % j == 0){ //i被j除尽
isFlag = false;
}
}
//
if(isFlag == true){
System.out.println(i);
}
//重置isFlag
isFlag = true;
}
}
}
/*
题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。
说明：break关键字的使用：一旦在循环中执行到break，就跳出循环
*/
import java.util.Scanner;
class ForTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个正整数：");
int m = scan.nextInt();
System.out.println("请输入第二个正整数：");
int n = scan.nextInt();
//获取最大公约数
//1.获取两个数中的较小值
int min = (m <= n)? m : n;
//2.遍历
for(int i = min;i >= 1 ;i--){
if(m % i == 0 && n % i == 0){
System.out.println("最大公约数为：" + i);
break;//一旦在循环中执行到break，就跳出循环
}
}
//获取最小公倍数
//1.获取两个数中的较大值
int max = (m >= n)? m : n;
//2.遍历
for(int i = max;i <= m * n;i++){
if(i % m == 0 && i % n == 0){
System.out.println("最小公倍数：" + i);
break;
}
}
}
}
/*
100000以内的所有质数的输出。实现方式一
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。
对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumberTest1 {
public static void main(String[] args) {
boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
int count = 0;//记录质数的个数
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
//优化二：对本身是质数的自然数是有效的。
//for(int j = 2;j < i;j++){
for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
if(i % j == 0){ //i被j除尽
isFlag = false;
break;//优化一：只对本身非质数的自然数是有效的。
}
}
//
if(isFlag == true){
//System.out.println(i);
count++;
}
//重置isFlag
isFlag = true;
}
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("质数的个数为：" + count);
System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13
}
}
/*
100000以内的所有质数的输出。实现方式二
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。
对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumberTest2 {
public static void main(String[] args) {
int count = 0;//记录质数的个数
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
label:for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
if(i % j == 0){ //i被j除尽
continue label;
}
}
//能执行到此步骤的，都是质数
count++;
}
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("质数的个数为：" + count);
System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13
}
}
衡量一个代码的优劣：
1. 正确性
2. 可读性
3. 健壮性
4. 高效率和低储存：时间复杂度和空间复杂度(衡量算法的好坏)
8.补充
break和continue关键字的使用
使用范围 循环中使用的作用(不同点) 相同点
break: switch-case
循环结构中 结束当前循环 关键字后面不能声明执行语句
continue: 循环结构中 结束当次循环 关键字后面不能声明执行语句
补充：带标签的break和continue的使用
return在方法中讲。
/*
如何从键盘获取不同类型的变量：需要使用Scanner类
具体实现步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化:Scanner scan = new Scanner(System.in);
3.调用Scanner类的相关方法（next() / nextXxx()），来获取指定类型的变量
注意：
需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException
导致程序终止。
*/
//1.导包：import java.util.Scanner;
import java.util.Scanner;
class ScannerTest{
public static void main(String[] args){
//2.Scanner的实例化
Scanner scan = new Scanner(System.in);
//3.调用Scanner类的相关方法
System.out.println("请输入你的姓名：");
String name = scan.next();
System.out.println(name);
System.out.println("请输入你的芳龄：");
int age = scan.nextInt();
System.out.println(age);
System.out.println("请输入你的体重：");
double weight = scan.nextDouble();
System.out.println(weight);
System.out.println("你是否相中我了呢？(true/false)");
boolean isLove = scan.nextBoolean();
System.out.println(isLove);
//对于char型的获取，Scanner没有提供相关的方法。只能获取一个字符串
System.out.println("请输入你的性别：(男/女)");
String gender = scan.next();//"男"
char genderChar = gender.charAt(0);//获取索引为0位置上的字符
System.out.println(genderChar);
}
}
9510
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
