java api文档
Overview (Java SE 17 & JDK 17)
if-else****结构
java
/*
测试if-else的嵌套使用
案例：有键盘输入三个整数，分别存入变量num1,num2,num3，对他们进行排序（使用if-else,if-else），并且从小到大输出
//拓展：你能实现从大到小顺序的排列吗
1.从开发经验讲，没有写过超过三层的嵌套if-else结构
2.如果if-else中的执行语句块中一行执行语句，则此执行语句所在的一对{}可以省略，但是，不建议省略
*/
class IfElseTest2 {
public static void main(String[] args) {
int num1 = 30;
int num2 = 21;
int num3 = 44;
if(num1 >= num2) {
if(num3 >= num1)
System.out.println(num2 + "," + num1 + "," + num3);
else if(num3 <= num2)
System.out.println(num3 + "," + num2 + "," + num1);
else // num2 < num3
System.out.println(num2 + "," + num3 + "," + num1);
//System.out.println(num2 + "," + num3 + "," + num1);
}else{ // num1 < num2
if(num3 >= num2) {
System.out.println(num1 + "," + num2 + "," + num3);
}else if(num3 <= num1){
System.out.println(num3 + "," + num1 + "," + num2);
}else{ // num1 < num3
System.out.println(num1 + "," + num3 + "," + num2);
}
}
}
}
/*
岳小鹏参加Java考试，他和父亲岳不群达成承诺:
如果:
成绩为100分时，奖励一辆跑车;
成绩为(80，99]时，奖励一辆山地自行车:
当成绩为[60,80]时，奖励环球影城一日游:
其它时，胖揍一顿。
说明:默认成绩是在[0,100]范围内
结论：
1.如果多个表达式之间没有交集（理解是互斥关系），则那个条件表达式声明在上面，哪个声明在下面都可以
如果多个表达式之间是包含关系，则需要将范围小的条件表达式声明在范围大的条件表达式的上面，否则，范围小的条件表达式不可能被执行
*/
class IfElseTest1 {
public static void main(String[] args) {
int score = 61;
if(score == 100){
System.out.println("奖励一辆跑车");
}else if(score > 80 && score <= 99) {
System.out.println("奖励一辆山地自行车");
}else if(score >= 60 && score <= 80) {
System.out.println("奖励环球影城一日游");//奖励环球影城一日游
}else {
System.out.println("胖揍一顿");
}//这样写可以随意交换顺序
score = 88;
if(score == 100){
System.out.println("奖励一辆跑车");
}else if(score >= 60) {
System.out.println("奖励环球影城一日游"); //奖励环球影城一日游
}else if(score > 80) {
System.out.println("奖励一辆山地自行车");
}else {
System.out.println("胖揍一顿");
} //这样写不能交换顺序
}
}
/*
分支结构中的if-else（条件判断结构）
一、三种结构
第一种：
if(条件表达式){
执行表达式
}
第二种：二选一
if(条件表达式){
执行表达式1
}else{
执行表达式2
}
第三种：n选一
if(条件表达式){
执行表达式1
}else if(条件表达式){
执行表达式2
}else if(条件表达式){
执行表达式3
}
...
else{
执行表达式n
}
*/
class IfTest {
public static void main(String[] args) {
//举例1
int heartBeats = 79;
if(heartBeats < 60 || heartBeats > 100){
System.out.println("需要做进一步检查");
}
System.out.println("检查结束");
//举例2
int age = 23;
if(age < 18){
System.out.println("你还可以看动画片");
}else{
System.out.println("你可以看成人电影了");
}
//举例3
if(age < 0){
System.out.println("您输入的数据非法");
}else if(age < 18){
System.out.println("青少年时期");
}else if(age < 35){
System.out.println("青壮年时期");
}else if(age < 60){
System.out.println("中年时期");
}else if(age < 120){
System.out.println("老年时期");
}else{
System.out.println("你是要成仙啊~~");
}
}
}
java
/*
如何从键盘获取不同类型的变量：需要使用Scanner类
具体实现步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化:Scanner scan = new Scanner(System.in);
3.调用Scanner类的相关方法（next() / nextXxx()），来获取指定类型的变量
注意：
需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException
导致程序终止。
如何从键盘获取不同类型(基本数据类型、string类型)的变量:使用Scanner类。
1.使用Scanner获取不同类型数据的步骤
步骤1:导包import iava.util.Scanner
步骤2:提供(或创建)一个Scanner类的实例
步骤3:调用Scanner类中的方法，获取指定类型的变量
步骤4:关闭资源，调用Scanner类的close()
2.案例:小明注册某交友网工，要求录入个人相关信息。如下:
请输入你的网名、你的年龄、你的体重、你是否单身、你的性别等情况。
3.Scanner类中提供了获取byte \ short \ int \ long \ float \ double \ boolean \ String类型变量的方法
注意：没有提供获取char类型变量的方法，需要使用next().charAt(0)
*/
//1.步骤1：导包：import java.util.Scanner;
//不是lang等常用的包下面都需要导包
import java.util.Scanner;
class ScannerTest {
public static void main(String[] args) {
//步骤2：提供(或创建)一个Scanner类的实例
Scanner scan = new Scanner(System.in);
System.out.print("欢迎光临你来我往交友网");
System.out.print("请输入你的网名：");
//步骤3:调用Scanner类中的方法，获取指定类型的变量
String name = scan.next();
System.out.print("请输入你的年龄：");
int age = scan.nextInt();
System.out.print("请输入你的体重：");
double weight = scan.nextDouble();
System.out.print("你是否单身（单身：true，不单身：false）：");
boolean isSingle = scan.nextBoolean();
//男\女 直接这样写会报错，会被识别为转义字符，需要使用转义字符来转化
System.out.print("请输入你的性别：（男\\女）：");
char gender = scan.next().charAt(0);
System.out.println("网名：" + name + "，年龄：" + age + "，体重：" + weight + "，是否单身：" + isSingle + "，性别：" + gender);
System.out.print("注册完成，欢迎继续进入体验");
//步骤4：关闭资源，调用Scanner类的close()
scan.close();
}
}
/*
大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：
高：180cm以上；富：财富1千万以上；帅：是。
如果这三个条件同时满足，则："我一定要嫁给他!!!"
如果三个条件有为真的情况，则："嫁吧，比上不足，比下有余。"
如果三个条件都不满足，则："不嫁！"
*/
import java.util.Scanner;
class IfExer1 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入你的身高：(cm)");
int height = scan.nextInt();
System.out.println("请输入你的财富：(千万)");
double wealth = scan.nextDouble();
/*
方式一：
System.out.println("请输入你是否帅：(true/false)");
boolean isHandsome = scan.nextBoolean();
if(height >= 180 && wealth >= 1 && isHandsome){
System.out.println("我一定要嫁给他!!!");
}else if(height >= 180 || wealth >= 1 || isHandsome){
System.out.println("嫁吧，比上不足，比下有余。");
}else{
System.out.println("不嫁！");
}
*/
//方式二：
System.out.println("请输入你是否帅：(是/否)");
String isHandsome = scan.next();
//if(height >= 180 && wealth >= 1 && isHandsome == "是"){ //这样写会报错 == 判断的 isHandsome 与 "是" 是不是一个，在内存中这两个不是同一个东西，只不过内存一样而已
if(height >= 180 && wealth >= 1 && isHandsome.equals("是")){
System.out.println("我一定要嫁给他!!!");
}else if(height >= 180 || wealth >= 1 || isHandsome.equals("是")){
//.equals()是否相等 判断内容是否相等
System.out.println("嫁吧，比上不足，比下有余。");
}else{
System.out.println("不嫁！");
}
}
}获取随机数：
4.需求：获取一个[a,b]范围的随机整数？
(int)(Math.random() * (b - a + 1)) + a
java
/*
如何获取一个随机数?
1.可以使用Java提供的API:Math类的random()
2.random()调用以后，会返回一个[0.0,1.0)范围的double型的随机数
3.需求1:获取一个[0,100]范围的随机整数?
需求2:获取一个[1,100]范围的随机整数?
4.需求：获取一个[a,b]范围的随机整数？
(int)(Math.random() * (b - a + 1)) + a
*/
class RandomTest {
public static void main(String[] args) {
double d1 = Math.random();
System.out.println("d1 = " + d1);
int num1 = (int)(Math.random() * 101); // [0.0,1.0) --> [0.0,101.0) ---> [0,100]
System.out.println("num1 = " + num1);
int num2 = (int)(Math.random() * 100) + 1; //[0.0,1.0) --> [0.0,101.0) ---> [0,99] ---> [1,100]
}
} switch-case****结构
java
/*
分支结构之二：switch-case
1.格式
switch(表达式){
case 常量1:
执行语句1;
//break;
case 常量2:
执行语句2;
//break;
...
default:
执行语句n;
//break;
}
2.说明：
① 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构
末尾结束为止。
② break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
③ switch结构中的表达式，只能是如下的6种数据类型之一：
byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
④ case 之后只能声明常量。使用表达式与这些常量做相等的判断，不能声明范围。
switch中的表达式只能是特定的数据类型，如下；byte \ short \ char \ int \ 枚举（enum，jdk5.0新增) \ String（jdk7.0新增）
⑤ break关键字是可选的。
⑥ default:相当于if-else结构中的else.
default结构是可选的，而且位置是灵活的。
开发中，使用switch-case时，通常case匹配的情况都有限
@开发中凡是可以使用switch-case结构的场景，都可以改写为-else。反之，不成立
开发中，如果一个具体问题既可以使用switch-case，又可学使用if-else的时候，推荐使用switch-case。
为什么?switch-case相较于if-else效率稍高
*/
class SwitchCaseTest {
public static void main(String[] args) {
int num = 10;
switch(num){
default:
System.out.println("other"); //other
break;
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break; // 结束当前的switch-case语句
case 2:
System.out.println("two");
break;
case 3:
System.out.println("three");
break;
/*default:
System.out.println("other");
break;*/
}
//另咧：
String season = "summer";
switch(season){
case "Spring":
System.out.println("春暖花开");
break;
case "summer":
System.out.println("夏日炎炎");
break; // 结束当前的switch-case语句
case "autumn":
System.out.println("秋高气爽");
break;
case "winter":
System.out.println("冬雪皑皑");
break;
default:
System.out.println("季节输入有误");
break;
}
//错误的例子：编译不通过
int number = 20;
/*switch(number){
// 错误: 不兼容的类型: boolean无法转换为int
case number > 0:
System.out.println("正数");
break;
case number < 0:
System.out.println("负数");
break;
default:
System.out.println("0");
break;
}*/
}
}注意判断成绩是否合格当中的第三个方式：
java
/*
案例3:使用switch-case实现:对学生成绩大于60分的，输出"合格"。低于60分的，输出"不合格"。
*/
class SwitchCaseTest1 {
public static void main(String[] args) {
//定义一个学生的成绩
int score = 78;
//根据需求：进行分支
//方式1：
/*switch(score){
case 0:
System.out.println("不及格");
break;
case 1:
System.out.println("不及格");
break;
case 2:
System.out.println("不及格");
break;
//...
case 100:
System.out.println("及格");
break;
default:
System.out.println("成绩输入有误");
break;
}*/
//方式2：体会case穿透
switch(score/10){
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("不及格");
break;
case 6:
case 7:
case 8:
case 9:
case 10:
System.out.println("及格");
break;
default:
System.out.println("成绩输入有误");
break;
}
//System.out.println("num1 = " + num1);
//方式3：
switch(score/60){
case 0:
System.out.println("不及格");
break;
case 1:
System.out.println("及格");
break;
default:
System.out.println("成绩输入有误");
break;
}
}
}switch-case样式穿透的具体实现：
java
/*
案例:编写程序:从键盘上输入2023年的"month"和"day"，要求通过程序输出输入的日期为2023年的第几天。
*/
import java.util.Scanner;
class SwitchCaseTest2 {
public static void main(String[] args) {
//1.使用Scanner，从键盘获取2023年的month，day
Scanner input = new Scanner(System.in);
System.out.println("请输入2023年的月份：");
int month = input.nextInt(); //阻塞式方法
System.out.println("请输入2023年的天：");
int day = input.nextInt(); //阻塞式方法
//2.使用switch-case实现分支结构
int sumDays = 0; // 记录总天数
//方式1：推荐，存在数据的冗余
/*switch(month) {
case 1:
sumDays = day;
break;
case 2:
sumDays = 31 + day;
break;
case 3:
sumDays = 31 + 28 + day;
case 4:
sumDays = 31 + 28 + 31 + day;
//...
case 12:
sumDays = 31 + 28 + ... + 30 + day;
}*/
//方式2：数据穿透，这个地方使用if-else可能并不是那么好
switch(month) {
case 12:
sumDays += 30;//31:11月份的总天数
case 11:
sumDays += 31;//31:10月份的总天数
case 10:
sumDays += 30;//31:9月份的总天数
case 9:
sumDays += 31;//31:8月份的总天数
case 8:
sumDays += 31;//31:7月份的总天数
case 7:
sumDays += 30;//31:6月份的总天数
case 6:
sumDays += 31;//31:5月份的总天数
case 5:
sumDays += 30;//31:4月份的总天数
case 4:
sumDays += 31;//31:3月份的总天数
case 3:
sumDays += 28;//28:2月份的总天数
case 2:
sumDays += 31; //31:1月份的总天数
case 1:
sumDays += day;
break;
}
//从符合条件的那一项开始向下穿透加上当月天数
System.out.println("2023年" + month + "月" + day + "日是当前的第" + sumDays + "天"); //2023年7月3日是当前的第184天
input.close(); // 为了防止内存泄漏
}
} 循环结构
循环结构之for循环
java
/*
For循环结构的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型的变量或表达式
③ 循环体
④ 迭代条件
二、for循环的结构
for(①;②;④){
③
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
*/
class ForTest {
public static void main(String[] args) {
//需求1：题目：输出5行HelloWorld
/*System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");*/
for(int i = 1; i <= 50; i++){
System.out.println("HelloWorld");
}
//此时编译不通过，因为此时i已经出了其作用域范围
//System.out.println(i);
//需求2：
//int num = 1;
//for(System.out.print("a");num < 3; System.out.print("c"),num++){
// System.out.print("b");
//} // 看执行顺序
//输出结果：abcbc
//需求3：遍历1-100以内的偶数，并获取偶数的个数，获取所有的偶数的和
int count = 0; // 记录偶数的个数
int sum = 0; // 记录所有的偶数的和
for(int i = 1; i <= 100; i++) {
if(i % 2 == 0){
count++;
sum += i;
}
}
System.out.println("偶数的个数为：" + count); //50
System.out.println("偶数的总和为：" + sum); //2550
}
}水仙花案例：
java
/*
题目:输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
例如:153=1*1*1 + 3*3*3 + 5*5*5
*/
class ForTest1 {
//153 370 371 407
public static void main(String[] args) {
//遍历所有的3位数
for(int i = 100; i<999;i++){
//针对于每一个三位数i，获取其各个位上数值
int ge = i % 10;
int shi = i / 10 % 10; // 或 int shi = i % 100 / 10
int bai = i /100;
//判断是否满足水仙花数的规则
if(i == ge * ge * ge + shi * shi * shi + bai * bai * bai) {
System.out.println(i);
}
}
}
} 最大公约数，最小公倍数
java
/*
说明:输入两个正整数m和n，求其最大公约数和最小公倍数。
比如:12和20的最大公约数是4，最小公倍数是60。
约数：12为例，约数有1,2,3,4,6,12
20为例，约数有1,2,4,5,10,20
倍数：12为例，倍数有12,24,36,48,60,72，...
20为例，倍数有20,40,60,80，...
说明:
1.我们可以在循环结构中使用break。一旦执行break，就跳出(或结束)当前循环结构。
方式1:循环条件不满足。(即循环条件执行完以后是false)
方式2:在循环体中执行了break
*/
class ForTest2 {
public static void main(String[] args) {
int m = 12;
int n = 20;
//获取m和m当中的较小值
int min = (m < n) ? m : n;
//最大公约数
//方式1：
int result = 1;
for(int i = 1; i <= min;i++){
if(m % i == 0 && n % i == 0){
result = i;
}
}
System.out.println("最大公约数为：" + result); //4
//方式2：推荐
for(int i = min; i >= 1; i--){
if(m%i==0 && n%i==0){
System.out.println("最大公约数为：" + i); //4
break; // 一旦找到了，就退出循环
}
}
//需求2：最小公倍数
int max = (m > n) ? m : n;
for(int i = max; i < m*n; i++){
if(i%m == 0 && i%n==0){
System.out.println("最小公倍数为：" + i); //最小公倍数为：60
break; // 一旦找到了，就退出循环
}
}
}
} 循环结构之while循环
java
/*
While 循环的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件
二、while循环的结构
①
while(②){
③;
④;
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
说明：
1.写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
2.我们写程序，要避免出现死循环。
3.for循环和while循环是可以相互转换的！
区别：for循环和while循环的初始化条件部分的作用范围不同。while循环中的初始化条件在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
//需求1：遍历50次HelloWorld
int i1 = 1;
while(i1 <= 50){
System.out.println("HelloWorld");
i1++; // 一定要小心，不要弄丢了
}
//需求2：遍历1-100以内的偶数，并获取偶数的个数，获取所有偶数的和
int j = 1;
int count = 0; // 记录偶数的个数
int sum = 0; // 记录偶数的总和
while(j<=100){
if(j%2==0){
//System.out.println(j);
count++;
sum += j;
}
j++;
}
System.out.println("偶数的个数为：" + count); //50
System.out.println("偶数的总和为：" + sum); //2550
}
}猜随机数
java
/*
随机生成一个100以内的数，猜这个随机数是多少?
从键盘输入数，如果大了，提示大了:如果小了，提示小了;如果对了，就不再猜了，并统计一共猜了多少次。
提示:生成一个[a,b]范围的随机数的方式:(int)(Math.random()*(b-a+ 1)+ a)
*/
import java.util.Scanner;
class whileCaseTest{
public static void main(String[] args) {
//1.生成一个[1,100]范围的随机整数
int random = (int)(Math.random()*100)+1;
//2.使用Scanner，从键盘获取数据
Scanner scan = new Scanner(System.in);
int guess = scan.nextInt();
//3.声明一个变量，记录猜的次数
int guessCount = 1;
//4.使用循环结构，进行多次循环的对比和获取数据
while(random != guess){
if(guess > random){
System.out.println("你输入的数据大了");
}else if(guess < random){
System.out.println("你输入的数据小了");
}
System.out.println("请输入1-100范围的一个整数：");
guess = scan.nextInt();
guessCount++;
}
//能结束结束，就意味着random和guess相等了
System.out.println("恭喜你！猜对了！");//101
System.out.println("共猜了" + guessCount + "次");
scan.close();
}
}珠穆朗玛峰与纸的案例
java
/*
世界最高山峰是珠穆朗玛峰，它的高度是8848.86米，假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
*/
class WhileTest2{
public static void main(String[] args) {
//1.声明珠峰的高度，纸的默认厚度
double paper = 0.1; //单位：毫米
double zf = 8848860; //单位：毫米
//2.定义一个变量，记录折纸的次数
int count = 0;
//3.通过循环结构，不断调整纸的厚度（当纸的厚度超过珠峰高度时，停止循环）
while(paper <= zf){
paper *= 2;
count++;
}
System.out.println("paper的高度为：" + (paper / 1000)+"米，超过了珠峰的高度"+(zf/1000) + "米");
System.out.println("共折纸" + count + "次");
/*
paper的高度为：13421.7728米，超过了珠峰的高度8848.86米
共折纸27次
*/
}
}循环结构之do-while循环
java
/*
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 i = 1;
int count = 0; //记录偶数的个数
int sum = 0; // 记录偶数的总和
do{
if(i%2 == 0) {
//System.out.println(i);
count++;
sum += i;
}
i++;
}while(i<=100);
System.out.println("偶数的个数为：" + count); // 50
System.out.println("偶数的总和为：" + sum); //2550
//**********************************
int num1 = 10;
while(num1 > 10) {
//不满足条件不会执行
System.out.println("while:hello");
num1--;
}
int num2 = 10;
do
{
System.out.println("do-while:hello"); //do-while:hello
num2--;
}
while (num2 > 10);
}
}ATM取款机
java
/*
题目:模拟ATM取款
声明变量balance并初始化为0，用以表示银行账户的余额，下面通过ATM机程序实现存款，取款等功能。
=========ATM========
1、存款
2、取款
3、显示余额
4、退出
请选择(1-4):
*/
import java.util.Scanner;
class DoWhileTest1{
public static void main(String[] args) {
//1.定义balance的变量，记录账户余额
double balance = 0.0;
boolean flag = true; // 控制循环的结束
Scanner scan = new Scanner(System.in); //实例化Scanner
do{
//2.声明ATM取款的界面
System.out.println("=======ATM========");
System.out.println("1、存款");
System.out.println("2、取款");
System.out.println("3、显示余额");
System.out.println("4、退出");
System.out.print("请选择(1-4):");
//3.使用Scanner获取用户的选择
int selection = scan.nextInt();
switch(selection) {
//4.根据用户的选择，决定执行存款、取款、显示余额、退出的操作
case 1:
System.out.print("请输入存款的金额：");
double money1 = scan.nextDouble();
if(money1 > 0){
balance += money1;
}
break;
case 2:
System.out.print("请输入取款的金额：");
double money2 = scan.nextDouble();
if(money2>0 && money2<balance){
balance -= money2;
}else{
System.out.print("输入的数据有误或余额不足");
}
break;
case 3:
System.out.print("账户余额为：" + balance);
break;
case 4:
flag = false;
System.out.print("感谢使用，欢迎下次光临");
break;
default:
System.out.println("输入有误，请重新输入");
//break;
} //break退出switch，退出switch之后，紧接着执行while当中的flag
}while(flag); // 循环条件不满足会结束循环
//关闭资源
scan.close();
}
}
无限循环
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
java
/*
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
*/
import java.util.Scanner;
class ForWhileTest1{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int positiveCount = 0; //记录正数的个数
int negativeCount = 0; //记录负数的个数
while(true){
System.out.print("请输入一个整数（输入为0时结束程序）：");
int num = scan.nextInt();
if(num > 0){ // 正数
positiveCount++;
}else if(num < 0){//负数
negativeCount++;
}else{//0
System.out.println("程序结束");
break;
}
}
System.out.println("正数的个数为：" + positiveCount);
System.out.println("负数的个数为：" + negativeCount);
scan.close();
}
}嵌套循环**(多重循环)**
案例：
java
/*
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环
2.
外层循环：循环结构B
内层循环：循环结构A
3. 说明
① 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次
③ 内层循环相当于外层循环的循环体
4. 技巧：
外层循环控制行数，内层循环控制列数
实际开发中我们不会出现三层以上的循环结构，三层的循环结构都很少见，三层的循环结构相当于有厚度了，立方体的效果
*/
class ForForTest{
public static void main(String[] args) {
//******
for(int i = 1;i<=6;i++){
System.out.print("*");
}
System.out.println("\n##########################");
/*
******
******
******
******
******
*/
for(int j = 1;j<=5;j++){ //5行
for(int i = 1;i<=6;i++){ //6列
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(每一行中*的个数）
****** 1 6
***** 2 5
**** 3 4
*** 4 3
** 5 2
* 6 1
*/
for(int i =1; i<=6;i++){
for(int j =1; j<=(7-i);j++){
System.out.print("*");
}
System.out.println();
}
/*
i(第几行） j(每一行中-的个数） j(每一行中*的个数） 2*i + j = 10 j = 10-2*i
--------* 1 8 1 k = 2 * i - 1
------* * * 2 6 2
----* * * * * 3 4 5
--* * * * * * * 4 2 7
* * * * * * * * * 5 0 9
--* * * * * * * 1 2 7
----* * * * * 2 4 5
------* * * 3 6 2
--------* 4 8 1
*/
//上半部分
for(int i = 1; i<=5;i++){
//-
for(int j = 1;j <= 10-2*i;j++){
System.out.print("-");
}
//*
for(int k = 1;k<=2 * i - 1;k++){
System.out.print("* ");
}
System.out.println();
}
//下半部分
for(int i = 1; i<=4;i++){
//-
for(int j = 1;j <= 2*i;j++){
System.out.print("-");
}
//*
for(int k = 1;k<=9-2 * i;k++){
System.out.print("* ");
}
System.out.println();
}
}
}九九乘法表:
java
/*
九九乘法表
*/
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+"\t");
}
System.out.println();
}
}
}break、continue
java
/*
break和continue关键字的使用
使用范围 循环中使用的作用(不同点) 相同点
break: switch-case
循环结构中 结束（或跳出）当前循环结构 关键字后面不能声明执行语句
continue: 循环结构中 结束（或跳出）当次循环 关键字后面不能声明执行语句
了解带标签的break和continue的使用
开发中，break的使用频率要远高于continue
*/
class BreakContinueTest {
public static void main(String[] args) {
for(int i = 1; i<= 10;i++){
if(i%4==0){
//break; //123
continue; //跳出当次循环，但是没有退出循环，继续开始下一次循环
//编译不通过
//System.out.println("今晚上迪丽热巴要约我"); //错误: 无法访问的语句
}
System.out.print(i); //123567910
}
System.out.println();
//***************************
label:for(int j = 1; j<=4;j++){
for(int i = 1; i<= 10;i++){
if(i%4==0){
//break; //结束包裹他的最近的一层
//continue;
//了解
//break label; //123
//continue label; //123123123123
}
System.out.print(i); //123567910
}
//break;
System.out.println();
}
}
}
java
/*
遍历100000以内的所有的质数。体会不同的算法实现，其性能的差别
此PrimeNumberTest1.java是实现方式1
*/
class PrimeNumberTest1 {
public static void main(String[] args) {
/*for(int i = 2; i<=100;i++){ //遍历100以内的自然数
int number = 0; //记录从2开始这个数i有几个约束（从2开始，到i-1为止）
//判定i是否是质数
for(int j = 2; j<i;j++){
if(i%j ==0){
number++;
}
}
if(number == 0){
System.out.println(i);
}
}*/
//获取系统当前的时间
long start = System.currentTimeMillis();
boolean isFlag = true; // isFlag定义在外面得出的结果有问题
int count = 0; // 记录质数的总个数
//运行出来的结果只有2,3这两个质数，此时isFlag还是true，当4的时候，更改了isFlag的值为false，此后这个isFlag就一直是false，如果要定义在外面，就需要重置一下isFlag，在每次循环之后
//方式2：
for(int i = 2; i<=100;i++){ //遍历100以内的自然数
//boolean isFlag = true;
//判定i是否是质数
for(int j = 2; j<i;j++){
if(i%j ==0){
isFlag = false;
}
}
if(isFlag){
//System.out.println(i);
count++;
}
isFlag = true;
}
//获取系统当前的时间
long end = System.currentTimeMillis();
System.out.println("质数的总个数为：" + count);
System.out.println("花费的时间为：" + (end-start));
}
}查找质数算法优化：
java
/*
遍历100000以内的所有的质数。体会不同的算法实现，其性能的差别
此PrimeNumberTest2.java是方式2，针对于PrimeNumberTest1.java中算法的优化
*/
class PrimeNumberTest2 {
public static void main(String[] args) {
//获取系统当前的时间
long start = System.currentTimeMillis();
boolean isFlag = true; // isFlag定义在外面得出的结果有问题
int count = 0; // 记录质数的总个数
//运行出来的结果只有2,3这两个质数，此时isFlag还是true，当4的时候，更改了isFlag的值为false，此后这个isFlag就一直是false，如果要定义在外面，就需要重置一下isFlag，在每次循环之后
//方式2：
for(int i = 2; i<=100000;i++){ //遍历100以内的自然数
//boolean isFlag = true;
//判定i是否是质数
for(int j = 2; j<=Math.sqrt(i);j++){
if(i%j ==0){
isFlag = false;
break; //针对于非质数有效果
}
}
if(isFlag){
//System.out.println(i);
count++;
}
isFlag = true;
}
//获取系统当前的时间
long end = System.currentTimeMillis();
System.out.println("质数的总个数为：" + count); //9592
System.out.println("花费的时间为：" + (end-start)); //7188 ---> 加上break:653 ---> 加上Math.sqrt(): 7
}
}return 的使用
