Java基础–>一篇讲全Java常用类（详细易懂，建议收藏）
文章目录
1.字符串相关的类
String类
提到与字符串相关的类，我们第一个想到的肯定就是String类了。在我们还在写helloworld的时候，我们在主函数的第一行都会写到
public static void main(String[] args)
其实啊我们很早就和String类见了面，而且在刚开始学习Java的过程中也总是会和String类打交道。这里我将对String类做更详细的介绍。对于String类，我们不仅要看到它的表面，更要深入其内部一探究竟。
概述
String类是表示字符串的类，它将字符串用一对""引起来表示。
现在我们很轻易地知道String类是用来表示字符串的类了，那么它到底是怎么表示字符串的，它所表示的字符串又有什么属性和功能我们现在还不是很清楚。我们深入String的源码，就可以解决我们的一些疑惑了。
进入String类的内部后，我们发现String类是被声明为final的。这就表明它是不可被继承的。
往后看，可以看到String类实现了Serializable接口，Comparable接口和CharSequence接口。
那实现了这些接口对于String类都有什么用呢？
我们再次向更深层次的地方探索。
Serializable接口中没有方法或字段，仅用于标识有序列化的语义，那么就表明String字符串是支持序列化的。
Comparable接口中声明了一个compareTo()方法，String类通过重写这个方法，就可以比较字符串的大小。
CharSequence接口是为了进行字符串操作标准的统一，JDK提供的接口标准。StringBuffer、StringBuilder也都实现了此接口。
再往下看，我们看到在其内部声明了一个byte型数组，这个数组就是用来存储字符串的。
在Java 8 中，String类内部还使用char型数组来存储数据，在Java 9 后，String类改用byte型数组来存储数据，并且还新增了一个变量coder来标识使用了哪一种编码。
此外，我们可以看到value数组也是被声明为final的，这就表明value数组被初始化后就不能够再改变了。这就表明String是不可变的字符串。我们就称String的这种特性为不可变性。如果我们看遍String类中定义的方法，我们就会发现String内部没有改变 value 数组的⽅法，因此可以保证 String 不可变。
创建String类的对象
以上我们已经对于String类已经有所了解。至于String类中定义的方法，我们后面给出介绍。在使用String类的方法之前，我们需要知道怎么去创建一个String类的对象。
我们有两种方式创建String类的对象
1.字面量的定义方式
例如：
String str = “hello”；2.通过关键字new一个String类的对象
例如：
String str = new String(“hello”);
我们看下面一段代码：
public class StringTest{
public static void main(String[] args){
String s1 = "hello";
String s2 = new String("hello");
System.out.println(s1 == s2);//false
String s3 = "hello";
System.out.println(s1 == s3);//true
System.out.println(s2 == s3);//false
}
}
这里的s1和s2都是表示字符串"hello"，那么从表面上看，我们可以说s1和s2是相等的。那我们肯定就想要看一看是不是和我们的想的一样。但是我们通过输出 s1 == s2 的结果发现却是false。我们通过 == 号比较的是s1 和 s2的地址值。这就说明，虽然s1和s2存储的是同一个字符串，但是它们在内存中存储的位置却是不相同的。那么，s1和s2到底在内存中是如何存储的呢。
字符串对象是如何存储的
我们以上述程序的代码段为例说明
String s1 = “hello”;
String s2 = new String(“hello”);
通过字面量方式的内存分析：首先在字符串常量池中查找是否存在字符串常量“hello”，如果没有则创建一个”hello”，并且把变量s1的值指向常量池中的”abc”。
通过创建对象的内存分析：首先在堆内存中创建一个对象，然后在常量池中查找是否存在字符串”hello”，如果没有则创建，有则直接指向此对象的值。
如下图：
String类的常用方法
- int length()：返回字符串的长度： return value.length
- char charAt(int index)： 返回某索引处的字符return value[index]
- boolean isEmpty()：判断是否是空字符串：return value.length == 0
- String toLowerCase()： 使用默认语言环境，将 String 中的所有字符转换为小写
- String toUpperCase()： 使用默认语言环境，将 String 中的所有字符转换为大写
- String trim()： 返回字符串的副本，忽略前导空白和尾部空白
- boolean equals(Object obj)：比较字符串的内容是否相同
- boolean equalsIgnoreCase(String anotherString)： 与equals方法类似，忽略大小写
- String concat(String str)： 将指定字符串连接到此字符串的结尾。 等价于用“+”
- int compareTo(String anotherString)： 比较两个字符串的大小
- String substring(int beginIndex)： 返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
- String substring(int beginIndex, int endIndex)： 返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
测试代码如下：
运行
package com.zhang.test.string;
import org.junit.Test;
import java.util.Locale;
public class StringMethodTest {
@Test
public void test4(){
//替换
String str1 = "我爱java";
//替换字符串
String str2 = str1.replace("java", "php");
System.out.println("原字符串:"+str1);
System.out.println("替换字符串:"+str2);
//替换一个字符
String str3 = str1.replace('我','你');
System.out.println("原字符串:"+str1);
System.out.println("替换单个字符:"+str3);
System.out.println("-----------------------------");
String str4 = "12hello34world5java7891mysql1456";
//把字符串中的数字替换成，如果结果中开头有，的话去掉
//regex:正则表达式
String str5 = str4.replaceAll("\\d+",",").replaceAll("^,|,$","");
System.out.println("原字符串:"+str4);
System.out.println("按指定规则替换字符:"+str5);
System.out.println("---------------------------------------");
//匹配
String str6 = "12345";
//判断str6字符串是否全部有数字组成，有1-n哥数字组成
boolean matches = str6.matches("\\d+");
System.out.println("判断"+str6+"字符串是否全部有数字组成，有1-n哥数字组成:"+matches);
String tel = "0552-6552324";
//判断这是否是一个安徽的固定电话
boolean result = tel.matches("0552-\\d{7,8}");
System.out.println("判断"+tel+"是否是一个安徽的固定电话:"+result);
System.out.println("-------------------------------------------------");
//切片
String str7 = "hello|world|java";
String[] strs = str7.split("\\|");
System.out.println("将字符串"+str7+"按|分成若干个子字符串");
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
System.out.println();
String str8 = "hello.world.java";
String[] strs2 = str8.split("\\.");
System.out.println("将字符串"+str8+"按.分成若干个子字符串");
for (int i = 0; i < strs2.length; i++) {
System.out.println(strs2[i]);
}
System.out.println();
}
@Test
public void test3(){
String s1 = "javaSE";
//是否以某字符串开始
System.out.println("判断字符串"+s1+"是否以字符串”java“开始:"+s1.startsWith("java"));
//是否以某字符串结束
System.out.println("判断字符串"+s1+"是否以字符串”SE“结束:"+s1.endsWith("SE"));
System.out.println("判断字符串从索引值为4开始"+s1+"是否以字符串”SE“开头:"+s1.startsWith("SE", 4));
//是否包含某个字符串
System.out.println("判断字符串"+s1+"是否包含字符串”java“:"+s1.contains("java"));
//indexOf(String str)返回第一次找到字符创的索引值
System.out.println("返回字符串"+s1+"中字符‘a’第一次出现的索引值”:"+s1.indexOf("a"));
//未找到返回-1
System.out.println("返回字符串"+s1+"中字符串”lol“第一次出现的索引值”:"+s1.indexOf("lol"));
//从指定位置开始查找
System.out.println("返回字符串"+s1+"从索引值为2的地方开始寻找字符‘a’第一次出现的索引值”:"+s1.indexOf("a",2));
String s2 = "hellorworld";
//从后往前找，返回的索引值仍是从左往右的
System.out.println("从后往前找:返回字符串"+s2+"中字符串”or“第一次出现的索引值”:"+s2.lastIndexOf("or"));
//从指定位置开始，从右往左边找
System.out.println("从后往前找:返回字符串"+s1+"从索引值为2的地方开始寻找字符串”or“第一次出现的索引值”:"+s2.lastIndexOf("or",6));
//什么情况下，indexOf()和lastIndexOf()返回值相同?
//情况1：存在唯一的一个str 情况2：不存在str
}
@Test
public void test2() {
String s1 = "helloworld";
String s2 = "HelloWorld";
System.out.println(s1+"和"+s2+"是否相等:"+s1.equals(s2));//false
System.out.println(s1+"和"+s2+"是否相等:(忽略大小写)"+s1.equalsIgnoreCase(s2));//true
//concat():将指定字符串连接到此字符的结尾，等价于用“+”
String s3 = "abc";
String s4 = s3.concat("def");
System.out.println("将字符串def连接到字符串"+s3+"的后面:"+s4);
//compareTo:比较两个字符串的大小
String s5 = "abc";
String s6 = "abd";
String s7 = "abc";
//涉及到字符串排序
System.out.println("比较字符串"+s5+"和字符串"+s6+"的大小:"+s5.compareTo(s6));
System.out.println("比较字符串"+s6+"和字符串"+s5+"的大小:"+s6.compareTo(s5));
System.out.println("比较字符串"+s5+"和字符串"+s7+"的大小:"+s5.compareTo(s7));
//提取子串
String s8 = "javaEE";
String s9 = s8.substring(4);//java
String s10 =s8.substring(0, 4);
System.out.println("原字符串"+s8);
System.out.println("提取字符串"+s8+"从头到索引值为4的子串，不包含索引值为4的字符:"+s9);
System.out.println("提取字符串"+s8+"从索引值为0到索引值为4的子串，索引值为4的字符:"+s10);
}
@Test
public void test1(){
String s1 = "helloworld";
System.out.println("输出字符串"+s1+"的长度:"+s1.length());//10
System.out.println("输出字符串"+s1+"的第一个字符:"+s1.charAt(0));//h
System.out.println("输出字符串"+s1+"的最后一个字符:"+s1.charAt(9));//d
System.out.println("输出字符串"+s1+"索引值为8的字符:"+s1.charAt(8));//l
System.out.println("判断字符串"+s1+"是否为空:"+s1.isEmpty());//false
System.out.println("将字符串"+s1+"转化为大写:"+s1.toUpperCase(Locale.ROOT));//HELLOWORLD
System.out.println("原字符串"+s1);//s1 = "helloworld“
System.out.println("将字符串"+s1+"转换为小写:"+s1.toLowerCase(Locale.ROOT));//helloworld
String s2 = " hel lo wo rld ";
String s3 = s2.trim();
//去除的是首尾的空格，中间的空格无法消除
System.out.println("--------"+s2+"-------");
System.out.println("去除的是首尾的空格，中间的空格无法消除");
System.out.println("--------"+s3+"-------");
}
}
运行结果如下：
String与基本数据类型的转换
String --> 基本数据类型，包装类:
调用包装类的静态方法parseXxx(str)
基本数据类型，包装类 --> String：
调用String重载的valueOf(xxx)
String与字符串数组的转换
String --> char[]:
调用String的toCharArray()
char[] --> String:
调用String的构造器
String与字节数组的转换
String --> byte[]:
调用String的getBytes()
byte[]–>String:
调用String的构造器
说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则，会出现乱码。
测试代码如下：
import org.junit.Test;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
/**
* 涉及到String类与其他结构之间的转换
*/
public class StringTest01 {
@Test
public void test3() throws UnsupportedEncodingException {
String str1 = "abc123中国";
//使用默认的字符集进行转换
byte[] bytes = str1.getBytes(StandardCharsets.UTF_8);
System.out.println(Arrays.toString(bytes));
//使用gbk字符集进行编码
byte[] gbks = str1.getBytes("gbk");
System.out.println(Arrays.toString(gbks));
System.out.println("--------------------------------");
String str2 = new String(bytes);//使用默认的字符集，进行解码
System.out.println(str2);
String str3 = new String(gbks);
System.out.println(str3);//出现乱码。原因：编码集和解码集不一致
//使用gbk字符集进行解码
String str4 = new String(gbks,"gbk");
System.out.println(str4);
}
@Test
public void test2(){
String str1 = "abc123";
char[] charArray = str1.toCharArray();
for (int i = 0; i < charArray.length; i++) {
System.out.println(charArray[i]);
}
char[] arr = new char[]{'h','e','l','l','o'};
String str2 = new String(arr);
System.out.println(str2);
}
@Test
public void test1(){
String str1 = "123";
int num = Integer.parseInt(str1);
String str2 = String.valueOf(num);
String str3 = num + "";
}
}
运行结果如下：
至此，String类的常用方法都已经测试完了。如果想要了解关于String类更多的方法，可以查看JDK帮助文档。
StringBuffer类和StringBuilder类
概述
我们都知道String字符串是不可变的，那么当我们想要使用可变的字符串时，我们就可以使用StringBuffer类或者是StringBuilder类。
StringBuffer是线程安全，可变的字符序列。StringBuilder也是可变的字符序列，但是不能保证同步。
创建StringBuffer类和StringBuilder类的对象
这里的StringBuffer与StringBuilder相似，对于StringBuffer适用的，StringBuilder同样也适用。所以，这里就只对StringBuffer类做详解。
StringBuffer类不同于String类，我们必须要去new一个对象，也就是调用StringBudder的构造器创建一个对象。
那么，我们就需要对StringBufffer类的构造器有所了解。
以上是JDK帮助文档中对于StringBuffer类构造器的概述。
这里我们可以看到StringBuffer类在创建一个字符串对象时，底层的数组初始容量是16，这是不同于String类的。
了解了StringBuffer类的构造器，我们就知道怎么去创建一个StringBuffer类的对象了。
如下：
StringBuffer str = new StringBuffer(“hello”);
StringBuffer类和StringBuilder类的常用方法
对于StringBuffer类和StringBuilder类的常用方法，我们只需要记住以下几个常用的方法就可以了。
增:append(xxx)
删:delete(xxx)
改:setCharAt(int n ,char ch) / replace(int start , int end ,String str)
查:charAt(int n)
插:insert(int offset , xxx)
长度:length()
遍历:for() + charAt() / toString()
测试代码如下：
import org.junit.Test;
/**
* 关于StringBuffer和StringBuilder的使用
*/
public class StringBufferAndBuilder {
public void test3() {
//初始设置
long startTime = 0l;
long endTime = 0l;
String text = "";
StringBuffer buffer = new StringBuffer("");
StringBuilder builder = new StringBuilder("");
//开始对比
startTime = System.currentTimeMillis();
for (int i = 0; i < 200000; i++) {
buffer.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuffer的执行时间:" + (endTime - startTime));
startTime = System.currentTimeMillis();
for (int i = 0; i < 200000; i++) {
builder.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuilder的执行时间:" + (endTime - startTime));
startTime = System.currentTimeMillis();
for (int i = 0; i < 200000; i++) {
text = text + i;
}
endTime = System.currentTimeMillis();
System.out.println("String的执行时间:" + (endTime - startTime));
}
@Test
public void test2() {
StringBuffer s1 = new StringBuffer("abc");
s1.append(1);//没有转换为ASCII码值
s1.append("1");
System.out.println(s1);//abc11
// s1.delete(2,4);//左闭右开
// s1.replace(2,4,"hello");
// s1.insert(2,false);//是插入，并不是替换
// System.out.println(s1.length());//将false看成是5个字符
// s1.reverse();
String s2 = s1.substring(1, 3);//s1并没有变化
System.out.println(s1);
}
@Test
public void test1(){
StringBuffer sb1 = new StringBuffer("abc");
sb1.setCharAt(0,'m');
System.out.println(sb1);
System.out.println(sb1.length());
StringBuffer sb2 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组
System.out.println(sb2.length());
}
}
运行结果如下：
test1
test2
test3
test3是对比String,StringBuffer,StringBuilder三者的效率所做的测试
经过对比我们可以得出以下结果：
String,StringBuffer,StringBuilder三者的效率
从高到低排列：
StringBuilder > StringBuffer > String
因为StringBuffer和StringBuilder类是可变的，StringBuffer和StringBuilder类的对象直接在原有的字符串后追加新的字符就可以了，而String类是不可变的，在追加新的字符时，需要将当前字符连接新字符后赋值给一个新的数组，频繁的创建数组需要花费大量的时间，所以相对于StringBuffer和StringBuilder类，String类的效率较低。而对比StringBuffer和StringBuilder类，因为StringBuffer是线程安全的，需要做一些线程安全的检查，需要花费一定的时间，所以相对于StringBuilder，效率较低。
String,StringBuffer,StringBuilder三者的异同以及StringBuffer的底层分析
三者的异同
String: 不可变的字符序列;底层使用char[]存储;
StringBuffer: 可变的字符序列;线程安全的，效率偏低;底层使用char[]存储;
StringBuilder: 可变的字符序列;线程不安全的，效率高；JDK5.0新增;底层使用char[]存储;
底层分析
这里扩充一下三者底层数组存储的不同：
底层分析
String str = new String();//new char[0];底层创建了一个长度是0的数组
String str1 = new String(“abc”);//new char[]{‘a’,‘b’,‘c’};
底层创建了一个长度是3的数组
StringBuffer str2 = new StringBuffer();//char[] value = new char[16];
底层创建了一个长度是16的数组
现在我们有一个问题，当我们输出str,str1的数组长度是0和3，那么当我们输出StringBuffer类创建的字符串对象str2时，输出的是不是16呢。
然而并不是，此时输出的数组长度为0
System.out.println(str2.length());// 0
有如下代码：
StringBuffer sb2 = new StringBuffer(“abc”);
那我们需要解决一个问题，这种方式底层是创建了一个长度为16的数组，然后将abc放进去???
观察源码发现，实际上，并不是这样。以上代码等价于在底层进行如下操作:
char[] value = new char[“abc”.length() + 16];
此时的数组长度字符串的长度+16
输出str2的长度，结果为3
System.out.println(str2.length());// 3
扩容问题
如果要添加的数据底层数组盛不下了，就需要扩容底层的数组
默认情况下，扩容为原来的2倍 + 2，同时将原有数组中的元素复制到新的数组中。
我们也可以通过StringBuffer(int capacity) 或 StringBuilder(int capacity)方法设置底层数组的长度。
2.与日期时间相关的类
关于日期类，只需要掌握如何使用即可。以下是对与日期时间相关的类的总结。
1. java.lang.System类
System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
public static long currentTimeMillis()
测试代码如下：
//1.System类中的currentTimeMillis()
@Test
public void test1(){
long time = System.currentTimeMillis();//ms
//返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
//称为时间戳
System.out.println(time);
}
测试结果如下：
2. Date类
2.1 java.util.Date
Date类的构造器方法很多已经弃用了，我们只需要掌握以下两个构造方法即可。
构造器1:创建一个对应当前时间的Date对象
构造器2:创建指定毫秒数的Date对象
2.2 java.sql.Date类
java.sql.Date类对应着数据库中的日期类型变量
创建java.sql.Date类对象的方式
java.sql.Date --> java.util.Date
java.sql.Date是java.util.Date的子类直接赋值即可
java.util.Date --> ava.sql.Date
java.sql.Date date1 = new java.sql.Date(date.getTime());
对于java.util.Date类我们也只需要掌握以下两种方法即可
toString(): 显示当前的牛，月，日，时，分，秒
getTime(): 获取当前Date对象对应的毫秒数(时间戳)。
时间戳： 即当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
对于以上两种date类测试代码如下：
@Test
public void test2(){
//构造器1:Date:创建一个对应当前时间的Date对象
Date date1 = new Date();
System.out.println(date1.toString());
System.out.println(date1.getTime());
//构造器2:创建指定毫秒数的Date对象
Date date2 = new Date(1222222222222l);
System.out.println(date2.toString());
//创建java.sql.Date对象
java.sql.Date date3 = new java.sql.Date(1222222222222l);
System.out.println(date3.toString());
//java.sql.Date --> java.util.Date
date2 = date3;
System.out.println(date2.toString());
//java.util.Date --> java.sql.Date
//情况1:父类强转子类报错
Date date4 = new java.util.Date(1222222222222l);
java.sql.Date date5 = (java.sql.Date) date4;
//情况2:
Date date6 = new Date();
// java.sql.Date date7 = (java.sql.Date) date6;
java.sql.Date date7 = new java.sql.Date(date6.getTime());
System.out.println(date7);
}
运行结果如下：
3.SimpleDateFormat类
SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。 它允许格式化（日期–>文本），解析（文本–>日期）和归一化。
格式化：日期–>文本
解析：文本–>日期
关于SimpleDateFormat类，我们需要了解如下方法：
- 格式化：
- SimpleDateFormat() ： 默认的模式和语言环境创建对象
- public SimpleDateFormat(String pattern)： 该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用：
- public String format(Date date)： 方法格式化时间对象date
- 解析：
- public Date parse(String source)： 从给定字符串的开始解析文本，以生成一个日期。
测试代码如下：
@Test
public void testSimpleDateFormat() throws ParseException {
//实例化SimpleDateFormat:使用默认的构造器
SimpleDateFormat sdf = new SimpleDateFormat();
//格式化:日期 --> 字符串
Date date = new Date();//创建一个Date对象获取当前时间
// System.out.println(date);//打印当前时间
String format = sdf.format(date);//格式化
System.out.println(format);
//解析: 字符串 --> 日期
String str = "2021/8/12 下午1:58";
Date parse = sdf.parse(str);//解析
System.out.println(parse);
System.out.println("********************按照指定方式格式化和解析：调用带参数的构造器********************");
// SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyy.MMMMM.dd GGG hh:mm aaa");
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//格式化
String format1 = sdf1.format(date);
System.out.println(format1);
//解析:要求字符串必须是符合SimpleDateFormat识别的格式，通过构造器参数体现
//否则，就会抛异常
Date parse1 = sdf1.parse("2021-08-12 02:06:39");
System.out.println(parse1);
}
运行结果如下：
4. java.util.Calendar(日历)类
Calendar类是一个抽象类，主用用于完成日期字段之间相互操作的功能。
Calendar类是一个抽象类，我们就不能通过new关键字去创建它的对象了。
有以下两种方式创建Calendar类的对象
方式一：创建其子类(GregorianCalendar)的对象
方式二：调用其静态方法getInstance()
常用方法
- get(int field)： 返回给定日历字段的值。
- public void set(int field,int value)： 设置字段中的值 YEAR ， MONTH ， DAY_OF_MONTH ， HOUR_OF_DAY ， MINUTE和 SECOND 。
- public void add(int field,int amount)： 根据日历的规则，将指定的时间量添加或减去给定的日历字段。
- public final Date getTime()： 返回一个 Date表示此物体 Calendar的时间值。
- public final void setTime(Date date)： 使用给定的 Date设置此日历的时间。
测试代码如下：
@Test
public void testCalendar(){
//1.Calendar实例化
//方式一：创建其子类(GregorianCalendar)的对象
//方式二：调用其静态方法getInstance()
Calendar calendar = Calendar.getInstance();
// System.out.println(calendar.getClass());
//2.常用方法
//get()
int days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);
System.out.println(+calendar.get(Calendar.DAY_OF_YEAR));
//set()
calendar.set(Calendar.DAY_OF_MONTH,22);
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);
//add()
calendar.add(Calendar.DAY_OF_MONTH,-3);
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);
//getTime():日历类 --> Date
Date date = calendar.getTime();
System.out.println(date);
//setTime():Date --> 日历类
Date date1 = new Date();
calendar.setTime(date1);
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);
}
注意:获取月份时，一月是0，二月是1，以此类推，12月是11
获取星期时:周日是1，周二是2，以此类推，周六是7
运行结果如下：
5.java.time
JDK 8中引入了java.time，其功能非常强大，将来很长一段时间内他都会为我们服务。
java.time 中包含了所有关于本地日期（LocalDate）、本地时间（LocalTime）、本地日期时间（LocalDateTime）、 时区（ZonedDateTime） 和持续时间（Duration） 的类。
5.1 LocalDate、LocalTime、LocalDateTime的使用
LocalDate： LocalDate是一个不可变的日期时间对象，表示日期，通常被视为年月日。 也可以访问其他日期字段，例如日期，星期几和星期。 例如，值“2007年10月2日”可存储在LocalDate 。
LocalTime： LocalTime是一个不可变的日期时间对象，代表一个时间，通常被看作是小时 - 秒。 时间表示为纳秒精度。 例如，值“13：45.30.123456789”可以存储在LocalTime。
LocalDateTime： LocalDateTime是一个不可变的日期时间对象，代表日期时间，通常被视为年 - 月 - 日 - 时 - 分 - 秒。 也可以访问其他日期和时间字段，例如日期，星期几和星期。 时间表示为纳秒精度。 例如，值“2007年10月2日在13：45.30.123456789”可以存储在LocalDateTime 。
| 方法 | 描述 |
|---|---|
| now() | 获取当前的日期、时间、日期和时间 |
| of() | 设置指定的年、月、日、时、分、秒，没有偏移量 |
| getXxx() | 返回相关的属性 |
| withXxx() | 设置相关的属性 |
| plusXxx() | 相关的属性增加相应的值 |
| minusXxx() | 相关的属性减少相应的值 |
测试代码如下：
@Test
public void test1(){
//now():获取当前的日期、时间、日期和时间
LocalDate localDate = LocalDate.now();
LocalTime localTime = LocalTime.now();
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println(localDate);
System.out.println(localTime);
System.out.println(localDateTime);
//of():设置指定的年、月、日、时、分、秒，没有偏移量
LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 6, 13, 23, 43);
System.out.println(localDateTime1);
//getXxx()
System.out.println(localDateTime.getDayOfMonth());
System.out.println(localDateTime.getDayOfWeek());
System.out.println(localDateTime.getMonth());
System.out.println(localDateTime.getMonthValue());
System.out.println(localDateTime.getMinute());
//体现不可变性
//withXxx():设置相关的属性
LocalDate localDate1 = localDate.withDayOfMonth(22);
System.out.println(localDate);
System.out.println(localDate1);
LocalDateTime localDateTime2 = localDateTime.withHour(4);
System.out.println(localDateTime);
System.out.println(localDateTime2);
//体现不可变性
//plusXxx()
LocalDateTime localDateTime3 = localDateTime.plusMonths(3);
System.out.println(localDateTime);
System.out.println(localDateTime3);
//minusXxx()
LocalDateTime localDateTime4 = localDateTime.minusDays(5);
System.out.println(localDateTime);
System.out.println(localDateTime4);
}
测试结果如下：
对于以上代码段：
LocalDate localDate1 = localDate.withDayOfMonth(22);
System.out.println(localDate);
System.out.println(localDate1);当我们去设置相关属性值的时候，需要一个新的对象接收。
这就体现了LocalDate是不可变时间对象。
5.2 Instant
Instant：时间戳
| 方法 | 描述 |
|---|---|
| ofEpochMilli(long epochMilli) | 返回在1970-01-01 00:00:00基础上加上指定毫秒数之后的Instant类的对象 |
| atOffset(ZoneOffset offset) | 将此瞬间与偏移组合起来创建一个 OffsetDateTime 。 |
| toEpochMilli() | 将此瞬间转换为1970-01-01T00：00：00Z的时期的毫秒数。 |
测试代码如下：
@Test
public void testInstant(){
//now():获取本初子午线对应的时间
Instant instant = Instant.now();
System.out.println(instant);//2021-08-12T08:06:07.957071300Z
//与我们的时间相差8个小时
//添加时间的偏移量
OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
System.out.println(offsetDateTime);
//toEpochMilli():获取对应的毫秒数(距1970年01月01日0时0分0秒)UTC --> Date类的getTime()
long l = instant.toEpochMilli();
System.out.println(l);
//ofEpochMilli():通过给定的毫秒数，获取Instant实例 --> Date(long millis)
Instant instant1 = Instant.ofEpochMilli(1550475314878l);
System.out.println(instant1);
}
测试结果如下：
6.DateTimeFormatter类
DateTimeFormatter类：格式化器用于打印和解析日期时间对象。
| 方法 | 描述 |
|---|---|
| ofPattern(String pattern) | 返 回 一 个 指 定 字 符 串 格 式 的 |
| DateTimeFormatter | |
| format(TemporalAccessor t) | 格式化一个日期、时间，返回字符串 |
| parse(CharSequence text) | 将指定格式的字符序列解析为一个日期、时间 |
该类共有三种格式化的方式，重点掌握第三种
方式一:预定义的标准格式。
方式二:本地化相关的格式。
方式三:自定义的格式(重点)
废话不多说，直接看代码，仔细看注释，跟着代码走
测试代码如下：
@Test
public void testDateTimeFormat(){
//方式一:预定义的标准格式。
DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
//格式化:日期 --> 字符串
LocalDateTime localDateTime = LocalDateTime.now();
String str1 = formatter.format(localDateTime);
System.out.println(localDateTime);
System.out.println(str1);
//解析: 字符串 --> 日期
TemporalAccessor parse = formatter.parse(str1);
System.out.println(parse);
//方式二:本地化相关的格式。
//本地化相关格式。如:ofLocalizedDateTime()
//FormatStyle.SHORT / FormatStyle.MEDIUM / FormatStyle.LONG 适用于LocalDateTime
// DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
// 为什么是LONG就出错
DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
//格式化
String str2 = formatter1.format(localDateTime);
System.out.println(localDateTime);
System.out.println(str2);//SHORT : 2021/8/12 下午4:30
本地化相关格式。如:ofLocalizedDate()
//FormatStyle.SHORT / FormatStyle.MEDIUM / FormatStyle.LONG / FormatStyle.FULL 适用于LocalDate
DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
//格式化
String str3 = formatter2.format(LocalDate.now());
System.out.println(str3);//2021年8月12日星期四
//解析
TemporalAccessor parse1 = formatter2.parse(str3);
System.out.println(parse1);
//方式三:自定义的格式(重点)
//ofPattern("yyyy-MM-dd hh:mm:ss ")
DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
//格式化
String str4 = formatter3.format(localDateTime.now());
System.out.println(str4);
//解析
TemporalAccessor parse2 = formatter3.parse(str4);
System.out.println(parse2);
}
测试结果如下：
3.System类
概述
当我们编写第一个java程序的时候，我们在主函数里写到 System.out.println(“hello world!”); 其实这就是我们将要讲述的System类所提供的方法。当我们对System类有所了解后，我们就可以对上述语句进行更准确的分析。我们不仅要知道怎么写，而且要知道为什么这样写。接下来将对System类进行详解。
System类代表系统类，位于java.lang包下。系统级的很多属性和控制方法都放置在该类的内部。System类是被private修饰，所以不能创建System类的对象。System类提供了一些类变量和方法，允许直接通过System类来调用这些类变量和方法。
System类提供了代表标准输入、标准输出和错误输出的类变量，并提供了一些静态方法用于访问环境变量、系统属性的方法，还提供了加载文件和动态链接库的方法。
我们通过System的源码可以看到，System内定义了三个成员变量，分别是err，in，out，分别对应上述的标准错误输出流，标准输入流，标准输出流。
我们在我的Java编程练习day01都练习过。
out是PrintStream的final static来修饰的，所以，out是可以调用printStream中的方法的。
那么我们就可以对我们写的第一个语句System.out.println(“hello world!”);进行说明了。
System.out.println(“hello world!”);
即调用了System的成员变量out(标准输出流)的println()方法
System类的常用方法
1.currentTimeMillis(): 返回当前时间，以毫秒为单位。即返回当前时间距1970年1月1日0时0分0秒的毫秒数。
2.exit(int status): 终止当前运行的Java虚拟机。通俗的说，就是退出当前程序。当参数为0时表示正常退出，否则为异常退出。
3.gc(): 运行垃圾回收器。
4.getProperty(String key): 获取指定键指示的系统属性。
常见的属性名和属性的作用如下：
| 属性名 | 属性说明 |
|---|---|
| java.version | java运行时环境版本 |
| java.home | java安装目录 |
| os.name | 操作系统的名称 |
| os.version | 操作系统的版本 |
| user.name | 用户的账户名称 |
| user.home | 用户的主目录 |
| user.dir | 用户的当前工作目录 |
测试代码如下:
@Test
public void test1(){
String javaVersion = System.getProperty("java.version");
System.out.println("java的version:" + javaVersion);
String javaHome = System.getProperty("java.home");
System.out.println("java的home:" + javaHome);
String osName = System.getProperty("os.name");
System.out.println("os的name:" + osName);
String osVersion = System.getProperty("os.version");
System.out.println("os的version:" + osVersion);
String userName = System.getProperty("user.name");
System.out.println("user的name:" + userName);
String userHome = System.getProperty("user.home");
System.out.println("user的home:" + userHome);
String userDir = System.getProperty("user.dir");
System.out.println("user的dir:" + userDir);
}
运行结果如下：
4.Math类
java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回
值类型一般为double型。
| 方法 | 说明 |
|---|---|
| abs | 绝对值 |
| acos,asin,atan,cos,sin,tan | 三角函数 |
| sqrt | 平方根 |
| pow(double a,doble b) | a的b次幂 |
| log | 自然对数 |
| exp | e为底指数 |
| max(double a,double b) | 返回二者中的最大值 |
| min(double a,double b) | 返回二者中的最小值 |
| random() | 返回0.0到1.0的随机数 |
| long round(double a) | double型数据a转换为long型（四舍五入） |
| toDegrees(double angrad) | 弧度—>角度 |
| toRadians(double angdeg) | 角度—>弧度 |
| ceil() | 向上取整 |
| floor() | 向下取整 |
| round() | 四舍五入 |
测试代码如下：
@Test
public void test(){
System.out.println("-1.0的绝对值:"+Math.abs(-1.0)); //绝对值
System.out.println("81.0的平方根:"+Math.sqrt(81.0)); //平方根
System.out.println("sin(1.0)的值:"+Math.sin(1.0)); //三角函数
System.out.println("2^10 = "+Math.pow(2,10)); //幂
System.out.println("log 1 = "+Math.log(1.0)); //自然对数
System.out.println("e^1 = "+Math.exp(1.0)); //e为底的指数
System.out.println("13 和 14 哪个大:"+Math.max(13,14)); //两者之间较大的
System.out.println("13 和 14 哪个小:"+Math.min(13,14)); //两者之间较小的
System.out.println("随机数:"+Math.random()); //随机数
System.out.println("1.5向上取整:"+Math.ceil(1.5)); //向上取整
System.out.println("1.5向下取整:"+Math.floor(1.5)); //向下取整
System.out.println("4.7四舍五入:"+Math.round(4.7)); //四舍五入
System.out.println("4.4四舍五入:"+Math.round(4.4)); //四舍五入
System.out.println("弧度—>角度"+Math.toDegrees(23));//弧度—>角度
System.out.println("角度—>弧度"+Math.toRadians(23));//角度—>弧度
}
运行结果如下：
这里讲一下Math类的round方法，它表示“四舍五入”，算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整。
5.BigInteger类与BigDecimal类
BigInteger
概述
Integer类作为int的包装类，能存储的最大整型值为231 - 1，Long类也是有限的，最大为263-1。。如果我们想要表示的数字比它们所表示的最大数值都要大，那又该如何表示呢。
java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供了所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。
接下来，我将介绍BigInteger的相关内容。
创建BigInteger的对象
BigInteger有如下构造器：
BigInteger(String val)：根据字符串构建BigInteger对象
示例如下：
BigInteger num = new BigInteger("100000000000000000000000000000");
BigInteger类的常用方法
| 方法 | 说明 |
|---|---|
| public BigInteger abs() | 返回此 BigInteger 的绝对值的 BigInteger。 |
| BigInteger add(BigInteger val) | 返回其值为 (this + val) 的 BigInteger |
| BigInteger subtract(BigInteger val) | 返回其值为 (this - val) 的 BigInteger |
| BigInteger multiply(BigInteger val) | 返回其值为 (this * val) 的 BigInteger |
| BigInteger divide(BigInteger val) | 返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分。 |
| BigInteger remainder(BigInteger val) | 返回其值为 (this % val) 的 BigInteger。 |
| BigInteger[] divideAndRemainder(BigInteger val) | 返回包含 (this / val) 后跟(this % val) 的两个 BigInteger 的数组。 |
| BigInteger pow(int exponent) | 返回其值为 (thisexponent) 的 BigInteger。 |
测试代码如下：
@Test
public void test(){
BigInteger num1 = new BigInteger("-123123123123123123123123");
BigInteger num2 = new BigInteger("123456789123456789123456");
//绝对值
BigInteger num3 = num1.abs();
System.out.println(num1+"的绝对值:"+num3);
//加
num3 = num1.add(num2);
System.out.println(num1 +"+"+ num2+"="+num3);
//减
num3 = num1.subtract(num2);
System.out.println(num1 +"-"+ num2+"="+num3);
//乘
num3 = num1.multiply(num2);
System.out.println(num1 +"×"+ num2+"="+num3);
//除 整数相除只保留整数部分
num3 = num1.divide(num2);
System.out.println(num1 +"÷"+ num2+"="+num3);
//求余
num3 = num1.remainder(num2);
System.out.println(num1 +"%"+ num2+"="+num3);
//返回包含 (this / val) 后跟(this % val) 的两个 BigInteger 的数组
BigInteger[] num = num1.divideAndRemainder(num2);
for (BigInteger c:num) {
System.out.println(c);
}
//幂
num3 = num1.pow(2);
System.out.println(num1+"的平方:"+num3);
}
运行结果如下：
BigDecimal
一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。
BigDecimal类支持不可变的、任意精度的有符号十进制定点数。
创建BigDecimal的对象
BigDecimal有如下构造器：
public BigDecimal(double val)
public BigDecimal(String val)
BigDecimal类的常用方法
加：public BigDecimal add(BigDecimal augend)
减：public BigDecimal subtract(BigDecimal subtrahend)
乘：public BigDecimal multiply(BigDecimal multiplicand)
除：public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
测试代码如下：
@Test
public void test(){
BigDecimal num1 = new BigDecimal("12435.351");
BigDecimal num2 = new BigDecimal("11");
System.out.println(num1 +"+"+ num2+"="+num1.add(num2));
System.out.println(num1 +"-"+ num2+"="+num1.subtract(num2));
System.out.println(num1 +"×"+ num2+"="+num1.multiply(num2));
System.out.println(num1 +"÷"+ num2+"="+num1.divide(num2, 15, BigDecimal.ROUND_HALF_UP));
}
运行结果如下：
477
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
