Java基础编程\第二章(基本语法)
文章目录
- 第二章 基本语法
-
- 2.1标识符
-
-
- **Java中名称命名规范**
-
- 2.3变量分类(按照数据类型)
-
- 整型
- 浮点型
- 字符型
- 布尔型
- 2.4基本数据类型的运算规则
- 2.5String类型变量的使用
- 2.6二进制
-
- 原码、补码、反码
- 2.7运算符
-
- 算数运算符
- 赋值运算符
- 比较（关系）运算符
- 逻辑运算符
- 位运算符
-
- Train（2 * 8）
- Train（交换两个变量的值）
- 三元运算符
-
- Train（求60的十六进制值）
- 2.8Scanner类
-
-
- Train（Scanner输入/从键盘获取char）
-
- 2.9程序流程控制
-
- 2.9-1分支结构
-
- Train if-else(排序)
- Train if-else易错
- Train if-else(狗的年龄)
- ==Train(获取随机数)==
- Train(String方法)
- Train switch-case(从键盘获取char)
- Train switch-case(成绩是否及格)
- Train switch-case(已知月日输出某年第多少天)
- 2.9-2循环结构
-
- Train for(最大公约数和最小公倍数)
- Train(读入不确定个数)
- Train(商场库存清单)
- 2.9-3循环结构嵌套
-
- Train(打印*)
- Train(九九乘法表)
- Train(输出100以内的质数)
- Train(获取质数最简最快)
- 2.9-4break和continue
-
- Train(结束指定标识的一层循环结构)
- Train(1000内的完数)
第二章 基本语法
2.1标识符
- 标识符的使用：
标识符:凡是自己可以起名字的地方都叫标识符。比如:类名、变量名、方法名、接口名、包名…
-
标识符的命名规则:
- 由26个英文字母大小写，0-9，_或$组成
- 数字不可以开头。
- 不可以使用关键字和保留字，但能包含关键字和保留字。
- Java中 严格区分大小写，长度无限制
- 标识符不能包含空格。
Java中名称命名规范
- 包名:多单词组成时所有字母都小写: xxxyyyzzz
- 类名、接口名:多单词组成时，所有单词的首字母大写: XxxYyyZzz
- 变量名、方法名:多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写: xxxYyyZzz
- 常量名:所有字母都大写。多单词时每个单词用下划线连接: XXX_YYY_ZZZ
2.3变量分类(按照数据类型)
-
基本数据类型：
- 整型：byte（1字节） / short（2字节） / int（4字节） / long（8字节）
- 浮点型：float / double
- 字符型：char
- 布尔型：boolean
-
引用数据类型：
- 类（class） <——字符串
- 接口（interface）
- 数组（array）
整型
- byte：范围-128~127**（一般用int**）
- 声明long型变量时，必须以"L"或"l"结尾（输出不显示）
浮点型
- float（4字节）/ double（8字节）（一般用double）
- float表示的数值范围比long还大
- 定义float类型变量时，变量要以"f"或"F"结尾
字符型
- char（2字节）
char c1 = 'a'; //声明一个字符
char c2 = '中'; //声明一个字符
char c3 = '1'; //声明一个字符
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
//---------------------------
char c4 = '\n'; //转义字符
char c5 = '\t'; //制表符(Tab键)
System.out.println("hello" + c5);
System.out.println("world");//hello world
//----------------------------------------------
char c6 = '\u0043'; //直接使用Unicode值来表示字符型常量
System.out.println(c6);
//-------------------------------------
char c7 = 97;//开发中很少见
System.out.println(c7);//a
布尔型
boolean bb1 = true; //只能取 true / false
System.out.println(bb1);
//-----------------------------------------
System.out.println("输出\\n"); //输出\n
System.out.println("你不能\"参加\"了"); //输出你不能"参加"了
2.4基本数据类型的运算规则
前提：这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。
- 自动类型提升：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。此时的容量大小指的是，表示数的范围的大和小。比如: float容量要大于long的容量 特别的:当byte、 char、short（包括byte和byte）三种类型的变量做运算时，结果为int型 byte 、char、short --> int --> long --> float --> double
- 强制类型转换：可能导致精度损失
int i2 = 128;
byte b = (byte)i2;
System.out.println(b); //-128(也是一种精度损失)
//原因：128为int占4字节，为0000 0000 0000 0000 0000 0000 1000 0000
// 强制转化为byte后只剩下1字节为：1000 0000
// 最高位的数字变成了符号位：成了负数
// -128的补码为1000 0000（计算机以二进制补码形式保存所有整数）
- 定义long时若没有加"L"或"l"且没有超过int范围会把其当成int使用
- 定义float必须加"F"或"f"，否则编译不成功
- 整型变量：默认类型为int
- 浮点型变量：默认类型为double
float f = 12.3;//编译错误，定义float必须加"f"
float f = (float)12.3;//可以
//---------------------------------------------------
byte b = 12;
byte b1 = b + 1;//编译失败
float f1 = b + 12.3;//编译失败
2.5String类型变量的使用
- String属于引用数据类型，翻译为：字符串
- 声明String类型变量时使用""
String s1 = "Hello World";
System.out.println(s1);
String s2 = "a";//可以
String s3 = "";//可以
char C = '';//编译失败（两个空格可以编译通过）
- String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+，运算结果还是String类型
int number = 1001;
String numberStr = "学号：";
String info = numberStr + number;//学号：1001
boolean b1 = true;
String info1 = info + b1;
System.out.println(info1);//学号：1001true
//------------------------------------------
//输出* *
System.out.println("* *");//可以
System.out.println('*' + '\t' + '*');//第一个'*'代表ASC||码，执行加法
System.out.println('*' + "\t" + '*');//可以
System.out.println('*' + '\t' + "*");//第一个+执行运算
System.out.println('*' + ('\t' + "*"));//可以，先运行为String
2.6二进制
原码、补码、反码
- Java整数常量默认是int类型， 当用二进制定义整数时，其第32位是符号位;当是long类型时， 二进制默认占64位，第64位是符号位
- 二进制的整数有如下三种形式:
- 原码:直接将 一个数值换成二进制数。最高位是符号位
- 负数的反码:是对原码按位取反，只是最高位(符号位)确定为1
- 负数的补码:其反码加1
- 计算机以二进制补码的形式保存所有的整数
- 正数的原码、反码、补码都相同
- 负数的补码是其反码+1
2.7运算符
算数运算符
取模（取余）
- 结果的符号（正负）与被模数相同
int m1 = 12;
int m2 = 5;
System.out.println("m1 % m2 =" + m1 % m2);//若m1为正数，则结果为正数；m1为负数，结果为负数
自增
- 自增(自减)1不会改变自身的数据类型（包括++、+=等）
byte b1 = 127;//b1为0111 1111
b1++;//b1++为1000 0000
System.out.println("b1 =" + b1);//-128
赋值运算符
short s1 = 10;
s1 = s1 + 2;//编译失败，必须要强制类型转化
s1 += 2;//可以，数据类型不变（实际为自动强制转化）！！！！！！
比较（关系）运算符
== != > < >= <= instanceof(比较运算符结果都为boolean型)
逻辑运算符
- 只能适用于布尔类型变量
| & 逻辑与 | | 逻辑或 | ! 逻辑非 |
|---|---|---|
| && 短路与（推荐） | || 短路或（推荐） | ^ 逻辑异或(相同为false) |
- &和&&、|和||结果相同，都为true或false
区分 & 和 &&（& 和 | 无论前面如何，后面都要运算）
boolean b1 = false;
int num1 = 10;
if(b1 & (num1++ > 0)){
System.out.println("T");
}else{
System.out.println("Y");//Y
}
System.out.println("num1 =" + num1);//11
//-------------------------------------------
boolean b2 = false;
int num2 = 10;
if(b2 && (num2++ > 0)){
//两个&&——>短路求值(一个是错就不看了)
System.out.println("T");
}else{
System.out.println("Y");//Y
}
System.out.println("num2 =" + num2);//10
位运算符
位运算操作的都是整形数据
- <<（左移）在一定范围内，每向左移1位，相当于 * 2
- >>（右移）在一定范围内，每向移右1位，相当于 / 2
右移时，最高位为1就全部补1；最高位时0就全部补0
int i = 21;
System.out.println("i << 2=" + (i << 2));//84(21*2*2)
System.out.println("i << 3=" + (i << 3));//168(21*2*2*2)
System.out.println("i << 27=" + (i << 27));//-1476395008(符号位为1)
- >>>（无符号右移）：被移位二进制最高位无论是0或者是1，空缺位都用0补
- &（与运算）：二进制位进行&运算，只有1&1时结果是1，否则是0;
- |（或运算）：二进制位进行|运算，只有0|0时结果是0，否则是1;
- （异或运算）：相同二进制位进行运算，结果是0; 1^1=0 , 0^0=0 ；不相同二进制位运算结果是1。10=1，0^1=1
int m = 12;
int n = 5;
System.out.println("m & n :" + (m & n));//4
System.out.println("m | n :" + (m | n));//13
System.out.println("m ^ n :" + (m ^ n));//9
可以把1当成true，0当成false
m = k ^ n = (m ^ n) ^ n
- ~（取反运算）：二进制按补码各位取反（ 0 和 1 交换）
Train（2 * 8）
最高效的方式计算 2 * 8 ：2 << 3 或 8 << 1
Train（交换两个变量的值）
int num1 = 10,num2 = 20;
// 1.定义临时变量
int temp = num1;
num1 = num2;
num2 = temp;
System.out.println("num1 = " + num1 +",num2 = " + num2);
//2.累加 好处：不用定义临时变量
// 弊端：1.相加操作可能超出范围 2.有局限性（数据类型限制）：只适用数值类型
num1 = num1 + num2;
num2 = num1 - num2;
num1 = num1 - num2;
System.out.println("num1 = " + num1 +",num2 = " + num2);
三元运算符
(条件表法式) ? 表达式1 : 表达式2（三元运算符（优先）都可以写成if-else，if-else不一定能写成三元运算符）
- 条件表达式的结果为boolean类型
- 条件表达式为true执行表达式1，条件表达式为false执行表达式2
- 表达式1 和 表达式2要求统一为一个类型接受
- 三元运算符可以嵌套使用
int m = 12,n = 12;//获取两个数的最大值
String maxStr = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");//嵌套
System.out.println(maxStr);
//---------------------------------
int n1 = 12,n2 = 34,n3 = -12;//获取三个数的最大值
int max1 = (n1 > n2)? n1 : n2;
int max2 = (max1 > n3)? max1 : n3;
System.out.println("最大的数为" + max2);
Train（求60的十六进制值）
求一个0~255范围内的正数的十六进制值，以60为例：
//方法一：自动实现
String str1 = Integer.toBinaryString(60);//输出60的二进制
String str2 = Integer.toHexSring(60);//输出60的十六进制
//方法二：手动实现
int i1 = 60;//60的二进制：0000 0000 0000 0000 0000 0000 0011 1100
int i2 = i1 & 15;//15的二进制：0000 0000 0000 0000 0000 0000 0000 1111
//i1 & 15 取出了 "1100"
String j = (i2 > 9)? (char)(i2 - 10 +'A') + "" : i2 + "";//看i2是否超过9，转化成16进制
int i1 >>> 4;//开始提取0011，无符号右移后二进制成了0000 0000 0000 0000 0000 0000 0000 0011
i2 = temp & 15;//提取0011
String k = (i2 > 9)? (char)(i2 - 10 +'A') + "" : i2 + "";
System.out.println(k + "" + j);
2.8Scanner类
如何从键盘获取不同类型的变量：需要使用Scanner类
- 导包: import java.util.Scanner;
- Scanner的实例化:Scanner scan = new Scanner(System. in);
- 调用Scanner类的相关方法，来获取指定类型的变量
import java.util.Scanner;
class ScannerTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int num = scan.nextInt();//方法nextInt可以从输入中读取一个int值
System.out.println(num);
}
}
Train（Scanner输入/从键盘获取char）
import java.util.Scanner;
class ScannerTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
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);
}
}
注意：需要根据对应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException,导致程序终止
2.9程序流程控制
- 顺序结构
- 分支结构
- if-else（条件判断结构）：if(条件表达式)结果为true或false
- 单分支
- 双分支（二选一）
- 多分支（多选一）
- switch-case：switch(表达式)表达式不是条件表达式switch结构中的表达式，只能是如下的6种数据类型之一: byte、short、char、int、枚举类型（JDK5.0新增）、String类型（JDK8.0新增）
- if-else（条件判断结构）：if(条件表达式)结果为true或false
- 循环结构
- for（for和while可以相互转化）
- while(迭代条件)
- do-while
跳出循环两种方式：
- 循环条件部分返回false
- 在循环体中，执行break
continue:跳出当次循环 / return:结束方法（方法里包括循环）
2.9-1分支结构
Train if-else(排序)
/*编写程序:由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用if-else if-else)，并且从小到大输出。*/
import java.util.Scanner;
class IfTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个整数：");
int num1 = scan.nextInt();
System.out.println("请输入第二个整数：");
int num2 = scan.nextInt();
System.out.println("请输入第三个整数：");
int num3 = scan.nextInt();
if(num1 > num2){
if(num3 > num1){
System.out.println(num2 + "," + num1 + "," + num3);
}else if(num3 < num2){
System.out.println(num3 + "," + num2 + "," + num1);
}else{
System.out.println(num1 + "," + num3 + "," + num2);
}
}else{
if(num3 > num2){
System.out.println(num1 + "," + num2 + "," + num3);
}else if(num3 < num1){
System.out.println(num3 + "," + num1 + "," + num2);
}else{
System.out.println(num1 + "," + num3 + "," + num2);
}
}
}
}
Train if-else易错
//if-else语句不带大括号只包含一行
int x = 4;
int y = 1;
if(x > 2){
if(y > 2)
System.out.println("x + y");
System.out.println("shanwenyan");//输出(大括号)
}else
System.out.println("x - y");
Train if-else(狗的年龄)
/*我家的狗5岁了，5岁的狗相当于人类多大呢?其实，狗的前两年每一年相当于人类的10.5岁，之后每增加一-年就增加四岁。那么5岁的狗相当于人类多少年龄呢?应该是: 10.5+ 10.5+ 4+4+ 4= 33岁。*/
import java.util.Scanner;
class train{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入狗的年龄：");
double dogAge = scan.nextDouble();
if(dogAge > 0 && dogAge <= 2){
System.out.println("相当于人的" + dogAge * 10.5 + "岁");
}else if(dogAge > 2){
System.out.println("相当于人的" + (10.5 * 2 + (dogAge - 2) * 4) + "岁");
}else{
System.out.println("error");
}
}
}
Train(获取随机数)
//公式：[a,b]范围： (int)(Math.random() * (b -a + 1) + a)
--------------------------------------------------------
//获取[10,99]
//int value = Math.random(); 该方法范围为[0.0,1.0)
int value = (int)(Math.random() * 90 + 10);//范围为[10,99]
System.out.println("value");
Train(String方法)
//字符串：c.equals("是")
class train{
public static void main(String[] args){
int a = 1,b = 2;
String c = "是";
if(a < 2 && b < 3 && c.equals("是")){
//或c == "是"
System.out.println("zhen");
}else if(a < 1 || b < 2 || c.equals("是")){
System.out.println("jia");
}else{
System.out.println("error");
}
}
}
Train switch-case(从键盘获取char)
import java.util.Scanner;
class TestSwitch1
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
char i = scan.next().charAt(0);//char i = scan.nextChar();
/*
String s = scan.next();
char i = s.charAt(0);
*/
//在这里，从键盘上无法直接输入char类型的数据，
//只能通过输入字符串的形式，截取第一个字符来实现
switch(i){
case 'a':
System.out.println("A");
break;
case 'b':
System.out.println("B");
break;
case 'c':
System.out.println("C");
break;
case 'd':
System.out.println("D");
break;
case 'e':
System.out.println("E");
break;
default:
System.out.println("other");
break;
}
}
}
Train switch-case(成绩是否及格)
//成绩是否及格
int score = 78;
switch(score / 10){
//case情况过多
case 0:
case 1:
case 2:
case 3:
case 4:
case 5://多个case合并
System.out.println("不及格");
break;
case 6:
case 7:
case 8:
case 9:
case 10:
System.out.println("及格");
break;
}
---------------------------------------
int score = 78;
switch(score / 60){
case 0:
System.out.println("不及格");
break;
case 1:
System.out.println("及格");
break;
}
Train switch-case(已知月日输出某年第多少天)
//输入month和day计算为某年的第几天
//倒着计算可以避免冗余，不用每次都重新计算！
import java.util.Scanner;
class SwitchCaseTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入year：");
int year = scan.nextInt();
System.out.println("请输入month：");
int month = scan.nextInt();
System.out.println("请输入day：");
int day = scan.nextInt();
int sumDay = 0;
switch(month){
case 12:
sumDay += 30;//十一月
case 11:
sumDay += 31;//十月
case 10:
sumDay += 30;
case 9:
sumDay += 31;
case 8:
sumDay += 31;
case 7:
sumDay += 30;
case 6:
sumDay += 31;
case 5:
sumDay += 30;
case 4:
sumDay += 31;
case 3:
if((year % 4 == 0 && year % 100 != 0)|| year % 400 ==0){
sumDay += 29;
}else{
sumDay += 28;
}
case 2:
sumDay += 31;
case 1:
sumDay += day;
}
System.out.println(year + "年" + month + "月" + day + "日为" + year + "年第" + sumDay + "天");
}
}
2.9-2循环结构
循环结构的4个要素：1.初始化条件 2.循环条件（boolean类型） 3.循环体 4.迭代条件
Train for(最大公约数和最小公倍数)
//题目:输入两个正整数m和n，求其最大公约数和最小公倍数。
import java.util.Scanner;
class ForTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个正整数");
int num1 = scan.nextInt();
System.out.println("请输入第二个正整数");
int num2 = scan.nextInt();
//获取最大公约数
int min = (num1 <= num2)? num1 : num2;//获取两个数中较小值
for(int i = min;i >= 1;i--){
//最大公约数：从大到小找
if(num1 % i == 0 && num2 % i == 0){
System.out.println("最大公约数为" + i);
break;//只输出一个数就跳出循环
}
}
//获取最小公倍数
int max = (num1 >= num2)? num1 : num2;//获得两个数中的较大值
for(int j = max;j <= num1 * num2;j++){
if(j % num1 == 0 && j % num2 == 0){
System.out.println("最小公倍数为" + j);
break;
}
}
}
}
Train(读入不确定个数)
//从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
//for(;;) == while(true)
import java.util.Scanner;
class Train{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int positiveNumber = 0;
int negativeNumber = 0;
while(true){
//for(;;) == while(true)
int number = scan.nextInt();
if(number > 0){
positiveNumber++;
}else if(number < 0){
negativeNumber++;
}else{
break;
}
}
System.out.println("正数的个数为" + positiveNumber);
System.out.println("负数的个数为" + negativeNumber);
}
}
Train(商场库存清单)
class Computer{
public static void main(String[] args){
//苹果笔记本
String macBrand = "MacBookAir";
double macSize = 13.3;
double macPrice = 6988.88;
String macConfig = "i5处理器4GB";
int macCount = 5;
//联想ThinkPad
String thinkPadBrand = "联想ThinkPad T450";
double thinkPadSize = 14;
double thinkPadPrice = 5900;
String thinkPadConfig = "i5处理器4GB";
int thinkPadCount = 9;
//华硕ASUS
String ASUSBrand = "ASUS-FL580";
double ASUSSize = 15.6;
double ASUSPrice = 4988.88;
String ASUSConfig = "i7处理器4GB";
int ASUSCount = 7;
//列表顶部
System.out.println("-----------------------------------------------商场库存清单"
+ "--------------------------------------------------");
//列表中部
System.out.println("品牌型号 尺寸 价格 配置 数量 ");
System.out.println(macBrand + " " + macSize + " " + macPrice +
" " + macConfig + " " + macCount + " ");
System.out.println(thinkPadBrand + " " + thinkPadSize + " " + thinkPadPrice +
" " + thinkPadConfig + " " + thinkPadCount + " ");
System.out.println(ASUSBrand + " " + ASUSSize + " " + ASUSPrice +
" " + ASUSConfig + " " + ASUSCount + " ");
//列表尾部
System.out.println("-----------------------------------------------" +
"--------------------------------------------------------------");
double sumPrice = macPrice + thinkPadPrice + ASUSPrice;
int sumCount = macCount + thinkPadCount + ASUSCount;
System.out.println("库存机子总价格：" + sumPrice);
System.out.println("库存机子的总数为：" + sumCount);
}
}
2.9-3循环结构嵌套
Train(打印*)
/*输出(i:控制行数，j：控制列数)
****
***
**
*
*/
for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 5 - i;j++){
//i + j = 5
System.out.print("*");
}
System.out.println();//一行输出完后换行
}
----------------------------------------------------------
/*输出 （增减不一致，必须分两步写）
*
**
***
****
*****
****
***
**
*
*/
class Train{
public static void main(String[] args){
//上半部分
for(int i = 1;i <=5;i++){
for(int j = 1;j <= i;j++){
System.out.print("*");
}
System.out.println();
}
//下半部分
for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 5 - i;j++){
//i + j = 5
System.out.print("*");
}
System.out.println();//一行输出完后换行
}
}
}
/*打印
*
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
*
*/
class Train{
public static void main(String[] args){
// 上半部分
for (int i = 0; i < 5; i++) {
// 输出“-”
for (int j = 0; j < 4 - i; j++) {
System.out.print(" ");
}
// 输出“* ”
for (int k = 0; k < i + 1; k++) {
System.out.print("* ");
}
System.out.println();
}
// 下半部分
for (int i = 0; i < 4; i++) {
for (int j = 0; j < i + 1; j++) {
System.out.print(" ");
}
for (int k = 0; k < 4 - i; k++) {
System.out.print("* ");
}
System.out.println();
}
}
}
Train(九九乘法表)
class Train{
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();
}
}
}
Train(输出100以内的质数)
//质数：素数，只能被1和它本身整除的自然数-->从2开始到这个数-1为止，都不能被这个数整除
class PrimeNumberTest{
public static void main(String[] args){
boolean isFlag = true;
for(int i = 2;i <= 100;i++){
//遍历100以内的自然数
for(int j = 2;j < i;j++){
//j：被i除（i以内的数，2到i-1）
if(i % j == 0){
isFlag = false; //i被j除尽过就进来，isFlag值改变
}
}
if(isFlag == true){
//没被除尽过，所以为质数
System.out.println(i);
}
isFlag = true;//重置isFlag
}
}
}
----------------------------------------------------------------
//优化1： 加break（对本身非质数的自然数有效）
class PrimeNumberTest{
public static void main(String[] args){
//获取当前时间距离1970-01-01 00：00：00 的毫秒数
long start = System.currentTimeMillis();
boolean isFlag = true;
for(int i = 2;i <= 100;i++){
//遍历100以内的质数
for(int j = 2;j < i;j++){
//j：被i除（i以内的数，2到i-1）
if(i % j == 0){
isFlag = false; //i被j除尽过就进来，isFlag值改变
break; //一旦有一个数被除尽了就不是质数，就不用算到i-1了。只对本身非质数的数有效，对质数无效，质数还是要算到i-1。
}
}
if(isFlag == true){
//没被除尽过，所以为质数
System.out.println(i);
}
isFlag = true;//重置isFlag
}
//获取当前时间距离1970-01-01 00：00：00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("共花费的时间为" + (end - start));
}
}
----------------------------------------------------------------
//优化2：j <= Math.sqrt(i)（对本身质数的自然数有效）
class PrimeNumberTest{
public static void main(String[] args){
//获取当前时间距离1970-01-01 00：00：00 的毫秒数
long start = System.currentTimeMillis();
boolean isFlag = true;
for(int i = 2;i <= 100;i++){
//遍历100以内的质数
for(int j = 2;j <= Math.sqrt(i);j++){
/*
j <= Math.sqrt(i)即可
1 * 16 = 16、2 * 8 = 16、4 * 4 = 16；
前面的数在增大，后面的数在减小，极限为 根号16（取根号）
前面都除不尽，后面肯定也除不尽
*/
if(i % j == 0){
isFlag = false; //i被j除尽过就进来，isFlag值改变
break;
}
}
if(isFlag == true){
//没被除尽过，所以为质数
System.out.println(i);
}
isFlag = true;//重置isFlag
}
//获取当前时间距离1970-01-01 00：00：00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("共花费的时间为" + (end - start));
}
}
---------------------------------------------------------------
---------------------------------------------------------------
//因为每次输出质数会拖慢运算时间，如果只计算质数的个数，运行速度会快很多！
class PrimeNumberTest{
public static void main(String[] args){
//获取当前时间距离1970-01-01 00：00：00 的毫秒数
long start = System.currentTimeMillis();
int count = 0;
boolean isFlag = true;
for(int i = 2;i <= 100;i++){
//遍历100以内的质数
for(int j = 2;j <= Math.sqrt(i);j++){
/*
j <= Math.sqrt(i)即可
1 * 16 = 16、2 * 8 = 16、4 * 4 = 16；
前面的数在增大，后面的数在减小，极限为 根号16（取根号）
前面都除不尽，后面肯定也除不尽
*/
if(i % j == 0){
isFlag = false; //i被j除尽过就进来，isFlag值改变
break;
}
}
if(isFlag == true){
//没被除尽过，所以为质数
count++;//System.out.println(i);
}
isFlag = true;//重置isFlag
}
//获取当前时间距离1970-01-01 00：00：00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("共有的质数为：" + count);
System.out.println("共花费的时间为" + (end - start));
}
}
Train(获取质数最简最快)
class PrimeNumberTest{
public static void main(String[] args){
//获取当前时间距离1970-01-01 00：00：00 的毫秒数
long start = System.currentTimeMillis();
int count = 0;
label:for(int i = 2;i <= 100;i++){
//遍历100以内的质数
for(int j = 2;j <= Math.sqrt(i);j++){
if(i % j == 0){
continue label;
}
}
//continue结束外部循环，所以count++在内循环外
count++;//System.out.println(i);
}
//获取当前时间距离1970-01-01 00：00：00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("共有的质数为：" + count);
System.out.println("共花费的时间为" + (end - start));
}
}
2.9-4break和continue
- break适用范围：
- switch-case
- 循环结构中（结束==当前==循环）
- continue适用范围：
- 循环结构中（结束==当次==循环）
break和continue关键字后面不能声明执行语句
Train(结束指定标识的一层循环结构)
label:for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
break label; //结束指定标识的一层循环结构
//输出123
//continue label; //结束指定标识的一层循环结构的当次循环
//输出123123123123
}
System.out.print(j);
}
System.out.println();
}
Train(1000内的完数)
class Train{
public static void main(String[] args){
/*
一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1+2+3.
编程找出1000以内的所有完数。 (因子:除去这个数本 身的其它约数)
*/
for(int i = 1;i <= 1000;i++){
int factor = 0;//每次新定义一个factor，不用重置了
for(int j = 1;j <= i/2;j++){
//j <= i/2即可
if(i % j == 0){
factor += j;
}
}
if(i == factor){
System.out.println(i);
}
}
}
}