======================================================================================
首先,纠正一个经常犯下的错误:
String str = “123”;
//错误的,强转的前提必须是子父类的前提下!!!
int num = (int)str;
String 转 int:(调用包装类的静态方法,Integer.parseXxx())
String str = “123”;
//调用包装类的静态方法,才是正确的
int num = Integer.parseInt(str)
int 转 String:(调用包装类的静态方法,Integer.toString() 和 String.valueOf())
String s2;
String s3;
int num2 = 123;
//方式一:Integer.toString()方法
s2 = Integer.toString(num2);
//方式二:String.valueOf()方法
s3 = String.valueOf(num2);
System.out.println(s2.getClass()+ “,” +s3.getClass());
//class java.lang.String , class java.lang.String
//方式三:就是通过加空字符串 “” 。
String s4 = 123 + “”;
牢记toCharArray()函数方法:
package com.holmes.java04;
import org.junit.Test;
public class StringTest {
@Test
public void test1(){
String str1 = “abc123”;
//调用String的toCharArray()拆分字符串 转为 字符数组。
char[] charArray = str1.toCharArray();
//遍历一下charArray
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);
}
}
8.4 String字符串 和 byte[]字节数组 之间的转换
这里就会出现一个编码和解码的一个效果:
**String 转为 byte[]:
(调用String的getBytes()方法)**
package com.holmes.java04;
import org.junit.Test;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Array;
import java.util.Arrays;
public class StringTest {
@Test
public void test1() throws UnsupportedEncodingException {
//调用String的getBytes()方法
String str1 = “abc123中国”;
byte[] bytes = str1.getBytes(); //使用默认的字符集(utf-8),进行转换
//Arrays.toString()方法显示字符串。
System.out.println(Arrays.toString(bytes));
//[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67],这里结果就是aciII码
//此外,在utf-8当中一个汉字是占3个字节。
//使用gbk编码,就要添加参数
byte[] gbks = str1.getBytes(“gbk”);
System.out.println(Arrays.toString(gbks));
//[97, 98, 99, 49, 50, 51, -42, -48, -71, -6] 在gbk中一个汉字包含两个字节。
}
}
**byte[]字节数组 转 String字符串:
(new对象参数传入,来转换)**
package com.holmes.java04;
import org.junit.Test;
import java.io.UnsupportedEncodingException;
public class StringTest {
@Test
public void test1() throws UnsupportedEncodingException {
//调用String的getBytes()方法
String str1 = “abc123中国”;
byte[] bytes = str1.getBytes(); //使用默认的字符集(utf-8),进行转换
byte[] gbks = str1.getBytes(“gbk”);
//同样这里也是用默认的字符集(utf-8)来进行解码
String str2 = new String(bytes);
System.out.println(str2);
//因为这里是通过gbk编码的,但使用utf-8来解码就会乱码
String str3 = new String(gbks);
System.out.println(str3);
//abc123中国
//abc123�й�
}
}
===============================================================================
因为一个final,就导致结果不同,牢记常量与常量拼接的结果是存储在常量池中,且常量池不会存在相同内容的常量。final声明后变量就变成了常量!
package com.holmes.java04;
import org.junit.Test;
public class StringTest {
@Test
public void test1(){
String s1 = “javaEEhadoop”;
String s2 = “javaEE”;
String s3 = s2 + “hadoop”;
System.out.println(s1 == s3); //false
//final声明后,s4就变成了常量,常量和常量的拼接结果就在常量池中,因此返回true。
final String s4 = “javaEE”;
String s5 = s4 + “hadoop”;
System.out.println(s1 == s5); //true
}
}
10. StringBuffer 和 StringBuilder 介绍
=================================================================================================
本质上字符串存储规则,其实就是个char[]数组,String不可变,StringBuffer和StringBuilder可变。
String , StringBuffer , StringBuilder三者的异同?
String:不可变的字符序列。
StringBuffer:可变的字符序列:线程安全的,效率偏低。
StringBuilder:可变的字符序列:jdk5.0新增,线程不安全的,效率高。
上面三者底层使用char[]存储。(StringBuffer和StringBuilder因为继承AbstractStringBuilder,因此也是char[] value存储。)
11. String ,StringBuffer,StringBuilder 源码分析
=========================================================================================================
String源码分析:
String str = new String();
//执行实际源码为:char[] value = new char[0];
String str1 = new String(“abc”);
//执行实际源码为:char[] value = new char[]{‘a’,‘b’,‘c’};
StringBuffer源码分析:(StringBuilder源码差不多,就是安不安全的问题)
StringBuffer sb1 = new StringBuffer();
//执行实际源码为:char[] value = new char[16]; 底层创建了一个长度是16的数组。
sb1.append(‘a’); //value[0] = ‘a’;
sb1.append(‘b’); //value[1] = ‘b’;
StringBuffer sb2 = new StringBuffer(“abc”);
//执行实际源码为:char[] value = new char[“abc”.length() + 16]; 字符串的长度外加16个长度数组。
//问题1:System.out.println(sb2.length()); 输出为3呢,还是3+16呢?
//答案:其实和加不加16没关系,因为length返回的count,是数组中有多少数据。
//问题2:既然开始定义长度为16,一旦满了就会有一个扩容问题?
//如果要添加的数据底层数组盛不下了,那就需要扩容底层的数组。
//append方法中,调用了ensureCapacityInternal(确保容量完整的)方法,进而满足扩容。
//默认情况下扩容为原来容量的2倍(向左进位1,就是乘于2)+2,同时将原有数组中的元素复制到新的数组中。
开发中建议大家使用:StringBuffer(int capacity) 或 StringBuilder(int capacity)。可以直接定义容量大小,区别就是安全不安全。
12. StringBuffer 和 StringBuilder类常用的方法
====================================================================================================
StringBuffer和StringBuilder的常用方法差不多,都是一样:
当append和insert时,如果原来value数组长度不够,可扩容。
package com.holmes.java04;
import org.junit.Test;
public class StringBufferBuilderTest {
@Test
public void test1(){
StringBuffer sb1 = new StringBuffer(“abc”);
sb1.append(1);
sb1.append(‘1’);
System.out.println(sb1);
//注意:像delete这样的方法,删除的索引是左闭右开!!
sb1.delete(2,4);
System.out.println(sb1);
sb1.replace(2,4,“hello”);
System.out.println(sb1);
sb1.insert(2,“c”);
System.out.println(sb1);
sb1.reverse();
System.out.println(sb1);
System.out.println( sb1.indexOf(“c”));
System.out.println(sb1.substring(2,4));
System.out.println(sb1.charAt(5));
sb1.setCharAt(0,‘m’);
System.out.println(sb1);
}
}
方法链是一个很重要的形式,方法链的原理:
13. 对比String ,StringBuffer,StringBuilder的效率
=========================================================================================================
package com.holmes.java04;
import org.junit.Test;
public class StringBufferBuilderTest {
@Test
public void test1(){
long startTime = 0;
long endTime = 0;
String text = “”;
StringBuffer buffer = new StringBuffer(“”);
StringBuilder builder = new StringBuilder(“”);
startTime = System.currentTimeMillis();
for (int i = 0;i < 20000; i++){
buffer.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println(“StringBuffer的执行时间:” + (endTime - startTime));
startTime = System.currentTimeMillis();
for (int i = 0;i < 20000; i++){
builder.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println(“StringBuilder的执行时间:” + (endTime - startTime));
startTime = System.currentTimeMillis();
for (int i = 0;i < 20000; i++){
text += i;
}
endTime = System.currentTimeMillis();
System.out.println(“String的执行时间:” + (endTime - startTime));
//String的效率远远小于前两者
//效率从高到低排列: StringBuilder > StringBuffer > String
//考虑是否有线程安全问题是否要同步,就要使用StringBuffer. StringBuffer线程安全,StringBuilder线程不安全。
}
}
==================================================================================
计算世界时间的主要标准有:
方法一:
java.lang.System类的日期时间:(计算时间差)
-
System.currentTimeMillis()返回当前时间于1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
-
此方法经常用来计算时间差。
方法二:
java.util.Date类表示特定的瞬间,精确到毫秒:
package com.holmes.java04;
/*
方式一:两个构造器使用
构造器一:Date() :创建一个对应当前时间的Date对象。
构造器二:创建指定毫秒数(时间戳)的Date对象。
方式二:两个方法的使用
调用toString()方法:显示当前的年,月,日,时,分,秒。
getTime()方法:获取当前Date对象对应的毫秒数(时间戳)。
*/
import org.junit.Test;
import java.util.Date;
public class DateTimeTest {
@Test
public void test2(){
//构造器一:Date() :创建一个对应当前时间的Date对象
Date date1 = new Date();
//调用toString()方法:显示当前的年,月,日,时,分,秒
System.out.println(date1.toString());//Sat Nov 06 14:55:02 CST 2021
//getTime()方法:获取当前Date对象对应的时间戳
System.out.println(date1.getTime());//1636181996537
//构造器二:创建指定毫秒数(时间戳)的Date对象
Date date2 = new Date(1636181996537L);
System.out.println(date2.toString());
}
}
在sql也有一个,java.sql.Date类,对应着数据库中的日期类型的变量。
package com.holmes.java04;
/*
java.sql.Date类的Date对象:
同样调用toString()方法和getTime()方法
*/
import org.junit.Test;
import java.sql.Date;
public class DateTimeTest {
@Test
public void test2(){
//创建java.sql.Date的对象
Date date1 = new Date(23453456342L);
System.out.println(date1.toString()); //1970-09-29
System.out.println(date1.getTime()); //23453456342
}
}
怎么将sql.Date 转为 util.Date对象?
因为多态性,直接赋值就可。
package com.holmes.java04;
import org.junit.Test;
public class DateTimeTest {
@Test
public void test2(){
//创建java.sql.Date的对象
java.sql.Date date1 = new java.sql.Date(23453456342L);
//创建java.util.Date的对象
java.util.Date date2 = new java.util.Date();
//sql.Date 转 util.Date 多态性直接赋值就可
date2 = date1;
System.out.println(date2);
}
}
怎么将util.Date 转为 sql.Date对象?
因为参数都有毫秒(时间戳),所以我们可以通过getTime()的方式来解决这种问题!!
package com.holmes.java04;
import org.junit.Test;
public class DateTimeTest {
@Test
public void test2(){
//创建java.sql.Date的对象
java.sql.Date date1 = new java.sql.Date(23453456342L);
//创建java.util.Date的对象
//情况一:左边是util,右边是sql,多态性,这样就可以强转。
java.util.Date date2 = new java.sql.Date(32453476342L);
java.sql.Date date3 = (java.sql.Date)date2;
System.out.println(date3); //1971-01-11
//情况二:都是util直接强转会报错!!cannot be cast
java.util.Date date4 = new java.util.Date(32453476342L);
//java.sql.Date date5 = (java.sql.Date)date4; 错误的!
//但是有一个方法getTime(),来获得毫秒数就可以直接当作参数传递过去,就完美解决了
java.sql.Date date6 = new java.sql.Date(date4.getTime());
System.out.println(date6); //2021-11-06
}
}
================================================================================
16. JDK8之前日期时间API SimpleDateFormat类
=================================================================================================
SimpleDateFormat是对日期Date类的格式化和解析。
-
使用format()方法,格式化:日期 转为 字符串。
-
使用parse()方法,解析:格式化的逆过程,字符串 转为 日期
package com.holmes.java05;
import org.junit.Test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateTimeTest {
@Test
public void testSimpleDateFormat() throws ParseException {
//实例化SimpleDateFormat:使用默认的构造器
SimpleDateFormat sdf = new SimpleDateFormat();
//格式化:日期 转为 字符串
Date date = new Date();
String formatStr = sdf.format(date);
System.out.println(formatStr);
//解析:格式化的逆过程,字符串 转为 日期
//需要注意的是字符串的格式也必须和date格式一样,不然就抛出异常了
String str = “21-11-7 下午3:04”;
Date date1 = sdf.parse(str);
System.out.println(date1);
}
}
SimpleDateFormat的参数,不同格式的参数对应不同返回的结果。可以查看java参考手册这对SimpleDateFormat有参数的构造器这一节。
package com.holmes.java05;
import org.junit.Test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateTimeTest {
@Test
public void testSimpleDateFormat() throws ParseException {
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy.MM.dd G ‘at’ HH:mm:ss z”);
System.out.println(sdf.format(date));
//常用格式如下:
//年:小写y,月:大写M,时分秒:小写hms。
SimpleDateFormat sdf1 = new SimpleDateFormat(“yyyy-MM-dd hh:mm:ss”);
//格式化format:日期 转为 字符串
System.out.println(sdf1.format(date));
//解析,同样这里parse解析的格式也必须和参数定义的格式一样!!否则抛出异常
System.out.println(sdf1.parse(“1999-11-07 04:07:55”));;
//2021.11.07 公元 at 16:09:21 CST
//2021-11-07 04:09:21
//Sun Nov 07 04:07:55 CST 1999
}
}
很多页面传字符串"2020-09-08" 转为java.sql.Date(以方便存储数据库中)。
package com.holmes.java05;
import org.junit.Test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class DateTimeTest {
@Test
public void testExer() throws ParseException {
String str = “2020-09-08”;
//参数格式有一种为:“yyyy-MM-dd hh:mm:ss”
//要对应前端传过来的数据,像后面的hh:mm:ss,忽略就行。
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd”);
//util下的date
java.util.Date dateUtil = sdf.parse(str);
java.sql.Date dateSql = new java.sql.Date(dateUtil.getTime());
System.out.println(dateSql);
}
}
总天数差的一些计算,可以用到方法类和getTime类方法。
17. JDK8之前日期时间API Calendar(日历类)
=============================================================================================
首先,Calendar是一个抽象类,抽象类不能声明对象。
Calendar因为有set()方法可以随意改变日期,便有了可变性,一旦set()设置了指定日期,calendar就会设定。
虽然他不能声明对象,但它有个子类GregorianCalendar,该子类可以创建构造器。
Calendar(日历类)实例化方式:
-
方式一:创建其子类(GregorianCalendar)的对象。
-
方式二:调用其静态方法getInstance()来创建对象。
package com.holmes.java05;
import org.junit.Test;
import java.util.Calendar;
import java.util.GregorianCalendar;
public class DateTimeTest {
// Calendar日历类的使用
@Test
public void testExer(){
//1.实例化
//方式一:创建其子类(GregorianCalendar)的对象
GregorianCalendar gregorianCalendar = new GregorianCalendar();
//方式二:调用其静态方法getIntance()
Calendar calendar = Calendar.getInstance();
//其实调用getInstance()方法,还是用的子类GregorianCalendar。
System.out.println(calendar.getClass());//class java.util.GregorianCalendar
}
}
Calendar类的常用方法:
package com.holmes.java05;
import org.junit.Test;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
public class DateTimeTest {
// Calendar日历类的使用
@Test
public void testExer(){
//方式二:调用其静态方法getIntance()
Calendar calendar = Calendar.getInstance();
//常用方法
//1. get()方法操作:(获取当前日期)
//查看这个月的第几天:calendar.get(Calendar.DAY_OF_MONTH)
int days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(“查看这个月的第几天:” + days);
//查看今年的第几天:calendar.get(Calendar.DAY_OF_YEAR)
System.out.println(“查看今年的第几天:” + calendar.get(Calendar.DAY_OF_YEAR));
//2. set()方法操作:(重新设置当前日期)
calendar.set(Calendar.DAY_OF_MONTH,22);
System.out.println(“重新设置本月天数:”+ calendar.get(Calendar.DAY_OF_MONTH));
//3. add()方法操作:(在当前的日期基础上,增加)
calendar.add(Calendar.DAY_OF_MONTH,3);
System.out.println(“在当前的日期基础上,增加相应日期:”+ calendar.get(Calendar.DAY_OF_MONTH));
//4. getTime()方法操作:(通过日历类的getTime方法,获得了一个Date对象。)
Date date = calendar.getTime();
System.out.println(date);
//5. setTime()方法操作:(将Date对象)
Date date1 = new Date();
calendar.setTime(date1);
//注意在获取一月是0,星期时周日是1,周六是7.
//因此,月份要加1 ; 星期要减1
System.out.println(calendar.get(Calendar.YEAR)+ “年” + (calendar.get(Calendar.MONTH) + 1) + “月” + calendar.get(Calendar.DAY_OF_MONTH) + “号”);
System.out.println(“星期:” + (calendar.get(Calendar.DAY_OF_WEEK) - 1));
System.out.println(“今年的第几个周:” + calendar.get(Calendar.WEEK_OF_YEAR));
}
}
注意获取月份和星期时很重要!!
日期偏移量的问题:
package com.holmes.java05;
import org.junit.Test;
import java.util.Date;
public class JDKDateTimeTest {
@Test
public void testDate(){
//日期偏移量的问题:
//年要减1900,月要减1,才是我们想要得到的内容
Date date1 = new Date(2020 - 1900,9 - 1,8);
System.out.println(date1);
}
}
18. JDK8 新时间日期的 API (java.time)
=============================================================================================
JDK8中的新的java.time中包含了所有关于本地日期(LocalDate),本地时间(LocalTime),本地日期时间(LocalDateTime),时区(ZonedDateTime)和持续时间(Duration)的类。
18.2 LocalDate , LocalTime , LocalDateTime的使用
-
now()方法:用来创建对,获取当前的日期,时间。使用频率最高的是LocalDateTime。
-
of()方法:设置指定的年,月,日,时,分,秒。该方法设置没有偏移量的!!
创建了对象,那必须有方法对应,见下:
package com.holmes.java05;
import org.junit.Test;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
public class JDKDateTimeTest {
@Test
public void testDate(){
//now()方法:用来创建对,获取当前的日期,时间。使用频率最高的是LocalDateTime
LocalDate localDate = LocalDate.now();//Date日期
LocalTime localTime = LocalTime.now();//Time时间
LocalDateTime localDateTime = LocalDateTime.now();//DateTime日期加时间
System.out.println(localDate);//2021-11-09
System.out.println(localTime);//16:32:46.154
System.out.println(localDateTime);//2021-11-09T16:32:46.154
//of()方法:设置指定的年,月,日,时,分,秒。该方法设置没有偏移量的!!
LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 6, 13, 23, 13);
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()方法:设置相关属性:(注意它是有返回值的!!!)
//与Calendar类不同,这里体现了不可变性
//因为他有返回值,localDateTime2就是localDateTime.withDayOfMonth(22)的返回值对象。
//localDateTime 和 localDateTime2 之间不会相应。
LocalDateTime localDateTime2 = localDateTime.withDayOfMonth(22);//设置当前月份的天数
System.out.println(localDateTime);
System.out.println(localDateTime2);
LocalDateTime localDateTime3 = localDateTime.withHour(4);//设置当前小时
System.out.println(localDateTime);
System.out.println(localDateTime3);
//plusXxx()方法:是添加属性数量
LocalDateTime localDateTime4 = localDateTime.plusMonths(3);
System.out.println(localDateTime);
System.out.println(localDateTime4);
//minuxXxx()方法:上面是加法,那么这里就是做减法了
LocalDateTime localDateTime5 = localDateTime.minusDays(4);
System.out.println(localDateTime);
System.out.println(localDateTime5);
}
}
java.time.Instant也是基于1970年1月1日0时0分0秒(UTC)开始。
首先,要确定一个时区问题,UTC是按照本初子午线来开始的。
两种创建Instant实例方式:
-
now()方法:获取本初子午线对应的标准时间(UTC)
-
ofEpochMilli()方法:也是实例化的方式,它可以接受long型的参数,从而获取时间。
instant实例化对应的方法:
-
atOffset()方法:定义时区偏移量的。
-
toEpochMilli()方法:获取从1970年1月1日0时0分0秒(UTC)开始到现在对应的毫秒数
package com.holmes.java05;
import org.junit.Test;
import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
public class InstantTest {
@Test
public void test(){
//now()方法:获取本初子午线对应的标准时间(UTC)
Instant instant = Instant.now();
//这里算出的是本初子午线的时间,也就是伦敦的位置时区
System.out.println(instant);//2021-11-11T09:02:36.799Z
//atOffset()方法:我们北京位处东八区,因此要加8个小时。offsetDateTime就是用来定义时区偏移量的
OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
System.out.println(offsetDateTime);//2021-11-11T17:02:36.799+08:00
//toEpochMilli()方法:获取从1970年1月1日0时0分0秒(UTC)开始到现在对应的毫秒数
long l = instant.toEpochMilli();
System.out.println(l);//1636621675611
//ofEpochMilli()方法:也是实例化的方式,它可以接受long型的参数,从而获取时间。
Instant instant1 = Instant.ofEpochMilli(1636621675611L);
System.out.println(instant1);
}
}
**总结:
本质上,Date类和Instant类差不多,功能和方法都差不多。**
18.4 JDK8 新日期时间API java.time.format.DateTimeFormatter
这里DateTimeFormatter就与上面的SimpleDateFormat差不多。
方式一:预定义的标准格式,ISO_LOCAL_DATE_TIME,ISO_LOCAL_DATE,ISO_LOCAL_TIME
-
format()方法格式化:日期 --》 字符串。
-
parse()方法解析:字符串 --》 日期
package com.holmes.java05;
import org.junit.Test;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAccessor;
public class DateTimeFormatterTest {
@Test
public void test(){
//方式一:预定义的标准格式,ISO_LOCAL_DATE_TIME,ISO_LOCAL_DATE,ISO_LOCAL_TIME
DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
//format()方法格式化:日期 --》 字符串
LocalDateTime localDateTime = LocalDateTime.now();
String str1 = formatter.format(localDateTime);
System.out.println(str1);//2021-11-11T17:45:51.145
//parse()方法解析:字符串 --》 日期
TemporalAccessor parse = formatter.parse(“2021-11-11T17:45:51.145”);
System.out.println(parse);
}
}
方式二:本地化相关的格式
- **1.ofLocalizedDateTime()方法:(ofLocalizeDateTime对应的就是DateTime的格式类)
参数:FormatStyle.SHORT, FormatStyle.MEDIUM, FormatStyle.LONG**
- **2.ofLocalizedDate()方法:(ofLocalizeDate对应的就是Date的格式类)
参数:相比较上面多了一个FormatStyle.FULL,FormatStyle.SHORT, FormatStyle.MEDIUM, FormatStyle.LONG**
package com.holmes.java05;
import org.junit.Test;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;
import java.util.Date;
public class DateTimeFormatterTest {
@Test
public void test2(){
//方式二:本地化相关的格式
//1.ofLocalizedDateTime()方法:(ofLocalizeDateTime对应的就是DateTime的格式类)
//参数:FormatStyle.SHORT, FormatStyle.MEDIUM, FormatStyle.LONG
DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
LocalDateTime localDateTime = LocalDateTime.now();
//不同的参数,获得的格式也不同。
String str = formatter.format(localDateTime);
System.out.println(str);//21-11-11 下午6:20
TemporalAccessor parse = formatter.parse(“21-11-11 下午6:20”);
System.out.println(parse);//{},ISO resolved to 2021-11-11T18:20
//2.ofLocalizedDate()方法:(ofLocalizeDate对应的就是Date的格式类)
//参数:相比较上面多了一个FormatStyle.FULL,FormatStyle.SHORT, FormatStyle.MEDIUM, FormatStyle.LONG
//同样不同的参数,也是获得不同的格式
DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
String str2 = formatter1.format(LocalDate.now());
System.out.println(str2);//2021年11月11日 星期四
}
}
方式三:自定义的格式,这种方式是重点!!
- **ofPattern()方法:来自定义
ofPattern(“yyyy-MM-dd hh:mm:ss”)。**
package com.holmes.java05;
import org.junit.Test;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;
import java.util.Date;
public class DateTimeFormatterTest {
@Test
public void test3(){
//方式三:自定义的格式,如:ofPattern(“yyyy-MM-dd hh:mm:ss”)
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(“yyyy-MM-dd hh”);
//格式化
String str = formatter.format(LocalDateTime.now());//2021-11-11 06
System.out.println(str);//2021-11-11 06
//解析
TemporalAccessor parse = formatter.parse(“2021-11-11 06”);
System.out.println(parse);//{HourOfAmPm=6},ISO resolved to 2021-11-11
}
}
=========================================================================
Java中的对象(引用数据类型),正常情况下,只能进行比较使用 == ,=!来比较地址值,像 >,< ,>= ,<=等没办法对引用数据类型对象进行比较的。
但是在开发场景中,我们需要对多个对象进行排序,言外之意,就需要比较对象的大小。
这就用到了Comparable 或 Comparator接口了。
像实现Comparable接口调用sort方法也叫做自然排序。
Comparable接口的使用举例:
-
像String,包装类等实现了Comparable接口,重写了compareTo(obj)方法,给出了比较两个对象大小的方式。
-
重写compareTo(obj)的规则:
如果当前对象this大于形参对象obj,则返回正整数;
如果当前对象this小于形参对象obj,则返回负数;
如果当前对象this等于形参对象obj,则返回零。
像String这种系统类排序处理:
实现Comparable接口的对象列表(和数组)可以通过 Collection.sort(针对集合排序) 或 Arrays.sort(针对数组排序) 进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素,无序指定比较器。
package com.holmes.java05;
import org.junit.Test;
import java.util.Arrays;
public class CompareTest {
@Test
public void test(){
//像String,包装类等实现了Comparable接口,重写了compareTo()方法,给出了比较两个对象大小的方式
String[] arr = new String[]{“AA”,“CC”,“MM”,“BB”,“OO”,“FF”};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
对于自定义类来说:
如果需要排序,我们可以让自定义类实现Comparable接口,重写compareTo(obj)方法。
在compareTo(obj)方法中指明如何排序。
同时,可能排序遇到相同的会存在二级排序的情况。
自定义类实例:
goods类:
package com.holmes.java05;
public class Goods implements Comparable{
private String name;
private double price;
public Goods() {
}
public Goods(String name,double price) {
this.name = name;
this.price = price;
}
public String getName() {
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Android开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
Java中的对象(引用数据类型),正常情况下,只能进行比较使用 == ,=!来比较地址值,像 >,< ,>= ,<=等没办法对引用数据类型对象进行比较的。
但是在开发场景中,我们需要对多个对象进行排序,言外之意,就需要比较对象的大小。
这就用到了Comparable 或 Comparator接口了。
像实现Comparable接口调用sort方法也叫做自然排序。
Comparable接口的使用举例:
-
像String,包装类等实现了Comparable接口,重写了compareTo(obj)方法,给出了比较两个对象大小的方式。
-
重写compareTo(obj)的规则:
如果当前对象this大于形参对象obj,则返回正整数;
如果当前对象this小于形参对象obj,则返回负数;
如果当前对象this等于形参对象obj,则返回零。
像String这种系统类排序处理:
实现Comparable接口的对象列表(和数组)可以通过 Collection.sort(针对集合排序) 或 Arrays.sort(针对数组排序) 进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素,无序指定比较器。
package com.holmes.java05;
import org.junit.Test;
import java.util.Arrays;
public class CompareTest {
@Test
public void test(){
//像String,包装类等实现了Comparable接口,重写了compareTo()方法,给出了比较两个对象大小的方式
String[] arr = new String[]{“AA”,“CC”,“MM”,“BB”,“OO”,“FF”};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
对于自定义类来说:
如果需要排序,我们可以让自定义类实现Comparable接口,重写compareTo(obj)方法。
在compareTo(obj)方法中指明如何排序。
同时,可能排序遇到相同的会存在二级排序的情况。
自定义类实例:
goods类:
package com.holmes.java05;
public class Goods implements Comparable{
private String name;
private double price;
public Goods() {
}
public Goods(String name,double price) {
this.name = name;
this.price = price;
}
public String getName() {
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
[外链图片转存中…(img-KI0ZZMBC-1715334630395)]
[外链图片转存中…(img-f6EqQkPB-1715334630395)]
[外链图片转存中…(img-eQKYKdFh-1715334630396)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Android开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!