2. 常用类Api - 1
System系统类
系统类无法被继承成也无法被实例化
public final class System {
private System() { }
}
// static final PrintStream err
// “标准”错误输出流。
// static final InputStream in
// “标准”输入流。
// static final PrintStream out
// “标准”输出流。
系统类常用方法
| 方法 | 说明 |
|---|---|
| exit(int status) 0正常关闭 !0非正常关闭 | 终止当前运行的 Java 虚拟机 |
| gc() | 在 Java 虚拟机中运行垃圾收集器 |
| currentTimeMillis() | 以毫秒为单位返回当前时间 |
| arraycopy(Object src, int srcPos, Object dest, int destPos, int length) | 将指定源数组中的数组从指定位置开始复制到目标数组的指定位置 |
| console() | 返回与当前 Java 虚拟机关联的唯一对象（如果有） |
...
arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
src 源数组 srcPos 原数组起始位置 dest 目标数组 destPost 目标数组中起始位置 length 要复制的数组元素的数量
Math数学类
PI返回π
| 方法 | 说明 |
|---|---|
| abs() | 返回值的绝对值 |
| random() | 返回一个double带正号的值，大于或等于0.0且小于1.0 |
| max() | 返回两个值中的较大者。 |
| min() | 返回两个值中的较小者。 |
| sin(double a) | 返回角度的三角正弦值。 |
| cos(double x) | 返回角度的三角余弦值。 |
...
3. 包装类
Java有八种基本数据类型：byte、short、int、long、float、double、boolean、char
Java为其提供了8种对应的包装类：Byte、Short、Integer、Long、Float、Double、Boolean、Character
| 数据类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
| char | Character |
包装类方法（基本通用）
XXXValue(); 获取包装类中的数据
parseXXX(); 字符串数据转换
// JDK 1.8之前的写法 Integer integer = new Integer(100); // JDK 9 以后 Integer integer = 100;
JDK1.5后的自动装箱/拆箱特性
装箱和拆箱
int 和 Integer的转换
public class Test2 {
public static void main(String[] args) {
int score=666;
Integer score1 = new Integer(score);
System.out.println("score对应的Integer类型结果为：" + score1);
Integer a=new Integer(1230);
int i=a.intValue();
System.out.println("由Integer类型转换为int类型的结果为：" + i);
}
}
public class Test2 {
public static void main(String[] args) {
Integer score1 = 666;//自动装箱
System.out.println("score对应的Integer类型结果为：" + score1);
int i=score1;//自动拆箱
System.out.println("由Integer类型转换为int类型的结果为：" + i);
}
}
基本数据类型和字符串类型之间的转化(基本数据类型转换为字符串类型方法)
// 基本类型直接与""相连接即可实现转换，如：66+""； double a=12.5; System.out.println(a+"");//12.5 System.out.println(a+""+10);//12.510 // 先转换为包装类型，然后调用toString方法 double a=12.5; String a1=Double.toString(a);//这里先转换为Double类型，然后调用toString方法 System.out.println(a1);//12.5 System.out.println(a1+66);//12.566 // 使用String的静态方法valueof转换 double a=12.5; String a1=String.valueOf(a);//使用String的valuOf方法 System.out.println(a1+88);//12.588
使用包装类时要注意的问题
包装类的缓存范围
boolean：true和false byte：-128～127 char：0～127 short：-128～127 int：-128～127 long：-128～127
对于float和double没有缓存
Integer num1 = 200;
Integer num2 = 200;
System.out.println("num1==num2: "+(num1==num2));
Integer num3 = 100;
Integer num4 = 100;
System.out.println("num3==num4: "+(num3==num4));
4. Date日期类
| 方法和描述 |
|---|
| boolean after(Date date) 若当调用此方法的Date对象在指定日期之后返回true,否则返回false。 |
| boolean before(Date date) 若当调用此方法的Date对象在指定日期之前返回true,否则返回false。 |
| Object clone( ) 返回此对象的副本。 |
| int compareTo(Date date) 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。 |
| int compareTo(Object obj) 若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。 |
| boolean equals(Object date) 当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。 |
| long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。 |
| int hashCode( ) 返回此对象的哈希码值。 |
| void setTime(long time) 用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。 |
| String toString( ) 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。 |
日期格式化
SimpleDateFormat类格式化符号
| 字母 | 描述 | 示例 |
|---|---|---|
| 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 |
| " | 单引号 |
// Demo
Date d = new Date();
Date d = new Date();
System.out.println(d);
// 要转换的格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
SimpleDateFormat sdf1 = new SimpleDateFormat(
"一年中的第 D 天 一年中第w个星期 一月中第W个星期 E a 在一天中K时 z时区");
// 格式化日期，日期->字符串
String formatDate = sdf.format(d);
String formatDate1 = sdf1.format(d);
System.out.println(formatDate);
System.out.println(formatDate1);
String s = "2022-07-13 15:12:34 000";
try {
Date date = sdf.parse(s);// 格式化日期，字符串->日期
System.out.println(date);
} catch (ParseException e) {
e.printStackTrace();
}
5. Calendar日历类
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 | 星期几 |
6. 日期类
| 日期类 | 作用 |
|---|---|
| LocalDate（.now()） | 获取日期 |
| LocalTime（.now()） | 获取时间 |
| LocalDateTime（.now()） | 获取日期 + 时间 |
// 年月日时分秒 LocalDateTime p1 = LocalDateTime.now(); // 年月日 LocalDate p2 = LocalDate.now(); // 时分秒 LocalTime p3 = LocalTime.now();
使用 DateTimeFormatter 对象来进行格式化
LocalDateTime p = LocalDateTime.now();
// 创建 DateTimeFormatter 对象方式1
DateTimeFormatter time = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.???");
String format = time.format(p);
System.out.println("格式化的日期=" + format);
// 方式2
p.format(time);
分别获取年、月、日、时、分、秒
LocalDateTime p = LocalDateTime.now();
System.out.println("年=" + p.getYear());
System.out.println("月=" + p.getMonth());
System.out.println("月=" + p.getMonthValue());
System.out.println("日=" + p.getDayOfMonth());
System.out.println("时=" + p.getHour());
System.out.println("分=" + p.getMinute());
System.out.println("秒=" + p.getSecond());
设置指定时间
LocalDateTime p = LocalDateTime.of(int year, Month month, int dayOfMonth, int hour, int minute, int second);
LocalDateTime p = LocalDateTime.parse(""); // 必须满足时间格式（yyyy-HH-mmTHH:mm:ss.???）
// LocalDateTime.parse
ISO_LOCAL_DATE_TIME = new DateTimeFormatterBuilder()
.parseCaseInsensitive()
.append(ISO_LOCAL_DATE)
.appendLiteral('T')
.append(ISO_LOCAL_TIME)
.toFormatter(ResolverStyle.STRICT, IsoChronology.INSTANCE);
用plus方法对时间进行加
LocalDateTime p = LocalDateTime.now();
// 在当前日期上加366天
LocalDateTime loctime = p.plusDays(366);
System.out.println("366天后=" + dateTimeFormatter.format(loctime));
用minus方法对时间进行减
LocalDateTime p = LocalDateTime.now();
// 在30000分钟前是什么时候
LocalDateTime loctime = p.minusMinutes(30000);
System.out.println("30000分钟前的时间=" + dateTimeFormatter.format(loctime));
7. ChronoUnit时间计算
package com.lty;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
public class ChronoUnitDemo {
public static void main(String[] args) {
LocalDateTime today = LocalDateTime.now();
LocalDateTime birthDate = LocalDateTime.of(2000, 5, 21, 0, 0, 0, 0);
System.out.println("相差的年数: " + ChronoUnit.YEARS.between(birthDate,today));
System.out.println("相差的月数: " + ChronoUnit.MONTHS.between(birthDate,today));
System.out.println("相差的周数: " + ChronoUnit.WEEKS.between(birthDate,today));
System.out.println("相差的天数: " + ChronoUnit.DAYS.between(birthDate,today));
System.out.println("相差的时数: " + ChronoUnit.HOURS.between(birthDate, today));
System.out.println("相差的分数: " + ChronoUnit.MINUTES.between(birthDate, today));
System.out.println("相差的秒数: " + ChronoUnit.SECONDS.between(birthDate,today));
System.out.println("相差的毫秒数: " + ChronoUnit.MILLIS.between(birthDate,today));
System.out.println("相差的微秒数: " + ChronoUnit.MICROS.between(birthDate,today));
System.out.println("相差的纳秒数: " + ChronoUnit.NANOS.between(birthDate, today));
System.out.println("相差的半天数: " + ChronoUnit.HALF_DAYS.between(birthDate, today));
System.out.println("相差的十年数: " + ChronoUnit.DECADES.between(birthDate,today));
System.out.println("相差的世纪有年数: " + ChronoUnit.CENTURIES.between(birthDate,today));
System.out.println("相差的千年数: " + ChronoUnit.MILLENNIA.between(birthDate,today));
System.out.println("相差的纪元数: " + ChronoUnit.ERAS.between(birthDate,today));
}
}
8. Instant 时间戳
获取时间戳的对象
// 通过 静态方法 now() 获取 Instant now = Instant.now();
Instant n = Instant.now(); // Instant --> Date Date d = Date.from(n); // Date - > nstant Instant in = d.tolnstant();
9. String字符串类
-
String是唯一一个设计了字面常量的引用数据类型
-
String拥有一个字符串常量池的设计
-
String判断非空，应该判定两个条件
-
String对象的值一旦确定不能改变 （因为字符串的底层为数组）
// 字符串常量池的使用
String str1 = "hello world";
String str2 = "hello world";
String str3 = new String("hello world");
System.out.println(str1 == str2); // true
System.out.println(str1 == str3); // false
字符串的底层是才有字符数组char[]实现的，每一个字符都有一个索引值
| 方法 | 描述 |
|---|---|
| char charAt(int index) | 返回指定索引处的 char 值。 |
| int compareTo(Object o) | 把这个字符串和另一个对象比较。 |
| Int compareTo(String anotherString) | 按字典顺序比较两个字符串。 |
| int compareToIgnoreCase(String str) | 按字典顺序比较两个字符串，不考虑大小写。 |
| String concat(String str) | 指定字符串连接到此字符串的结尾。 |
| boolean contentEquals(StringBuffer sb) | 当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。 |
| static String copyValueOf(char[] data) | 返回指定数组中表示该字符序列的 String。 |
| static String copyValueOf(char[] data, int offset, int count) | 返回指定数组中表示该字符序列的 String。 |
| boolean endsWith(String suffix) | 测试此字符串是否以指定的后缀结束。 |
| boolean equals(Object anObject) | 将此字符串与指定的对象比较。 |
| boolean equalsIgnoreCase(String anotherString) | 将此 String 与另一个 String 比较，不考虑大小写。 |
| byte[] getBytes() | 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 |
| void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) | 将字符从此字符串复制到目标字符数组。 |
| int hashCode() | 返回此字符串的哈希码。 |
| int indexOf(int ch) | 返回指定字符在此字符串中第一次出现处的索引。 |
| int indexOf(int ch, int fromIndex) | 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。 |
| int indexOf(String str) | 返回指定子字符串在此字符串中第一次出现处的索引。 |
| int indexOf(String str, int fromIndex) | 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。 |
| String intern() | 返回字符串对象的规范化表示形式。 |
| int lastIndexOf(int ch) | 返回指定字符在此字符串中最后一次出现处的索引。 |
| int lastIndexOf(int ch, int fromIndex) | 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。 |
| int lastIndexOf(String str) | 返回指定子字符串在此字符串中最右边出现处的索引。 |
| int lastIndexOf(String str, int fromIndex) | 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。 |
| int length() | 返回此字符串的长度。 |
| boolean matches(String regex) | 告知此字符串是否匹配给定的正则表达式。 |
| boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) | 测试两个字符串区域是否相等。 |
| boolean regionMatches(int toffset, String other, int ooffset, int len) | 测试两个字符串区域是否相等。 |
| String replace(char oldChar, char newChar) | 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 |
| String replaceAll(String regex, String replacement) | 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 |
| String replaceFirst(String regex, String replacement) | 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。 |
| String[] split(String regex) | 根据给定正则表达式的匹配拆分此字符串。 |
| String[] split(String regex, int limit) | 根据匹配给定的正则表达式来拆分此字符串。 |
| boolean startsWith(String prefix) | 测试此字符串是否以指定的前缀开始。 |
| boolean startsWith(String prefix, int toffset) | 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。 |
| CharSequence subSequence(int beginIndex, int endIndex) | 返回一个新的字符序列，它是此序列的一个子序列。 |
| String substring(int beginIndex) | 返回一个新的字符串，它是此字符串的一个子字符串。 |
| String substring(int beginIndex, int endIndex) | 返回一个新字符串，它是此字符串的一个子字符串。 |
| char[] toCharArray() | 将此字符串转换为一个新的字符数组。 |
| String toLowerCase() | 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。 |
| String toLowerCase(Locale locale) | 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。 |
| String toString() | 返回此对象本身（它已经是一个字符串！）。 |
| String toUpperCase() | 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。 |
| String toUpperCase(Locale locale) | 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。 |
| String trim() | 返回字符串的副本，忽略前导空白和尾部空白。 |
| static String valueOf(primitive data type x) | 返回给定data type类型x参数的字符串表示形式。 |
| contains(CharSequence chars) | 判断是否包含指定的字符系列。 |
| isEmpty() | 判断字符串是否为空。 |
10. StringBuffer 和 StringBuilder 类
区别：
-
StringBuffer线程安全的
-
StringBuilder线程不安全的
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 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("demo..");
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);
}
}
然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
public class Test{
public static void main(String args[]){
StringBuffer sBuffer = new StringBuffer("demo：");
sBuffer.append("www");
sBuffer.append(".runoob");
sBuffer.append(".com");
System.out.println(sBuffer);
}
}
StringBuffer|StringBuilder 支持的主要方法
| 方法描述 |
|---|
| public StringBuffer append(String s) 将指定的字符串追加到此字符序列。 |
| public StringBuffer reverse() 将此字符序列用其反转形式取代。 |
| public delete(int start, int end) 移除此序列的子字符串中的字符。 |
public insert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中。 |
insert(int offset, String str) 将 str 参数的字符串插入此序列中。 |
replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。 |
StringBuffer|StringBuilder 类的其他常用方法
| 方法描述 |
|---|
| int capacity() 返回当前容量。 |
char charAt(int index) 返回此序列中指定索引处的 char 值。 |
| void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。 |
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 dst。 |
| int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。 |
| int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。 |
| int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。 |
| int lastIndexOf(String str, int fromIndex) 返回 String 对象中子字符串最后出现的位置。 |
| int length() 返回长度（字符数）。 |
void setCharAt(int index, char ch) 将给定索引处的字符设置为 ch。 |
| void setLength(int newLength) 设置字符序列的长度。 |
| CharSequence subSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。 |
String substring(int start) 返回一个新的 String，它包含此字符序列当前所包含的字符子序列。 |
String substring(int start, int end) 返回一个新的 String，它包含此序列当前所包含的字符子序列。 |
| String toString() 返回此序列中数据的字符串表示形式。 |
个人了解
使用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 |
为什么计算机时间要从1970年1月1日0点开始算起
很多编程语言起源于UNIX系统，而UNIX系统认为1970年1月1日0点是时间纪元，所以我们常说的UNIX时间戳是以1970年1月1日0点为计时起点时间的。
最初计算机操作系统是32位，而时间也是用32位表示。
System.out.println(Integer.MAX_VALUE); 2147483647
Integer 在JAVA内用32位表示，因此32位能表示的最大值是2147483647。另外1年365天的总秒数是 31536000，2147483647/31536000 = 68.1，也就是说32位能表示的最长时间是68年，从1970年开始的话，加上68.1，实际最终到2038年01月19日03时14分07秒，便会到 达最大时间，过了这个时间点，所有32位操作系统时间便会变为10000000 00000000 00000000 00000000，算下来也就是1901年12月13日20时45分52秒，这样便会出现时间回归的现象，很多软件便会运行异常了。
因为用32位来表示时间的最大间隔是68年，而最早出现的UNIX操作系统考虑到计算机产生的年代和应用的 时限综合取了1970年1月1日作为UNIX TIME的纪元时间(开始时间)，至于时间回归的现象相信随着64为操作系统的产生逐渐得到解决，因为用64位操作系统可以表示到 292,277,026,596年12月4日15时30分08秒，相信我们的N代子孙，哪怕地球毁灭那天都不用愁不够用了，因为这个时间已经是千亿年以后了。
扫一扫
322
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
