Java基础语法
Hello World 代码
public class HelloWorld{
public static void main(String[] args){
System.out.println("HelloWorld!");
}
}常量定义(编码规范要求为大写)：
final 数据类型 常量名 = 值;
如 final double PI = 3.14;
常量可以先声明再赋值，且只能赋值一次，而且必须要有赋值。
数据类型：
数据类型 | 默认值 | 存储格式 | 数据范围 | 包装类型 |
short | 0 | 2个字节 | -32,768 到 32,767 | Short |
int | 0 | 4个字节 | -2,147,483,648 到 2,147,483,647 | Integer |
byte | 0 | 1个字节 | -128 到 127 | Byte |
char | 空 | 2个字节 | Unicode 的字符范围：\u0000(即为 0)到 \uffff(即为 65,535) | Character |
long | 0L 或 0l | 8 个字节 | -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 | Long |
float | 0.0F 或 0.0f | 4 个字节 | 32 位 IEEEE-754 单精度范围 | Float |
double | 0.0 或 0.0D(d) | 8 个字节 | 64 位 IEEE-754 双精度范围 | Double |
boolean | false | 1 位 | true 或 false | Boolean |
long 修饰的变量需要在数值后面加上 L 或者 l，比如 long num = 1L;，一般使用大写 L，为了避免小写 l 与数值 1 混淆。
float 类型的数值后面需要加上 F 或者 f，否则会被当成 double 类型处理。double 类型的数值可以加上 D 或 d，也可以不加。
char 类型需要将字符用单引号括起来char a = 'a'，char 可以和整数互相转换，如果字符 a 也可以写成char a = 97。也可以用十六进制表示char a = '\u0061'。
Java 中布尔值不能和整数类型或者其它类型互相转换。
字符串：
字符串是常量，它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。
方法：
// 两种定义方法
String s = "test";
String s = new String("test");
// 可调用的方法
length()
equals()
equalsIgnoreCase() // 忽略大小写比较
== // 比较内存地址
concat() // 或者直接用 + 号
charAt() // 按照索引值获得指定字符使用 + 进行连接，不仅可以连接字符串，也可以连接其他类型。但是要求进行连接时至少有一个参与连接的内容是字符串类型。
其他方法总结如下：
方法 | 返回值 | 功能描述 |
indexOf(char ch) | int | 搜索字符 ch 第一次出现的索引 |
indexOf(String value) | int | 搜索字符串 value 第一次出现的索引 |
lastIndexOf(char ch) | int | 搜索字符 ch 最后一次出现的索引 |
lastIndexOf(String value) | int | 搜索字符串 value 最后一次出现的索引 |
substring(int index) | String | 提取从位置索引开始到结束的字符串 |
substring(int beginindex, int endindex) | String | 提取 beginindex 和 endindex 之间的字符串部分 |
trim() | String | 返回一个前后不含任何空格的调用字符串的副本 |
运算符：
算术运算符：+，-，*，/，%，++，--
前缀自增自减法 (++i,--i): 先进行自增或者自减运算，再进行表达式运算。
后缀自增自减法 (i++,i--): 先进行表达式运算，再进行自增或者自减运算。
位运算符：&, |, ^, ~, <<, >>, >>>(按位右移补0)
位运算时先转换为二进制，再按位运算。
逻辑运算符：&&(或&), ||(或|), !, ^
关系运算符：==, !=, >, <, >=, <=, ?:(三目运算符)
运算符优先级：
输入Scanner:
import java.util.Scanner;
public class Sum {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a = in.nextInt();
int b = in.nextInt();
System.out.println(a + b);
}
}关键字：
方法：
访问修饰符 返回值类型 方法名(参数列表) {
方法体
}访问修饰符：代表方法允许被访问的权限范围， 可以是 public、protected、private 或者省略(default).
实参和形参的区别：
流程控制：if，else，switch, while, do-while, for,
如果 if(或 else if，或 else) 条件成立时的执行语句只有一条，是可以省略大括号的！
int days = 31;
if(days > 30) // 注意没有冒号
System.out.println("本月是大月");
else
System.out.println("本月是小月");StringBuilder:
以删除字符串中的空白符为例
import java.util.Scanner;
public class StringUtil {
public static void main(String[] args) {
Scanner in =new Scanner(System.in);
//获取String值
String a=in.nextLine();
StringBuilder stringBuilder = new StringBuilder(a);
for (int i = 0; i < stringBuilder.length(); i++) {
if (stringBuilder.charAt(i)==' ') {
stringBuilder.deleteCharAt(i);
i--;
}
}
System.out.println(stringBuilder.toString());
}
}跳转语句：break, continue,
数组：
int ages[]; // 声明，或者 int[] ages;
ages = new ages[10]; // 分配空间
int [] ages = {12,18,9,33,45,60}; // 声明并初始化int [] a1 = {1,2,3};
int [] a2;
a2 = a1; // 只是复制了一个引用// for-each语法
for(元素类型 元素变量 : 遍历对象){
执行的代码
}
// 比如：
for(int age:ages){
System.out.println("数组中第"+i+"个元素是"+age);
i++;
}面向对象
Java中一切皆对象。对象包含属性和行为。
具有相同属性和行为的一类实体被称为类。
一个类可以包含以下的类型变量：
局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。类变量：也叫静态变量，类变量也声明在类中，方法体之外，但必须声明为 static 类型。
定义和使用对象：
类名 对象名 = new 类名();
//引用对象属性
对象名.属性
//引用对象方法
对象名.方法定义类的时候不会为类开辟内存空间，但是一旦创建了对象，系统就会在内存中为对象开辟一块空间，用来存放对象的属性值和方法。
每个类都有构造方法，在创建该类的对象的时候他们将被调用，如果没有定义构造方法，Java 编译器会提供一个默认构造方法(默认构造方法是一个无参构造方法)。
构造方法的名称必须与类名相同，一个类可以定义多个构造方法。构造方法的重载：方法名相同，但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法。
创建对象实例时，object只是一个对象引用。
Object object=new Object();静态成员与静态方法：
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。
被 static 修饰的方法是静态方法，静态方法不依赖于对象，不需要将类实例化便可以调用，由于不实例化也可以调用，所以不能有 this，也不能访问非静态成员变量和非静态方法。但是非静态成员变量和非静态方法可以访问静态方法。
final:
final 修饰类，则该类不允许被继承，为最终类
final 修饰方法，则该方法不允许被覆盖(重写)
final 修饰属性：该属性一经初始化便不可改变(基本类型值不可变，对象属性引用不可变)，初始化方式(二选一)：定义处，或者构造函数里
final 修饰变量，则该变量的值只能赋一次值，即常量
权限修饰符：
封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别。
修改属性的可见性，在属性的前面添加修饰符 (private)
对每个值属性提供对外的公共方法访问，如创建 getter/setter(取值和赋值)方法，用于对私有属性的访问
在 getter/setter 方法里加入属性的控制语句，例如我们可以加一个判断语句，对于非法输入给予否定
this 关键字代表当前对象。使用 this.属性 操作当前对象的属性，this.方法 调用当前对象的方法。
继承：is-a关系
class 子类 extends 父类子类会拥有父类除了private之外的所有方法和属性。
子类拥有父类除 private 以外的所有属性和方法。
子类可以拥有自己的属性和方法。
子类可以重写实现父类的方法。
Java 中的继承是单继承，一个类只有一个父类。
Java 实现多继承的一个办法是 implements(实现)接口，但接口不能有非静态的属性，这一点请注意。
super可以调用父类的属性和方法。
子类构造方法需要调用父类的构造方法时，在子类的构造方法体里最前面的位置：super()。
方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。
方法中的参数列表必须不同。比如：参数个数不同或者参数类型不同。
重载的方法中允许抛出不同的异常
可以有不同的返回值类型，但是参数列表必须不同。
可以有不同的访问修饰符。
方法重写一定要与原父类的方法语法保持一致，比如返回值类型，参数类型及个数，和方法名都必须一致。
多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
多态也称作动态绑定(dynamic binding)，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
实现多态的三个条件：继承、重写和向上转型(即父类引用指向子类对象)。
Java中多态的实现方式：继承父类进行方法重写，抽象类和抽象方法，接口实现。
Animal b = new Dog(); //b是父类的引用指向的是子类的对象由于 Dog 继承于 Animal，所以 Dog 可以自动向上转型为 Animal，所以 b 是可以指向 Dog 实例对象的。
不能使用一个子类的引用去指向父类的对象，因为子类对象中可能会含有父类对象中所没有的属性和方法。
如果定义了一个指向子类对象的父类引用类型，那么它除了能够引用父类中定义的所有属性和方法外，还可以使用子类强大的功能。但是对于只存在于子类的方法和属性就不能获取。
class Animal {
//父类方法
public void bark() {
System.out.println("动物叫！");
}
}
class Dog extends Animal {
//子类重写父类的bark方法
public void bark() {
System.out.println("汪、汪、汪！");
}
//子类自己的方法
public void dogType() {
System.out.println("这是什么品种的狗？");
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Animal();
Animal b = new Dog();
Dog d = new Dog();
a.bark();
b.bark();
//b.dogType();
//b.dogType()编译不通过
d.bark();
d.dogType();
}
}因此，向上转型，在运行时，会遗忘子类对象中与父类对象中不同的方法，也会覆盖与父类中相同的方法——重写(方法名，参数都相同)。
抽象类：
用 abstract 修饰符定义抽象类。
用 abstract 修饰符定义抽象方法，只用声明，不需要实现。
包含抽象方法的类就是抽象类。
抽象类中可以包含普通的方法，也可以没有抽象方法。
抽象类的对象不能直接创建，通常是定义引用变量指向子类对象。
抽象类是限制规定子类必须实现某些方法，但不关注实现细节。抽象类作为子类的模板，从而避免了子类设计的随意性。
子类实现方法前要加 @Override。
接口：
接口不能用于实例化对象。
接口中方法只能是抽象方法、default 方法、静态方法。
接口成员是 static final 类型。
接口支持多继承。
// Animal.java
interface Animal {
//int x;
//编译错误,x需要初始化，因为是 static final 类型
int y = 5;
public void eat();
public void travel();
}接口可以拥有私有方法和私有静态方法，但是只能被该接口中的 default 方法和静态方法使用。
修饰符 interface A extends 接口1，接口2{
}
修饰符 class A implements 接口1，接口2{
}内部类：
将一个类的定义放在另一个类的定义内部，这就是内部类。而包含内部类的类被称为外部类。
内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类。
内部类的方法可以直接访问外部类的所有数据，包括私有的数据(反之不行)。
内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便。
内部类允许继承多个非接口类型。
创建内部类对象： 内部类 对象名 = 外部类对象.new 内部类();
注：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。
对于一个名为 outer 的外部类和其内部定义的名为 inner 的内部类。编译完成后出现 outer.class 和 outer$inner.class 两类。
所以内部类的成员变量 / 方法名可以和外部类的相同。
// People.java
//外部类People
public class People {
private String name = "LiLei"; //外部类的私有属性
//内部类Student
public class Student {
String ID = "20151234"; //内部类的成员属性
//内部类的方法
public void stuInfo(){
System.out.println("访问外部类中的name：" + name);
System.out.println("访问内部类中的ID：" + ID);
}
}
//测试成员内部类
public static void main(String[] args) {
People a = new People(); //创建外部类对象，对象名为a
Student b = a.new Student(); //使用外部类对象创建内部类对象，对象名为b
// 或者为 People.Student b = a.new Student();
b.stuInfo(); //调用内部对象的suInfo方法
}
}Student 类相当于 People 类的一个成员变量，所以 Student 类可以使用任意访问修饰符。
如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如上述代码中：a.this。
成员内部类不能含有 static 的变量和方法，因为成员内部类需要先创建了外部类，才能创建它自己的。
静态内部类：
静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问。new People().name。
如果外部类的静态成员与内部类的成员名称相同，可通过 类名.静态成员 访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过 成员名 直接调用外部类的静态成员。
创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名 = new 内部类();。
// People.java
//外部类People
public class People {
private String name = "LiLei"; //外部类的私有属性
/*外部类的静态变量。
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。
*/
static String ID = "510xxx199X0724XXXX";
//静态内部类Student
public static class Student {
String ID = "20151234"; //内部类的成员属性
//内部类的方法
public void stuInfo(){
System.out.println("访问外部类中的name：" + (new People().name));
System.out.println("访问外部类中的ID：" + People.ID);
System.out.println("访问内部类中的ID：" + ID);
}
}
//测试成员内部类
public static void main(String[] args) {
Student b = new Student(); //直接创建内部类对象，对象名为b
b.stuInfo(); //调用内部对象的suInfo方法
}
}局部内部类，是指内部类定义在方法和作用域内。
局部内部类也像别的类一样进行编译，但只是作用域不同而已，只在该方法或条件的作用域内才能使用，退出这些作用域后无法引用的。
// People.java
//外部类People
public class People {
//定义在外部类中的方法内：
public void peopleInfo() {
final String sex = "man"; //外部类方法中的常量
class Student {
String ID = "20151234"; //内部类中的常量
public void print() {
System.out.println("访问外部类的方法中的常量sex：" + sex);
System.out.println("访问内部类中的变量ID:" + ID);
}
}
Student a = new Student(); //创建方法内部类的对象
a.print();//调用内部类的方法
}
//定义在外部类中的作用域内
public void peopleInfo2(boolean b) {
if(b){
final String sex = "man"; //外部类方法中的常量
class Student {
String ID = "20151234"; //内部类中的常量
public void print() {
System.out.println("访问外部类的方法中的常量sex：" + sex);
System.out.println("访问内部类中的变量ID:" + ID);
}
}
Student a = new Student(); //创建方法内部类的对象
a.print();//调用内部类的方法
}
}
//测试方法内部类
public static void main(String[] args) {
People b = new People(); //创建外部类的对象
System.out.println("定义在方法内：===========");
b.peopleInfo(); //调用外部类的方法
System.out.println("定义在作用域内：===========");
b.peopleInfo2(true);
}
}匿名内部类：
匿名内部类，顾名思义，就是没有名字的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。
但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。
// Outer.java
public class Outer {
public Inner getInner(final String name, String city) {
return new Inner() {
private String nameStr = name;
public String getName() {
return nameStr;
}
};
}
public static void main(String[] args) {
Outer outer = new Outer();
Inner inner = outer.getInner("Inner", "NewYork");
System.out.println(inner.getName());
}
}
interface Inner {
String getName();
}匿名内部类是不能加访问修饰符的。要注意的是，new 匿名类，这个类是要先定义的, 如果不先定义，编译时会报错该类找不到。
同时，在上面的例子中，当所在的方法的形参需要在内部类里面使用时，该形参必须为 final。这里可以看到形参 name 已经定义为 final 了，而形参 city 没有被使用则不用定义为 final。
然而，因为匿名内部类没名字，是用默认的构造方法的，无参数的，如果需要该类有带参数的构造方法，示例如下：
public Inner getInner(final String name, String city) {
return new Inner(name, city) {
private String nameStr = name;
public String getName() {
return nameStr;
}
};
}注意这里的形参 city，由于它没有被匿名内部类直接使用，而是被抽象类 Inner 的构造方法所使用，所以不必定义为 final。
package命名空间：
把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
包采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。
包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
包的命名规范是全小写字母拼写。
Java常用类
Arrays：
import java.util.Arrays;
方法 | 描述 |
List asList(T... a) | 返回由指定数组构造的 List |
void sort(Object[] a) | 对数组进行排序 |
void fill(Object[] a, Object val) | 为数组的所有元素都赋上相同的值 |
boolean equals(Object[] a, Object[] a2) | 检查两个数组是否相等 |
int binarySearch(Object[] a, Object key) | 对排序后的数组使用二分法查找数据 |
import java.util.Arrays;
import java.util.Random;
public class ArraysDemo {
public static void main(String[] args) {
int[] arr = new int[10];
//将数组元素都设为9
Arrays.fill(arr, 9);
System.out.println("fill:" + Arrays.toString(arr));
Random random = new Random();
for (int i = 0; i < arr.length; i++) {
//使用100以内的随机数赋值数组
arr[i] = random.nextInt(101);
}
//重新赋值后的数组
System.out.println("重新赋值：" + Arrays.toString(arr));
//将索引为5的元素设为50
arr[5] = 50;
//排序
Arrays.sort(arr);
//排序后的数组
System.out.println("sort排序后：" + Arrays.toString(arr));
//查找50的位置
int i = Arrays.binarySearch(arr, 50);
System.out.println("值为50的元素索引："+i);
//复制一份新数组
int[] newArr = Arrays.copyOf(arr, arr.length);
//比较
System.out.println("equals:"+Arrays.equals(arr, newArr));
}
}StringBuilder:
StringBuilder 类是可变的。
构造方法 | 说明 |
StringBuilder() | 构造一个其中不带字符的 StringBuilder，其初始容量为 16 个字符 |
StringBuilder(CharSequence seq) | 构造一个 StringBuilder，它包含与指定的 CharSequence 相同的字符 |
StringBuilder(int capacity) | 构造一个具有指定初始容量的 StringBuilder |
StringBuilder(String str) | 并将其内容初始化为指定的字符串内容 |
方法 | 返回值 | 功能描述 |
insert(int offsetm,Object obj) | StringBuilder | 在 offsetm 的位置插入字符串 obj |
append(Object obj) | StringBuilder | 在字符串末尾追加字符串 obj |
length() | int | 确定 StringBuilder 对象的长度 |
setCharAt(int index,char ch) | void | 使用 ch 指定的新值设置 index 指定的位置上的字符 |
toString() | String | 转换为字符串形式 |
reverse() | StringBuilder | 反转字符串 |
delete(int start, int end) | StringBuilder | 删除调用对象中从 start 位置开始直到 end 指定的索引(end-1)位置的字符序列 |
replace(int start, int end, String str) | StringBuilder | 使用一组字符替换另一组字符。将用替换字符串从 start 指定的位置开始替换，直到 end 指定的位置结束 |
Calendar:
Date 类附有两大功能：
允许用年、月、日、时、分、秒来解释日期。
允许对表示日期的字符串进行格式化和句法分析。
类 Calendar 来完成第一种功能，类 DateFormat 来完成第二项功能。
DateFormat 是 java.text 包中的一个类。与 Date 类有所不同的是，DateFormat 类可以接受用各种语言和不同习惯表示的日期字符串。
Calendar 类是一个抽象类，我们更多的是使用 Calendar 类的子类 GregorianCalendar 类。
构造方法 | 说明 |
GregorianCalendar() | 创建的对象中的相关值被设置成指定时区，缺省地点的当前时间，即程序运行时所处的时区、地点的当前时间 |
GregorianCalendar(TimeZone zone) | 创建的对象中的相关值被设置成指定时区 zone，缺省地点的当前时间 |
GregorianCalendar(Locale aLocale) | 创建的对象中的相关值被设置成缺省时区，指定地点 aLocale 的当前时间 |
GregorianCalendar(TimeZone zone,Locale aLocale) | 创建的对象中的相关值被设置成指定时区，指定地点的当前时间 |
TimeZone 是 java.util 包中的一个类，其中封装了有关时区的信息。每一个时区对应一组 ID。类 TimeZone 提供了一些方法完成时区与对应 ID 两者之间的转换。
//太平洋时区的 ID 为 PST
TimeZone tz0 = TimeZone.getTimeZone("PST")
//getDefault()可以获取主机所处时区的对象
TimeZone tz1 = TimeZone.getDefault()Locale 只是一种机制，它用来标识一个特定的地理、政治或文化区域获取一个 Locale 对象的构造方法：
//调用Locale类的构造方法
Locale l0 = new Locale(String language)
Locale l1 = new Locale(String language, String country)
Locale l2 = new Locale(String languge, String country, String variant)
//调用Locale类中定义的常量
Locale l1 = Locale.CHINA示例：
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class CalendarDemo {
public static void main(String[] args) {
System.out.println("完整显示日期时间：");
// 字符串转换日期格式
DateFormat fdate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = fdate.format(new Date());
System.out.println(str);
// 创建 Calendar 对象
Calendar calendar = Calendar.getInstance();
// 初始化 Calendar 对象，但并不必要，除非需要重置时间
calendar.setTime(new Date());
// 显示年份
System.out.println("年： " + calendar.get(Calendar.YEAR));
// 显示月份 (从0开始, 实际显示要加一)
System.out.println("月： " + calendar.get(Calendar.MONTH));
// 当前分钟数
System.out.println("分钟： " + calendar.get(Calendar.MINUTE));
// 今年的第 N 天
System.out.println("今年的第 " + calendar.get(Calendar.DAY_OF_YEAR) + "天");
// 本月第 N 天
System.out.println("本月的第 " + calendar.get(Calendar.DAY_OF_MONTH) + "天");
// 3小时以后
calendar.add(Calendar.HOUR_OF_DAY, 3);
System.out.println("三小时以后的时间： " + calendar.getTime());
// 格式化显示
str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime());
System.out.println(str);
// 重置 Calendar 显示当前时间
calendar.setTime(new Date());
str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime());
System.out.println(str);
// 创建一个 Calendar 用于比较时间
Calendar calendarNew = Calendar.getInstance();
// 设定为 5 小时以前，后者大，显示 -1
calendarNew.add(Calendar.HOUR, -5);
System.out.println("时间比较：" + calendarNew.compareTo(calendar));
// 设定7小时以后，前者大，显示 1
calendarNew.add(Calendar.HOUR, +7);
System.out.println("时间比较：" + calendarNew.compareTo(calendar));
// 退回 2 小时，时间相同，显示0
calendarNew.add(Calendar.HOUR, -2);
System.out.println("时间比较：" + calendarNew.compareTo(calendar));
// calendarNew创建时间点
System.out.println((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendarNew.getTime()));
// calendar创建时间点
System.out.println((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime()));
System.out.println("时间比较：" + calendarNew.compareTo(calendar));
}
}Date:
Date 类经常用来获取系统当前时间。
构造方法 | 说明 |
Date() | 构造一个 Date 对象并对其进行初始化以反映当前时间 |
Date(long date) | 构造一个 Date 对象，并根据相对于 GMT 1970 年 1 月 1 日 00:00:00 的毫秒数对其进行初始化 |
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateDemo {
public static void main(String[] args) {
String strDate, strTime;
Date objDate = new Date();
System.out.println("今天的日期是：" + objDate);
long time = objDate.getTime();
System.out.println("自1970年1月1日起以毫秒为单位的时间(GMT)：" + time);
strDate = objDate.toString();
//提取 GMT 时间
strTime = strDate.substring(11, (strDate.length() - 4));
//按小时、分钟和秒提取时间
strTime = "时间：" + strTime.substring(0, 8);
System.out.println(strTime);
//格式化时间
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(formatter.format(objDate));
}
}Math:
Math 类在 java.lang 包中，常用方法如下：
方法 | 返回值 | 功能描述 |
sin(double numvalue) | double | 计算角 numvalue 的正弦值 |
cos(double numvalue) | double | 计算角 numvalue 的余弦值 |
acos(double numvalue) | double | 计算 numvalue 的反余弦 |
asin(double numvalue) | double | 计算 numvalue 的反正弦 |
atan(double numvalue) | double | 计算 numvalue 的反正切 |
pow(double a, double b) | double | 计算 a 的 b 次方 |
sqrt(double numvalue) | double | 计算给定值的正平方根 |
abs(int numvalue) | int | 计算 int 类型值 numvalue 的绝对值，也接收 long、float 和 double 类型的参数 |
ceil(double numvalue) | double | 返回大于等于 numvalue 的最小整数值 |
floor(double numvalue) | double | 返回小于等于 numvalue 的最大整数值 |
max(int a, int b) | int | 返回 int 型 a 和 b 中的较大值，也接收 long、float 和 double 类型的参数 |
min(int a, int b) | int | 返回 a 和 b 中的较小值，也可接受 long、float 和 double 类型的参数 |
rint(double numvalue) | double | 返回最接近 numvalue 的整数值 |
round(T arg) | arg 为 double 时返回 long，为 float 时返回 int | 返回最接近 arg 的整数值 |
random() | double | 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0 |
