本文详细介绍了Java核心API，涵盖常用数据类型和工具类。重点讲解了String、StringBuffer等类的特点、方法，如String的不可变性、字符串拼接方式，以及StringBuffer的增删改操作。还介绍了日期、数字、字符处理相关类，如Date、Math、Character类等。
Java核心Api
常用数据类型
| String |
|---|
| StringBuffer和StringBuilder类 |
| Integer |
| Object |
工具类
| System |
|---|
| Arrays |
| Collections |
| Math |
String类
java.lang.String 类是 Java 中用于表示字符串的类。在 Java 中，字符串是一组字符的序列，String底层是一个char[] 数组，而 String 类提供了一系列方法来操作字符串。以下是 String 类的一些重要特点和方法：
1. 不可变性：
String 对象一旦创建，它的值就不能被修改，即它是不可变的。任何对字符串的操作都会创建一个新的字符串对象。
- 字符串池：
Java 中的字符串池是一种存储字符串的内存区域，可以通过使用字符串字面量（例如 "hello"）或调用 String 类的 intern() 方法将字符串添加到池中。字符串池的存在有助于节省内存，提高字符串的重用性。
- 构造方法：
String 类有多个构造方法，其中最常用的是：
String()：创建一个空字符串。String(String original)：通过复制给定的字符串创建一个新的字符串。String(char[] value)：通过字符数组创建一个新的字符串。String(StringBuffer buffer)：通过StringBuffer对象创建一个新的字符串。
- 常用方法：
String 类提供了许多方法来执行字符串操作，包括：
length()：返回字符串的长度。charAt(int index)：返回指定索引处的字符。concat(String str)：将指定字符串连接到此字符串的末尾。equals(Object obj)：比较字符串是否相等。substring(int beginIndex)：返回一个新的字符串，从指定索引开始到字符串的末尾。substring(int beginIndex, int endIndex)：返回一个新的字符串，包含从指定开始索引到结束索引之间的字符。indexOf(String str)：返回指定子字符串在字符串中第一次出现的位置。toUpperCase()：将字符串转换为大写。toLowerCase()：将字符串转换为小写。- 等等。
- 不同于
StringBuilder和StringBuffer：
与 StringBuilder 和 StringBuffer 不同，String 是不可变的。StringBuilder 和 StringBuffer 是可变的字符串序列，它们允许在现有对象的基础上进行修改，而不是创建新的对象。
使用 String 类时要注意不可变性的特性，因为频繁的字符串拼接可能导致创建大量临时对象，影响性能。在这种情况下，可以考虑使用 StringBuilder 或 StringBuffer 来提高效率。
比较相关
| 返回值类型 | 方法名 | 描述 |
|---|---|---|
| boolean | contentEquals() | 将此字符串与指定的 StringBuffer 比较。 |
| boolean | endsWith(String suffix) | 测试此字符串是否以指定的后缀结束。 |
| boolean | startsWith(String prefix) | 测试此字符串是否以指定的前缀开始。 |
| int | compareTo(Object o) | 字符串与对象进行比较。 |
| int | compareToIgnoreCase(String str) | 按字典顺序比较两个字符串，不考虑大小写 |
| boolean | equals(Object anObject) | 将此字符串与指定的对象比较。 |
| boolean | equalslgnoreCase(Object anObject) | 与另一个 String 比较，不考虑大小写 |
转换相关
| 返回值类型 | 方法名 | 描述 |
|---|---|---|
| byte[] | getBytes（） | String 编码为 byte 序列 |
| String[] | split(String regex) | 根据给定正则表达式的匹配拆分此字符串 |
| String | copyValueOf(char[] data) | 返回指定数组中表示该字符序列的字符串 |
| char[] | toCharArray() | 将此字符串转换为一个新的字符数组。 |
查找相关
| 返回值类型 | 方法名 | 描述 |
|---|---|---|
| char | charAt(int index) | 返回指定索引处的字符 |
| int | hashCode | 返回此字符串的hash值 |
| int | indexOf(String str) | 返回指定子字符串在此字符串中第一次出现处的索引。 |
| int | lastIndexOf(String str) | 返回指定字符在此字符串中最后一次出现处的索引 |
其他类型
| 返回值类型 | 方法名 | 描述 |
|---|---|---|
| int | length() | 返回此字符串的长度 |
| boolean | matc(String regex) | 字符串是否匹配给定的正则表达式 |
| String | valueOf | 给定data type类型x参数的字符串表示形式 |
Java字符串拼接
int和String拼接成String
用+拼接
public class Demo6test {
public static void main(String[] args) {
int a = 10;
String str = "abc";
System.out.println(a+str);
}
}
结果：
10abc
将int转化为string，用+或者string的concat方法拼接
public class Demo6test {
public static void main(String[] args) {
int a = 10;
String str = "abc";
System.out.println(str + String.valueOf(a));
System.out.println(str.concat(String.valueOf(a)));
}
}
结果：
abc10
abc10
String和String拼接成String
concat方法
当两个变量都为String类型且值不为null时，可以用concat方式。
String str1 = "abc";
String str2 = "def";
String result = str1.concat(str2);
append方法
当需要拼接至少三个量的时候，可以考虑使用StringBuffer.append()以避免临时字符串的产生
StringBuffer buffer = new StringBuffer();
buffer.append("a");
buffer.append("b");
buffer.append("c");
System.out.println(buffer.toString());
当a,b,c拼接起来会很长时，可以给在构造器中传入一个合适的预估容量以减少因扩展缓冲空间而带来的性能开销。
StringBuffer buffer=new StringBuffer(a.length()+b.length()+c.length());
使用+拼接
当拼接量为三个及以上，只用一个连续拼接的语句就可完成时，从使代码简洁角度考虑，用+方式。
String a="a";
String b="b";
String c="c";
String result=a+b+c;
字符串广泛应用 在 Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。
创建字符串
创建字符串最简单的方式如下:
String str = "Runoob";
用构造函数创建字符串：
String str2=new String("Runoob");
创建格式化字符串
我们知道输出格式化数字可以使用 printf() 和 format() 方法。
String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象。
String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。
如下所示：
System.out.printf("浮点型变量的值为 " +
"%f, 整型变量的值为 " +
" %d, 字符串变量的值为 " +
"is %s", floatVar, intVar, stringVar);
String fs;
fs = String.format("浮点型变量的值为 " +
"%f, 整型变量的值为 " +
" %d, 字符串变量的值为 " +
" %s", floatVar, intVar, stringVar);
String s = new String(“hello”) 和 String s = “hello”; 的区别?
avaCopy codeString s1 = new String("hello");
String s2 = "hello";
这两行代码创建了两个字符串对象，但它们之间有一些重要的区别：
- 内存分配方式：
new String("hello")显式地使用new关键字创建了一个新的字符串对象。这种方式会在堆内存中为字符串分配新的内存空间，即使字符串常量池中已经存在 “hello”。"hello"是字符串字面量，会被存储在字符串常量池中。如果字符串常量池中已经存在相同的字符串，那么不会创建新的对象，而是返回已存在的对象的引用。
- 对象的比较：
s1通过new String("hello")创建的字符串对象，即使内容与字符串常量池中的 “hello” 相同，但它是一个新的对象，与字符串常量池中的对象不相等（使用==比较时为false）。s2直接赋值为字符串字面量 “hello”，这个字符串字面量在字符串常量池中已存在，因此s2实际上是指向字符串常量池中的对象，与常量池中的对象相等（使用==比较时为true）。
javaCopy codeSystem.out.println(s1 == s2); // false
System.out.println(s1.equals(s2)); // true
总的来说，使用 new String("hello") 明确创建了一个新的字符串对象，而直接使用字符串字面量 “hello” 则可以利用字符串常量池的优化，减少对象的创建。在一般情况下，推荐使用字符串字面量的方式，因为它更加高效。
package com.test.demo12;
public class Demo04String {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "world";
String s3 = "helloworld";
System.out.println(s3 == s1 + s2); // false
System.out.println(s3.equals(s1 + s2)); // true
String s4 = new String("hello"); // 堆
String s5 = "hello"; //常量
s5 += s4;
System.out.println(s5); // s5的位置？
String s6 = "hello" + "world";
System.out.println(s3 == s6); // true 为什么？
String s7 = "helloworld";
System.out.println(s3 == s7); // true
/*
常量相加： String s6 = "hello" + "world"; => 保存在常量池中
执行过程：
1. 会将 hello world 分别存在放常量区
2. 将其相加的结果也会放在常量区中 helloworld
3. 在常量区中对于多个相同的helloworld会指向同一个内存地址
变量相加： 对于 s3 == s1 + s2
执行过程：
对于常量池中的s1 和 s2 变量进行相加，会在堆空间中创建一个String类型的对象空间，并将
s1和s2的值进行拼接，放入对象的堆空间中
总结：
两个字符串变量相加 和 两个字符串常量相加 结果的存储位置不一样
*/
}
}
我爱学 => -26, -120, -111, -25, -120, -79, -27, -83, -90,
// JAVA => 74, 65, 86, 65
String str2 = "我爱学JAVA";
byte[] bytes1 = str2.getBytes("UTF-8");
System.out.println(bytes1);
System.out.println(Arrays.toString(bytes1)); // 对于中文，在UTF-8编码下，一个中文字符占用3个字节
System.out.println(bytes1.length);
char[] charArray1 = str2.toCharArray();
System.out.println(Arrays.toString(charArray1)); // 对于一个中文表示一个 字符，结果为[我, 爱, 学, J, A, V, A]
String方法
StringBuffer类
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。
public class RunoobTest{
public static void main(String args[]){
StringBuilder sb = new StringBuilder(10);
sb.append("Runoob..");
System.out.println(sb);
sb.append("!");
System.out.println(sb);
sb.insert(8, "Java");
System.out.println(sb);
sb.delete(5,8);
System.out.println(sb);
}
}
结果：
Runoob..
Runoob..!
Runoob..Java!
RunooJava!
增删改
| 返回值 | 内容 | 描述 |
|---|---|---|
| StringBuffer | append(Object obj) | 追加 Object参数的字符串表示。 |
| StringBuffer | insert(int offset, Object obj) | 将 Object参数的字符串表示插入到此字符序列中 |
| StringBuffer | delete(int start, int end) | 删除此序列的子字符串中的字符。 |
| StringBuffer | deleteCharAt(int index) | 删除 char在这个序列中的指定位置。 |
| void | setCharAt(int index, char ch) | 指定索引处的字符设置为 ch 。 |
| StringBuffer | replace(int start, int end, String str) | 用指定的String中的字符替换此序列的子字符串中的 String 。 |
查询相关
| 返回值 | 内容 | 描述 |
|---|---|---|
| char | charAt(int index) | 返回 char在指定索引在这个序列值。 |
| int | indexOf(String str) | 返回指定子字符串第一次出现的字符串内的索引。 |
| int | lastIndexOf(String str) | 返回指定子字符串最右边出现的字符串内的索引 |
| int | capacity() | 返回当前容量。 |
| int | length() | 返回长度（字符数）。 |
其他
| 返回值 | 内容 | 描述 |
|---|---|---|
| void | setLength(int newLength) | 设置字符序列的长度。 |
| String | substring(int start) | 返回一个新的 String ，其中包含此字符序列中当前包含的字符的子序列。 |
| String | toString() | 返回表示此顺序中的数据的字符串。 |
| StringBuffer | reverse() | 导致该字符序列被序列的相反代替。 |
StringBuffer方法
| 序号 | 方法描述 |
|---|---|
| 1 | public StringBuffer append(String s) 将指定的字符串追加到此字符序列。 |
| 2 | public StringBuffer reverse() 将此字符序列用其反转形式取代。 |
| 3 | public delete(int start, int end) 移除此序列的子字符串中的字符。 |
| 4 | public insert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中。 |
| 5 | insert(int offset, String str) 将 str 参数的字符串插入此序列中。 |
| 6 | replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。 |
| 序号 | 方法描述 |
|---|---|
| 1 | int capacity() 返回当前容量。 |
| 2 | char charAt(int index) 返回此序列中指定索引处的 char 值。 |
| 3 | void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。 |
| 4 | void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 dst。 |
| 5 | int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。 |
| 6 | int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。 |
| 7 | int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。 |
| 8 | int lastIndexOf(String str, int fromIndex) 返回 String 对象中子字符串最后出现的位置。 |
| 9 | int length() 返回长度（字符数）。 |
| 10 | void setCharAt(int index, char ch) 将给定索引处的字符设置为 ch。 |
| 11 | void setLength(int newLength) 设置字符序列的长度。 |
| 12 | CharSequence subSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。 |
| 13 | String substring(int start) 返回一个新的 String，它包含此字符序列当前所包含的字符子序列。 |
| 14 | String substring(int start, int end) 返回一个新的 String，它包含此序列当前所包含的字符子序列。 |
| 15 | String toString() 返回此序列中数据的字符串表示形式。 |
字符串转化数字
package com.isea.java;
public class Test {
public static void main(String[] args) {
String str = "123";
Integer num1 = new Integer(str);
int num2 = Integer.parseInt(str);
Integer num3 = Integer.valueOf(str);
System.out.println(num1 + "\t" + num2 + "\t" + num3);//123 123 123
}
}
Interger类
比较相关
| 返回值 | 内容 | 描述 |
|---|---|---|
| static int | compare(int x, int y) | 比较两个 int数字值。 |
| int | compareTo(Integer anotherInteger) | 数字比较两个 Integer对象。 |
| static int | compareUnsigned(int x, int y) | 比较两个 int值，以数值方式将值视为无符号。 |
| boolean | equals(Object obj) | 将此对象与指定的对象进行比较。 |
| static String | toString() | 返回一个 String指定整数的 String对象。 |
转化相关
Integer转其他类型
| 返回值 | 内容 | 描述 |
|---|---|---|
| byte | byteValue() | 返回此值 Integer为 byte的基本收缩转换后 |
| double | doubleValue() | 返回此值 Integer为 double一个宽元转换后。 |
| float | floatValue() | 返回此值 Integer为 float一个宽元转换后。 |
| int | intValue() | 将 Integer的值作为 int 。 |
| long | longValue() | 返回此值 Integer为 long一个宽元转换后。 |
| short | shortValue() | 返回此值 Integer为 short一个宽元转换后。 |
其他类型转Integer
| 返回值 | 内容 | 描述 |
|---|---|---|
| static int | parseInt(String s) | |
| static Integer | valueOf(String s) | 返回一个 Integer对象，保存指定的值为 String 。 |
| static Integer | valueOf(整形浮点型 i) | 返回一个 Integer指定的 整形浮点型值的 Integer实例。 |
其他
| 返回值 | 内容 | 描述 |
|---|---|---|
| static int | sum(int a, int b) | 根据+运算符将两个整数相加。 |
| int | max(int a, int b) | 返回两个 int的较大值，就像调用 |
| int | min(int a, int b) | 返回两个 int的较小值，就像调用 |
| static int | reverse(int i) | 返回由指定的二进制补码表示反转位的顺序而获得的值 int值。 |
| static int | reverseBytes(int i) | 返回反转指定的二进制补码表示的字节顺序而获得的值 int值。 |
Object类和Scanner类
Object
| protected Object | clone() 创建并返回此对象的副本。 |
|---|---|
| boolean | equals(Object obj) 指示一些其他对象是否等于（比较的是地址）。 |
| protected void | finalize() 当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。 |
| 类<?> | getClass() 返回此 Object的运行时类。 |
| int | hashCode() 返回对象的哈希码值。 |
| void | notify() 唤醒正在等待对象监视器的单个线程。 |
| void | notifyAll() 唤醒正在等待对象监视器的所有线程。 |
| String | toString() 返回对象的字符串表示形式。 |
| void | wait() 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。 |
| void | wait(long timeout) 导致当前线程等待，直到另一个线程调用 notify()方法或该对象的 notifyAll()方法，或者指定的时间已过。 |
| void | wait(long timeout, int nanos) 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法，或者某些其他线程中断当前线程，或一定量的实时时间。 |
Java输入输出
Java Scanner类
Scanner s = new Scanner(System.in); //获取输入
String str1 = scan.next(); //接收输入
next() 与 nextLine() 区别
next():
- 1、一定要读取到有效字符后才可以结束输入。
- 2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
- 3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
- next() 不能得到带有空格的字符串。
nextLine()：
- 1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
- 2、可以获得空白。
实例：
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Scanner scanner1 = new Scanner(System.in);
int b = scanner1.nextInt();
int a = scanner.nextInt();
System.out.println(a);
int x = 0;
int y = 0;
System.out.printf("x:%d\n",x);
Scanner scanner2 = new Scanner(System.in);
String c = scanner2.nextLine();
System.out.println(c);
}
输出
System.out.println("Hello Java"); // 输出后换行
System.out.print("Hello Java\n"); // 与println效果相同
System.out.print("Hello Java"); // 输出不换行
System.out.printf("%d",10); // 格式化的输出，输出方式与C语言基本相同
| 转换符 | 类型 | 使用方法 | 输出结果 |
|---|---|---|---|
| d | 十进制整数 | (“%d”,10) | 10 |
| x | 十六进制整数 | (“%x”,10) | A |
| o | 八进制整数 | (“%o”,10) | 12 |
| f | 定点浮点数 | (“%f”,100f) | 100.000000 |
| e | 指数浮点数 | (“%e”,100f) | 1.000000e+02 |
| g | 通用浮点数 | (“%g”,100f) | 100.000 |
| a | 十六进制浮点数 | (“%a”,100) | 0x1.9p6 |
| s | 字符串 | (“%s”,10) | 10 |
| c | 字符 | (“%c”,‘1’) | 1 |
| b | 布尔值 | (“%b”,10) | true |
| h | 散列码 | (“%h”,10) | a |
| % | 百分号 | (“%.2f%%”,2/7f) | 10 |
System类
修改流相关
| 返回值类型 | 内容 | 描述 |
|---|---|---|
| static void | setIn(InputStream in) | 重新分配“标准”输入流。 |
| static void | setOut(PrintStream out) | 重新分配“标准”输出流。 |
| static void | setErr(PrintStream err) | 重新分配“标准”错误输出流。 |
修改配置相关
| 返回值类型 | 内容 | 描述 |
|---|---|---|
| static void | setProperties(Properties props) | 将系统属性设置为 Properties参数。 |
| static String | setProperty(String key, String value) | 设置由指定键指示的系统属性。 |
| static String | getProperty(String key) | 获取指定键指示的系统属性。 |
| static String | getProperty(String key, String def) | 获取指定键指示的系统属性。 |
| static String | clearProperty(String key) | 删除指定键指定的系统属性。 |
其他
| 返回值类型 | 内容 | 描述 |
|---|---|---|
| static void | arraycopy(Object src, int srcPos, Object dest, int destPos, int length) | 将指定源数组中的数组从指定位置复制到目标数组的指定位置。 |
| static void | gc() | 运行垃圾回收器。 |
| static void | exit(int status) | 终止当前运行的Java虚拟机。 |
| String | ineSeparator() | 获得当前操作系统的行分隔符 |
| static long | nanoTime() | 返回当前时间（以纳秒为单位）。 |
| static long | currentTimeMillis() | 返回当前时间（以毫秒为单位）。 |
Arrays类
| 返回值类型 | 方法 | 说明 |
|---|---|---|
| String | toString（array） | 将数组array转换成字符串 |
| void | sort（array） | 对数组进行升序排列 |
| void | fill（array，value） | 将数组arr全部元素赋值为val |
| boolean | equals（array1，array2） | 判断两个数组是否相等 |
| T[] | copyOf（array，length） | 将数组arr复制成一个长度为length的新数组 |
| int | binarySearch(array, val) | 查询元素val在arr中的下标值 |
| list | asList(array) | 数组转换为list集合 |
| T[] | copyOfRange(arry,length) | 指定数组的指定范围复制到新数组中 |
| int | hashCode(array) | 获得数组的哈希值 |
Collection
排序相关
| 返回值类型 | 方法 | 描述 |
|---|---|---|
| void | sort | 对集合进行升序排列 |
| void | reverse | 反转集合 |
| void | shuffle | 随机排列集合 |
| Comparator | reverseOrder | 返回一个逆序比较器 |
增删改
| 返回值类型 | 方法 | 说明 |
|---|---|---|
| void | fill | 用给定元素填充集合 |
| int | swap | 交换集合中的两个元素 |
| boolean | replaceAll | 将列表中一个指定值的所有出现替换为另一个 |
| boolean | addAll | 将所有指定的元素添加到指定的集合 |
查找
| 返回值 | 方法 | 说明 |
|---|---|---|
| Object | binarySearch | 使用二叉搜索算法搜索集合中的指定元素 |
| Object | min | 根据其元素的自然顺序返回给定集合的最小元素 |
| Object | max | 根据其元素的自然顺序返回给定集合的最大元素 |
| int | frequency | 返回指定集合中与指定对象相等的元素数 |
| boolean | disjoint | 如果两个指定的集合没有共同的元素则返回true |
| int | indexOfSubList | 返回指定源列表中指定目标列表的第一次出现的起始位置 |
| int | lastIndexOfSubList | 返回指定源列表中指定目标列表的最后一次出现的起始位置 |
其他
| 返回值 | 方法 | 说明 |
|---|---|---|
| list | copy | 将所有元素从一个列表复制到另一个列表中 |
| ArrayList | list | 枚举转数组列表 |
| Collection | synchronized | 返回一个线程安全的集合 |
| Collection | empty | 返回一个空集合 |
| Enumeration | enumeration | 返回指定集合的枚举。 |
| boolean | disjoint | 如果两个指定的集合没有共同的元素则返回true |
Date类和DateFormat类
java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。
第一个构造函数使用当前日期和时间来初始化对象。
Date( )
第二个构造函数接收一个参数，该参数是从 1970 年 1 月 1 日起的毫秒数。
Date(long millisec)
Date 对象创建以后，可以调用下面的方法。
| 序号 | 方法和描述 |
|---|---|
| 1 | boolean after(Date date) 若当调用此方法的Date对象在指定日期之后返回true,否则返回false。 |
| 2 | boolean before(Date date) 若当调用此方法的Date对象在指定日期之前返回true,否则返回false。 |
| 3 | Object clone( ) 返回此对象的副本。 |
| 4 | int compareTo(Date date) 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。 |
| 5 | int compareTo(Object obj) 若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。 |
| 6 | boolean equals(Object date) 当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。 |
| 7 | long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。 |
| 8 | int hashCode( ) 返回此对象的哈希码值。 |
| 9 | void setTime(long time) 用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。 |
| 10 | String toString( ) 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。 |
日期比较
Java使用以下三种方法来比较两个日期：
使用 getTime() 方法获取两个日期（自1970年1月1日经历的毫秒数值），然后比较这两个值。
使用方法 before()，after() 和 equals()。例如，一个月的12号比18号早，则 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。
使用 compareTo() 方法，它是由 Comparable 接口定义的，Date 类实现了这个接口。
使用 SimpleDateFormat 格式化日期
import java.util.*;
import java.text.*;
public class DateDemo {
public static void main(String[] args) {
Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
System.out.println("当前时间为: " + ft.format(dNow));
}
}
结果：
当前时间为: 2018-09-06 10:16:34
日期和时间的格式化编码
| 字母 | 描述 | 示例 |
|---|---|---|
| G | 纪元标记 | AD |
| y | 四位年份 | 2001 |
| M | 月份 | July or 07 |
| d | 一个月的日期 | 10 |
| h | A.M./P.M. (1~12)格式小时 | 12 |
| H | 一天中的小时 (0~23) | 22 |
| m | 分钟数 | 30 |
| s | 秒数 | 55 |
| S | 毫秒数 | 234 |
| E | 星期几 | Tuesday |
| D | 一年中的日子 | 360 |
| F | 一个月中第几周的周几 | 2 (second Wed. in July) |
| w | 一年中第几周 | 40 |
| W | 一个月中第几周 | 1 |
| a | A.M./P.M. 标记 | PM |
| k | 一天中的小时(1~24) | 24 |
| K | A.M./P.M. (0~11)格式小时 | 10 |
| z | 时区 | Eastern Standard Time |
| ’ | 文字定界符 | Delimiter |
| " | 单引号 | ` |
使用printf格式化日期
printf 方法可以很轻松地格式化时间和日期。使用两个字母格式，它以 %t 开头并且以下面表格中的一个字母结尾。
- %tY：输出四位数的年份，例如：2023
- %ty：输出两位数的年份，例如：23
- %tm：输出两位数的月份，例如：02
- %tB：输出月份的全名，例如：February
- %tb：输出月份的缩写，例如：Feb
- %tA：输出星期的全名，例如：Wednesday
- %ta：输出星期的缩写，例如：Wed
- %td：输出两位数的日期，例如：24
- %te：输出一位或两位数的日期，例如：24 或 02
- %tH：输出24小时制的小时数，例如：23
- %tI：输出12小时制的小时数，例如：11
- %tM：输出分钟数，例如：45
- %tS：输出秒数，例如：30
- %tp：输出上午还是下午，例如：AM 或 PM
- %tZ：输出时区，例如：GMT+08:00
| 转换符 | 说明 | 示例 |
|---|---|---|
| %tc | 包括全部日期和时间信息 | 星期六 十月 27 14:21:20 CST 2007 |
| %tF | "年-月-日"格式 | 2007-10-27 |
| %tD | "月/日/年"格式 | 10/27/07 |
| %tr | "HH:MM:SS PM"格式（12时制） | 02:25:51 下午 |
| %tT | "HH:MM:SS"格式（24时制） | 14:28:16 |
| %tR | "HH:MM"格式（24时制） | 14:28 |
解析字符串为时间
SimpleDateFormat 类有一些附加的方法，特别是parse()，它试图按照给定的SimpleDateFormat 对象的格式化存储来解析字符串。例如：
import java.util.*;
import java.text.*;
public class DateDemo {
public static void main(String[] args) {
SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");
String input = args.length == 0 ? "1818-11-11" : args[0];
System.out.print(input + " Parses as ");
Date t;
try {
t = ft.parse(input);
System.out.println(t);
} catch (ParseException e) {
System.out.println("Unparseable using " + ft);
}
}
}
结果：
$ java DateDemo
1818-11-11 Parses as Wed Nov 11 00:00:00 GMT 1818
$ java DateDemo 2007-12-01
2007-12-01 Parses as Sat Dec 01 00:00:00 GMT 2007
package com.test.demo13;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo1Date {
public static void main(String[] args) throws ParseException {
Date date =new Date();
System.out.println(date);
System.out.println(date.getTime());//获得当前时间戳 以毫秒为单位
//SimpleDateFormat对象有默认时间格式
SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
String dateStr1=simpleDateFormat.format(date);//format格式化
System.out.println(dateStr1);
//自定义开发常用标准时间格式 2023-12-25 14：00：00 YYYY-MM-dd HH:mm:ss
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateStr2=simpleDateFormat1.format(date);
System.out.println(dateStr2);//2023-12-25 14:23:37
//2023年12月25日 14点15分01秒-->2023-12-25 14:15:01
SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy年MM月dd日'T'HH点mm分ss秒");
//第二个参数表示解析的格式
Date parseDate = simpleDateFormat2.parse("2023年12月25日T14点15分01秒");
System.out.println(parseDate);
//再转化一次
}
}
Calendar类
我们现在已经能够格式化并创建一个日期对象了，但是我们如何才能设置和获取日期数据的特定部分呢，比如说小时，日，或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar 类。
Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。
Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。
创建一个代表系统当前日期的Calendar对象
Calendar c = Calendar.getInstance();//默认是当前日期
创建一个指定日期的Calendar对象
使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。
//创建一个代表2009年6月12日的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12);
Calendar类对象字段类型
Calendar类中用以下这些常量表示不同的意义，jdk内的很多类其实都是采用的这种思想
| 常量 | 描述 |
|---|---|
| Calendar.YEAR | 年份 |
| Calendar.MONTH | 月份 |
| Calendar.DATE | 日期 |
| Calendar.DAY_OF_MONTH | 日期，和上面的字段意义完全相同 |
| Calendar.HOUR | 12小时制的小时 |
| Calendar.HOUR_OF_DAY | 24小时制的小时 |
| Calendar.MINUTE | 分钟 |
| Calendar.SECOND | 秒 |
| Calendar.DAY_OF_WEEK | 星期几 |
Calendar类对象信息的设置
Set设置
如：
Calendar c1 = Calendar.getInstance();
调用：
public final void set(int year,int month,int date)
c1.set(2009, 6, 12);//把Calendar对象c1的年月日分别设这为：2009、6、12
利用字段类型设置
如果只设定某个字段，例如日期的值，则可以使用如下set方法：
public void set(int field,int value)
把 c1对象代表的日期设置为10号，其它所有的数值会被重新计算
c1.set(Calendar.DATE,10);
把c1对象代表的年份设置为2008年，其他的所有数值会被重新计算
c1.set(Calendar.YEAR,2008);
其他字段属性set的意义以此类推
Add设置
Calendar c1 = Calendar.getInstance();
把c1对象的日期加上10，也就是c1也就表示为10天后的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, 10);
把c1对象的日期减去10，也就是c1也就表示为10天前的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, -10);
其他字段属性的add的意义以此类推
Calendar类对象信息的获得
Calendar c1 = Calendar.getInstance(); // 获得年份 int year = c1.get(Calendar.YEAR); // 获得月份 int month = c1.get(Calendar.MONTH) + 1; // 获得日期 int date = c1.get(Calendar.DATE); // 获得小时 int hour = c1.get(Calendar.HOUR_OF_DAY); // 获得分钟 int minute = c1.get(Calendar.MINUTE); // 获得秒 int second = c1.get(Calendar.SECOND); // 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推） int day = c1.get(Calendar.DAY_OF_WEEK);
GregorianCalendar类
Calendar类实现了公历日历，GregorianCalendar是Calendar类的一个具体实现。
Calendar 的getInstance（）方法返回一个默认用当前的语言环境和时区初始化的GregorianCalendar对象。GregorianCalendar定义了两个字段：AD和BC。这是代表公历定义的两个时代。
下面列出GregorianCalendar对象的几个构造方法：
| 序号 | 构造函数和说明 |
|---|---|
| 1 | GregorianCalendar() 在具有默认语言环境的默认时区内使用当前时间构造一个默认的 GregorianCalendar。 |
| 2 | GregorianCalendar(int year, int month, int date) 在具有默认语言环境的默认时区内构造一个带有给定日期设置的 GregorianCalendar |
| 3 | GregorianCalendar(int year, int month, int date, int hour, int minute) 为具有默认语言环境的默认时区构造一个具有给定日期和时间设置的 GregorianCalendar。 |
| 4 | GregorianCalendar(int year, int month, int date, int hour, int minute, int second) 为具有默认语言环境的默认时区构造一个具有给定日期和时间设置的 GregorianCalendar。 |
| 5 | GregorianCalendar(Locale aLocale) 在具有给定语言环境的默认时区内构造一个基于当前时间的 GregorianCalendar。 |
| 6 | GregorianCalendar(TimeZone zone) 在具有默认语言环境的给定时区内构造一个基于当前时间的 GregorianCalendar。 |
| 7 | GregorianCalendar(TimeZone zone, Locale aLocale) 在具有给定语言环境的给定时区内构造一个基于当前时间的 GregorianCalendar。 |
这里是GregorianCalendar 类提供的一些有用的方法列表：
| 序号 | 方法和说明 |
|---|---|
| 1 | void add(int field, int amount) 根据日历规则，将指定的（有符号的）时间量添加到给定的日历字段中。 |
| 2 | protected void computeFields() 转换UTC毫秒值为时间域值 |
| 3 | protected void computeTime() 覆盖Calendar ，转换时间域值为UTC毫秒值 |
| 4 | boolean equals(Object obj) 比较此 GregorianCalendar 与指定的 Object。 |
| 5 | int get(int field) 获取指定字段的时间值 |
| 6 | int getActualMaximum(int field) 返回当前日期，给定字段的最大值 |
| 7 | int getActualMinimum(int field) 返回当前日期，给定字段的最小值 |
| 8 | int getGreatestMinimum(int field) 返回此 GregorianCalendar 实例给定日历字段的最高的最小值。 |
| 9 | Date getGregorianChange() 获得格里高利历的更改日期。 |
| 10 | int getLeastMaximum(int field) 返回此 GregorianCalendar 实例给定日历字段的最低的最大值 |
| 11 | int getMaximum(int field) 返回此 GregorianCalendar 实例的给定日历字段的最大值。 |
| 12 | Date getTime() 获取日历当前时间。 |
| 13 | long getTimeInMillis() 获取用长整型表示的日历的当前时间 |
| 14 | TimeZone getTimeZone() 获取时区。 |
| 15 | int getMinimum(int field) 返回给定字段的最小值。 |
| 16 | int hashCode() 重写hashCode. |
| 17 | boolean isLeapYear(int year) 确定给定的年份是否为闰年。 |
| 18 | void roll(int field, boolean up) 在给定的时间字段上添加或减去（上/下）单个时间单元，不更改更大的字段。 |
| 19 | void set(int field, int value) 用给定的值设置时间字段。 |
| 20 | void set(int year, int month, int date) 设置年、月、日的值。 |
| 21 | void set(int year, int month, int date, int hour, int minute) 设置年、月、日、小时、分钟的值。 |
| 22 | void set(int year, int month, int date, int hour, int minute, int second) 设置年、月、日、小时、分钟、秒的值。 |
| 23 | void setGregorianChange(Date date) 设置 GregorianCalendar 的更改日期。 |
| 24 | void setTime(Date date) 用给定的日期设置Calendar的当前时间。 |
| 25 | void setTimeInMillis(long millis) 用给定的long型毫秒数设置Calendar的当前时间。 |
| 26 | void setTimeZone(TimeZone value) 用给定时区值设置当前时区。 |
| 27 | String toString() 返回代表日历的字符串。 |
实例
import java.util.*;
public class GregorianCalendarDemo {
public static void main(String[] args) {
String months[] = {
"Jan", "Feb", "Mar", "Apr",
"May", "Jun", "Jul", "Aug",
"Sep", "Oct", "Nov", "Dec"};
int year;
// 初始化 Gregorian 日历
// 使用当前时间和日期
// 默认为本地时间和时区
GregorianCalendar gcalendar = new GregorianCalendar();
// 显示当前时间和日期的信息
System.out.print("Date: ");
System.out.print(months[gcalendar.get(Calendar.MONTH)]);
System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
System.out.println(year = gcalendar.get(Calendar.YEAR));
System.out.print("Time: ");
System.out.print(gcalendar.get(Calendar.HOUR) + ":");
System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
System.out.println(gcalendar.get(Calendar.SECOND));
// 测试当前年份是否为闰年
if(gcalendar.isLeapYear(year)) {
System.out.println("当前年份是闰年");
}
else {
System.out.println("当前年份不是闰年");
}
}
}
以上实例编译运行结果如下：
Date: Apr 22 2009
Time: 11:25:27
当前年份不是闰年
Number & Math类
Math类方法
| xxxValue() | 将 Number 对象转换为xxx数据类型的值并返回。 | Integer x = 5; // 返回 byte 原生数据类型 System.out.println( x.byteValue() ); |
|---|---|---|
| compareTo(NumberSubClass referenceName) | 将number对象与参数比较。 | 如果指定的数与参数相等返回 0。 如果指定的数小于参数返回 -1。 如果指定的数大于参数返回 1。 |
| equals() | 用于判断 Number 对象与方法的参数进是否相等。 | 在Integer中 比较的就是对应的数字的值.在String中 先是比较地址，地址一样就返回true，地址不一样会根据不同数据类型去执行比较值的方法Object中的equals方法，比较的就是两个对象的地址 |
| valueOf() | 返回一个 Number 对象指定的内置数据类型 | **Integer valueOf(int i)：**返回一个表示指定的 int 值的 Integer 实例。 **Integer valueOf(String s)😗*返回保存指定的 String 的值的 Integer 对象。 Integer valueOf(String s, int radix): 返回一个 Integer 对象，radix --字符串 s 使用的进制数，用于指定使用的进制数。（对于负数字符串为”-89“这种，才可以显示为负数） |
| toString() | 以字符串形式返回值。 | public class Test{ public static void main(String args[]){ Integer x = 5; System.out.println(x.toString()); System.out.println(Integer.toString(12)); } } |
| parseInt() | 用于将字符串参数作为有符号的十进制整数进行解析。 | public class Test{ public static void main(String args[]){ int x =Integer.parseInt(“9”); double c = Double.parseDouble(“5”); int b = Integer.parseInt(“444”,16); System.out.println(x); System.out.println©; System.out.println(b); } } 结果：9 5.0 1092 |
Character类
Character 类用于对单个字符进行操作。
Character 类在对象中包装一个基本类型 char 的值
| 转义序列 | 描述 |
|---|---|
| \t | 在文中该处插入一个tab键 |
| \b | 在文中该处插入一个后退键 |
| \n | 在文中该处换行 |
| \r | 在文中该处插入回车 |
| \f | 在文中该处插入换页符 |
| ’ | 在文中该处插入单引号 |
| " | 在文中该处插入双引号 |
| \ | 在文中该处插入反斜杠 |
Character类的方法
| 序号 | 方法与描述 |
|---|---|
| 1 | isLetter() 是否是一个字母 |
| 2 | isDigit() 是否是一个数字字符 |
| 3 | isWhitespace() 是否是一个空白字符 |
| 4 | isUpperCase() 是否是大写字母 |
| 5 | isLowerCase() 是否是小写字母 |
| 6 | toUpperCase() 指定字母的大写形式 |
| 7 | toLowerCase() 指定字母的小写形式 |
| 8 | toString() 返回字符的字符串形式，字符串的长度仅为1 |
基本包装类/Random类
package com.test.demo12;
import java.util.Random;
public class Demo15Random {
public static void main(String[] args) {
/*
随机种子：
给定一个任意值，当运行得到结果时，该结果在后续每次运行中都一致
为什么需要种子：
一般用于演示，保证每次的演示结果是一致的
*/
Random random=new Random(10);
int i =random.nextInt();
System.out.println(i);
int i1=random.nextInt(10);//0-10
System.out.println(i1);
}
}
| 2 | isDigit() 是否是一个数字字符 |
| 3 | isWhitespace() 是否是一个空白字符 |
| 4 | isUpperCase() 是否是大写字母 |
| 5 | isLowerCase() 是否是小写字母 |
| 6 | toUpperCase() 指定字母的大写形式 |
| 7 | toLowerCase() 指定字母的小写形式 |
| 8 | toString() 返回字符的字符串形式，字符串的长度仅为1 |
基本包装类/Random类
package com.test.demo12;
import java.util.Random;
public class Demo15Random {
public static void main(String[] args) {
/*
随机种子：
给定一个任意值，当运行得到结果时，该结果在后续每次运行中都一致
为什么需要种子：
一般用于演示，保证每次的演示结果是一致的
*/
Random random=new Random(10);
int i =random.nextInt();
System.out.println(i);
int i1=random.nextInt(10);//0-10
System.out.println(i1);
}
}
扫一扫
2169
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
