IDEA中Debug调试：可以参考这个博主的这篇博客：http://t.csdn.cn/Ha1T0；
一个简单的热身练习：
byte a = 0 ; short b = 128 ;a = (byte) b ;问：a=？
在Java中，byte类型是一个有符号的8位整数，其取值范围是从-128到127。而short类型是一个有符号的16位整数，其取值范围是从-32768到32767。
在这个例子中，变量a被声明为byte类型，它的初始值为0，变量b被声明为short类型，它的初始值为128。当我们将b的值赋给a时，由于byte类型的取值范围比short类型小，因此在将b的值转换为byte类型时可能会出现截断。具体来说，由于128在二进制中的表示是10000000，它的最高位是1，因此在将它转换为byte类型时，最高位的1会被解释为符号位，表示这是一个负数。
按照Java中的二进制补码表示法，负数的补码是其绝对值的二进制表示取反再加1。因此，我们将128的绝对值取反得到01111111，然后加上1，得到10000000。这就是-128在二进制补码表示法下的表示。因此，最终a的值为-128.
不能做Switch参数的数据类型有哪些？基本数据类型当中：float 、 double 、long 、boolean；注意！字符串也可以作为它的参数！Switch中可以定义变量，也可以嵌套Switch。
总之，在Java中，switch语句的参数类型必须是整型、字符型或者枚举类型（字符串也可）。
continue 是 Java 中的一个关键字，用于跳过当前循环中剩余的代码，直接开始下一次循环。
当 continue 语句被执行时，程序会跳过当前循环中 continue 语句下面的所有语句，然后开始下一次循环。这样可以在满足特定条件时跳过某些操作，提高代码的效率和可读性。
continue 通常用于 for、while、do-while 循环中，可以在循环体内的任何位置使用。在 for 循环中，continue 语句通常放在循环体的最后一行。
运用continue来写一个代码：求出100~200之间3的倍数和4的倍数
for (int i = 100; i <= 200; i++) {
if (i % 3 != 0 && i % 4 != 0) {
continue; // 跳过非3和4的倍数的数
}
if (i % 3 == 0) {
System.out.print(i + "是3的倍数 ");
}
if (i % 4 == 0) {
System.out.print(i + "是4的倍数");
}
System.out.println(); // 换行
}在Java中，println、print和printf都是用于输出数据的方法，但它们有一些区别：
println：输出一个字符串，并在末尾自动换行。
print：输出一个字符串，但不会自动换行。如果遇到空格，就停止输出！
printf：可以格式化输出一个字符串，可以使用占位符 %。
int num = 123;
String str = "Hello, world!";
double dbl = 3.14159;
// 使用 println 输出
System.out.println(num); // 输出：123 并换行
System.out.println(str); // 输出：Hello, world! 并换行
System.out.println(dbl); // 输出：3.14159 并换行
// 使用 print 输出
System.out.print(num); // 输出：123
System.out.print(str); // 输出：Hello, world!
System.out.print(dbl); // 输出：3.14159
// 使用 printf 输出
System.out.printf("num = %d, str = %s, dbl = %.2f", num, str, dbl);
// 输出：num = 123, str = Hello, world!, dbl = 3.14在Java中，格式化转换符是一种用于控制输出格式的特殊字符，可以在字符串中使用。以下是一些常见的格式化转换符及其说明：
%d：表示输出十进制整数。
%f：表示输出浮点数。默认保留六位小数，可以使用%.nf来指定保留的小数位数。
%s：表示输出字符串。
%c：表示输出字符。
%b：表示输出布尔值。
%n：表示输出换行符。
%t：表示输出日期或时间。可以与以下格式化转换符一起使用：
%tY：表示输出年份。
%tm：表示输出月份。
%td：表示输出日。
%tH：表示输出小时（24小时制）。
%tM：表示输出分钟。
%tS：表示输出秒。
import java.util.Scanner;
Scanner scanner =new Scanner(System.in);
System.out.println("请输入你的年龄：> ");
int age =scanner.nextInt();
System.out.println("年龄"+age);
scanner.nextLine();//注意消除回车的影响
System.out.println("请输入你的名字：> ");
String name =scanner.nextLine();//nextLine 读入一行；next遇到空格结束；
System.out.println("名字"+name);
System.out.println("请输入你的工资：> ");
float money =scanner.nextFloat();//nextLine 读入一行；next遇到空格结束；
System.out.println("工资"+money);
while(scanner.hasNextInt()){
int a = scanner.nextInt();
System.out.println(a);
}最下面那段代码是在使用Java的Scanner类从控制台读取整数。while循环的条件是Scanner对象的hasNextInt()方法返回true，即控制台输入还有整数待读取时，就执行循环体中的代码。在循环体中使用Scanner对象的nextInt()方法读取控制台输入的整数，将其赋值给变量a，然后打印，这个循环会一直读取整数，直到控制台输入的不再是整数，才会跳出循环。
在 Java 中，hasNext() 和 hasNextLine() 都是用于判断输入流中是否有下一个标记或行的方法，但是它们之间存在一些区别：
hasNext() 用于判断输入流中是否有下一个标记（token），标记之间由分隔符（默认情况下是空格）分隔，如果有则返回 true，否则返回 false。
hasNextLine() 用于判断输入流中是否有下一行，如果有则返回 true，否则返回 false。
因此，hasNext() 可以用于检测输入流中是否还有其他数据类型的输入，比如整数、浮点数等，hasNext() 方法也可以读取字符串。该方法用于检查输入流是否还有下一个标记，如果有则返回 true，否则返回 false。当读取字符串时，标记可以是空格、制表符、换行符等。但是，它只是检查是否有下一个标记，而不会移动指针读取标记内容。如果要读取标记内容，需要使用 next() 方法。而 hasNextLine() 只能检测是否还有字符串类型的输入。另外，hasNextLine() 会读取掉输入流中的换行符（\n），而 hasNext() 不会。因此，如果需要读取下一行输入，建议使用 hasNextLine()。
当我们先使用nextInt() 或 nextFloat()等方法读取基本数据类型后，如果紧接着使用nextLine()方法读取字符串时，会出现无法读取字符串的情况，因为在读取基本数据类型时会把回车符(\n)留在输入缓冲区中，而nextLine()方法会读取回车符前面的所有字符，包括之前留下的回车符。此时可以使用scanner.nextLine()方法将回车符消除，从而可以正确读取下一行输入的字符串。
通常情况下，next()读取输入的内容到第一个空格或回车之前，因此不需要使用nextLine()消除回车的影响。但是，在使用next()之后，如果要读取一行内容，需要先调用nextLine()将之前的回车消除掉，再进行读取。例如：
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个字符串：");
String str = scanner.next();
scanner.nextLine(); // 消除回车的影响
System.out.print("请输入一行内容：");
String line = scanner.nextLine();这样可以避免因为之前的next()未消除回车的影响而导致的错误输入
Java中的Random和Math都可以用于生成随机数，但是它们之间有一些区别。
Random是一个类，提供了一些用于生成伪随机数的方法。它的实例需要先进行初始化，可以使用默认种子或者指定种子，以便生成确定的随机数序列。Random可以生成各种类型的随机数，包括整数、浮点数和布尔值等。Random还可以生成符合特定分布的随机数序列，比如高斯分布等。
Math是Java中的一个数学类，提供了一些基本的数学方法和常量，包括一些生成随机数的方法。Math提供的生成随机数的方法都是静态方法，可以直接使用，不需要创建实例。Math只能生成基本数据类型的随机数，包括整数和浮点数，而且只能生成均匀分布的随机数序列。
总体来说，如果需要生成符合特定分布的随机数序列，或者需要生成一些复杂的随机数序列，可以使用Random类。如果只需要生成简单的均匀分布的随机数，可以使用Math类的相关方法。
在Java中，可以使用 Random 和 Math 两个类来生成随机数。它们的区别如下：
生成随机数的方式不同：
Random 类通过调用 nextXXX() 方法（如 nextInt(), nextDouble() 等）来生成不同类型的随机数。
Math 类通过调用 random() 方法来生成 double 类型的随机数。注意，Math.random() 方法生成的随机数范围是 [0,1)。
种子的使用不同：
Random 类可以通过构造函数传递一个种子参数，如果传递相同的种子参数，则会生成相同的随机数序列。
Math 类没有提供设置种子的方法，因此无法生成相同的随机数序列。
Random 类支持设置随机数生成器的算法和种子来源：
Random 类可以通过 setSeed(long seed) 方法来设置随机数生成器的种子，也可以通过 setSeed(byte[] seed) 来设置种子。此外，还可以使用 SecureRandom 类来保证随机数的安全性。
Math 类不支持设置随机数生成器的算法和种子来源。
下面是使用 Random 和 Math 生成随机数的代码示例：
使用 Random 生成随机数：
import java.util.Random;
public class RandomDemo {
public static void main(String[] args) {
Random random = new Random(); // 创建一个 Random 实例
// 生成 5 个随机整数
for (int i = 0; i < 5; i++) {
int randInt = random.nextInt(10); // 生成 0~9 之间的随机整数
System.out.println(randInt);
}
}
}使用 Math 生成随机数：
public class MathDemo {
public static void main(String[] args) {
// 生成 5 个 [0,1) 之间的随机 double 值
for (int i = 0; i < 5; i++) {
double randDouble = Math.random();
System.out.println(randDouble);
}
}
}从上面的代码可以看出，使用 Random 生成随机数需要先创建一个 Random 对象，然后调用其 nextInt() 等方法来生成随机数。而使用 Math.random() 方法生成随机数则更加简单，直接调用即可，但是生成的随机数范围只能是 [0,1) 之间的 double 类型数值。
此外，使用 Random 可以设置一个种子参数，生成的随机数序列会因种子参数不同而不同，而使用 Math.random() 则没有种子参数可设置。
在 Java 中，Random 类中的种子参数指的是初始化生成随机数的起点或者起源。使用相同的种子参数，可以保证生成的随机数序列是相同的。
Random 类中有两种构造方法：
Random()：使用当前时间作为种子参数，生成一个随机数生成器。
Random(long seed)：使用指定的种子参数生成一个随机数生成器。
如果使用相同的种子参数，那么每次生成的随机数序列都会是一样的。这在某些情况下是非常有用的，例如需要生成固定的随机数序列，或者在测试中需要保证每次生成的随机数都是相同的。
下面是一个使用 Random 类生成随机数的例子：
import java.util.Random;
public class RandomExample {
public static void main(String[] args) {
Random random1 = new Random(); // 使用当前时间作为种子参数
Random random2 = new Random(12345); // 使用指定的种子参数
System.out.println("随机数序列1：");
for (int i = 0; i < 5; i++) {
System.out.print(random1.nextInt(10) + " ");
}
System.out.println("\n随机数序列2：");
for (int i = 0; i < 5; i++) {
System.out.print(random2.nextInt(10) + " ");
}
}
}上面的代码中，我们创建了两个不同的 Random 对象，一个使用当前时间作为种子参数，另一个使用指定的种子参数 12345。然后，我们分别生成了它们的随机数序列，并输出到控制台。
运行程序后，我们可以看到两个随机数序列分别是：
随机数序列1：
1 2 9 0 3
随机数序列2：
6 0 3 3 0 可以发现，由于使用了不同的种子参数，两个随机数序列是不同的。如果我们将两个 Random 对象的种子参数改为相同的值，那么它们生成的随机数序列就会相同。
猜数字游戏：
public static void main1(String[] args) {
Scanner scanner = new Scanner(System.in);
Random random = new Random();
int randNum = random.nextInt(101);//[0,101)
//50-100的随机数 random.nextInt(50)--[0,50) + 50;
while (true) {
System.out.println("请输入你要猜的数字：");
int num = scanner.nextInt();
if(num < randNum) {
System.out.println("猜小了！");
}else if(num == randNum) {
System.out.println("猜对了！");
break;
}else {
System.out.println("猜大了！");
}
}
}求出1到100之间的素数：
public static void main2(String[] args) {
for (int n = 1; n <= 100; n++) {
//int n = 9;
int i = 2;
for (; i <= Math.sqrt(n); i++) {
if(n % i == 0) {
break;
}
}
//有几种情况 ？ 2--》 1、 不符合循环条件 2、因为遇到了 break
if(i > Math.sqrt(n)) {
System.out.println(n + " 是素数！ ");
}
}
}找所有自幂数（水仙花数、四叶玫瑰数、五角星数......）：
public static void main3(String[] args) {
for (int i = 1; i <= 999999 ; i++) {
//i == 123
int count = 0;//记录位数
int tmp = i;
while (tmp != 0) {
tmp /= 10;
count++;
}
tmp = i;//123
int sum = 0;
while (tmp != 0) {
sum += Math.pow(tmp % 10,count);
tmp /= 10;
}
if(sum == i) {
System.out.println(i);
}
}
}求出一个数字的二进制位中1的个数：
我们发现，这个数每次&（这个数-1）的值会比上一次少1。
public static void main(String[] args) {
int n = -1;
int count = 0;
while (n != 0) {
n = n & (n-1);
count++;
}
System.out.println(count);
}编写代码模拟三次密码输入的场景。 最多能输入三次密码，密码正确，提示“登录成功”,密码错误， 可以重新输 入，最多输入三次。三次均错，则提示退出程序 ：
我先写了这个：
public static void main(String[] args){
String code="code";
Scanner sc = new Scanner(System.in);
int trying=0;
for(trying=1;trying<=3;trying++){
System.out.println("请输入密码：");
String password = sc.nextLine();
if(password==code){
System.out.println("密码正确！！！登录成功！！!");
break;
}
else{
System.out.printf("密码错误，您还有%d次机会！",3-trying);
}
}
if(trying==3){
System.out.println("退出程序......");
}
}
}有问题！！！经查询：
这段代码的问题：
在比较字符串相等时应该使用 equals() 方法，而不是使用 == 进行比较。
以下是修改后的代码：
public static void main(String[] args){
String code = "code";
Scanner sc = new Scanner(System.in);
int trying = 0;
for(trying = 1; trying <= 3; trying++){
System.out.println("请输入密码：");
String password = sc.nextLine();
if(password.equals(code)){
System.out.println("密码正确！！！登录成功！！!");
break;
} else {
System.out.printf("密码错误，您还有%d次机会！", 3 - trying);
}
}
if(trying > 3){
System.out.println("退出程序......");
}
}在这个修改后的代码中，我们使用了 equals() 方法来比较字符串相等，也加入了 break 语句，当输入正确密码时及时退出循环。此外，我们还可以在输入密码之前增加一行代码 sc.next()，用于清除输入流中的回车符。
在Java中，使用 == 比较两个字符串时，实际上是在比较它们的内存地址是否相同。而字符串是一种特殊的对象类型，在Java中使用双引号声明的字符串实际上是一个对象。因此，如果使用 == 进行比较，结果可能与预期不同。即使两个字符串的内容相同，但它们在内存中的地址不同，使用 == 进行比较也会返回 false。
正确的方法是使用 equals 方法进行比较，它会比较两个字符串的内容是否相同，而不是它们在内存中的地址。例如，应该使用 password.equals(code) 来比较两个字符串是否相同。
获取一个数二进制序列中所有的偶数位和奇数位， 分别输出二进制序列：
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int m = scan.nextInt();
int n = 31;
System.out.println("奇数位：");
while (n >= 0) {
if (n % 2 == 1) {
System.out.print((m >> n) & 1);
}
n--;
}
int j = 30;
System.out.println("\n偶数位：");
while (j >= 0) {
if (j % 2 == 0) {
System.out.print((m >> j) & 1);
}
j--;
}
}在输出奇数位和偶数位时，注意位运算和判断条件。
输出时应该使用 print() 方法，使用 println() 方法会换行。
给定两个数，求这两个数的最大公约数：
我先写了：
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.println("请输入a和b：》");
int a= scan.nextInt(); //9 //15 //12 //28
int b=scan.nextInt(); //15 //9 //28 //12
while(b!=0){
int c=a; //9 15 9 6 //15 9 6 //12 28 12 16 12 //28 12 16 12
a=b; //15 9 6 3 //9 6 3 //28 12 16 12 4 //12 16 12 4
b=c%b; //9 6 3 0 //6 3 0 //12 16 12 4 0 //16 12 4 0
}
System.out.println(a);
}
}
这段代码实现了辗转相除法求解两个数的最大公约数，代码本身没有明显的问题。不过，可以考虑添加一些异常处理，例如当输入的a和b为0时，程序可能会进入无限循环。
优化后：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("请输入a和b：");
int a = scan.nextInt();
int b = scan.nextInt();
while(a!=0&&b!=0){
if (a < b) {
int temp = a;
a = b;
b = temp;
}
while (b != 0) {
int c = a;
a = b;
b = c % b;
}
System.out.println("最大公约数为：" + a);
}
}
}这只是为了稍微减少计算次数和增强可读性才确保a>b，但是在原来的代码里其实a和b的大小对程序的运行的影响其实并不大。
还有一些别的实现方法：
gcd 函数用于计算两个整数的最大公约数（Greatest Common Divisor），具体实现使用的是辗转相除法（Euclidean algorithm）。
辗转相除法的思想是：对于任意正整数a和b（a > b），假设r是a除以b的余数，则a和b的最大公约数等于b和r的最大公约数。
根据这个思想，我们可以写出递归实现的 gcd 函数：
public static int gcd(int a, int b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}这个函数首先检查 b 是否为 0，如果是，则返回 a，这是递归的基本情况；如果不是，则递归调用 gcd 函数，并把 b 和 a%b 作为参数传递给它。因为 a%b 是 a 除以 b 的余数，所以根据辗转相除法的思想，b 和 a%b 的最大公约数就是 a 和 b 的最大公约数。
比如，计算 84 和 36 的最大公约数，调用 gcd(84, 36) 会得到：
gcd(84, 36) -> gcd(36, 12) -> gcd(12, 0) -> 12
最终得到的结果是 12，也就是 84 和 36 的最大公约数。
更相减损术
基本思路是：先求两个数的差，再用较小数和差继续做差，直到两个数相等为止。最后得到的数就是这两个数的最大公约数。
具体实现代码如下：
public static int gcd(int a, int b) {
if (a == b) {
return a;
} else if (a > b) {
return gcd(a - b, b);
} else {
return gcd(a, b - a);
}
}质因数分解法
基本思路是：将两个数分别分解质因数，然后找到两个数中共有的质因数，将它们相乘得到最大公约数。
具体实现代码如下：
public static int gcd(int a, int b) {
int min = Math.min(a, b);
int max = Math.max(a, b);
for (int i = min; i >= 2; i--) {
if (min % i == 0 && max % i == 0) {
return i;
}
}
return 1;
}以上两种方法都可以求出两个数的最大公约数，但它们的时间复杂度不同。辗转相除法的时间复杂度是 O(log n)，更相减损术的时间复杂度是 O(n)，而质因数分解法的时间复杂度是 O(sqrt(n))。因此在实际应用中，应根据具体情况选择合适的方法。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
