public class WeekDay {
public static void main(String[] args) {
/**
* first
* Java是基于JVM虚拟机的跨平台语言，一次编写到处运行
* Java程序易于编写，而且有垃圾回收机制，开发者不必考虑内存的管理
* Java虚拟机拥有工业级的稳定新和高度优化的性能，且经过了长期的考验
* Java拥有最广泛的开源社区的支持
*/
/**
*方法是可以执行的代码块，main是方法名，()括号括起来的是方法参数，
* main方法有一个参数，参数类型是String【】，参数名是args
* public、static是用来修饰方法的，表示一个公开的静态犯法，void是方法的返回类型
*一个Java源码只能定义一个public类型的class，并且class名称和文件名要完全一致
* 使用javac可以将 .java 源码编译成 .class字节码
* 使用java可以运行一个已经编译的Java程序，参数是类名。
*/
/**
* public是访问修饰符，表示class是公开的
* 不写public可以正确编译，但是这个类无法从命令行执行
* 在class内部，可以定义若干方法（method）
*/
/**
* javat提供了两种变量类型，基本类型和引用类型
* 基本类型：整型、浮点型、布尔型、字符型
*/
/**
*定义整型
* int i = 2147483647;
* int i2 = -2147483648;
* int i3 = 2_000_000_000; // 加下划线更容易识别
* int i4 = 0xff0000; // 十六进制表示的16711680
* int i5 = 0b1000000000; // 二进制表示的512
* long l = 9000000000000000000L; // long型的结尾需要加L
*/
/**
* 移位运算
* >>右移 <<左移
* 在计算机中，整数都是以二进制来表示的
* 所以对于计算机来说，运算速度最快应该是移位
* 例如：7向左移一位得到的是14，7左移动两位得到的是28
* 7 0000 0111
* 左移一位是 14 0000 1110 = 8+4+2 = 14
* 左移二位是 14 0001 1100 = 16+8+4 = 28
* 1*7=7 2*7=14 4*7=28
* 8 0000 1000
* 左移一位是 14 0001 0000 = 16
* 左移二位是 14 0010 0000 = 32
* 是有规律的，但是以32位为例，当左移的29位时，最高位变成了 1 ，最高位是符号位，表示 - 负号
* int n = 7; // 00000000 00000000 00000000 00000111 = 7
* int a = n << 1; // 00000000 00000000 00000000 00001110 = 14
* int b = n << 2; // 00000000 00000000 00000000 00011100 = 28
* int c = n << 28; // 01110000 00000000 00000000 00000000 = 1879048192
* int d = n << 29; // 11100000 00000000 00000000 00000000 = -536870912
* 类似的对整数28进行右移，7*2^2,右移一位变成，7*2^1
* int n = 28; // 00000000 00000000 00000000 00011100 = 28
* int a = n >> 1; // 00000000 00000000 00000000 00001110 = 14
* int b = n >> 2; // 00000000 00000000 00000000 00000111 = 7
* int c = n >> 3; // 00000000 00000000 00000000 00000011 = 3
* int d = n >> 4; // 00000000 00000000 00000000 00000001 = 1
* int e = n >> 5; // 00000000 00000000 00000000 00000000 = 0
* 对一个负数进行右移，最高位的符号位1保持不变，结果的的符号不变
* int n = -536870912;
* int a = n >> 1; // 11110000 00000000 00000000 00000000 = -268435456
* int b = n >> 2; // 11111000 00000000 00000000 00000000 = -134217728
* int c = n >> 28; // 11111111 11111111 11111111 11111110 = -2
* int d = n >> 29; // 11111111 11111111 11111111 11111111 = -1
* 无符号的右移运算，使用>>>，
* 它的特点是不管符号位，右移后高位总是补0，
* 因此，对一个负数进行>>>右移，它会变成正数，原因是最高位的1变成了0：
* int n = -536870912;
* int a = n >>> 1; // 01110000 00000000 00000000 00000000 = 1879048192
* int b = n >>> 2; // 00111000 00000000 00000000 00000000 = 939524096
* int c = n >>> 29; // 00000000 00000000 00000000 00000111 = 7
* int d = n >>> 31; // 00000000 00000000 00000000 00000001 = 1
* 对byte和short类型进行移位时，会首先转换为int再进行位移。
* 左移就是不断的 *2 右移就是不断的 ÷2
*/
/**
* 运算符的优先级
* 在Java的计算表达式中，运算优先级从高到低依次是：
* （）
* ！ ~ ++ --
* * / %
* + -
* << >> >>>
* &
* |
* += -= *= /=
*/
/**
* 在计算机中，浮点数的表示范围虽然大，但是却无法精确的表示
* 浮点数 0.1 在计算机中使用二进制表示是一个无线循环小数
* 由于浮点数的运算存在误差，所以比较两个浮点数是否相等方法是判断两个浮点数之差的绝对值是否小于一个很小的数
* 在进行复杂四则运算的时候，不会出现自动转换
* 例如：1.2 + 24/5 结果是5.2 24/5得到的结果是4
* 在进行整数运算的时候除数为0是会报错的，但是在进行浮点预算时除数为0并不会报错，但是会返回几个特殊值
* NaN表示Not a Number
* Infinity表示无穷大
* -Infinity表示负无穷大
*/
/**
* 布尔运算
* 对于布尔类型boolean，永远只有true和false两个值。
* 布尔运算是一种关系运算，包括以下几类：
* 非运算 !
* 比较运算符：>，>=，<，<=， ==，!=
* 与运算 &&
* 或运算 ||
* 关系运算符的优先级从高到低依次是：
* !
* >，>=，<，<=
* ==，!=
* &&
* ||
* 短路与，如果一个布尔运算的表达式能提前确定结果，则后续不再执行，直接返回结果
* 三元运算符
* b ? x : y 它根据第一个布尔表达式的结果，分别返回后续两个表达式之一的计算结果
*/
// TODO DODO
/**
* 字符类型char是基本数据类型，他是character的缩写
* 一个char可以保存一个Unicode字符
* char c1 = 'A';
* char c2 = '中';
* Java在内存中总是使用Unicode表示字符，一个英文字符和一个中文字符都用一个char类型，
* 表示。他们都占连个字节。
* 要显示一个字符的Unicode编码，只需将char类型直接赋值给int类型即可：
* int n1 = 'A'; // 字母“A”的Unicodde编码是65
* int n2 = '中'; // 汉字“中”的Unicode编码是20013
* 也可以直接用转义字符\u + Unicode编码来表示一个字符：
* // 注意是十六进制:
* char c3 = '\u0041'; // 'A'，因为十六进制0041 = 十进制65
* char c4 = '\u4e2d'; // '中'，因为十六进制4e2d = 十进制20013
* 字符串类型
*和char类型不同，字符串String类型是引用类型，使用 " " ,表示字符串
* \n 换行 \r 回车 \t Tab \u#### 表示一个Unicode编码字符
* 引用类型的变量可以指向一个空值null，它表示不存在，即该变量不指向任何对象。
* Java的字符类型char是基本类型，字符串String是引用类型
* 基本类型的变量是持有每个值，引用类型的变量是指向某个对象
*/
/**
* 数组类型
* 定义一个数组类型的变量，使用数组类型'类型[]'和基本类型变量不同，数组变量初始化必须使用new int[5]
* 表示创建一个可以容纳5个int元素的数组。
* 数组所有元素初始化为默认值，整型都是0，浮点型是0.0，布尔型是false。
* 数组一旦创建大小是不可以改变的
* 数组是引用类型，在使用索引访问数组元素时，索引超出范围，运行时将报错
* 数组创建的三种方式：
* int[] arr = new int[长度];arr[0]=0;...
* int[] arr = new int[]{1,2,3,4,5};编译器会自动推算数组长度
* 先声明 int[] arr; arr = new[]{1,2};
* 数组元素可以是值类型、引用类型，但是数组本身是引用类型。
*/
}
}
流程控制
在Java程序中，jvm默认会以分号 ; 结束。但是在实际的代码中，程序需要进行条件判断、循环
输入输出
格式化输出使用System.out.printf()，通过使用占位符%?，printf()可以把后面的参数格式化成指定格式：
double d = 0.123456;
System.out.printf("%.2f\n", d); // 显示两位小数0.12
System.out.printf("%.4f\n", d); // 显示4位小数0.1235
//为什么会变成0.1235不是0.1234是和double的精度有关
//注意：浮点数在计算机中常常无法精确表示，并且计算可能出现误差，因此，判断浮点数相等用==判断不准确
| 占位符 | 说明 |
|---|---|
| %d | 格式化输出整数 |
| %x | 格式化输出十六进制整数 |
| %f | 格式化输出浮点数 |
| %e | 格式化输出科学计数法表示的浮点数 |
| %s | 格式化字符串 |
**注意：**由于%号表示占位符，当你想要输出%号时需要%%，%%表示一个%字符本身，并用0补足8位，两个%占位符必须传入两个数
int n = 12345000;
System.out.printf("n=%d, hex=%08x", n, n);
设计一个程序，输入上次考试成绩和本次考试成绩，然后输出成绩提高的百分比，保留两位小数位（例如，21.75%）。
Scanner input = new Scanner(System.in);
System.out.println("输入本次考试成绩：");
double now = input.nextDouble();
System.out.println("输入上一次的成绩：");
double old = input.nextDouble();
double exa ;
if (old != 0 && now != 0) {
if (now > old) {
exa = (now - old)/old * 100;
System.out.printf("你的成绩提高了：%.2f",exa);
System.out.print("%，再接再厉");
}else{
System.out.println("成绩退步了");
}
}else{
System.out.println("考0分，咱就不谈提高百分比了...");
}
if
| if语句的基本语法 | if else语句的基本语法 | if else if语句的基本语法 |
|---|---|---|
| if (条件) { //条件满足时执行 } | if (条件) { //条件满足时执行 }else{ //条件不满足时执行 } | if (条件) { //条件1满足时执行 }else if(条件2){ //条件2满足时执行 }else{ //条件1、2都不满足时执行 } |
当if语句没有 {} 大括号时，默认只执行第一句。
和equals的区别，也可以简单的理解为判断地址，equals判断内容
| == | equals |
|---|---|
| 判断值类型是否相等 | 判断引用类型变量内容是否相等 |
| 判断引用是否相等 |
在进行equals判断的时候要注意避免空指针异常NullPointerException
for循环经常用来遍历数组，因为通过计数器可以根据索引来访问数组的每个元素。
for each和for循环相比，for each循环的变量n不再是计算器，而是直接对应到数组的每个元素，for each循环无法指定遍历顺序，也无法获取数组的索引（下标）。
switch多重选择
switch(表达式)
{
case 值1:
语句1:
break;
case 值2:
语句2:
break;
...
default:
语句n:
break;
}
通过key的值，匹配到case，然后执行语句。
switch (key = 1) {
case 1:
执行语句
break;
case 2:
语句
break;
default:
语句
break;
一般和Scanner配合使用。switch 和 if 。
if (key == 1) {
//执行语句
} else if (key == 2) {
//执行语句
} else {
//执行语句，一般是关闭程序语句
}
如果在switch中忘记写break，会向下击穿（如果case控制的语句体后面不写break,将会出现穿透现象，在不判断下一个case值得情况下，向下运行，直到遇到break，或者整体switch语句结束。），会造成严重的逻辑错误，切忌不要忘记写break。
使用switch实现一个简单的石头、剪子、布游戏。
Scanner input = new Scanner(System.in);//输入
int choose = 0;
do {
System.out.println("1: 石头");
System.out.println("2: 剪刀");
System.out.println("3: 布");
System.out.println("please choice:");
int choice = input.nextInt();
if (choice < 4 && choice > 0) {
switch (choice) {
case 1:
stone();//石头方法
break;
case 2:
forfex();//剪刀方法
break;
case 3:
cloth();//布方法
break;
default:
System.out.println("系统异常退出");
System.exit(0);
break;
}
}else{
System.out.println("只有剪刀石头布");
}
System.out.println("输入0继续");
choose = input.nextInt();
} while (choose == 0);
剪刀、石头、布方法。
switch语句可以做多重选择，然后执行匹配的case语句后续代码；
switch的计算结果必须是整型、字符串或枚举类型；
public static void cloth() {
int g = getGuess();
if (g == 1) {
System.out.println("输了，输了，我的石头");
} else if (g == 2) {
System.out.println("不好意思，我的剪刀，你输了");
}else if (g == 3) {
System.out.println("我也是布，平局，再来");
}
}
public static void forfex() {
int g = getGuess();
if (g == 1) {
System.out.println("不好意思，我的石头，你输了");
} else if (g == 2) {
System.out.println("我也是剪刀，平局，再来");
}else if (g == 3) {
System.out.println("输了，输了，我的布");
}
}
public static void stone() {
int g = getGuess();
if (g == 1) {
System.out.println("我也是石头，平局，再来");
} else if (g == 2) {
System.out.println("输了，输了，我的剪刀");
}else if (g == 3) {
System.out.println("不好意思，我的布，你输了");
}
}
//产生一个1-3的随机数
public static int getGuess() {
Random random = new Random();
int g = random.nextInt(3) + 1;
System.out.println(g);
return g;
}
从Java 14开始，switch语句正式升级为表达式，不再需要break，并且允许使用yield返回值。
大多数时候，在switch表达式内部，我们会返回简单的值。
但是，如果需要复杂的语句，我们也可以写很多语句，放到{…}里，然后，用yield返回一个值作为switch语句的返回值：
注意新语法使用->，如果有多条语句，需要用{}括起来。不要写break语句，因为新语法只会执行匹配的语句，没有穿透效应。还可能用switch语句给某个变量赋值。
String fruit = "apple";
int opt = switch (fruit) {
case "apple" -> 1;
case "pear", "mango" -> 2;
default -> 0;
}; // 注意赋值语句要以;结束
System.out.println("opt = " + opt);
while和do while
| while循环 | do while循环 |
|---|---|
| while (条件表达式) { 循环语句 } // 继续执行后续代码 | do { 执行循环语句 } while (条件表达式); |
while：
while循环在每次循环开始前，首先判断条件是否成立。如果计算结果为true，就把循环体内的语句执行一遍，如果计算结果为false，那就直接跳出循环。
while循环先判断循环条件是否满足，再执行循环语句；
while循环可能一次都不执行；
编写循环时要注意循环条件，并避免死循环。
do while:
do while循环则是先执行循环，再判断条件，条件满足时继续循环，条件不满足时退出。
do while循环先执行循环，再判断条件；
do while循环会至少执行一次。
for循环
for (初始条件; 循环检测条件; 循环后更新计数器) {
// 执行语句
}
// 不设置结束条件:
for (int i=0; ; i++) {
...
}
// 不设置结束条件和更新语句:
for (int i=0; ;) {
...
}
// 什么都不设置:
for (;;) {
...
}
for each循环
for循环经常用来遍历数组，因为通过计数器可以根据索引来访问数组的每个元素：
和for循环相比，foreach循环的变量n不再是计数器，而是直接对应到数组的每个元素。foreach循环的写法也更简洁。但是，foreach循环无法指定遍历顺序，也无法获取数组的索引。
除了数组外，foreach循环能够遍历所有“可迭代”的数据类型，包括List、Map等。
一般情况下：
for循环通过计数器可以实现复杂循环；
for each循环可以直接遍历数组的每个元素；
for(类型 变量名:集合) {
语句块;
}
类型：集合元素的类型
变量名：表示集合中的每一个元素
集合：是被遍历的集合对象或者数组
foreach循环和普通循环不同的是，它无需循环条件，不需要循环迭代语句，这部分由系统来完成，foreach循环自动迭代数组的每个元素，当每个元素都被迭代一次后，foreach循环自动结束。
break和continue
break跳出当前循环。
break总是跳出最近的一层循环。
continue提前结束本次循环，直接执行下一次循环
冒泡排序
int[] arr = {28, 12, 89, 73, 65, 18, 96, 50, 8, 36};
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - i - 1 ; j++) {
if (arr[j] > arr[j + 1]) {
arr[j+1] = arr[j+1] + arr[j];
arr[j] = arr[j + 1] - arr[j];
arr[j + 1] = arr[j + 1] - arr[j];
}
}
}
int[] arr = {28, 12, 89, 73, 65, 18, 96, 50, 8, 36};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
//降序排序
int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
Arrays.sort(ns);
for (int i = 0; i < ns.length; i++) {
System.out.println(ns[ns.length - i - 1]);
}
java程序的入口是main方法。
面向对象编程
面向对象编程，是一种通过对象的方式，把现实世界映射到计算机模型的一种编程方法。现实世界中，我们定义了“人”这种抽象的概念，而具体的人是“小明”、“小红、等。所以 人 可以定义为一个类（class） ，而具体的人则是实例（instance）。
| 现实世界 | 计算机模型 | Java代码 |
|---|---|---|
| 人 | 类 / class | class Person { } |
| 小明 | 实例 / ming | Person ming = new Person() |
| 小红 | 实例 / hong | Person hong = new Person() |
| 小军 | 实例 / jun | Person jun = new Person() |
同样的，“书”也是一种抽象的概念，所以它是类，而《Java核心技术》、《Java编程思想》、《Java学习笔记》则是实例：
| 现实世界 | 计算机模型 | Java代码 |
|---|---|---|
| 书 | 类 / class | class Book { } |
| Java核心技术 | 实例 / book1 | Book book1 = new Book() |
| Java编程思想 | 实例 / book2 | Book book2 = new Book() |
| Java学习笔记 | 实例 / book3 | Book book3 = new Book() |
类（class）就是一种对象模板，它定义了如何创建实例，因此class本身就是一种数据类型
实例（instance）是对象实例，instance是根据class创建的实例，可以创建多个instance，每个instance类型相同，但是属性可能不相同。
定义class
在java中，创建一个类，例如给这个类命名为Person，就是定义一个class：
class Person{
public String name;
public int age;
}
一个class可以包含多个字段（filed），字段用来描述一个类的特征。上面Person类，我们定义了两个字段，一个是String类型的字段name，一个是int类型的age。通过class把一组数据汇集到一个对象上，实现了数据封装。
public是用来修饰字段的，它表示这个字段可以被外部访问。
创建实例
定义了class，只是定义了对象模板，而要根据对象模板创建出真正的对象实例，必须使用new操作符。new操作符可以创建一个实例，然后我们需要定义一个引用类型的变量来指向这个实例:
Person ming = new Person();
上述代码创建了一个Person类型的实例，并通过变量ming指向它。
注意区分Person ming是定义Person类型的变量ming，而new Person()是创建Person实例。
有了指向这个实例的变量，我们就可以通过这个变量来操作实例。访问实例变量可以用变量.字段，例如：
ming.name = "Xiao Ming"; // 对字段name赋值
ming.age = 12; // 对字段age赋值
System.out.println(ming.name); // 访问字段name
Person hong = new Person();
hong.name = "Xiao Hong";
hong.age = 15;
上述两个变量分别指向两个不同的实例，它们在内存中的结构如下：
┌──────────────────┐
ming ──────>│Person instance │
├──────────────────┤
│name = "Xiao Ming"│
│age = 12 │
└──────────────────┘
┌──────────────────┐
hong ──────>│Person instance │
├──────────────────┤
│name = "Xiao Hong"│
│age = 15 │
└──────────────────┘
两个instance拥有class定义的name和age字段，且各自都有一份独立的数据，互不干扰。
一个Java源文件可以包含多个类的定义，但只能定义一个public类，且public类名必须与文件名一致。如果要定义多个public类，必须拆到多个Java源文件中。
小结
在OOP中，class和instance是“模版”和“实例”的关系；
定义class就是定义了一种数据类型，对应的instance是这种数据类型的实例；
class定义的field，在每个instance都会拥有各自的field，且互不干扰；
通过new操作符创建新的instance，然后用变量指向它，即可通过变量来引用这个instance；
访问实例字段的方法是变量名.字段名；
指向instance的变量都是引用变量。
Java中String、StringBuffer和StringBuilder三者的区别：
一、三者的区别主要体现在速度和线程安全方面两个方面。
YI、在执行速度方面。
StringBuilder > StringBuffer > String
String最慢的原因
1.因为Sttring为字符串，是常量。而StringBuffer和StringBuilder均为字符串变量。
换一种说法就是String对象一旦创建之后该对象是不可以更改的，但后两者的对象是变量，是可以改变的。
-
String对象一旦创建就无法更改了，此时可以把它当成一个常量。
-
Java对String对象进行操作，实际上是一个不断创建新对象，然后将不在引用的老对象进行回收的过程，所以它慢。
StringBuffer和StringBuilder的对象是变量。对变量的操作时可以直接对对象本身进行操作，不需要创建新的对象。
ER、线程安全
就线程来说，StringBuilder是线程不安全的，而StringBuffer是线程安全的。
如果一个StringBuffer对象在字符串缓冲区被多个线程访问使用的时候，StringBuffer中很多方法是带synchronized关键字（源码中），所以保证线程是安全的，但是StringBuilder的方法中没有synchronized关键字，所以不能保证线程安全。
String适用于少量的字符串操作的情况。
StringBuilder适用于单线程下在字符缓冲区进行大量操作的情况。
StringBuffer使用于多线程下载字符缓冲区进行大量操作的情况。
String类的构造方法
public String():空构造
public String(String original):把字符串常量值转成字符串
public String(byte[] bytes):把字节数组转成字符串
public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串(index:表示的是从第几个索引开始, length表示的是长度)
public String(char[] value):把字符数组转成字符串
public String(char[] value,int index,int count):把字符数组的一部分转成字符串
String类的判断功能
public boolean equals(Object obj): 比较字符串的内容是否相同,区分大小写
public boolean equalsIgnoreCase(String str): 比较字符串的内容是否相同,忽略大小写
public boolean contains(String str): 判断字符串中是否包含传递进来的字符串
public boolean startsWith(String str): 判断字符串是否以传递进来的字符串开头
public boolean endsWith(String str): 判断字符串是否以传递进来的字符串结尾
public boolean isEmpty(): 判断字符串的内容是否为空串""。
String类的获取功能
public int length(): 获取字符串的长度。
public char charAt(int index): 获取指定索引位置的字符
public int indexOf(int ch): 返回指定字符在此字符串中第一次出现处的索引。
public int indexOf(String str): 返回指定字符串在此字符串中第一次出现处的索引。
public int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
public int indexOf(String str,int fromIndex): 返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
可以顺带提一下lastIndexOf系列：indexOf系列是从前往后开始，lastIndexOf系列是从后往前开始
public String substring(int start): 从指定位置开始截取字符串,默认到末尾。
public String substring(int start,int end): 从指定位置开始到指定位置结束截取字符串。
String类的转换功能
public byte[] getBytes(): 把字符串转换为字节数组。
public char[] toCharArray(): 把字符串转换为字符数组。
public static String valueOf(char[] chs): 把字符数组转成字符串。
public static String valueOf(int i): 把int类型的数据转成字符串。
注意：String类的valueOf方法可以把任意类型的数据转成字符串。
public String toLowerCase(): 把字符串转成小写。
public String toUpperCase(): 把字符串转成大写。
public String concat(String str): 把字符串拼接。
String类的其他功能
String的替换功能：
public String replace(char old,char new) 将指定字符进行互换
public String replace(String old,String new) 将指定字符串进行互换
String的去除字符串两空格：
public String trim() 去除两端空格
String的按字典顺序比较两个字符串：
public int compareTo(String str) 会对照ASCII 码表 从第一个字母进行减法运算 返回的就是这个减法的结果
如果前面几个字母一样会根据两个字符串的长度进行减法运算返回的就是这个减法的结果
如果连个字符串一摸一样 返回的就是0
public int compareToIgnoreCase(String str) 跟上面一样 只是忽略大小写的比较
在使用Java的FileWriter写文件，需要换行时，假设已经新建FileWriter fw。
//在Windows操作系统中，fw.write("\n"); 是不行的，需要 fr.write("\r\n"); 即回车换行
//在Linux系统中，只要 fw.write("\n"); 即可
//为了程序能在不同操作系统运行，可以写成
w.write(System.getProperty("line.separator"));
import java.util.Random;
public class Test06 {
public static void main(String[] args) {
Random r = new Random();
double d1 = r.nextDouble(); // 生成[0,1.0]区间的小数
double d2 = r.nextDouble() * 7; // 生成[0,7.0]区间的小数
int i1 = r.nextInt(10); // 生成[0,10]区间的整数
int i2 = r.nextInt(18) - 3; // 生成[-3,15)区间的整数
long l1 = r.nextLong(); // 生成一个随机长整型值
boolean b1 = r.nextBoolean(); // 生成一个随机布尔型值
float f1 = r.nextFloat(); // 生成一个随机浮点型值
System.out.println("生成的[0,1.0]区间的小数是：" + d1);
System.out.println("生成的[0,7.0]区间的小数是：" + d2);
System.out.println("生成的[0,10]区间的整数是：" + i1);
System.out.println("生成的[-3,15]区间的整数是：" + i2);
System.out.println("生成一个随机长整型值：" + l1);
System.out.println("生成一个随机布尔型值：" + b1);
System.out.println("生成一个随机浮点型值：" + f1);
System.out.print("下期七星彩开奖号码预测：");
for (int i = 1; i < 8; i++) {
int num = r.nextInt(9); // 生成[0,9]区间的整数
System.out.print(num);
}
}
}
Math 类的 random() 方法没有参数，它默认会返回大于等于 0.0、小于 1.0 的 double 类型随机数，即 0<=随机数<1.0。对 random() 方法返回的数字稍加处理，即可实现产生任意范围随机数的功能。
下面使用 random() 方法实现随机生成一个 2~100 偶数的功能。具体代码如下：
public class Test07 {
public static void main(String[] args) {
int min = 2; // 定义随机数的最小值
int max = 102; // 定义随机数的最大值
// 产生一个2~100的数
int s = (int) min + (int) (Math.random() * (max - min));
if (s % 2 == 0) {
// 如果是偶数就输出
System.out.println("随机数是：" + s);
} else {
// 如果是奇数就加1后输出
System.out.println("随机数是：" + (s + 1));
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
