第一章：用Eclipse来做计算
1.1第一个Java程序
1：FIle ==> New ==> Other ==> Java Project ==> Next
2：此时进入到页面：Create a Java Project；Project name：hello
package hello;
public class Hello {
public static void main(String[] args) {
// TODO Auto-generated method stub
Sys //使用Alt+/，程序会自动跳出以这个开头的东西
System.out.println("hello world");
}
1.2.1：读输入
问题：初学者容易犯的错误，当这个程序有输入OR程序还没有结束，我们又去启动这个程序；启多个程序在跑耗费资源。
package hello;
import java.util.Scanner;
public class Hello {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("hello world");
// Scanner in = new Scanner(System.in);
// System.out.println("echo：" + in.nextLine());
System.out.println("2+3="+ 5);
System.out.println("2+3"+2+3); //运算优先级
System.out.println("2+3"+(2+3)); // +号用来做字符串连接
}
}
注意：有两个快捷键：鼠标光标在第一行，shift+鼠标方向下键，你想要几行就可以选中几行；Ctrl + /，对当前代码行进行注释。
1.2.2变量
1、我们在执行加减法的时候，想要
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("你好");
Scanner in = new Scanner(System.in);
System.out.println("100-23=" + (100-in.nextInt()));
}
输入：23，输出：77 100-23=77
输入：33，输出：67 100-23=67 //结果是对的，但是23是死的，怎么样让它显示上发生变化。
2、in.nextInt() 帮我们读入一个数，那我们仍然使用nextInt()，这不是我们想要的结果。
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("你好");
Scanner in = new Scanner(System.in);
System.out.println("100-" + in.nextInt()+ "=" + (100-in.nextInt()));
}
3、此时引入变量：
概念：<变量类型><变量名称>
int price;
int amount;
int price,amount;
- 变量需要一个名字，变量的名字是一种标识符，意思是它是用来识别这个和那个的不同的名字。
- 标识符的规则：标识符只能由数字、字母、下划线组成，数字不可以出现在第一个位置上，java的关键字不可以用作标识符。
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("你好");
int price; //定义一个变量，变量名price，变量名的类型是int
Scanner in = new Scanner(System.in);
price = in.nextInt(); //把输入值用变量price尽心替换
System.out.println("100-" + price+ "=" + (100-price)); //in.nextInt()相应进行替换
}
程序改进：输入和输出参数都是变量，由我们自己指定，代码如下：
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("你好");
int price;
int amount = 100;
Scanner in = new Scanner(System.in);
price = in.nextInt();
amount = in.nextInt();
System.out.println(price + "-" + amount + "=" + (price-amount) );
}
对于这个小demo,，那我们故意输入price，那它就会报错，类型不匹配。
你好
price
Exception in thread "main" java.util.InputMismatchException
at java.util.Scanner.throwFor(Unknown Source)
at java.util.Scanner.next(Unknown Source)
at java.util.Scanner.nextInt(Unknown Source)
at java.util.Scanner.nextInt(Unknown Source)
at hello.VariableTest.main(VariableTest.java:12)
在这个程序中，我们使用int amount = 100; 为其进行赋值；
由于100永远不变，使用final int amount = 100; 进行修饰，final修饰的是常量。
注意：常量不能再被赋值，如下图amount1；
变量可以被再次赋值，如下图amount.
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("你好");
int price;
final int amount = 100;
Scanner in = new Scanner(System.in);
price = in.nextInt();
System.out.println(amount + "-" + price + "=" + (amount-price) );
}
1.2.3赋值
变量名需要被初始化才可以使用：
int price = 10；
System.out.println(price);
String name;
System.out.println(name); //系统提示变量一定要被初始化才能使用，the local variable name may not have been initialized.
表达式
1.3.1浮点数
1、需求1：英国人讲几尺几寸，把尺寸转换为米数；eg：5尺7寸，转换为米数是1.7018米。
package hello;
import java.util.Scanner;
public class TransformationTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
int foot;
int inch;
Scanner input = new Scanner(System.in);
System.out.print("请输入几尺：");
foot = input.nextInt();
System.out.print("请输入几寸：");
inch = input.nextInt();
System.out.println("foot=" + foot+",inch="+inch);
System.out.println((foot+inch/12)*0.3048); //12 --> 12.0(浮点数)
}
}
输入值进行测试：
第一次：
请输入几尺：5
请输入几寸：0
foot=5,inch=0
1.524
第二次：
请输入几尺：5
请输入几寸：1
foot=5,inch=1
1.524
思考：观察到寸上后实际没有发生转换；
原因：两个整数相除还是整数
System.out.println(10/3); 的值为3.
10和10.0在java中是两个不同的数。
修改的话仅仅只要把 12 ==> 12.0
System.out.println((foot+inch/12.0)*0.3048);
请输入几尺：5
请输入几寸：7
foot=5,inch=7
1.7018
引出概念：浮点数
概念：带小数点的数值.
- 当浮点数和整数放到一起进行运算时，java会将整数转换为浮点数，然后进行浮点数的运算。
- System.out.println((foot+inch/12)*0.3048);
- System.out.println((foot+inch/12.0)*0.3048);
也可以对inch进行重新定义：
从int inch; ==> double inch;
直接运行没问题，注意到inch = input.nextInt(); 意思是我们可以把一个输入的整数叫个inch，让他转换为double. int可以转换为double，double不能直接转换为int。
1、在计算机中，浮点运算是有误差的
输入：System.out.println(1.2-1.1);
输出：0.09999999999999987
注意：当我们需要精确计算的时候，使用整数
整数类型不能表达有小数部分的数，整数和整数的运算结果还是整数；计算机里会有纯粹的整数，是因为整数运算比较快，而且占地方小
1.3.2运算符优先级
第一章编程题
写一个将华氏温度转换成摄氏温度的程序，转换的公式是：
°F = (9/5)*°C + 32
其中C表示摄氏温度，F表示华氏温度。
程序的输入是一个整数，表示华氏温度。输出对应的摄氏温度，也是一个整数。
package hello;
import java.util.Scanner;
public class TemperatureConversion {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
System.out.print("请输入华氏度：");
int x = input.nextInt();
System.out.println((int)(x-32)*5/9);
// System.out.println((int)((x-32)/(9/5.0)));
}
}
2.1.1作比较
自动售票机的工作流程：
package hello;
import java.util.Scanner;
public class ChangeApp {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 1、初始化
Scanner in = new Scanner(System.in);
// 2、输入投币金额
System.out.println("请投币：");
double amount = in.nextInt();
// 3、打印车票
System.out.println("********");
System.out.println("**java车票**");
System.out.println("***无座***");
System.out.println("********");
// 4、计算并打印找零
System.out.println(amount - 10);
}
}
在2输入投币金额中增加两行，算是用作判断.
double amount = in.nextInt();
System.out.println(amount);
System.out.println(amount>=10);
2.1.2关系运算
1、计算两个值之间的关系，所以叫做关系运算符：
| 运算符 | 意义 |
|---|---|
| == | 相等 |
| != | 不相等 |
| > | 大于 |
| >= | 大于等于 |
| < | 小于 |
| <= | 小于等于 |
所有的关系运算符的优先级比算术运算符的低，但是比赋值运算高。
2、判断是否相等==和!=的优先级比其它的低，而连续的关系运算符是从左到右的。
- 5>4 == 6>5 左边5>4为true，右边6>5为true；所以返回值是true.
- 6>5>4 6>5的结果是true，true和4做比较是没有结果的.
- abtrue 对a,b赋值，判断是否相等，再去和true做判断
- ab6 a,b再怎么判断都是true，false是布尔类型，无法和数值做比较
- a==b>false true和false是不能比较大小的
- (a == b) > false X是不对的
3、浮点数相加是有误差的：
public static void main(String[] args) {
double a = 1.0;
double b = 0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1;
System.out.println("a:"+a +" b:"+ b);
System.out.println(1.0 == (0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1));
}
输出：a:1.0 b:0.9999999999999999
false
那么10个0.1相加和1.0的差距是多少呢？？？
System.out.println(Math.abs(a-b));
输出：1.1102230246251565E-16
2.2判断语句
2.2.1做判断
还是打印车票小程序：写一个if判断语句，输入金额>=10时才执行，其余时候不执行；
输入：15，输出：5；
输入：5，不继续执行.
if(amount >=10) {
// 打印车票
System.out.println("********");
System.out.println("**java车票**");
System.out.println("***无座***");
System.out.println("********");
// 计算并打印找零
System.out.println("找零" + (amount - 10));
}
2.2.2判断语句
满足条件：age < MINOR，就会输出（年轻是美好的）；不满足 age < MINOR这个条件时，就会输出（年龄决定了你的精神世界）。
if (height < max){
growth = 10;
} else{
growth = MAX - height;
}
2.2.3嵌套和级联的判断语句
package Judge;
import java.util.Scanner;
public class JudgeTest {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.print("请输入x:");
int x = in.nextInt();
System.out.print("请输入y:");
int y = in.nextInt();
System.out.print("请输入z:");
int z = in.nextInt();
int max;
if (x > y) {
if(x > z) {
max = x;
}else {max = z;}
}else {
if (y>z) {
max = y;
}else {
max = z;
}
}
System.out.println(max);
}
}
请输入x:80 请输入x:50 请输入x:40
请输入y:40 请输入y:60 请输入y:60
请输入z:20 请输入z:40 请输入z:80
80 60 80
流程图如下：
嵌套的判断：
- 当if的条件满足或者不满足的时候要执行的语句也可以是一条if或if-else语句，这就是嵌套的if语句.
1、if( code == READY)
if ( count < 20 )
System.out.println("一切正常\n");
else
System.out.println("继续等待")
//这个else回合第二个if相匹配，不管else的缩进在哪，它是和最近的if匹配。
2、修改程序：
if( code == READY){
if ( count < 20 )
System.out.println("一切正常\n");
}
else
System.out.println("继续等待")
//加上一对大括号后，else就会和第一个if匹配。
Tips：在if或else后面总是用{}，即使只有一条语句的时候
有效避免别人对你代码的误解。
分段函数使用if来实现：
if ( x > 0) {
f = -1;
} else if (x == 0) {
f =0;
} else {
f = 2 * x;
}
引出概念：级联的if-else if，语法如下：
if ( exp1 )
step1
else if( exp2 )
step2;
else
step3;
级联概念的两种写法：
第一种：
int f;
if (x < 0 ) {
f = -1;
} else if ( x == 0 ) {
f = 0;
} else {
f = 2 * x;
}
System.out.println(f);
第二种写法：
if ( x < 0 ) {
System.out.println(-1);
} else if ( x == 0 ) {
System.out.println(0);
} else {
System.out.println( 2 * x );
}
**总结：**我们肯定青睐于第一种写法，叫做单一出口，这个程序只有一个地方做输出；而不是像2中到处去输出；那比如我们要对（f + 1.0）；在1中直接改变变量值，而在2中需要所有值都加1.0.
2.2.2判断语句的常见问题
-
忘了大括号
eg: if ( age > 60)
salary = salary * 1.2;
System.out.println(salary) 无论age是否大于60，都会执行下面的话，解决：在if后加上{}，永远在if 和 else后加上大括号. -
if后面的分号
eg:
`package Judge;
import java.util.Scanner;
public class TestHasIfOrNot {
public static void main(String[] args) {
// TODO Auto-generated method stub
final int MINOR = 35;
System.out.print("请输入你的年龄：");
Scanner in = new Scanner(System.in);
int age = in.nextInt();
System.out.println("你的年龄是：" + age);
if (age < MINOR); {
System.out.println("年轻是美好的.");
}
System.out.println("年龄决定了你的精神世界，好好珍惜");
}
}`
if条件后有无分号; 有分号意味着直接结束；本来就可以在代码中写一对大括号{}，此时测试写else，会报错，提示没有if与之匹配。
-
错误的使用==和=
eg：if (age = MINOR)
Type mismatch: cannot convert from int to boolean（类型不匹配，=的表达式是赋值，整数；==是判断，true或者false） -
代码风格
1）在if和else之后必须加上大括号形成语句块
2）大括号内的语句缩进一个tab的位置
2.3多路分支
switch-case：
举例：
switch (控制表达式) { 控制表达式只能是整数型的结果
case 常量：
语句 常量可以是常数，也可以是常数计算的表达式
...
case 常量：
语句 根据表达式的结果，寻找匹配的case，并执行case后面的语句，一直到break为止
....
default: 如果所有的case都不匹配，那么就执行default后面的语句；如果没有default，那么就什么都不做
语句
....
}
break：
- switch语句可以看作是一种基于计算的跳转，计算控制表达式的值后，程序会跳转到相匹配的case（分支标号）处。分支标号只是说明switch内部位置的路标，在执行完成分支中的最后一条语句后，如果后面没有break，就会顺序执行到下面的case里去，直到遇到一个break,或者switch结束为止。
案例：
package Judge;
import java.util.Scanner;
public class SwitchApp {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
System.out.print("请输入：");
int type = in.nextInt();
switch(type)
{
case 1:
case 2:
System.out.println("你好");
break;
case 3:
System.out.println("晚上好");
case 4:
System.out.println("再见");
default:
System.out.println(".......");
break;
}
}
}
输入：1 输出：你好
输入：2 输出：你好 因为此时有break
输入：3 输出：晚上好 再见 …
输入：4 输出：再见 …
输入：除上述情况外的任意数字，都直接输出的是…
尝试用：switch-case完成如下：
f(x) = -1; x < 0
0; x = 0
2x; x > 0
第二章编程题：时间换算
题目内容：
UTC是世界协调时，BJT是北京时间，UTC时间相当于BJT减去8。现在，你的程序要读入一个整数，表示BJT的时和分。整数的个位和十位表示分，百位和千位表示小时。如果小时小于10，则没有千位部分；如果小时是0，则没有百位部分；如果小时不是0而且分小于10分，需要保留十位上的0。如1124表示11点24分，而905表示9点5分，36表示0点36分，7表示0点7分。
有效的输入范围是[0,2359]，并且十位不会大于5。即你的程序不可能从测试服务器读到0到2359以外或是分钟数大于59的输入数据。
你的程序要输出这个时间对应的UTC时间，输出的格式和输入的相同，即输出一个整数，表示UTC的时和分。整数的个位和十位表示分，百位和千位表示小时。如果小时小于10，则没有千位部分；如果小时是0，则没有百位部分；如果小时不是0而且分小于10分，需要保留十位上的0。
提醒：要小心跨日的换算。
输入格式:
一个整数，表示BJT的时和分。整数的个位和十位表示分，百位和千位表示小时。如果小时小于10，则没有千位部分；如果小时是0，则没有百位部分；如果小时不是0而且分小于10分，需要保留十位上的0。
输出格式：
一个整数，表示UTC的时和分。整数的个位和十位表示分，百位和千位表示小时。如果小时小于10，则没有千位部分；如果小时是0，则没有百位部分；如果小时不是0而且分小于10分，需要保留十位上的0。
输入样例：
933
输出样例：
133
package Judge;
import java.util.Scanner;
public class PiecewiseFunction {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.print("请输入北京时间：");
int time = in.nextInt();
//分理出小时、分钟
int utc = 0;
int hours = time/100;
int minutes = time%100;
if (minutes <= 59) {
if (hours == 8) {
utc = minutes;
}
if (hours < 8) {
utc = (hours-8+24)*100+minutes;
}
if (hours > 8) {
utc = (hours-8)*100+minutes;
}
System.out.println(utc);
}else {
System.out.println("边界值溢出");
}
}
}
第二章编程题：信号报告
题目内容：
无线电台的RS制信号报告是由三两个部分组成的：
R(Readability) 信号可辨度即清晰度.
S(Strength) 信号强度即大小.
其中R位于报告第一位，共分5级，用1—5数字表示.
Unreadable
Barely readable, occasional words distinguishable
Readable with considerable difficulty
Readable with practically no difficulty
Perfectly readable
报告第二位是S，共分九个级别，用1—9中的一位数字表示
Faint signals, barely perceptible
Very weak signals
Weak signals
Fair signals
Fairly good signals
Good signals
Moderately strong signals
Strong signals
Extremely strong signals
现在，你的程序要读入一个信号报告的数字，然后输出对应的含义。如读到59，则输出：
Extremely strong signals, perfectly readable.
输入格式:
一个整数，信号报告。整数的十位部分表示可辨度，个位部分表示强度。输入的整数范围是[11,59]，这个范围外的数字不可能出现在测试数据中。
输出格式：
一句话，表示这个信号报告的意义。按照题目中的文字，先输出表示强度的文字，跟上逗号和空格，然后是表示可辨度的文字，跟上句号。注意可辨度的句子的第一个字母是小写的。注意这里的标点符号都是英文的。注意逗号后面必须有一个空格。
输入样例：
33
输出样例：
Weak signals, readable with considerable difficulty.
Java代码案例：
package Judge;
import java.util.Scanner;
public class SignalReportApp {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
System.out.print("请输入一个整数：");
int number = in.nextInt();
int a = number/10;
int b = number%10;
switch (a){
case 1:System.out.print("Unreadable, ");break;
case 2:System.out.print("Barely readable, occasional words distinguishable, ");break;
case 3:System.out.print("Readable with considerable difficulty, ");break;
case 4:System.out.print("Readable with practically no difficulty, ");break;
case 5:System.out.print("Perfectly readable, ");break;
}
switch(b) {
case 1:System.out.print("Faint signals, barely perceptible");break;
case 2:System.out.print("Very weak signals");break;
case 3:System.out.print("Weak signals");break;
case 4:System.out.print("Fair signals");break;
case 5:System.out.print("Fairly good signals");break;
case 6:System.out.print("Good signals");break;
case 7:System.out.print("Moderately strong signals");break;
case 8:System.out.print("Strong signals");break;
case 9:System.out.print("Extremely strong signals");break;
}
}
}
第三章：循环
3.1.1车票打印
一个相对完善的购买车票的程序如下所示：
package Judge;
import java.util.Scanner;
public class ChangeNoteApp {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
//balance指的是顾客投的钱，初始值为0
int balance = 0;
while(true) //程序循环，并不会自动停止.
{
System.out.print("请投币：");
int amount = in.nextInt();
balance = balance + amount;
if (balance >= 10) {
//打印车票
System.out.println("************");
System.out.println("***Java城际铁路专线*********");
System.out.println("***票价10元*********");
System.out.println("************");
System.out.println("找零是：" + (balance-10));
balance = 0; //作用是当累计金额大于10块后进行一次找零；然后清零操作.
}
}
}
}
数数字的例子
输入任意数字，输出这个数字的位数。
int字符最大支持2147483647，10位。
package Judge;
import java.util.Scanner;
public class CountNumber {
public static void main(String[] args) {
// TODO Auto-generated method stub
//初始化
Scanner in = new Scanner(System.in);
System.out.print("请输入：");
int number = in.nextInt();
int count = 0;
while(number > 0) {
number = number /10;
count = count + 1;
System.out.println("number: " + number + "count: " + count);
}
System.out.println(count);
}
}
输入：352 输出：3
输入：57780 输出：5
while循环
需求：
if ( x > 0 ){ while ( x > 0 ) {
x = x/10; x = x / 10;
n =n+1; n = n + 1;
} }
while循环：
- 如果我们把while循环翻译为“当”，那么一个while循环的意思就是：当条件满足是，不断地重复执行循环体内的语句。
- 循环执行之前判断是否继续循环，所以有可能循环一次也没有被执行。
- 条件成立时循环继续的条件。
人脑模拟计算机的运行，在纸上列出所有的变量，随着程序的进展不断重新计算变量的值
小结：
验证：测试程序时常使用边界数据，如有效范围两端的数据、特殊的倍数等等
- 个位数
- 10；
- 0；
- 负数；
do_while循环
概念：
-
在进入循环的时候不做检查，而是在执行完一轮循环体代码之后，再来检查循环的条件是否满足，如果满足则继续下一轮循环，不满足则结束循环
do { <循环体语句> } while (<循环条件>);
package Judge;
import java.util.Scanner;
public class do_whileLoop {
public static void main(String[] args) {
// TODO Auto-generated method stub
//初始化
Scanner in = new Scanner(System.in);
System.out.print("请输入一个数字:");
int number = in.nextInt();
int count = 0;
do
{
number = number / 10;
count = count + 1;
System.out.println("number = " + number + "count = " + count);
}while (number > 0 );
System.out.println(count);
}
}
区别：在于什么时候进行判断
for循环
for循环
需求：阶乘
-
n! = 1234…*n
-
写一个程序，让用户输入n，然后计算输出n!
-
变量：显然读用户的输入需要一个int的n，然后计算的结果需要用一个变量保存，可以是int的factor，在计算中需要有一个变量不断地从1递增到n，那可以是int的i.
测试：20！是负的，为什么？
我们是使用计算机的内存表达数据的，一个int类型我们在计算机中占据4个字节，int类型只能表达到[ -2的31次方-1，2的31次方-1]
package Judge;
import java.util.Scanner;
public class ForLoop {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.print("请输入：");
int n = in.nextInt();
int factor = 1;
for (int i =1; i <= n; i++) {
factor = factor * i;
System.out.println("factor= " + factor + " i= " + i);
}
System.out.println(factor);
}
}
小结：for循环像是一个计数循环：设定一个计数器，初始化它，然后在计数器到达某个值之前，重复执行循环体，而每执行一轮循环，计数值以一定步进进行调整，比如加1或者减1
for（i=0;i<5;i=i+1）{
System.out.println(i);
}
for ( 初始化；条件；单步动作 ) {
}
1、第一个部分是一个初始化，可以定义一个新的变量
2、第二个部分是循环维持的条件。这个条件是先校验的，与while循环一样，进入循环之前，首先要校验条件是否满足，条件满足才会执行循环；条件不满足就结束循环。
3、第三个部分是步进，即每轮执行了循环体之后，必须执行的表达式。通常我们在这里改变了循环变量，进行加或减的操作。
空循环如下所示：
for (i = 0 ; i < 10; i++); // ; 的意思是这个for循环什么操作都不做
for(i = 0 ; i < 10; i++){
}
复合赋值
a = a + 6 ==> a += 6
a = a - 6 ⇒ a -= 6
a *= b + 6 ==> a = a * (b + 6)
a /= b * 6 ==> a = a / ( b * 6)
i++和++i的区别？
i = 6
a = i++ ==> a = 6 i = 7
a = ++i ⇒ a = 7 i = 7
3.3循环控制(含复合赋值、逻辑类型)
3.3.1循环控制
素数：概念：只能被1和自己整除的数，不包括1；
package Judge;
import java.util.Scanner;
public class PrimeNumber {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
int isPrime = 1;
System.out.print("请输入一个数：");
int n = in.nextInt();
for (int i = 2; i < n ; i++) {
if (n % i == 0) {
isPrime = 0;
System.out.println(n + "不是一个素数，i = " + i);
break;
}
}
if (isPrime == 1)
{
System.out.println(n + "是素数");
}
else
{
System.out.println(n + "不是素数");
}
}
}
break和continue的区别：
- break是跳出循环，不再继续这个循环
- continue是跳过循环这一轮剩下的语句进入下一轮
eg：1 2 3 4,4个同学在唱歌，2同学唱到一半觉得太难听，continue：3同学继续唱；3同学唱到一半还是太难听，于是break，也轮不到4同学继续了。
3.3.2多重循环
需求1：在判断素数的基础上输出100以内的素数？？
package Judge;
import java.util.Scanner;
public class PrimeNumberin100 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
for (int n = 2;n < 50 ;n++)
{
int isPrime = 1;
for (int i = 2; i < n; i++)
{
if (n % i == 0)
{
isPrime = 0;
break;
}
}
if (isPrime == 1)
{
System.out.print(n + " ");
}
else
{
// System.out.println(n + "不是素数");
}
}
}
}
需求2：凑硬币：如何用1角、2角、5角的硬币凑出10元以下的金额
package Judge;
import java.util.Scanner;
public class Match10 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
System.out.print("请投入金额：");
int amount = in.nextInt();
for (int one = 0; one <= amount;++one)
{
for(int five = 0;five <= amount/5; ++five)
{
for(int ten = 0;ten <= amount/10; ++ten)
{
for (int twenty = 0;twenty <= amount/20; ++twenty)
{
if(one+five*5+ten*10+twenty*20 == amount) {
System.out.println(one+"张1元，" + five + "张5元，"+ten+"张10元，"+twenty+"张20元");
}
}
}
}
}
}
}
测试输入输出：
请投入金额：15
0张1元，1张5元，1张10元，0张20元
0张1元，3张5元，0张10元，0张20元
5张1元，0张5元，1张10元，0张20元
5张1元，2张5元，0张10元，0张20元
10张1元，1张5元，0张10元，0张20元
15张1元，0张5元，0张10元，0张20元
4重循环，需求变更：我们输入一个金额，程序会给很多种方案； ==> 输入金额只输出一种结果。
在for循环中接力：
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
System.out.print("请投入金额：");
int amount = in.nextInt();
int isExit = 0;
for (int one = 0; one <= amount;++one)
{
for(int five = 0;five <= amount/5; ++five)
{
for(int ten = 0;ten <= amount/10; ++ten)
{
for (int twenty = 0;twenty <= amount/20; ++twenty)
{
if(one+five*5+ten*10+twenty*20 == amount) {
System.out.println(one+"张1元，" + five + "张5元，"+ten+"张10元，"+twenty+"张20元");
isExit = 1;
break;
}
} if (isExit == 1) break;
}if (isExit == 1) break;
}if (isExit == 1) break;
}
}
上面的每一层循环后加一行太过愚蠢，直接使用OUT和break OUT；去做匹配。
修改代码如下，注意修改的地方细致区别。
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
System.out.print("请投入金额：");
int amount = in.nextInt();
OUT:
for (int one = 0; one <= amount;++one)
{
for(int five = 0;five <= amount/5; ++five)
{
for(int ten = 0;ten <= amount/10; ++ten)
{
for (int twenty = 0;twenty <= amount/20; ++twenty)
{
if(one+five*5+ten*10+twenty*20 == amount) {
System.out.println(one+"张1元，" + five + "张5元，"+ten+"张10元，"+twenty+"张20元");
break OUT;
}
}
}
}
}
}
Break和continue
- 在循环前可以放一个标号来表示循环：
- label:
- 带标号的break和continue对那个循环起作用
3.3.3逻辑类型与逻辑运算
在判断素数的程序中，使用了isPrime这个变量来达是否素数，我们只用到了isPrime的两个值0、1，可以直接修改。
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
Boolean isPrime = true; //原先：int isPrime = 0;
System.out.print("请输入一个数：");
int n = in.nextInt();
for (int i = 2; i < n ; i++) {
if (n % i == 0) {
isPrime = false; //原先isPrime = 0;
System.out.println(n + "不是一个素数，i = " + i);
break;
}
}
if (isPrime) //原先isPrime == 1
{
System.out.println(n + "是素数");
}
else
{
System.out.println(n + "不是素数");
}
}
逻辑类型：
- 关系运算的结果是一个逻辑值，true或false。这个值可以保存在一个对应的逻辑类型的变量中，这样的变量类型是boolean.
- 布尔是为了纪念George Boole对逻辑计算的贡献
- boolean flag = true;
- boolean tooHign,tooSmall,tooRough;
- boolean done = false;
- 逻辑运算是对逻辑量进行的运算，只有逻辑量可以参与运算
| 运算符 | 描述 | 示例 | 结果 |
|---|---|---|---|
| ！ | 逻辑非 | !a | 如果a是true结果就是false，如果a是false结果就是true |
| && | 逻辑与 | a && b | 如果a和b都是true，结果就是true，否则就是false |
| “ | ” | 逻辑或 |
像4<x<6这样的式子，不是java能接受的式子，因为4<x的结果是一个逻辑值，逻辑值是不能和数值6做关系计算的。
==> x > 4 && x < 6
逻辑运算的优先级：
- ！> && > ||
- 举例：!done&&(count > MAX)
- 注意：单目运算的优先级都很高
- 给出式子：if ( ! n > 0) {}
- 编译器会报错：The operator ! is undefined for the argument type(s) intThe operator
3.4循环应用
3.4.1计数循环
int count = 100;
while ( count >= 100 ) {
count = count-1;
System.out.println(count);
}
System.out.println("发射");
问题：这个循环执行多少次？
循环停下来的时候，有没有输出最后的0？
循环结束后，count的值是多少？
package Judge;
import java.util.Scanner;
public class PrimeNumber {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
int count = 10;
while (count>0) {
System.out.println("发射");
count = count - 1;
}
System.out.println(count);
System.out.println("发射");
}
}
小套路：如果要模拟一个很大次数的循环，可以用一个小的次数来做，再来进行推断。
使用。
作业：程序发生改变：
int count = 10；
do {
System.out.println(count);
count = count - 1;
}while (count > 0 );
SYstem.out.println("发射！");
3.4.2算平均数
- 让用户输入一系列的正整数，最后输入-1表示输入结束，然后程序计算出这些数字的平均数，输出输入的数字的个数和平均数
- 变量 --> 算法 --> 流程图 --> 程序
需求分析：
- 一个记录读到的整数的变量
- 平均数要怎么计算？
- 只需要每读到一个数，就把它加到一个累加的变量里，到全部数据读完，再拿它去除读到的数的个数就行
- 一个变量记录累加的结果。一个变量记录读到得数
算法实现：
- 初始化变量sum和count为0；
- 读入number；
- 如果number不是-1，则将number加入sum，并将count加1，回到2；
- 如果number是-1，则计算和打印出sum/count（注意换成浮点来计算）
do-while(实现)
代码中注释掉的部分是while循环
package Judge;
import java.util.Scanner;
public class PrimeNumber {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
int number;
int sum = 0;
int count = 0;
// number = in.nextInt();
// while ( number != -1)
// {
// sum += number;
// count = count + 1;
// number = in.nextInt();
// }
do {
number = in.nextInt();
if(number != -1)
{
sum += number;
count =count +1;
}
}while (number != -1);
if (count > 0)
{
System.out.println("平均数" + (double)sum/count);
}
}
}
3.4.3猜数游戏
需求：
- 计算机随机想一个数，记在变量number中；
- 一个负责计次数的变量count初始化为0；
- 让用户输出一个数字a;
- count递增（加一）;
- 判断a和number的大小关系，如果a大，就输出“大”，如果a小，就输出“小”；
- 如果a和number是不相等的（无论大还是小），程序转回第三步；
- 否则，程序输出“猜中”和次数，然后结束
package Judge;
import java.util.Scanner;
public class GuessNumber {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
int number = (int)(Math.random()*100+1);
int a;
int count = 0;
do {
a = in.nextInt();
count= count+ 1;
if (a > number)
{
System.out.print("偏大");
}
else if(a < number)
{
System.out.print("偏小");
}
} while (a != number);
System.out.println("恭喜你才对了" + count+ " 次");
}
}
3.4.4整数分解
体验while和do-while的区别：
package Judge;
import java.util.Scanner;
public class IntegerResolve {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
int number;
number = in.nextInt();
int result = 0;
do
{
int digit = number % 10;
result = result*10+digit;
System.out.println(digit);
number = number / 10;
}while (number > 0);
System.out.println(result);
}
}
3.4.5求和
需求：
package Judge;
import java.util.Scanner;
public class IntegerResolve {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
System.out.print("请输入一个数：");
int n = in.nextInt();
double sum = 0.0;
for(int i = 1; i <= n; i++)
{
sum += 1.0/i;
}
System.out.println(sum);
System.out.printf("%.2f",sum);
}
}
需求变更：
思路：
1）加一个减一个 ==> 增加一个变量sign，sign = -sign；在循环中总是正负交替着.
package Judge;
import java.util.Scanner;
public class IntegerResolve {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
System.out.print("请输入一个数：");
int n = in.nextInt();
double sum = 0.0;
int sign = 1;
for(int i = 1; i <= n; i++) // for(int i = 1; i <= n; i++,sign = -sign) 使用逗号的意思是，for循环执行i++的同时执行sign = -sign;
{
sum += sign*1.0/i;
sign = -sign;
}
System.out.println(sum);
System.out.printf("%.2f",sum);
}
}
2）加一个正的加一个负的 ==> i是奇数加法，i是偶数减法.
package Judge;
import java.util.Scanner;
public class IntegerResolve {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
System.out.print("请输入一个数：");
int n = in.nextInt();
double sum = 0.0;
int sign = 1;
for(int i = 1; i <= n; i++)
{
// sum += sign*1.0/i;
// sign = -sign;
if (i % 2 == 1)
{
sum += 1.0/i;
}
else
{
sum -= 1.0/i;
}
}
System.out.println(sum);
System.out.printf("%.2f",sum);
}
}
3.4.6最大公约数
- 输入两个数 a 和 b,输出它们的最大公约数
- 输入：12 、18
- 输出：6
思路：
package Judge;
import java.util.Scanner;
public class IntegerResolve {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
System.out.print("请输入a:");
int a = in.nextInt();
System.out.print("请输入b:");
int b = in.nextInt();
int gcd = 1;
for (int i = 2; i <=a && i <=b;i++)
{
if (a % i ==0 && i == 0)
{
gcd = i;
}
}
System.out.println(a + "和" + b + "最大公约数" + gcd);
}
}
缺点：计算次数多，计算时间拉长
引出概念：辗转相除法
- 如果b等于0，计算结束，a就是最大公约数
- 否则，计算a除以b的余数，让a等于b，而b等于那个余数；
- 回到第一步
a是12，b是18，第一次的r：12除18的余数=12.
| b | r(表达余数) |
|---|---|
| 18（把b的值赋给a） | 12(12%18的余数) |
| 12（把b的值赋给a） | 6（18%12） |
| 6 | 0 |
因为不知道有几步；所以适合用while循环
package Judge;
import java.util.Scanner;
public class IntegerResolve {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
System.out.print("请输入a:");
int a = in.nextInt();
System.out.print("请输入b:");
int b = in.nextInt();
int oa = a;
int ob = b;
while ( b != 0)
{
int r = a%b;
System.out.println(a + "," + b + "," + r );
a = b;
b = r;
}
System.out.println(oa+"和"+ob+"最大公约数"+a);
}
}
编程题：奇偶个数
需求：
题目内容：
你的程序要读入一系列正整数数据，输入-1表示输入结束，-1本身不是输入的数据。程序输出读到的数据中的奇数和偶数的个数。
输入格式:
一系列正整数，整数的范围是（0,100000）。如果输入-1则表示输入结束。
输出格式：
两个整数，第一个整数表示读入数据中的奇数的个数，第二个整数表示读入数据中的偶数的个数。两个整数之间以空格分隔。
输入样例：
9 3 4 2 5 7 -1
输出样例：
4 2
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner can = new Scanner(System.in);
int num = can.nextInt();
int count1 = 0, count2 = 0;
while (num != -1) {
if (num % 2 == 1)
count1++; //记录奇数的个数
else
count2++; //记录偶数的个数
num = can.nextInt();
}
System.out.println(count1 + " " + count2);
}
}
编程题：数字特征值
提示：将整数从右向左分解，数位每次加1，而二进制值每次乘2。
输入格式:
一个非负整数，整数的范围是[0,1000000]。
输出格式：
一个整数，表示计算结果。
输入样例：
342315
输出样例：
13
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int number = in.nextInt();
int temp=number;
int i,count=0;
for(i=0;temp!=0;i++)
temp/=10;
if(number!=0)
do {
count*=2;
if(((int)(number/(Math.pow(10, i-1))))%2==i%2)
count+=1;
number=(int) (number%(Math.pow(10, i-1)));
i--;
} while (i>0);
System.out.println(count);
}
}
编程题：素数之和
题目内容：
我们认为2是第一个素数，3是第二个素数，5是第三个素数，依次类推。
现在，给定两个整数n和m，0<n<=m<=200，你的程序要计算第n个素数到第m个素数之间所有的素数的和，包括第n个素数和第m个素数。
输入格式:
两个整数，第一个表示n，第二个表示m。
输出格式：
一个整数，表示第n个素数到第m个素数之间所有的素数的和，包括第n个素数和第m个素数。
输入样例：
2 4
输出样例：
15
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
int sum = 0;
int count = 0;
if (0 < n && n <= m && m <= 200) {
for(int i =1;i<2000;i++){
if(isPrime(i)){
count++;
if(count>=n){
sum = sum +i;
}
}
if(count==m){
break;
}
}
} else {
return;
}
System.out.println(sum);
}
public static boolean isPrime(int n)
{
int i=0;
if(n < 2) return false;
if(n == 2) return true;
for(i = 2; i*i <= n; i++)
if(n%i == 0) return false;
return true;
}
}
1785
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
