文章目录
第二章 基本语法
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);
}
}
}
}