java第十三章：常用类
- java第十三章：常用类
- 八大wrapper(包装类)
- wrapper的装箱和拆箱
- wrapper课堂测试
- wrapper常用方法
- Integer类面试题
- String类
java第十三章：常用类
八大wrapper(包装类)
八种基本数据类型相应的引用类型——包装类
boolean--Boolean
char--Character
byte--Byte
short--Short
int--Integer
long--Long
float--Float
double--Double
Number类的wrapper
Boolean类
Character类
wrapper的装箱和拆箱
package com.lcz.commenclass.wrapper;
/**
* @author lcz
* @version 1.0
*/
public class Wrapper {
public static void main(String[] args) {
//jdk 5 前的 手动装箱和手动拆箱
//装箱：基本类型-->包装类型
//拆箱：包装类型-->基本类型
//1.1手动装箱
int i = 1;
//第一种方式
Integer integer1 = Integer.valueOf(i);
//第二种方式
Integer integer2 = new Integer(i);
//1.2手动拆箱
int j = integer1.intValue();
//2.1自动装箱
int m = 10;
Integer integer3 = m;//底层调用：Integer.valueOf(m)，属于编译器的底层优化
//2.2自动拆箱
Integer integer4 = new Integer(99);
int n = integer4;//底层调用：integer4.intValue()，属于编译器的底层优化
}
}
wrapper课堂测试
第二题：
三元运算符是一个整体，整体返回double，因为有类型自动转换，所以输出1.0
注：此为和第三题的区别
wrapper常用方法
-
wrapper到String
-
String到wrapper
-
MIN_VALUE
-
MAX_VALUE
-
isDIGIT
-
isLetter
-
isUpperCase
-
isLowerCase
-
isWhitespace
-
toUpperCase
-
toLowerCase
package com.lcz.commenclass.wrapper;
/**
* @author lcz
* @version 1.0
*
* 关于wrapper的常用方法
*/
public class CommenMethod {
public static void main(String[] args) {
//将wrapper转换为String
int i = 100;
//1.
String str = i + "";
//2.
String str1 = Integer.toString(i);
//3.
String str2 = String.valueOf(i);
System.out.println(i);
System.out.println(str1);
System.out.println(str2);
//将String转换为wrapper
String str3 = "1234";
int j = Integer.parseInt(str3);
int m = new Integer(str3);//利用Integer的重载构造器
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
char c = 'a';
System.out.println(Character.isDigit(c));
System.out.println(Character.isLetter(c));
System.out.println(Character.isUpperCase(c));
System.out.println(Character.isLowerCase(c));
System.out.println(Character.toUpperCase(c));
System.out.println(Character.toLowerCase(c));
System.out.println(Character.isWhitespace(c));
}
}
Integer类面试题
得需要阅读底层源码：Integer.valueOf()
主要看范围：-128到127就是直接返回值
若不是则new创建Integer对象
注：只要有基本数据类型，就会判断值是否相等，因为包装类会进行自动拆箱！！！
String类
String类的理解和创建
1.String对象 用于保存字符串，保存的是一组字符序列
2.String类字符串常量是双引号包起来的字符序列
3.String类的字符使用Unicode字符编码，一个字符占两个字节
4.Sring类有多个构造器，即：构造器重载
常用的：
String()
String(String original)
String(char[] a)
String(char[] a,int startIndex,int count)
//用于网络传输(字节数组)
String(byte[] b)
5.String类是final类，不可以被其他类继承
6.String类实现了三个接口：
Serializable:说明字符串可串行化，即可进行网络传输
Comparable:说明字符串可按某种规范进行比较
Charsequence：字符序列接口
7.String类有个属性 final char[] value 用来存放字符序列
8.value是final 类型，不可以修改：不可以指向新的地址，其中字符序列可修改，但也修改不到，因为私有
String类继承图
String对象两种创建方式
两种创建方式
两种方式：
1.直接赋值：String s = "lcz"
2.调用构造器：String s1 = new String("lcz")
解读：
1.先从常量池查看是否有"lcz"数据空间，若有，直接指向；若无则重新创建，然后指向。s最终指向的是常量池的空间地址
2.先在堆中创建空间，里面维护了value属性，指向常量池的"lcz"空间。若无，则重新创建，若有，则通过value指向。s1最终指向的是堆中的空间地址
两种创建方式的内存布局图
字符串测试题
字符串测试题1
当调用intern方法时，返回对应其属性value值的常量池的地址，若无，则创建并返回。
字符串测试题2
"lcz"本身返回的就是常量池的地址
字符串特性
字符串特性1
1）：String类是一个final类，不可继承修改value值，所以代表不可变的字符序列
2）：字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的：因为value属性是私有的final类型
字符串特性2
String a = "hello" + "abc";//优化等价 String a = "helloabc"
分析：编译器底层优化，判断创建的常量池对象，是否有引用指向，无则不创建
字符串特性3
规则：
String c1 = "ab" + "cd";常量相加，是在池中
String c1 = a + b;只要有变量相加，是在堆中
解读：(String c1 = a + b)
1.先 创建一个 StringBuilder sb = StringBulider()
2.执行 sb.append("hello")
3.sb.append("abc")
4.String c = sb.toString() toString方法返回的是一个 new的 value值是helloabc 的堆中String对象
所以 c 指向 堆中的对象(String) value[] -> 常量池中 "helloabc"
字符串特性4
考察：
堆中对象、栈的创建、常量池的引用
形参指向的改变对实参的指向无影响，但形参对实参指向的对象进行改变会对实参产生影响
String类常用方法
equals
equalsIgnoreCase
length
indexOf
lastIndexOf
substring//截取指定范围内的子串
trim//去前后空格
charAt//获取某索引处的字符
toUpperCase
toLowerCase
concat//拼接字符串
replace
split//分割字符串
compareTo//字符串的比较，根据minlenth可比则比，否则len1-len2
toCharArray//转换成字符数组
format//格式化字符串：%s、%d、%c、%.2f
package com.lcz.commenclass.string;
/**
* @author lcz
* @version 1.0
*/
public class String01 {
public static void main(String[] args) {
String s1 = "hello";
String s2 = " abc ";
System.out.println(s1.equals(s2));
System.out.println(s1.length());
System.out.println(s1.concat(s2));
System.out.println(s1.indexOf("e"));
System.out.println(s1.lastIndexOf("l"));
System.out.println(s1.substring(1,3));
System.out.println(s1.substring(1));
System.out.println(s2.trim());
System.out.println(s2.charAt(0));
System.out.println(s2.toLowerCase());
System.out.println(s2.toLowerCase());
System.out.println(s2.charAt(4));
System.out.println(s1.compareTo(s2));
System.out.println(s1.toCharArray());
char[] char1 = s1.toCharArray();
System.out.println(char1[0]);
}
}
StringBuffer类
结构剖析
java.lang.StringBuffer代表可变的字符序列,是一个容器
1.StringBuffer 的直接父类 是 AbstractStringBuilder
2.StringBuffer 实现了 Serializable,即StringBuffer的对象可以串行化(可以保存在文件、也可网络传输)
3.StringBuffer 的父类 还实现了 CharSequence、Appendable接口
4.在父类中 AbstractStringBuilder 有属性 char[] value,不是final
该 value 数组存放 字符串内容，数组结构存放在堆中，而不是常量池
5.StringBuffer是一个 final类，不能被继承
6.因为StringBuffer 字符内容 是存在 char[] value,所以在变化(增加/删除)时，不用每次都更换地址(即不是每次都创建新对象)，所以效率高于String
只有数组空间已满，扩容时需创建新对象，更换地址
Sring VS StringBuffer
1.String保存的是 字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低//private final char value[] 存放在常量池
2.StringBuffer保存的是 字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次都更新地址，效率较高//char[] value 存放在堆
StringBuffer的构造器
1.StringBuffer():
构造一个其中不带字符的字符串缓冲区，其初始容量为16个字符
2.StringBuffer(int capacity)://capacity[容量]
构造一个不带字符，但具有指定初始容量的字符串缓冲区
3.StringBuffer(String str):
构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容，value数组大小为str.length()+16
String和StringBuffer相互转换
1.String——>StringBuffer:
String s = "hello";
(1):
StringBuffer b1 = new StringBuffer(s);
(2):
StringBuffer b2 = new StringBuffer();
b2.append(s);
2.StringBuffer——>String:
(1):
String s1 = b1.toString();
(2):
String s2 = String(b1);
StringBuffer常见方法
增append(str)
删delete(start,end)
改replace(start,end,str)
查indexOf(str)
插insert(index,str)
获取长度length
package com.lcz.commenclass.StringBuffer;
/**
* @author lcz
* @version 1.0
*
* 关于StringBuffer方法：增删改查插长度
*/
public class StringBuffer01 {
public static void main(String[] args) {
StringBuffer s = new StringBuffer("hello");
//增
s.append(',');
s.append("张三丰").append(100).append(true);
System.out.println(s);
//删
s.delete(3,5);
System.out.println(s);
//改
s.replace(3,5,"lcz");
System.out.println(s);
//查
int indexOf = s.indexOf("lcz");
System.out.println(indexOf);
//插
s.insert(3,"lhc");
System.out.println(s);
//长度
System.out.println(s.length());
}
}
StringBuffer测试题
StringBuffer测试题1
看底层源码：
1.sb.append(null):不会报空指针异常，是将null作为字符插入value数组
2.new StringBuffer(null):会报空指针异常，因为初始化value数组长度用到了str.length
StringBuffer测试题2
对数字进行特殊处理：
package com.lcz.commenclass.StringBuffer;
/**
* @author lcz
* @version 1.0
* 需求：
* 将接收到的数字888888.69以888,888.69显示
* 代码实现：
* 1.希望使用StringBuffer的insert方法插入','
* 需要将 String 转成 StringBuffer
* 2.使用相关方法进行字符串的处理
*/
public class StringBuffer02 {
public static void main(String[] args) {
String inputstr = "888888.69";
int indexOf = inputstr.indexOf('.');
StringBuffer sb = new StringBuffer(inputstr);
//sb.insert(indexOf - 3,',');
for( ; indexOf - 3 > 0;indexOf -= 3){
sb.insert(indexOf-3,',');
}
System.out.println(sb);
}
}
StringBuilder
结构剖析
大部分几乎与StringBuffer结构一摸一样，唯一区别为：
StringBuilder的方法，没有做互斥的处理，即没有synchronized关键字，因此在单线程情况下使用StringBuilder
String、StringBuffer、StringBuilder的优缺点及选择
1.StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且方法也一样
2.String：不可变字符序列，效率低，但是复用率高
3.StringBuffer：可变字符序列、效率较高(增删)、线程安全
4.StringBuilder：可变字符序列，效率最高、线程不安全
5.String使用注意说明：如果对String做大量修改，不要使用String
结论：
1.如果字符串存在大量的修改操作，一般使用StringBuffer或StringBuilder
2.如果字符串存在大量的修改操作，并在单线程的情况，使用 StringBuilder
3.如果字符串存在大量的修改操作，并在多线程的情况，使用 StringBuffer
4.如果字符串很少修改，被多个对象引用，使用String，比如配置信息等
String、StringBuffer、StringBuilder效率测试
package com.lcz.commenclass.String_StringBuffer_StringBuilder;
/**
* @author lcz
* @version 1.0
*
* String、StringBuffer、StringBuilder效率测试
*/
public class test {
public static void main(String[] args) {
String text = "";
long startTime = 0L;
long endTime = 0L;
StringBuffer buffer = new StringBuffer("");
StringBuilder builder = new StringBuilder("");
//StringBuffer
startTime = System.currentTimeMillis();
for(int i = 0;i < 20000;i++){
buffer.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuffer的执行时间为：" + (endTime - startTime));
//StringBuilder
startTime = System.currentTimeMillis();
for(int i = 0;i < 20000;i++){
builder.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuilder的执行时间为：" + (endTime - startTime));
//String
startTime = System.currentTimeMillis();
for(int i = 0;i < 20000;i++){
text += i;
}
endTime = System.currentTimeMillis();
System.out.println("String的执行时间为：" + (endTime - startTime));
}
}
Math类常用方法
abs
pow：返回double
ceil：返回double
floor：返回double
round:四舍五入,返回long
sqrt：返回double
randon：返回double
max
min
练习题：获取一个a - b之间的一个随机整数
int num = (int)(a + Math.random()*(b-a+1))
package com.lcz.commenclass.math;
/**
* @author lcz
* @version 1.0
*
* 关于：Math类相关方法
*/
public class Math01 {
public static void main(String[] args) {
//1.abs
System.out.println(Math.abs(-9));
//2.pow,返回double
System.out.println(Math.pow(2,3));
//3.ceil,返回double
System.out.println(Math.ceil(3.5));
//4.floor,返回double
System.out.println(Math.floor(-4.3));
//5.round,返回long
long round = Math.round(4.0001);
System.out.println(round);
//6.sqrt,返回double
double res = Math.sqrt(16);
System.out.println(res);
//7.random,返回[0,1)之间的小数,返回double
int a = 2,b = 7;
int num = (int)(a + Math.random()*(b-a+1));
System.out.println(num);
}
}
Arrays类常用方法
toString(arr)：返回数组的字符串形式
sort(arr)、sort(arr,new Compartor{})：无返回值
自然排序和基于二叉树排序的定制排序
基于冒泡的定制排序
binarySearch(arr,element)：通过折半查找法进行查找，要求为有序数组，时间复杂度：O(以2为底n的对数)
copyOf(arr,len)：数组元素的复制,
fill(arr,fillElem)：填充数组元素
equals(arr1,arr2)：比较两个数组元素内容是否完全一致
asList：将一组值，转换成List(集合)
package com.lcz.commenclass.arrays;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
/**
* @author lcz
* @version 1.0
*
* 关于Arrays01类的相关方法
*/
public class Arrays01 {
public static void main(String[] args) {
//1.toString(arr)
System.out.println("===n1定制排序前===");
Integer[] n1 = {1,2,3,8,4,9,5};
System.out.println(Arrays.toString(n1));
//2.sort(arr)、sort(arr,new Compartor{})
//Arrays.sort(n1);
//System.out.println("===自然排序后===");
//System.out.println(Arrays.toString(n1));
System.out.println("===n1定制排序后===");
Arrays.sort(n1,new Comparator(){//n1需要为对象数组，不能是基本类型数组
@Override
public int compare(Object o1, Object o2) {
int n1 = (Integer) o1;
int n2 = (Integer) o2;
return n2 - n1;
}
});
System.out.println(Arrays.toString(n1));
//3.基于冒泡的定制排序
int[] n2 = {2,5,3,6,4,7,2};
System.out.println("===n2定制排序前===");
System.out.println(Arrays.toString(n2));
bubbleSort(n2, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
int n1 = (Integer) o1;
int n2 = (Integer) o2;
return n2 - n1;
}
});
System.out.println("===n2定制排序后");
System.out.println(Arrays.toString(n2));
//4.binarySearch
//要求为有序数组，无序数组排为有序也不行，若找不到，返回-(low+1),low为若存在的索引值
int[] n3 = {1,2,3,4};
System.out.println(Arrays.binarySearch(n3,2));
//5.copyOf(arr,len)
//(1):len > arr.length:补0
//(2):len < 0 抛出异常NegativeArraySizeException
//(3):底层调用的是System.arraycopy()
int[] arr2 = Arrays.copyOf(n3,3);
System.out.println(Arrays.toString(arr2));
//6.fill(arr,fillElem)
Arrays.fill(n3,1);
System.out.println(Arrays.toString(n3));
//7.equals(arr1,arr2)
System.out.println(Arrays.equals(n2,n3));
//8.asList
//(1):asList方法，将(2,3,45,5)转成一个集合
//(2):编译类型：List(接口)
//(3):运行类型：java.util.Arrays$ArrayList：是Arrays的静态内部类ArrayList
List asList = Arrays.asList(2,3,45,5);
System.out.println("asList:" + asList);
System.out.println("asList运行类型：" + asList.getClass());
}
public static void bubbleSort(int[] arr1,Comparator c){
int temp = 0;
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1.length -i - 1; j++) {
if(c.compare(arr1[j],arr1[j+1]) > 0){
temp = arr1[j];
arr1[j] = arr1[j+1];
arr1[j+1] = temp;
}
}
}
}
}
Arrays课堂练习
package com.lcz.commenclass.arrays;
import java.util.Arrays;
import java.util.Comparator;
/**
* @author lcz
* @version 1.0
*
* 需求：
* 1.自定义Book类，包含name和price属性，有一个Book[] books = 4本书对象
* 2.按price大小进行排序
* 3.按name长度大小进行排序
*/
class Book{
private String name;
private double price;
public Book(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
public class Arrays02 {
public static void main(String[] args) {
Book[] books = new Book[4];
books[0] = new Book("红楼梦",15);
books[1] = new Book("红楼",11);
books[2] = new Book("红",9);
books[3] = new Book("",13);
System.out.println("===按price定制排序前===");
System.out.println(Arrays.toString(books));
Arrays.sort(books, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
Book book1 = (Book) o1;
Book book2 = (Book) o2;
double n1 = book1.getPrice();
double n2 = book2.getPrice();
return (int)(n1 - n2);
}
});
System.out.println("===按price定制排序后===");
System.out.println(Arrays.toString(books));
}
}
System类常用方法
exit：退出当前程序
arraycopy：复制数组元素，用于底层调用(Arrays.copyOf)
currentTimeMillens：返回当前时间距离1970-1-1 0:0:0的毫秒数
gc：运行垃圾回收机制 System.gc();
测试
package com.lcz.commenclass.system;
/**
* @author lcz
* @version 1.0
*
* 关于System类相关方法
*/
public class System_ {
public static void main(String[] args) {
//1.exit
//0:表示程序退出的状态：正常退出
//System.exit(0);
//2.arraycopy
//参数：
//src:原数组
//srcPos：原数组复制起始位置
//dest：目标数组
//destPos：目标数组复制起始位置
//length：复制的元素长度
int[] n1 = {1,2,3};
int[] n2 = new int[3];
System.arraycopy(n1,0,n2,0,1);
for (int i = 0; i < n2.length; i++) {
System.out.println(n2[i]);
}
//3.currentTimeMillens:格林尼治时间
System.out.println(System.currentTimeMillis());
//4.gc
System.gc();
}
}
BigInteger和BigDecimal
应用场景：
1):BigInteger适合保存比较大的整型
2):BigDecimal适合保存精度更高的浮点型（小数）
常用方法：
- add
- subtract
- multiply
- divide
测试
package com.lcz.commenclass.bignum;
import java.math.BigDecimal;
/**
* @author lcz
* @version 1.0
*
* 关于BigDecimal类相关方法
*/
public class BigDecimal_ {
public static void main(String[] args) {
BigDecimal bigDecimal1 = new BigDecimal("161618.12222222222222222222");
BigDecimal bigDecimal2 = new BigDecimal("161618.122222222222222");
System.out.println(bigDecimal2.add(bigDecimal1));
System.out.println(bigDecimal2.subtract(bigDecimal1));
System.out.println(bigDecimal2.multiply(bigDecimal1));
System.out.println(bigDecimal2.divide(bigDecimal1));
//可能会报异常 Non-terminating decimal expansion
//因为碰到除不尽，无限循环，精度又很大，就异常：不可终止的小数扩展
}
}
package com.lcz.commenclass.bignum;
import java.math.BigInteger;
/**
* @author lcz
* @version 1.0
*
* BigInteger类相关方法
*/
public class BigInteger_ {
public static void main(String[] args) {
BigInteger bigInteger1 = new BigInteger("155646846846846");
BigInteger bigInteger2 = new BigInteger("155646846846846");
System.out.println(bigInteger2.add(bigInteger1));
System.out.println(bigInteger2.subtract(bigInteger1));
System.out.println(bigInteger2.multiply(bigInteger1));
System.out.println(bigInteger2.divide(bigInteger1));
}
}
日期类
第一代：Date
介绍
1.Date：精确到毫秒，代表特定的瞬间
java.util.Date
2.SimpleDateFormat:格式化和解析日期的类
3.
y 年
M 月
d 日
h 时(12)
H 时(24)
m 分
s 秒
E 星期几
第二代：Calendar
介绍
1.Calendar是一个抽象类，并且构造器是private
采用单例设计模式
2.可以通过 getInstance() 来获取实例
3.提供大量的方法和字段提供给程序员
YEAR 年
MONTH 月
DAY_OF_MONTH 日
HOUR 时(12)
HOUR_OF_DAY 时(24)
MINUTE 分
SECOND 秒
注：没有专门的格式化方法，需要程序员自行组合显示
第三代：LocalTime、LocalDate、LocalDateTime
前两代不足
1.可变性：日期和时间这样的类应该不可变
2.偏移性：Date中的年份从1900开始，而月份都从0开始
3.格式化：只有Date可以格式化输出
4.此外，存在线程安全问题；不能处理闰秒等(每隔两天，多出1s)
常见方法
1.now：
静态方法，类调用，获取日期或时间或日期加时间字段
2.getYear()
3.getMonth():返回月份英文
4.getMonthValue()：返回月份数字
5.getDayOfMonth():返回天
6.getHour()
7.getMinute()
8.getSecond()
DateTimeFormatter格式日期类
类似于SimpleDateFormat
y 年
M 月
d 日
h 时(12)
H 时(24)
m 分
s 秒
E 星期几
Instant时间戳
类似于Date
提供了一系列和Date类转换的方式
Instant——>Date：
Date date = Date.from(instant);
Date——>Instant：
Instant now = date.toInstant();
日期类测试
package com.lcz.commenclass.date;
import java.sql.Time;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.chrono.ChronoLocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;
/**
* @author lcz
* @version 1.0
*
* 关于一二三代日期类相关方法使用
*/
public class Date_ {
public static void main(String[] args) throws ParseException {
//第一代：Date
//1.创建Date对象
//无参创建
System.out.println("=====第一代日期类Date=====");
Date d1 = new Date();
System.out.println("d1 = " + d1);
//以毫秒数创建
Date d2 = new Date(1135153135);
System.out.println("d2 = " + d2);
//SimpleDateFormat格式化日期类
//(1):将Date对象格式化为字符串
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String format = sdf.format(d1);
System.out.println("Date对象格式化为字符串： "+format);
//(2):将字符串转化为对象
String s = "1986-01-01 17:56:47";
Date parse = sdf.parse(s);//sdf的格式化规则和字符串s不匹配，会报转化异常
System.out.println("字符串转化为Date对象： "+parse);
//第二代日期类：Calendar
System.out.println("=====第二代日期类Calendar=====");
Calendar c = Calendar.getInstance();
System.out.println("c = " + c);
System.out.println(Calendar.YEAR);
System.out.println(Calendar.MONTH);
System.out.println(Calendar.DAY_OF_MONTH);
System.out.println(Calendar.HOUR);
System.out.println(Calendar.HOUR_OF_DAY);
System.out.println(Calendar.MINUTE);
System.out.println(Calendar.SECOND);
//第三代日期类：LocalDateTime LocalDate LocalTime
LocalDateTime ldt = LocalDateTime.now();
LocalDate ld = LocalDate.now();
LocalTime lt = LocalTime.now();
System.out.println(ldt.getYear());
System.out.println(ldt.getMonth());
System.out.println(ldt.getMonthValue());
System.out.println(ldt.getDayOfMonth());
System.out.println(ldt.getHour());
System.out.println(ldt.getYear());
System.out.println(ldt.getMinute());
System.out.println(ldt.getSecond());
//格式化日期类:DateTimeFormatter
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String format1 = dtf.format(ldt);
System.out.println("格式化后的字符串 ： " + format1);
//时间戳：Instant
//(1):Date转化为Instant
Date d3 = new Date();
Instant instant = d3.toInstant();
System.out.println("Date转化为时间戳： " + instant);
//(2):Instant转化为Date
Date d4 = Date.from(instant);
System.out.println("时间戳转化为Date对象: " + d4);
//提供plus和minus对当前时间进行加或减
// 应用：如查看历史订单
LocalDateTime ldt1 = LocalDateTime.now();
LocalDateTime newldt = ldt1.plusDays(586);
System.out.println(newldt);
}
}
本章作业
字符串翻转
注册管理器
t.getYear());
System.out.println(ldt.getMonth());
System.out.println(ldt.getMonthValue());
System.out.println(ldt.getDayOfMonth());
System.out.println(ldt.getHour());
System.out.println(ldt.getYear());
System.out.println(ldt.getMinute());
System.out.println(ldt.getSecond());
//格式化日期类:DateTimeFormatter
DateTimeFormatter dtf = DateTimeFormatter.ofPattern(“yyyy-MM-dd HH:mm:ss”);
String format1 = dtf.format(ldt);
System.out.println("格式化后的字符串 ： " + format1);
//时间戳：Instant
//(1):Date转化为Instant
Date d3 = new Date();
Instant instant = d3.toInstant();
System.out.println("Date转化为时间戳： " + instant);
//(2):Instant转化为Date
Date d4 = Date.from(instant);
System.out.println("时间戳转化为Date对象: " + d4);
//提供plus和minus对当前时间进行加或减
// 应用：如查看历史订单
LocalDateTime ldt1 = LocalDateTime.now();
LocalDateTime newldt = ldt1.plusDays(586);
System.out.println(newldt);
}
}
### 本章作业
#### 字符串翻转
#### 注册管理器
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
