chapter13 常用类
chapter13 常用类
包装类
包装类的分类
- 针对于八种基本数据类型相应的引用类型--包装类
- 有了类的特点，就可以调用类中的方法
- boolean----Boolean
- char-----Character
- byte-----Byte
- short-----Short
- int-----Integer
- long----Long
- float----Float
- double---Double
包装类和基本数据类型转换
先展示一下int和Integer
- jdk1.5前手动装箱和拆箱；装箱：基本数据类型-->包装类型 拆箱：包装类型--->基本数据类型
- jdk5以后（含jdk5）的自动装箱和拆箱方式
- 自动装箱底层调用的是valueOf方法 比如Integer.valueOf()
- 其他包装类的用法类似
package javabase.chapter13;
public class Integer01 {
public static void main(String[] args) {
//演示int---Integer的装箱和拆箱
//1.手动装箱和拆箱
int n1 = 100;
//手动装箱的三种方式 int---Integer
Integer integer = Integer.valueOf(n1);
Integer integer1 = new Integer(n1);
Integer integer2 = new Integer(100);
//手动拆箱 Integer--int
int i = integer.intValue();
//随便敲敲 还真一样啊
char char1 = 'a';
Character char2 = new Character(char1);
Character char3 = new Character('b');
Character char4 = 'v';
//自动装箱
Integer integer5 = 10;
//说明 底层是调用的integer的valueOf方法 只不过自动调用了
//自动拆箱
int n5 = integer5;
//说明 底层调用Integer的intValue方法 也是自动调用的
}
}
包装类型和String类型相互转换
package javabase.chapter13;
public class WrapperVsString {
public static void main(String[] args) {
//包装类Integer---String
Integer i = 100; //自动装箱
//方式1
String str1 = i + "";
//方式2
String str2 = i.toString();
//方式3
String str3 = String.valueOf(i);
//String---包装类Integer
String str4 = "12345";
//1.自动装箱
Integer i2 = Integer.parseInt(str4);
//2.构造器
Integer i3 = new Integer(str4);
//包装类 Character与String相互转换
String str6 = "a";
//随便写写 简单猜测一下
//猜错了
//Character char1 = new Character("a");
//Character char2 = Character.valueOf(str6);
//再猜一下
Character char1 = 'a';
//这个猜对了
String str7 = char1.toString();
String str8 = String.valueOf(char1);
}
}
Integer类和Character类常用方法
源码点击去自己看吧
String类
String类的理解和创建对象
- String对象用于保存字符串，也就是一组字符序列
- 字符串常量对象是用双引号括起来的字符序列。例如“你好” “acb“ 等
- 字符串的字符使用Unicode编码，一个字符（不区分字母还是汉字)占两个字节
- String类较常用构造器（自己看源码，简单介绍几个）
介绍个屁，看源码
package javabase.chapter13.string_;
public class String01 {
public static void main(String[] args) {
//1.String对象用于保存字符串，也就是自足字符序列
//2.”Jack“字符串常量，双引号括起来的字符序列
//3.字符串的字符使用Unicode编码，一个字符占两个字节
//4.String类有很多构造器 构造器的重载
String s1 = new String();
String s2 = new String();
//自己看源码吧
//5.String类实现了接口Serializable【String 可以串行化，可以在网络传输】
//实现了接口 Comparable 【String对象可以比较大小】
//6.String类是final类，不能被其他的类继承
//7.String类有一个属性 private final char value[] 用于存放字符串内容
//8.一定要注意：value是一个final类型，不可以修改（需要功力）；即value不能指向信封地址，但是单个字符内容是可以变化的
//关于8的距离说明
final char[] value = {'a','b','v'};
char[] v2 = {'a','c','g'};
//value = v2; 报错
value[0] = 't'; //修改字符数组中的字符内容是可以的
}
}
创建String对象
2种方式：
- 直接赋值 String s = "hahaha";
- 调用构造器 String s = new String("hahahaha2");
2种方式的区别
方式一：先从常量池查看是否有hahaha数据空间，如果有，直接指向；如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址。
方式二：现在堆中创建空间，里面维护了value书香，指向常量池的hahahaha2空间。如果常量池中没有”hahahaha2“，重新创建，如果有，直接通过value指向。s2 最终指向的是队中的空间地址，二里面的value指向的是常量池中hahahah2的空间地址
图就不画了
String的intern方法说明：当调用intern方法时，如果池已经包含了一个等于此String对象的字符串，则返回池中的字符串。否则，将String对象添加到池中，并返回此String对象的引用
说白了 intern方法最终返回的是常量池的地址（对象）
字符串特性
说明
- String是一个final类，代表不可变的字符序列
- 字符串是不可变的。一个字符串对象一旦被分配，器内容是不可变的
String a = "asd";
String b = "bbb";
String c = a + b;
这个操作一共创建了三个对象 一个重要规则：String c = "asd" + "dsa" 常量相加 看的是池
String c = a + b 变量相加 看的是堆
String 常用方法
看源码 看api文档
StringBuffer类
基本介绍
- java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。
- 很多方法和String相同，但是StringBuffer是可变长度的
- StringBuffer是一个容器
源码解析：
public final class StringBuffer //StringBuffer是一个final类
extends AbstractStringBuilder //继承了抽象类AbstractStringBuilder
//AbstractStringBuilder的char[] value属性，存放字符序列
implements java.io.Serializable, CharSequence 实现了Serializable接口，可以保存到文件，或者网络传输
解读：
- StringBuffer的直接父类是AbstractStringBuilder
- StringBuffer实现了Serializable，即StringBuffer的对象可以串行化
- 在父类中 AbstractStringBuilder 属性char[] value 不是final的，该数组存放字符串内容，存放在堆中
- StringBuffer是一个final类，不能被继承
- 因为StringBuffer字符内容是存在char[] value，所以在变化（增加/删除），不用每次更换地址（即不是每次创建新对象），所以效率高于String
String VS StringBuffer
- String保存的是字符串常量，里面的值不饿能更改，每次String类的更新实际上是更改地址，效率较低 // private final char value[]
- String Buffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新，实际上可以更新内容，不用每次更i虚拟地址，效率更高 // char[] value
String和StringBuffer相互转换
package javabase.chapter13.stringbuffer_;
public class StringBuffer01 {
public static void main(String[] args) {
// String---StringBuffer
String str = "hello Tim";
//方式一 使用构造器
StringBuffer stringBuffer = new StringBuffer(str);
//说明：返回的才是StringBuffer对象，对str本身没有影响
//方式二 使用append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);
//StringBuffer---String
StringBuffer stringBuffer2 = new StringBuffer("hahahaha");
//方式一 使用StringBuffer提供的toString方法
String str2 = stringBuffer2.toString();
//方式二 使用构造器来搞定
String str3 = new String(stringBuffer2);
}
}
StringBuffer类常见方法
增append（str)
删 delete(startInde,endIndex)
改replace(startIndex,endIndex,new_value) 从索引x-y替换为新的内容
查indexOf(str) 查找指定的子串在字符串中出现的的索引 找不到就返回-1
插 insert(index,new_value) 哎指定位置插入new_value 原文索引位置自动后移
StringBuffer类课堂练习
package javabase.chapter13.stringbuffer_;
public class StringBufferExercise01 {
public static void main(String[] args) {
String str = null;
String str2 = "haha";
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(str);
System.out.println(stringBuffer.length());
stringBuffer.append(str2);
System.out.println(stringBuffer.length());
//下面的代码 底层会调用super(str.length()+16)
//但是 str是一个null 调用null的方法会报错 空指针 NullpointerException
StringBuffer sb1 = new StringBuffer(str);
System.out.println(sb1);
}
}
课后练习
package javabase.chapter13.stringbuffer_;
public class StringBufferExecrise02 {
public static void main(String[] args) {
String price = "12345678.9";
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(price);
for (int i = stringBuffer.lastIndexOf(".") - 3; i > 0; i-=3) {
stringBuffer.insert(i,".");
}
System.out.println(stringBuffer);
}
}
StringBuilder类
基本介绍
- 一个可变的字符序列。此类提供一个与StringBuffer兼容的API，但布保证同步（StringBuilder不是线程安全）。该类的设计作用StringBuffer的一个建议替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，他比StringBuffer更快
- 在StringBuilder上的主要操作是 append和insert方法，可重载这些方法以接受任意类型的数据
解读：
package javabase.chapter13.stringbuilder_;
public class StringBuilder01 {
public static void main(String[] args) {
/**
* public final class StringBuilder
* extends AbstractStringBuilder
* implements java.io.Serializable, CharSequence*/
// 说明：
//1. StringBuilder的直接父类是AbstractStringBuilder
//2. StringBuilder实现了Serializable接口，StringBuilder
// 的对象吃出串行化 可以输出到文本 以及在网络中传输
//3. AbstractStringBuilder 有属性 char[] value 不是final的
// 该数组存放 字符串内容 存储在堆中/
// StringBuilder 是final的 不能被继承
//字符内容是存在 char[] value, 所有在变化(增加/删除)
// 不用每次都更换地址(即不是每次创建新对象)， 所以效率高于 String
}
}
StringBuilder常用方法
StringBuilder和StringBuffer 军代表可变的字符序列，方法都是一样的 所以使用和StringBuffer一样
String StringBuffer StringBuilder比较
- StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
- String 不可变字符序列 效率低但是复用率高
- StringBuffer 可变字符序列，效率较高（增 删）线程安全（synchronized因为上锁了）
- StringBuilder 可变字符序列 效率最高、线程不安全 （因为他的方法没加synchronized）
- String使用注意说明：
- String s = "a" //创建了一个字符串
- s += "b" //实际上，原来的“a"字符串对象已经丢弃了，现在又产生了一个字符串s + "b"（实际上是"ab")。如果多次执行这些改变字符串内容的操作，会导致大量副本字符串对象留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能====揭露：如果我们堆String做大量的修改，不要使用String
String StringBuilder StringBuffer 效率测试
package javabase.chapter13.stringbuilder_;
public class StringVSStringBuilderVSStringBuffer {
public static void main(String[] args) {
long startTime = 0L;
long endTime = 0L;
StringBuffer buffer = new StringBuffer();
startTime = System.currentTimeMillis();
for (int i = 0; i < 800000; i++) {
buffer.append(i);
}
endTime = System.currentTimeMillis();
System.out.println("StringBuffer执行时间为" + (endTime-startTime));//31
StringBuilder builder = new StringBuilder();
startTime = System.currentTimeMillis();
for (int i = 0; i < 800000; i++) {
builder.append(i);
}
endTime = System.currentTimeMillis();
System.out.println("StringBuilder的执行时间为" + (endTime-startTime)); //16
String str = new String();
startTime = System.currentTimeMillis();
for (int i = 0; i < 800000; i++) {
str += "i";
}
endTime = System.currentTimeMillis();
System.out.println("String的执行时间为" + (endTime-startTime)); //很长
}
}
三者的选择
使用原则：
- 如果字符串存在大量的修改操作，一般使用StringBuilder和StringBuffer
- 如果字符串存在胆量的修改操作，并且是单线程的情况 使用StringBuilder
- 如果字符串存在大量的修改操作，并且是多线程的情况 使用StringBuffer
- 如果字符串很少的修改，被多个对象引用，使用String 比如配置信息等
Math类
基本介绍
Math类包含用于执行基本数学运算的方法，如 初等指数、对数、平方根和三角函数
常用方法一览表(均为静态方法)
自己看api文档吧
Math常见方法
package javabase.chapter13.math_;
public class MathMethod {
public static void main(String[] args) {
int value1 = Math.abs(-100); // 取绝对值
Double value2 = Math.pow(1,4); //求幂 2的4次方
double value3 = Math.ceil(3.9); //向上取整 4
double value4 = Math.floor(3.2); //向下取整 3
long value5 = Math.round(5.5); //四舍五入 6
double value6 = Math.sqrt(9.0); //开平方 3
int min = Math.min(1,9); // 返回两数最小值 1
int max = Math.max(10,90); // 返回两数最大值 90
//random 球随机数
//random返回的是 0<= x < 1之间的一个随机小鼠
//思考：请写出获取a-b之间的一个随机整数 ab均为整数 比如a=2 b=7
//即反悔哦一个数x 2 <= x <= 7
for (int i = 0; i < 10; i++) {
System.out.println((int)(2 + Math.random() * (7 - 2 + 1)));
}
}
}
Arrays类
Arrays类常见方法
Arrays里面包含了一些列静态方法，用于管理和操作数组(比如排序和搜索)
- toString 返回数组的字符串形式
- sort排序（自然排序和定制排序）
- binarySearch 通过二分搜索法机型查找，要求必须排好序
- copyOf 数组元素的复制
- fill 数组元素的填充
- equals 比较两个数组元素内容是否完全一致
- asList将一组值，转换成list
package javabase.chapter13.arrays_;
import java.util.Arrays;
import java.util.Comparator;
public class ArraysMethod01 {
public static void main(String[] args) {
Integer integers[] = {1, 20, 90};
//数组遍历
for (int i = 0; i < integers.length; i++) {
System.out.println(integers[i]);
}
//直接使用Arrays.toString方法 显示数组
System.out.println(Arrays.toString(integers));
//演示sort方法的使用
Integer[] arr = {1, 3, -7,9,18};
//进行排序
//1.可以直接使用冒泡排序 也可以直接使用Arrays提供的sort方法排序
//2.因为数组时引用类型，所以通过sort排序后，会直接影响到 实参arr
//使用默认排序方法
//Arrays.sort(arr);
//System.out.println(Arrays.toString(arr));
//使用冒泡排序
/*
int temp = 0;
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-i-1; j++){
if (arr[j] > arr[j+1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
*/
//使用定制排序
//3.sort 重载的，也可以通过传入一个接口Comparator实现定制排序
//4.调用地址排序时，传入两个参数 1 排序的数组arr 2实现Comparator接口的匿名内部类 要求实现compare方法
//5.这里体现了接口编程的方式
//6.源码分析
/*
Arrays.sort(arr, new Comparator<Integer>()最终到TimSort类的
private static <T> void binarySort(T[] a, int lo, int hi, int start,
Comparator<? super T> c)()
执行发哦binarySort方法的代码，会根据动态绑定机制c,compare()执行我们传入的匿名内部类compare()
while (left < right) {
int mid = (left + right) >>> 1;
if (c.compare(pivot, a[mid]) < 0)
right = mid;
else
left = mid + 1;
}
*/
//public int compare(Object o1,Object o2) 返回值 >0 还是<0
//会影响整个排序的结果，者就充分体现了 接口编程+动态绑定+匿名内部类的综合使用
//将来的底层框架和源码的使用方式 会非常常见
/*
Arrays.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
System.out.println(Arrays.toString(arr));
*/
//结合冒泡 + 定制
int temp = 0;
Comparator c = new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return (Integer)o1 - (Integer)o2;
}
};
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j <arr.length-i-1; j++){
//数组排序由c.compare()返回的值决定
if (c.compare(arr[j],arr[j+1])>0){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
package javabase.chapter13.arrays_;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.List;
public class ArrayMethod02 {
public static void main(String[] args) {
Integer[] arr = {1,2,90,123,456,789};
//binarySearch通过二分搜索法进行查找，要求必须排序好、
//解读：
//1.使用binarySearch二叉查找
//2.要求数组是有序的，如果数组是无序的，不能使用binarySearch
//3.如果数组中不存在改元素，就返回return -(low+1) //key not found.
int index = Arrays.binarySearch(arr,90);
System.out.println("index = " + index);
//copyOf数组元素的复制
//解读：
//1.从arr数组中，拷贝arr,length个元素到newArr数组中
//2.如果拷贝的长度>arr.length 就在新数组后边 增加null
//3.如果拷贝长度<0 就抛出异常 NegativeArraySizeException
//4.该方法的底层使用的是System.arraycopy()
Integer[] mewArr = Arrays.copyOf(arr,arr.length);
System.out.println(Arrays.toString(mewArr));
//fill数组元素的填充
//解读：使用99去填充num数组，可以理解成是替换原理的元素
Integer[] nums = new Integer[]{9,5,2,7};
Arrays.fill(nums,99);
System.out.println(Arrays.toString(nums));
//equals 比较两个数组内容是否完全一致
Integer[] arr2 = {1,2,3,4,5};
//解读：如果arr和arr2数组的元素完全一致，返回true 否则 false
boolean equalValue = Arrays.equals(arr,arr2);
System.out.println(equalValue);
//asList 将一组值 装欢成list
//解读：1.asList方法 会将（2，3，4，5，6，1）数据转黄成一个List结合
//2.返回的 asList编译类型List(接口)
//3.asList 运行类型 java.util.Arrays#ArrayList,是Arrays类的
//静态内部类private static class ArrayList<E> extends AbstractList<E>
// implements RandomAccess, java.io.Serializable
List asList = Arrays.asList(2,3,4,5,6,1);
System.out.println("asList = " + asList);
System.out.println("asList的运行类型" + asList.getClass());
}
}
课堂练习
按照书的价格从大到小排序
package javabase.chapter13.arrays_;
import java.util.Arrays;
import java.util.Comparator;
public class ArraysExercise {
public static void main(String[] args) {
Book[] books = new Book[4];
books[0] = new Book("西游记",25.00);
books[1] = new Book("水浒传",22.00);
books[2] = new Book("红楼梦",28.00);
books[3] = new Book("三国演绎",35.00);
//1.price 从大到小排列
Arrays.sort(books, new Comparator<Book>() {
@Override
public int compare(Book o1, Book o2) {
double priVal = o1.getPrice() - o2.getPrice();
if (priVal > 0){
return 1;
}else if (priVal < 0){
return -1;
}else {
return 0;
}
}
});
System.out.println(Arrays.toString(books));
}
}
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 +
'}';
}
}
System类
常见方法和案例
- exit 退出当前程序
- arraycopy 复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成数组复制
- currentTimeMillens 返回当前时间距离1970-1-1的毫秒数
- gc 运行垃圾回收机制 System.gc();
package javabase.chapter13.system_;
import java.lang.reflect.Array;
import java.util.Arrays;
public class System_ {
public static void main(String[] args) {
//exit 退出当前程序
System.out.println("ok1");
//解读： exit(0) 表示程序退出 0表示一个状态 正常的状态
//System.exit(0);
System.out.println("ok2");
//arraycopy 复制数组元素 比较适合底层调用
//一般来说 使用Array.copyOf完成数组复制
int src[] = {1,2,3};
int[] desc = new int[3]; //当前是{0，0，0}
//解读：搞清5个形参的意思
//src 原数组 srcPos 原数组开始位置索引 dest 目标数组 destPos 从目标数组哪个索引开始 length 从原数组拷贝多少到目标数组
System.arraycopy(src,0,desc,0,desc.length);
System.out.println(Arrays.toString(desc));
//currentTimeMillens
System.out.println(System.currentTimeMillis());
}
}
BigInteger和BigDecimal类
介绍
应用场景
- BigInteger适合保存比较大的整数
- BigDecimal适合保存精度更高的浮点数（小数）
常用方法
- add 加
- substract 减
- multiply 乘
- divide 除
package javabase.chapter13.bignum;
import java.math.BigInteger;
public class BigInteger_ {
public static void main(String[] args) {
//long l = 11111111111111111111111111111111111111l; 太大了装不下
//使用 BigInteger来解决
BigInteger bigInteger1 = new BigInteger("111111111111111111111111111111111111");
BigInteger bigInteger2 = new BigInteger("111111111111111111111111111111111111");
//不能直接对BigInteger使用 + - * /
//使用对应的方法 进行加减乘除的操作
BigInteger add = bigInteger1.add(bigInteger2);
BigInteger subtract = bigInteger1.subtract(bigInteger2);
BigInteger multiply = bigInteger1.multiply(bigInteger2);
BigInteger divide = bigInteger1.divide(bigInteger2);
System.out.println(divide);
//在BigDecimal 中 方法基本一样 唯独注意 除时候 需要指定精度 .. BigDecimal.ROUND_CEILING
//否则可能会报错。如果由无线循环小数 就会保留 分子的精度
//System.out.println(bigDecimal.divide(bigDecimal2, BigDecimal.ROUND_CEILING));
}
}
日期类
第一代日期类
- Data 精确到毫秒，代表特定的瞬间
- SimpleDataFormat 格式和解析日期的类
package javabase.chapter13.data_;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Data01 {
public static void main(String[] args) {
// 获取当前系统时间 这里的date是在java.util包 默认输出的格式是国外的 这里需要对格式进行转换
Date date = new Date();
System.out.println(date);
Date date1 = new Date(789654123);
System.out.println(date1);
//创建SimpleDateFormat对象 可以指定相应的格式
//这里的格式使用的字母是规定好的 不能乱写
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");
String format = simpleDateFormat.format(date);
System.out.println(format);
//把一个格式化的String转换成对应date
//得到Date仍然在输出时，还是安高国外的形式输出，如果希望指定分时输出，需要转换
//在把String---Date 使用sdf格式需要和给你的String的格式一样 否则会抛出异常
String str = "1999年01月01日 10:20:15";
Date date2 = simpleDateFormat.parse(str);
simpleDateFormat.format(date2);
}
}
第二代日期类
第二代日期类 主要是calendar类 （日历）
Calendar类是一个抽象类，他为特定瞬间与一组诸如YEAR MONTH DAY_OF——MONTH Hour等日历字段之间的转换提供了一些方法，并未操作日历字段（例如获得下星期的日期）提供了一些方法
第三代日期类
前两代日期类的不足：
jdk1.0中包含了一个java.util.Date类，但是他的大多数方法已经在jdk1.0引入Calendar类之后被弃用了。而Calendar类也存在问题是：
- 可变性：像日期和时间这样的类应该是不可变的
- 偏移性：Date中的年份是从1900开始的，而月份是从0开始
- 格式化：格式化对Date有用，Calendar则不行
- 此外，他们也不是线程安全的 不能处理闰秒等（每隔两天 多出1s）
第三代日期类：
- LocalDate（日期/年月日） LocalTime（时间/时分秒） LocalDateTime（日期时间/年月日时分秒）
- LocalDate 只包含日期 可以获取日期字段
- LocalTime 只包含时间 可以获取时间字段
- LocalDateTime 包含时间+日期 可以获取日期和时间字段
package javabase.chapter13.data_;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
public class LocalDate_ {
public static void main(String[] args) {
//第三代日期类
//解读：1.使用now（）返回表示当前日期时间的对象
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println(localDateTime);
//2.使用DateTimeFormatter对象 来进行格式化
//创建DateTimeFormatter对象
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formatter = dateTimeFormatter.format(localDateTime);
System.out.println(formatter);
System.out.println(localDateTime.getYear());
LocalDate now = LocalDate.now();
System.out.println(now);
LocalTime localTime = LocalTime.now();
System.out.println(localTime);
//提供plus 和 minus 方法 可以对当前时间济宁加或减
LocalDateTime localDateTime1 = localDateTime.plusDays(200);
LocalDateTime localDateTime2 = localDateTime.plusDays(-1);
System.out.println(localDateTime2);
}
}
DateTimeFormatter格式日期类
类似于SimpleDateFormat
DateTimeFormatter dtf = DateTimeFormatter.ofPattern(格式)
String str = dtf.format(日期对象)
Instant时间戳
类似于Date 提供一些列和Date类转换的方式
package javabase.chapter13.data_;
import java.time.Instant;
import java.util.Date;
public class Instant_ {
public static void main(String[] args) {
//1.通过静态方法now()获取便是当前时间戳的对象
Instant now = Instant.now();
System.out.println(now);
//通过from 把Instant转成Date
Date date = Date.from(now);
System.out.println(date);
//通过date的toInstant 把date转成Instant对象
Instant instant = date.toInstant();
System.out.println(instant);
}
}
第三代日期类更多方法
自己查看api文档，这个东西 多的记不住的 用到了 再研究吧
本章作业
记得做一下 看视频比对结果是否正确
浙公网安备 33010602011771号