第八章 常用类
作者：互联网
第八章 常用类
包装类(Wrapper)
概念
把基本数据包装成对象的特殊类型.
目的是让基本数据也具有对象的特征,比如调用方法.
| 基本数据类型 | 包装类 |
|---|---|
| boolean | Boolean |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| char | Character |
| float | Float |
| double | Double |
特点
-
包装类对象之间不可像基本值一样兼容
-
Double不能兼容Float
-
Long不能兼容Integer
装箱: boxing
基本数据值 => 对象
Integer obj = new Integer(200);
手工装箱
Xxx obj = new Xxx(xxx);
Xxx obj = new Xxx("xxx");
Xxx obj = Xxx.valueOf(xxx);
Xxx obj = Xxx.valueOf("xxx");
自动装箱
Xxx obj = xxx;
拆箱 : unboxing
对象 => 基本数据值
int n = obj.intValue();
手工拆箱
xxx = obj.xxxValue();
自动拆箱
xxx = obj;
String 与 基本数据类型之间转换
String => 基本数据类型
String s = "xxx";
xxx = Xxx.parseXxx(s);
基本数据类型 => String
String s = "" + xxx;//野路子
String s = String.valueof(xxx);正规做法
具体实例
public class WrapperTest {
@Test
public void test3() {
Boolean obj1 = new Boolean(false);
Boolean obj2 = new Boolean("true");
Boolean obj3 = Boolean.valueOf(true);
Boolean obj4 = Boolean.valueOf("false");
System.out.println("obj1 = " + obj1);
System.out.println("obj2 = " + obj2);
System.out.println("obj3 = " + obj3);
System.out.println("obj4 = " + obj4);
// 拆箱
boolean b1 = obj1.booleanValue();
boolean b2 = obj2;
String s1 = "true";
// String => boolean值
boolean b3 = Boolean.parseBoolean(s1);
// 基本值 => String
// "" + 基本值
String s2 = "" + b3;
Object[] arr = {3.22, 24.4f, 234L, 342, false, 'c'};
}
@Test
public void test2() {
Double obj1 = new Double(3.22); // 手工装箱
Double obj2 = new Double("234234.234234");
Double obj3 = Double.valueOf(2.322);
Double obj4 = Double.valueOf("234234.234");
Double obj5 = 9234.23423; // 自动装箱
//Double obj6 = 324; 不可以
//Double obj7 = 2.23f; 不兼容
Float obj8 = 3.88f;
double v1 = obj1.doubleValue(); // 手工拆箱
double v2 = obj2; // 自动拆箱
String s1 = "234234.23423";
// String => double值
double v3 = Double.parseDouble(s1);
System.out.println(v3);
}
// 练习 : 声明2个字符串, 内容是2个整数, 把第一个转换为int, 再装箱, 把第2个字符串直接装箱(String=>Integer)查API
// 手工拆箱求和, 自动拆箱求积, 并打印输出.
@Test
public void exer1() {
String s1 = "239";
String s2 = "823";
int n1 = Integer.parseInt(s1);
Integer obj1 = new Integer(n1);
//Integer obj2 = new Integer(s2);
//Integer obj2 = Integer.decode(s2); // 没问题
//Integer obj2 = Integer.getInteger(s2); // 有问题
Integer obj2 = Integer.valueOf(s2); // 没问题
int sum = obj1.intValue() + obj2.intValue();
System.out.println("sum = " + sum);
int multi = obj1 * obj2;
System.out.println("multi = " + multi);
}
@Test
public void test1() {
Integer obj1 = new Integer(50); // 手工装箱
Integer obj2 = 500; // 自动装箱 , Integer obj2 = new Integer(500);
int n1 = obj1.intValue(); // 手工拆箱
int n2 = obj2; // 自动拆箱
Object obj3 = 300;
System.out.println(obj1);
System.out.println(obj2);
System.out.println(n1);
System.out.println(n2);
String s1 = "234234";
// 工具方法, String => int
int n3 = Integer.parseInt(s1);
// int = > String
int n4 = 32842;
String s2 = "" + n4;
if (obj1 == 50) { // obj.intValue() == 50
System.out.println("llllll");
}
if (obj2 > 30) { // 自动拆箱
}
}
}
拓展(面试题)
public class WrapperTest {
@Test
public void method1() {
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j); // 比较地址 : false
Integer m = 1; // 自动装箱时, 如果数据在[-128~127], 取缓冲区中的现成的对象
Integer n = 1;
System.out.println(m == n);
Integer x = 128; // 128大于127, 所以装箱时会直接new Integer(...)
Integer y = 128;
System.out.println(x == y);
}
@Test
public void test1() {
Integer obj1 = new Integer(200);
Integer obj2 = 100;
Double obj3 = 3.22;
Float obj4 = 92.22f;
Long obj5 = 34234L;
int i = obj1.intValue();
double v = obj3.doubleValue();
float f = obj4;
long l = obj5;
}
}
字符串相关类
含义
String类：构造字符串对象
特点
-
字符串 是最重要的类, 没有之一.
-
字符串就是内容不可改变的Unicode字符序列. 字符串在字符串中的位置索引是固定的.
-
任何的对于字符串内容的修改都必须会产生新对象. 如果要频繁修改字符串内容, 效率非常低.
-
字符串 底层就是一个char[]
字符串的特性
-
String是一个final类，代表不可变的字符序列
-
字符串是不可变的。一个字符串对象一旦被配置，其内容是不可变的。
String类较常用构造方法
String s1 = new String();
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startIndex,int count)
创建字符串对象
@Test
public void test1() {
// 创建字符串对象
String s1 = new String(); // String s1 = "";, 空串表示有对象, 但是没有内容.
String s2 = null; // null表示啥也没有
String s3 = new String("abc"); // 产生的新对象和参数中的对象不是一回事
char[] arr = {'a', '我', '1', '3', 'G', 'X', '9', '你'};
String s4 = new String(arr); // 把字符数组变成字符串
System.out.println("s4 = " + s4);
// 第2个参数表示数组的开始下标, 第3个参数表示要选取几个字符
String s5 = new String(arr, 2, 4); // 字符数组的一部分 创建字符串
System.out.println("s5 = " + s5);
}
字符串常量池
所有的字符串常量 都直接保存在 永久区中的常量区中.
@Test
public void test2() {
//String s1 = "abcd"; // 字符串常量
final String s1 = "yewu"; // 常量区
String s2 = "java"; // 常量区
String s4 = "java"; // 常量区
String s3 = new String("java"); // GC区
System.out.println(s2 == s3); // false
System.out.println(s2 == s4); // true, 不要错以为字符串就可以这样比较!!!
System.out.println(s2.equals(s3)); // 比较内容, true
System.out.println("************************************");
String s5 = "yewujava"; // 常量区
String s6 = s1 + s2; // 字符串拼接时, 如果有变量参与, 它的拼接结果在gc区
System.out.println(s5 == s6); // false
System.out.println(s5.equals(s6)); // true
String s7 = s1 + "java"; // 如果全部都是常量的拼接,结果在常量区
System.out.println(s5 == s7);
String s8 = (s1 + s2).intern(); // 把在GC区中的字符串强行放入常量区, 如果常量区中没有此串,则创建新的,
// 如果有, 则返回已有串的地址.
// intern方法有可能会导致常量区暴满. java8中保存类模板数据的内存空间独立出来,称为元空间(meta space)
System.out.println(s5 == s8); // true
String s9 = new String("yyyzzz");
//String s10 = new String("yyy");
String s10 = s9;
String s11 = new String("yyy" + "zzz");
System.out.println(s9 == s10);
}
String类常用方法
-
public int length()
-
public char charAt(int index)
-
public char[] toCharArray()
-
public boolean equals(Object anObject)
-
public int compareTo(String anotherString)
-
public int indexOf(String str)
-
public int indexOf(String str ,int fromIndex)
-
public int lastIndexOf(String str)
-
public int lastIndexOf(String str ,int fromIndex)
-
public boolean startsWith(String prefix)
-
public boolean endsWith(String suffix)
-
public String substring(int beginIndex,int endIndex)
-
public String substring(int beginIndex)
-
public String replace(char oldChar,char newChar)
-
public String replaceAll(String old,String new)
-
public String trim()
-
public String concat(String str)
-
public String toUpperCase()
-
public String toLowerCase()
-
public String[] split(String regex)
字符串实例
0 2 6 10 16 23 29 35 37
String str = " abc XYZ 我喜欢你, 你喜欢我吗? 我不喜欢你 zzz 123 ";
| 方法 | 含义 | 实例 |
|---|---|---|
| ## public int length() | 获取数组串的长度, 字符数 | str.length() => 38 |
| ## public char charAt(int index) | 获取指定下标index位置处的字符 arr[index] | str.charAt(7) => 'Y', str.charAt(25) => '喜' |
| public char[] toCharArray() | 把字符串转换为相应的字符数组, 返回的是内部数组的一个副本 | |
| ### public boolean equals(Object anObject) | 比较两个字符串的内容是否相f等, 这是比较字符串必须要使用, 不可以使用== | |
| public boolean equalsIgnoreCase(String other) | 比较两个字符串的内容是否相等, 忽略大小写. | |
| ##### public int indexOf(String str) | 获取参数中的子串在当前串中首次出现的下标 | str.indexOf("喜欢") => 11 |
| public int indexOf(String str ,int fromIndex) | 获取参数中的子串在当前串中首次出现的下标, 从指定下标fromIndex开始检索，如果没有，返回-1 | str.indexOf("喜欢", 12) => 17 str.indexOf("喜欢", 18) => 25 str.indexOf("喜欢", 26) => -1 |
| public int lastIndexOf(String str) | 获取参数中的子串在当前串中首次出现的下标, 从右向左检索 | str.lastIndexOf("喜欢") => 25 |
| public int lastIndexOf(String str ,int fromIndex) | 获取参数中的子串在当前串中首次出现的下标, 从指定下标fromIndex开始检索，从右向左检索如果没有，返回-1 | str.lastIndexOf("喜str.lastIndexOf("喜欢", 24) => 17 str.lastIndexOf("喜欢", 16) => 11 str.lastIndexOf("喜欢", 10) => -1 |
| public boolean startsWith(String prefix) | 判断当前串是否以参数指定的子串为开始 | str.startsWith(" abc") => true |
| public boolean endsWith(String suffix) | 判断当前串是否以参数指定的子串为结束 | str.endsWith("zzz 123") => false |
| ##### public String substring(int beginIndex,int endIndex) | 从当前串中取子串, 从beginIndex(包含)开始到endIndex(不包含)结束 | str.substring(10, 21) => "我喜欢你, 你喜欢我吗", 子串长度 = 结束索引-开始索引 str.substring(23, str.length()); 从23开始, 取到末尾 |
| public String substring(int beginIndex) | 取子串, 从beginIndex(包含)取到末尾 | str.substring(23); |
| ### public String replace(char oldChar,char newChar) | 替换字符串中所有的oldChar为newChar | str.replace(' ', '#'); |
| public String replace(CharSequence old, CharSequence replacement) | 替换字符串中所有的old子串为新串replacement | |
| public String trim() | 修剪字符串首尾的空白字符(码值小于等于32), 产生新串 | str.strim() => "abc XYZ 我喜欢你, 你喜欢我吗? 我不喜欢你 zzz 123" |
| public String concat(String str) | 字符串连接, 和 + 一样的效果 | |
| public String toUpperCase() | 变大写字母 | |
| public String toLowerCase() | 变小写字母 | |
| public String[] split(String regex) | 以参数中的子串为切割器, 把字符串切割成多个部分, 切割完成后的切割器就被丢弃 | |
| ## public static String valueOf(...) | 把任意数据转换为相应的字符串内容 |
数组的复制方法
public static native void arraycopy ()
System.arraycopy(value, 0, result, 0, value.length);
第1个参数是源数组对象, 第2个参数是源数组的开始下标, 第3个参数是目标数组对象, 第4个参数是目标数组的开始下标.第5个参数是要复制的元素个数
public class StringTest {
@Test
public void test8() {
String s1 = "abcXYZ";
String s2 = "ABCxyz";
System.out.println(s1.equals(s2));
//s2 = null;
System.out.println(s1.equalsIgnoreCase(s2));
System.out.println(s1.toUpperCase().equals(s2.toUpperCase()));
}
@Test
public void test7() {
String s = "abasd,laksdjf,134234234,我和你,QQQQQ,大家好";
String[] split = s.split(",");
for (String s1 : split) {
System.out.println(s1);
}
System.out.println("*******************************************");
String path = "D:\\yewu\\02_Program\\Java\\jdk1.8.0_321\\bin;C:\\Windows\\system32;C:\\Windows;D:\\MyProgram\\_MyBin;C:\\Windows\\System32\\Wbem;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;C:\\Windows\\System32\\OpenSSH\\";
String[] split1 = path.split(";");
for (String s1 : split1) {
System.out.println(s1);
}
}
@Test
public void test6() {
String str = " abc XYZ 我喜欢你, 你喜欢我吗? 我不喜欢你 zzz 123 ";
String s1 = str.toUpperCase();
String s2 = str.toLowerCase();
System.out.println(s1);
System.out.println(s2);
}
@Test
public void test5() {
String str = " \r\nabc XYZ 我喜欢你, 你喜欢我吗? 我不喜欢你 zzz 123 QQQQjklsadflkja \n \t ";
System.out.println(str);
String trim = str.trim();
System.out.println(trim);
}
@Test
public void test4() {
String str = " abc XYZ 我喜欢你, 你喜欢我吗? 我不喜欢你 zzz 123 ";
String replace = str.replace(' ', '#');
System.out.println(replace);
String replace1 = str.replace(" ", ""); // 消除所有空格
System.out.println(replace1);
String replace2 = str.replace("", "$");
System.out.println(replace2);
}
// 将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefg”反转为”abfedcg”
@Test
public void exer22() {
String str = "abcdefghijklmn";
int beginIndex = 2;
int endIndex = 9; // c ~ i
char[] chars = str.toCharArray();
for (int i = 0; i < (endIndex - beginIndex) / 2; i++) {
char tmp = chars[beginIndex];
chars[beginIndex] = chars[endIndex - 1];
chars[endIndex - 1] = tmp;
beginIndex++;
endIndex--;
}
String result = new String(chars);
System.out.println(result);
}
@Test
public void exer2() {
String str = "abcdefghijklmn";
int beginIndex = 2;
int endIndex = 9; // c ~ i
// 剪切成3段, 只反转中间部分即可.
String s1 = str.substring(0, beginIndex);
String s2 = str.substring(beginIndex, endIndex);
String s3 = str.substring(endIndex);
char[] chars = s2.toCharArray();
for (int i = 0; i < chars.length / 2; i++) {
char tmp = chars[i];
chars[i] = chars[chars.length - 1 - i];
chars[chars.length - 1 - i] = tmp;
}
String result = s1 + new String(chars) + s3;
System.out.println(result);
}
@Test
public void test3() {
String str = " abc XYZ 我喜欢你, 你喜欢我吗? 我不喜欢你 zzz 123 ";
String substring = str.substring(10, 21);
System.out.println(substring);
String substring1 = str.substring(23, str.length()); // 从下标23开始, 取到末尾
System.out.println(substring1);
String substring2 = str.substring(23); // 和上面的调用是一样的效果.
System.out.println(substring2);
System.out.println(substring1.equals(substring2));
}
@Test
public void test2() {
String str = " abc XYZ 我喜欢你, 你喜欢我吗? 我不喜欢你 zzz 123 ";
System.out.println(str.startsWith(" abc"));
System.out.println(str.endsWith("zzz 123 "));
}
/*获取一个字符串在另一个字符串中出现的次数。
比如：获取"ab"在 "abkkcadkabkebfkabkskab"中出现的次数 */
@Test
public void exer1() {
String s1 = "abkkcadkabkebfkabkskab";
String s2 = "ab";
int count = 0;
int beginIndex = 0;
while (true) {
int index = s1.indexOf(s2, beginIndex);
if (index == -1) { //if (检索失败) {
break;
}
count++;
// beginIndex向右变化
beginIndex = index + 1;
}
System.out.println("count = " + count);
}
@Test
public void test1() {
String str = " abc XYZ 我喜欢你, 你喜欢我吗? 我不喜欢你 zzz 123 ";
//int index1 = str.indexOf("喜欢");
int index1 = str.indexOf("喜欢", 0);
System.out.println("index1 = " + index1);
int index2 = str.indexOf("喜欢", index1 + 1);
System.out.println("index2 = " + index2);
int index3 = str.indexOf("喜欢", index2 + 1);
System.out.println("index3 = " + index3);
int index4 = str.indexOf("喜欢", index3 + 1);
System.out.println("index4 = " + index4);
}
}
StringBuffer类
概念
StringBuilder : 内容可以改变的Unicode字符序列, 内部也是使用一个char[]来保存所有字符
特点
-
可以对字符串内容进行增删
-
它像一个容器,里面有大量的字符, 可以保存任意多个字符.
-
StringBuffer是一个容器
构造方法(构造器)
StringBuffer类有三个构造方法：
-
StringBuffer()初始容量为16的字符串缓冲区
-
StringBuffer(int size)构造指定容量的字符串缓冲区
-
StringBuffer(String str)将内容初始化为指定字符串内容
@Test
public void test1() {
StringBuilder sb1 = new StringBuilder(); // 默认创建容量为16的char[]
StringBuilder sb2 = new StringBuilder(2048); // 直接创建容量为2048的char[]
String s1 = "abcd";
StringBuilder sb3 = new StringBuilder(s1); // 创建容量为s1.length() + 16的char[]
}
StringBuffer类的常用方法
| 方法 | 含义 |
|---|---|
| StringBuilder append(...) | 在当前串的末尾追加新的内容, 内部内容就会变化. 为了和字符串的+操作保持一致 |
| StringBuilder insert(int index, String str) | 在指定下标index位置处插入任意内容. |
| StringBuilder delete(int beginIndex, int endIndex) | 删除从beginIndex开始到endIndex结束的区间. |
| public void setCharAt(int index, char newCh) | 替换指定下标index位置的字符为新字符newCh |
其他方法与String类相似
StringBuffer append(String s), StringBuffer append(int n) ,
StringBuffer append(Object o) , StringBuffer append(char n),
StringBuffer append(long n), StringBuffer append(boolean n),
StringBuffer insert(int index, String str)
public StringBuffer reverse()
StringBuffer delete(int startIndex, int endIndex)
public char charAt(int n )
public void setCharAt(int n ,char ch)
StringBuffer replace( int startIndex ,int endIndex, String str)
public int indexOf(String str)
public String substring(int start,int end)
public int length()
具体实例
@Test
public void exer1() {
String s1 = "abcde";
String s2 = "234234234";
String s3 = "我是汉字啊啊啊";
String s4 = "ADSFASD";
StringBuilder sb = new StringBuilder(s1);
sb.append(s2).insert(0, s3).insert(5, s4).delete(7, 12);
// "我是汉字啊AD啊啊abcde234234234
System.out.println(sb);
}
@Test
public void test3() {
StringBuilder sb = new StringBuilder(); // 内部数组长度为16
// 链式调用
sb.append("abc").append(false).append(32).append(29.23).insert(3, "我是汉字").delete(5, 10);
System.out.println(sb); // abc我是se3229.23
}
@Test
public void test2() {
StringBuilder sb = new StringBuilder(); // 内部数组长度为16
sb.append("abc");
sb.append(false);
sb.append(32);
sb.append(29.23); // "abcfalse3229.23"
System.out.println(sb);
System.out.println(sb.length());
sb.append('好');
sb.append('坏'); // 此时数组已满, 再添加这个字符时就会触发扩容操作.
// 扩容 : 原容量 * 2 + 2
sb.insert(3, "我是汉字"); // "abc我是汉字false3229.23";
System.out.println(sb);
sb.delete(5, 10);
System.out.println(sb); // abc我是se3229.23
sb.setCharAt(3, '你');
System.out.println(sb);
}
StringBuilder类
概念
StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且方法也一样
区别
-
String：不可变字符序列
-
StringBuffer：可变字符序列、效率低、线程安全
-
StringBuilder(JDK1.5)：可变字符序列、效率高、线程不安全
-
StringBuffer 是老的API, 效率低, 线程安全
-
StringBuilder 是新的API, 效率高, 线程不安全(首选)
String使用陷阱：
string s="a"; //创建了一个字符串 s=s+"b"; //实际上原来的"a"字符串对象已经丢弃了，现在又产生了一个字符串s+"b"（也就是"ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能。
三者的效率测试
@Test
public void test4() {
String text = "";
long startTime = 0L;
long endTime = 0L;
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 test5() {
String str = null;
StringBuffer sb = new StringBuffer();
sb.append(str);
System.out.println(sb.length());//4
System.out.println(sb);//null
//相当于：String s2 = "" + null;
//System.out.println(s2);
StringBuffer sb1 = new StringBuffer(str); // 出现空指针异常，相当于刷入null
System.out.println(sb1);//
}
日期类
java.lang.System类
System类提供的public static long currentTimeMillis()
用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
此方法适于计算时间差。
@Test
public void test1() {
long time = System.currentTimeMillis(); // 距离1970-01-01 00:00:00.000
System.out.println(time);
System.gc();
try {
System.exit(0);
boolean b = true;
if (b) {
return;
}
System.out.println("abcd");
} finally {
System.out.println("lkjkljlkjlkj"); // ?
}
}
System.gc();(了解)
System.gc()用于垃圾收集器，调用垃圾收集器将回收未使用的
System.gc()进行回收的准则：
-
回收没有被任何可达变量指向的对象
-
JDK实现
-
调用了Runtime类的gc方法
Runtime类的gc方法是个native方法，只能进入JVM代码去看其真正的实现
4. JVM实现
直接调用了JVM_GC()方法，在jvm.cpp中实现的
SimpleDateFormat类
日期显示
@Test
public void test2() {
long time = System.currentTimeMillis(); // 距离1970-01-01 00:00:00.000
System.out.println(time);
Date date = new Date();
System.out.println(date);
// 格式化器, 把日期串格式化成想要的样子
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.S D E");
String format = sdf.format(date);
System.out.println(format);
SimpleDateFormat字母索引表
-
Letter Date or Time Component Presentation Examples GEra designator Text ADyYear Year 1996;96YWeek year Year 2009;09MMonth in year (context sensitive) Month July;Jul;07LMonth in year (standalone form) Month July;Jul;07wWeek in year Number 27WWeek in month Number 2DDay in year Number 189dDay in month Number 10FDay of week in month Number 2EDay name in week Text Tuesday;TueuDay number of week (1 = Monday, ..., 7 = Sunday) Number 1aAm/pm marker Text PMHHour in day (0-23) Number 0kHour in day (1-24) Number 24KHour in am/pm (0-11) Number 0hHour in am/pm (1-12) Number 12mMinute in hour Number 30sSecond in minute Number 55SMillisecond Number 978zTime zone General time zone Pacific Standard Time;PST;GMT-08:00ZTime zone RFC 822 time zone -0800XTime zone ISO 8601 time zone -08;-0800;-08:00
常用方法
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.S D E"); ：格式化器, 把日期串格式化成想要的样子
String xxx = sdf.formate(日期对象)：将日期对象转换为字符串
Date xxx = sdf.pase(日期字符串)：把字符串解析为日期对象
@Test
public void test3() {
long time = System.currentTimeMillis(); // 距离1970-01-01 00:00:00.000
System.out.println(time);
Date date = new Date();
System.out.println(date);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String format = sdf.format(date);
System.out.println(format);
String str = "1999-02-05 12:30:40";
try {
Date parse = sdf.parse(str); // 把字符串解析为日期对象
System.out.println(parse);
} catch (ParseException e) {
e.printStackTrace();
}
String format1 = sdf.format(time);// 格式化毫秒
System.out.println(format1);
}
小时钟
import java.util.Date;
// 练习 : 写一个小时钟
public class Clock {
public static void main(String[] args) throws Exception {
java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
while (true) {
//Date date = new Date();
long time = System.currentTimeMillis();
String str = sdf.format(time);
//System.out.print("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b" + str);
System.out.print("\r" + str);
Thread.sleep(1000);//方法：休眠一秒钟
}
}
}
Date类
-
默认的toString() 是垃圾,
-
创建对象有年1900问题
-
月数据会多1
@Test
public void test4() {
Date date = new Date(2008 - 1900, 7, 8);
System.out.println(date);
}
Calendar类
-
toString() 不好.
-
内部用一个数组来保存所有数据. 访问数据不方便, 必须得提供下标.
-
月份数据差1
-
最大问题是内容可以改变. 导致历史数据无法还原.
@Test
public void test5() {
//Calendar calendar = new Calendar();
Calendar cal = Calendar.getInstance();// 工厂方法获取对象
System.out.println(cal);
// cal.getYear(); 无法直接获取年
int year = cal.get(Calendar.YEAR); // get(1)
System.out.println("year = " + year);
//cal.getMonth(); 无法直接获取月
int month = cal.get(Calendar.MONTH);// get(2)
System.out.println("month = " + month); // 内部的月数据比真实的月小1
int day = cal.get(Calendar.DAY_OF_MONTH); //
System.out.println("day = " + day);
// 设置年
//cal.setYear(2008);
cal.set(Calendar.YEAR, 2008);
cal.set(Calendar.MONTH, 7);
cal.set(Calendar.DAY_OF_MONTH, 8);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date time = cal.getTime();
System.out.println(sdf.format(time));
cal.add(Calendar.YEAR, 10); // 奥运会的10年后
time = cal.getTime();
System.out.println(sdf.format(time));
cal.add(Calendar.DAY_OF_MONTH, -800); // 奥运会的10年后的800天以前
time = cal.getTime();
System.out.println(sdf.format(time));
// 中间值不好还原
}
练习
// 练习 : 创建对象获取当前时间的Calendar, 把它设置为你的生日, 再获取你的百日, 打印输出.
@Test
public void exer() {
Calendar instance = Calendar.getInstance();
// 1978, 6, 9
instance.set(Calendar.YEAR, 1978);
instance.set(Calendar.MONTH, 5);
instance.set(Calendar.DAY_OF_MONTH, 9);
instance.add(Calendar.DAY_OF_MONTH, 100);
System.out.println(instance.getTime());
}
LocalDate、LocalTime、LocalDateTime类
java8新推的 : 内容不可改变, 所以对于它的改变都会产生新对象.
LocalDate : 纯日期 private final int year; private final short month; private final short day;
每个对象正好是8字节, 是最优的存储方案
LocalTime : 纯时间
LocalDateTime : 日期时间
常用方法
| 方法 | 描述 | 示例 |
|---|---|---|
| now() | 静态方法，根据当前时间创建对象 | LocalDate date = LocalDate.now(); LocalTime time = LocalTime.now(); LocalDateTime datetime = LocalDateTime.now(); |
| of() | 静态方法，根据指定日期/时间创建对象 | LocalDate date = LocalDate.of(2022, 10, 26); LocalTime time = LocalTime.of(02, 22, 56); LocalDateTime localDateTime = datetime.of(2022, 10, 26, 12, 10, 55); |
| plusDays, plusWeeks, plusMonths, plusYears | 向当前 LocalDate 对象添加几天、几周、几个月、几年 | |
| minusDays,minusWeeks, minusMonths,minusYears | 从当前 LocalDate 对象减去几天、几周、几个月、几年 | |
| plus, minus | 添加或减少一个 Duration 或 Period | |
| withDayOfMonth, withDayOfYear, withMonth, withYear | 将月份天数、年份天数、月份、年份修改为指定的值并返回新的 LocalDate 对象 | |
| getDayOfMonth | 获得月份天数(1-31) | |
| getDayOfYear | 获得年份天数(1-366) | |
| getDayOfWeek | 获得星期几(返回一个 DayOfWeek 枚举值) | |
| getMonth | 获得月份, 返回一个 Month 枚举值 | |
| getMonthValue | 获得月份(1-12) | |
| getYear | 获得年份 | |
| until | 获得两个日期之间的 Period 对象，或者指定 ChronoUnits 的数字 | |
| isBefore, isAfter | 比较两个 LocalDate | |
| isLeapYear | 判断是否是闰年 |
新日期格式化器
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
老的格式化器不能格式化新的对象
SimpleDateFormat sdf = new SimpleDateFormat 无法使用
具体实例
@Test
public void test9() {
LocalTime now = LocalTime.now();
System.out.println(now);
LocalDateTime datetime = LocalDateTime.now();
System.out.println(datetime);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//String format = sdf.format(datetime); // 老的格式化器不能格式化新的对象
//System.out.println(format);
// new DateTimeFormatter();
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String format = dateTimeFormatter.format(datetime);
System.out.println(format);
LocalDate date = LocalDate.of(2008, 8, 8);
System.out.println(date);
}
// 练习 : 创建对象获取当前时间的LocalDate, 把它设置为你的生日, 再获取你的百日, 打印输出.
@Test
public void exer2() {
System.out.println(LocalDate.now().withYear(1978).withMonth(6).withDayOfMonth(9).plusDays(100));
}
@Test
public void test6() {
//new LocalDate(); // 不可以直接创建对象, 构造器私有
LocalDate date1 = LocalDate.now();
System.out.println(date1);
int year = date1.getYear();
Month month = date1.getMonth();
int day = date1.getDayOfMonth();
System.out.println("year = " + year);
System.out.println("month = " + month);
System.out.println("day = " + day);
// 2008, 8, 8
//date1.setYear(2008); 不允许修改年, 原因是它的属性是final
/*
LocalDate date2 = date1.withYear(2008);// 伴随一个新的年, 要产生新对象
LocalDate date3 = date2.withMonth(8);
LocalDate date4 = date3.withDayOfMonth(8);
System.out.println(date4);
*/
LocalDate date2 = date1.withYear(2008).withMonth(8).withDayOfMonth(8);
System.out.println("date2 = " + date2);
LocalDate date3 = date2.plusMonths(8); // 8月后
System.out.println(date3);
}
Math类
常用方法
random() 返回0.0到1.0的随机数
long round(double a) double型数据a转换为long型（四舍五入）
public class MathTest {
@Test
public void test1() {
System.out.println(Math.random());// [0~1)随机浮点数
System.out.println(Math.round(3.5)); // 4
System.out.println(Math.round(-3.2));
System.out.println(Math.round(-3.8));
System.out.println(Math.round(-3.5)); // -3
}
}
BigInteger类(了解)
概念
Integer类作为int的包装类，能存储的最大整型值为2^31-1，BigInteger类的数字范围较Integer类的数字范围要大得多，可以支持任意精度的整数。
构造器
BibInteger(String val)
l常用方法
常用方法
-
public BigInteger abs()
-
public BigInteger add(BigIntegerval)
-
public BigInteger subtract(BigIntegerval)
-
public BigInteger multiply(BigIntegerval)
-
public BigInteger divide(BigIntegerval)
-
public BigInteger remainder(BigIntegerval)
-
public BigInteger pow(int exponent)
-
public BigInteger[] divideAndRemainder(BigIntegerval)
BigDecimal类(了解)
概念
一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。BigDecimal类支持任何精度的定点数。
构造器
public BigDecimal(double val) public BigDecimal(String val)
常用方法
-
public BigDecimal add(BigDecimal augend)
-
public BigDecimal subtract(BigDecimal subtrahend)
-
public BigDecimal multiply(BigDecimal multiplicand)
-
public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
标签：常用,String,int,System,第八章,println,public,out 来源： https://www.cnblogs.com/0313yewu/p/16247656.html