Java常用类

字符串相关的类

String的特性

String类:代表字符串。Java程序中的所有字符串字面值(如 "abc"）都作为此类的实例实现。
String是一个final类，代表不可变的字符序列。
字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。
String对象的字符内容是存储在一个字符数组value[]中的。

String对象的创建

String的实例化方式
- 通过字面量定义的方式
- 通过new+构造器的方式

		//本质上在字符串常量池存储hello，在栈上存储地址。
		String str = "hello";
		//本质上this.value = new char[0];
		String s1 = new String();
		//this.value = original.value;
		String s2 = new String(str);
		//this.value = Arrays.copyOf(value, value.length);
		char[]a  = {'a','1','2','3'};
		String s3 = new String(a);
		String s4 = new String(a,1,2);
		
		System.out.println(s1);//("")
		System.out.println(s2);//hello
		System.out.println(s3);//a123
		System.out.println(s4);//12

字符串常量存储在字符串常量池，目的是共享。
字符串非常量对象存储在堆中。

字符串的特性

常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
只要其中有一个是变量，结果就在堆中
如果拼接的结果调用intern()方法，返回值就在常量池中

//		常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
//		只要其中有一个是变量，结果就在堆中
//		如果拼接的结果调用intern()方法，返回值就在常量池中
		String s1 = "javaEE";
		String s2 = "hadoop";
		String s3 = "javaEEhadoop" ;
		String s4 = "javaEE" +"hadoop";
		String s5 = s1 +"hadoop" ;
		String s6 = "javaEE" + s2;
		String s7 = s1 + s2;
		System.out.println(s3 == s4);//true
		System.out.println(s3 == s5);//false
		System.out.println(s3 == s6);//false
		System.out.println(s3 == s7);//false
		System.out.println(s5 == s6);//false
		System.out.println(s5 == s7);//false
		System.out.println(s6 == s7);//false
		
		String s8 = s5.intern();
		System.out.println(s8 == s3);//true

String使用陷阱

String s1 = "a";
说明:在字符串常量池中创建了一个字面量为"a"的字符串
s1 = s1 + "b";
说明:实际上原来的“a”字符串对象已经丢弃了，现在在堆空间中产生了一个字符串s1+"b"(也就是"ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能。
String s2 = "ab";
说明:直接在字符串常量池中创建一个字面量为"ab"的字符串。
String s3 = "a" + "b";
说明:s3指向字符串常量池中已经创建的"ab"的字符串。
String s4 = s1.intern();
说明:堆空间的s1对象在调用intern()之后，会将常量池中已经存在的"ab"字符串赋值给s4。

String常用方法

字符串简单运算方法

int length():返回字符串的长度:return value.length
char charAt(int index):返回某索引处的字符return value[index]
boolean isEmpty():判断是否是空字符串: return value.length == o
String toLowerCase():使用默认语言环境，将 String 中所有字符转换为小写
String toUpperCase():使用默认语言环境，将 String中的所有字符转换为大写
String trim():返回字符串的副本，忽略前导空白和尾部空白
boolean equals(Object obj):比较字符串的内容是否相同boolean
equalslgnoreCase(String anotherString):与equals方法类似，忽略大小写
String concat(String str):将指定字符串连接到此字符串的结尾。等价于用“+”
int compareTo(String anotherString):比较两个字符串的大小（相当于转成int型进行减法）可以进行字符串排序
String substring(int beginIndex):返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
String substring(int beginIndex, int endIndex):返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始

字符串查找方法

boolean contains(CharSequence s):当且仅当此字符串包含指定的char 值序列时，返回true（查找是否存在）
int indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str, int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str, int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索

注: indexOf和lastIndexOf方法如果未找到都是返回-1

字符串其他方法（替换、正则...）

String replace(char oldChar,char newChar):返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。（找不到就不操作）
String replace(CharSequence target, CharSequence replacement):使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
String replaceAll(String regex,String replacement):使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串。
String replaceFirst(String regex,String replacement):使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串。
boolean matches(String regex):告知此字符串是否匹配给定的正则表达式。
String]split(String regex):根据给定正则表达式的匹配拆分此字符串。
String[]split(String regex, int limit):根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

正则表达式简单示例

		String str = "12hello34world5java7891mysq1456";
		//把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
		//^，开头 ，$结尾
		String string = str.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
		System.out.println(string);
		
		
		
		String str1 = "12345";
		//判断str字符串中是否全部有数字组成，即有1-n个数字组成
		boolean matches = str1.matches ( "\\d+");
		System.out. println(matches);
		
		
		String tel = "0571-4534289";//判断这是否是一个杭州的固定电话
		boolean result = tel.matches ( "0571-\\d{7,8}");
		System.out.println(result);

//根据| 拆分为不同的字符串
		String str = "hello|world|java";
		String[]strs = str.split("\\|");
		for (int i = 0; i < strs.length; i++) {
			System.out.println(strs[i]);
		}

类型转换

字符串→基本数据类型、包装类

Integer包装类的public static int parselnt(String s):可以将由“数字”字符组成的字符串转换为整型。
类似地,使用java.lang包中的Byte、Short、Long、FloatDouble类调相应的类方法可以将由“数字”字符组成的字符串，转化为相应的基本数据类型。

基本数据类型、包装类→字符串

调用String类的public String valueOf(int n)可将int型转换为字符串

相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(doubled)、valueOf(boolean b)可由参数的相应类型到字符串的转换

		String str1 = "123";
		int a =  Integer.valueOf(str1);
		System.out.println(a);//123
		
		String str2 = String.valueOf(a);
		System.out.println(str2);//"123"
		
		String str3 = a+"";//在常量池中
		System.out.println(str3);//"123"

字符数组→字符串

String类的构造器:String(char)和 String(char[]，int offset,intlength)分别用字符数组中的全部字符和部分字符创建字符串对象。

字符串→字符数组

public char[] toCharArray():将字符串中的全部字符存放在一个字符数组中的方法。

public void getChars(int srcBegin, int srcEnd, char[] dst,int dstBegin):提供了将指定索引范围内的字符串存放到数组中的方法。

		// 字符串--字符数组
		String a = "abcd";
		char[] b = a.toCharArray();
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);//a b c d
		}
		//字符数组--字符串
		char[] c = {'s','d','w','a'};
		String d = new String(c);//通过构造器
		System.out.println(d);//sdwa

字节数组→字符串

String(byte[):通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
String(byte，int offset,int length):用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象。

字符串→字节数组

public bytell getBytes():使用平台的默认字符集将此String编码为byte序列，并将结果存储到一个新的byte 数组中。

public bytell getBytes(String charsetName):使用指定的字符集将此String 编码到 byte序列，并将结果存储到新的 byte数组。

		//字符串--字节码数组
		String str = "abc123汉字";
		byte[] bytes = str.getBytes();//默认使用设置的解码方式解码（这里是GBK）
		System.out.println(Arrays.toString(bytes));
		//[97, 98, 99, 49, 50, 51, -70, -70, -41, -42]
		
		
		byte[] utf = str.getBytes("UTF-8");//使用UTF-8解码
		System.out.println(Arrays.toString(utf));
		//[97, 98, 99, 49, 50, 51, -26, -79, -119, -27, -83, -105]
	
		//字节码数组--字符串
		
		String str0 = new String(bytes);//使用默认的编码
		System.out.println(str0);//abc123汉字
		
		String str1 = new String(utf,"UTF-8");//指定编码方式编码
		System.out.println(str1);//abc123汉字

StringBuffer类

String 和StringBuffer、StringBuilder三者的异同？
不同点：
- String：不可变的字符序列;
- StringBuffer：可变的字符序列，线程安全的，效率低;
- StringBuilder：可变的字符序列，JDK5.0新增，线程不安全的，效率高;
相同点：
- 都是使用char[] 数组存储

扩容机制

对于StringBuffer和StringBuilder来说，如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。

默认情况下，扩容为原来容量的2倍＋2，同时将原有数组中的元素复制到新的数组中。

指导意义：

实际开发中为了效率应使用StringBuffer(int capacity)或者StringBuilder(int capacity)来创建字符串

package String;

public class Demo09 {
	public static void main(String[] args) {
		String str = new String();
		//char[] value = new char[0];
		String str1 = new String("abc");
		//char[] value = new char[]{'a','b','c'};
		
		StringBuffer sb1 = new StringBuffer();
		//char[] value = new char[16];
		//底层创建了一个长度为16的char[]数组。
		sb1.append('a');
		//value[0] = 'a';
		sb1.append('b');
		//value[1] = 'b';
		
		StringBuffer sb2 = new StringBuffer("abc");
		//char[] value = new char["abc".length+16]
	}
}

StringBuffer类常用方法

StringBuffer append(xxx):提供了很多的append()方法，用于进行字符串拼接
StringBuffer delete(int start,int end):删除指定位置的内容
StringBuffer replace(int start, int end, String str):把[start,end)位置替换为str
StringBuffer insert(int offset,xxx):在指定位置插入XXX
StringBuffer reverse():把当前字符序列逆转

字符串练习题

模拟一个trim方法，去除字符串两端的空格。

package String;

public class Demo04 {
	public static void main(String[] args) {
		//模拟一个trim方法，去除字符串两端的空格。
		String str = "   最 初 的 回忆    ";
//		String str1 =  str.trim();
//		System.out.println(str1);//最 初 的 回忆
		String str2 = trimDemo(str);
		System.out.println(str2);//最 初 的 回忆
	}
	//trimDemo方法
	static String trimDemo(String str) {
		char[] chars = str.toCharArray();
		int st = 0;
		int len=chars.length;
		while(st<chars.length && chars[st]==' ') {
			st++;
		}
		while(st<chars.length && chars[len-1]==' ') {
			len--;
		}
		if (st>0||len<chars.length) {
			return str.substring(st,len);
		}else {
			return str;
		}
	}
}

将一个字符串进行反转。将字符串中指定部分进行反转。比如"abcdefg"反转为”abfedcg"

public String reverse3(String str, int start, int end) {
		StringBuffer s = new StringBuffer(str.length());
		s.append(str.substring(0, start));
		for (int i = end; i >= start; i--) {
			s.append(str.charAt(i));
		}
		s.append(str.substring(end + 1));
		return s.toString();
	}

获取一个字符串在另一个字符串中出现的次数。比如:获取“ab”在“abkkcadkabkebfkabkskab”中出现的次数

package String;

public class Demo06 {
	public static void main(String[] args) {
//		获取一个字符串在另一个字符串中出现的次数。
//		比如:获取“ab”在“abkkcadkabkebfkabkskab”中出现的次数
		String str = "abkkcadkabkebfkabkskab";
		String str1 = "ab";
		
		System.out.println(appearCount(str, str1));
	}
	public static int appearCount(String str,String contain) {
		int index = str.indexOf(contain);
		int count = 0;
		while (index != -1) {
			index = str.indexOf(contain,index+1);
			count++;
		}
		return count;
	}
}

获取两个字符串中最大相同子串。比如:str1 = "abcwerthelloyuiodef;str2 = "cvhellobnm"

提示:将短的那个串进行长度依次递减的子串与较长的串比较。

package String;

public class Demo07 {
	public static void main(String[] args) {
		String str1 = "abcwerthelloyuiodef";
		String str2 = "sadahellocvbcvb";
		
		System.out.println(SeekMaxSameString(str1, str2));
		
	}
	public static String SeekMaxSameString(String str1,String str2) {
		int maxLen = 0;
		int st = 0;
		String str = str2;
		for (int i = 0; i < str.length(); i++) {
			for (int j = str.length()-i; j > 0; j--) {
				int st1 = str1.indexOf(str2);
				if (st1>= 0 && str2.length()>maxLen) {
					maxLen = str2.length();
					st = st1;
				}
				str2 = str2.substring(0,j);
			}
			str2 = str.substring(i);
		}
		return str1.substring(st,st + maxLen);
	}
}

对字符串中字符进行自然顺序排序。

提示:
字符串变成字符数组。
对数组排序，选择，冒泡，Arrays.sort();3）将排序后的数组变成字符串。

package String;

import java.util.Arrays;

public class Demo08 {
	public static void main(String[] args) {
		String demo = "davxcvfgerqeqfdhvbnv36454864";
		System.out.println(Stringsort(demo));;
		
	}
	public static String Stringsort(String str) {
		byte[] demo = str.getBytes();
		Arrays.sort(demo);
		String str1 = new String(demo);
		return str1;
	}
}

面试题

		String str = null;
		StringBuffer sb = new StringBuffer();
		sb.append(str);
		
		System.out.println(sb.length());//4
		
		
		
		System.out.println(sb);//null
		
		StringBuffer sb1 = new StringBuffer(str);//空指针异常
		System.out.println(sb1);

JDK8 之前的日期、时间API

java.lang.System类

System类提供的public static long currentl imeMIs()用米这刖N间与1970年1月1日0时0分O秒之间以毫秒为单位的时间差。

此方法适于计算时间差

计算世界时间的主要标准有:
- UTC(Coordinated Universal Time)
- GMT(Greenwich Mean Time)
- CST(Central Standard Time)

	long time = System.currentTimeMillis();
		System.out.println(time);
		//这个时间是时间戳。

java.util.Date类

表示特定的瞬间，精确到毫秒

构造器
- Date():使用无参构造器创建的对象可以获取本地当前时间。
- Date(long date)
常用方法
- getTime():返回自1970年1月1日00:00:00 GMT以来此 Date 对象表示的毫秒数。获取当前Data对象对应的时间戳
- toString():把此Date对象转换为以下形式的 String:dow mon ddhh:mm:ss zzz yyyy其中:dow是一周中的某一天(Sun,Mon,Tue,Wed，Thu,Fri, Sat)，zzz是时间标准。
- 其它很多方法都过时了。
java.sql.Data类

对应着数据库中的日期类型的变量

实例化?

将java.until.Date对象转换为java.sql.Date?

package com.company.timedatatest;


import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
//        创建java.sqL.Date对象
        java.sql.Date date3 = new java.sql.Date(35235325345L);
        System.out.println(date3);//1971-02-13

//        如何将java.utiL.Date对象转换为java.sqL.Date对象转换为java
//        情况一
        Date date4 = new java.sql.Date(2343243242323L);
        java.sql.Date date5 = (java.sql.Date) date4;
        System.out.println(date5);//2044-04-03
//        情况二
        Date date6 = new Date();
        /*
        错误示范
        java.sql.Date date7 = (java.sql.Date) date6;
        System.out.println(date7);
         */
        java.sql.Date date7 = new java.sql.Date( date6.getTime());
        System.out.println(date7);

    }
}

java.text.SimpleDateFormat类

Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类。
它允许进行格式化:日期→文本、解析:文本→日期
格式化:
- SimpleDateFormat():默认的模式和语言环境创建对象
- public SimpleDateFormat(String pattern):该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用:
- public String format(Date date):方法格式化时间对象date
解析:
- public Date parse(String source):从给定字符串的开始解析文本，以生成一个日期。

package dateAPI;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.SimpleTimeZone;

public class Demo01 {
    public static void main(String[] args) throws ParseException {
        //实例化 默认格式化
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
        //格式化 日期--字符串
        Date date = new Date();
        System.out.println(date);//Mon Oct 18 20:07:43 CST 2021

        String format = simpleDateFormat.format(date);
        System.out.println(format);//21-10-18 下午8:08

        //解析 格式化的逆过程，字符串--日期
        String str = "18-10-10 下午7:18";
        Date date1 = simpleDateFormat.parse(str);
        System.out.println(date1);//Wed Oct 10 19:18:00 CST 2018

        //*****************************************
        System.out.println("****************************");
        //实例化
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        //格式化
        Date date2 = new Date();
        String str2 = simpleDateFormat1.format(date2);
        System.out.println(str2);
        //解析
        Date date3 = simpleDateFormat1.parse("2020-02-18 11:18:26");
        System.out.println(date3);
    }
}

练习题

//    字符串"2020-09-08"转换为 java.sql.date类型
    public static void main(String[] args) throws ParseException {
        String str = "2020-09-08";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf.parse(str);
        System.out.println(date);

        java.sql.Date birthDate = new java.sql.Date(date.getTime());
        System.out.println(birthDate);
    }

    public static void main(String[] args) throws ParseException {
//        渔夫三天打鱼两天晒网，从1990-01-01开始到现在，问今天是在打鱼还是晒网？

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date2 = sdf.parse("1990-01-01");
        Date date1 = sdf.parse("2020-09-08");
        long time = date1.getTime()-date2.getTime();
        long day = 1000*60*60*24;
        long zhou = 5*day;
        if (time % zhou <= (3*day)) {
            System.out.println("渔夫在打鱼");
        }else{
            System.out.println("渔夫在晒网");
        }
    }

java.util.Calendar(日历)类

Calendar是一个抽象基类，主用用于完成日期字段之间相互操作的功能。
获取Calendar实例的方法
- 使用Calendar.getInstance()方法
- 调用它的子类GregorianCalendar的构造器。
一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY 、MINUTE、SECOND
- public void set(int field ,int value)
- public void add(int field,int amount)
- public final Date getTime()
- public final void setTime(Date date)
- 注意:
  - 获取月份时:一月是0，二月是1，以此类推，12月是11
  - 获取星期时:周日是1，周二是2，。。。。周六是7

package dateAPI;

import java.nio.charset.Charset;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

public class Demo04 {
    public static void main(String[] args) {

//      Calendar日历类（抽象类）
//      1.实例化
//     方式一：创建其子类（GregorianCalendar）的对象
//     方式二：调用其静态方法 getInstance
//      Calendar calendar = new GregorianCalendar();
        Calendar calendar1 = Calendar.getInstance();
//      System.out.println(calendar);
        System.out.println(calendar1);
        //java.util.GregorianCalendar[time=1634560864400,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2021,MONTH=9,WEEK_OF_YEAR=43,WEEK_OF_MONTH=4,DAY_OF_MONTH=18,DAY_OF_YEAR=291,DAY_OF_WEEK=2,DAY_OF_WEEK_IN_MONTH=3,AM_PM=1,HOUR=8,HOUR_OF_DAY=20,MINUTE=41,SECOND=4,MILLISECOND=400,ZONE_OFFSET=28800000,DST_OFFSET=0]
//      2.常用方法
//      get()
        int days = calendar1.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);
//      set()
        calendar1.set(Calendar.DAY_OF_MONTH,22);
        days = calendar1.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);

//        add()
        calendar1.add(Calendar.DAY_OF_MONTH,3);
        days = calendar1.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);

//        getTime() 日历类---Date类
        Date date = calendar1.getTime();
        System.out.println(date);

//        setTime()  Date类---日历类
        calendar1.setTime(date);
        System.out.println(calendar1.get(Calendar.DAY_OF_MONTH));

    }
}

JDK8中新日期时间API

新日期时间API出现的背景

如果我们可以跟别人说:“我们在1502643933071见面，别晚了!”那么就再简单不过了。但是我们希望时间与昼夜和四李有大，‘EIDK1%1入Calendar类之后被弃用一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引了。而Calendar并不比Date好多少。它们面临的问题是:
- 可变性:像日期和时间这样的类应该是不可变的。
- 偏移性:Date中的年份是从1900开始的，而月份都从O开始。
- 格式化:格式化只对Date有用，Calendar则不行。
- 此外，它们也不是线程安全的;不能处理闰秒等。
总结:对日期和时间的操作一直是Java程序员最痛苦的地万之一。

新时间日期API

第三次引入的API是成功的，并且Java 8中引入的java.time API已经纠正了过去的缺陷，将来很长一段时间内它都会为我们服务。
Java8吸收了Joda-Time 的精华，以一个新的开始为Java创建优秀的API。新的java.time 中包含了所有关于本地日期（LocaIDate)本地时间(LocalTime）、本地日期时间（(LocalDateTime）、时区(ZonedDateTime）和持续时间（Duration）的类。历史悠久的Date类新增了tolnstant()方法，
用于把 Date转换成新的表示形式。这些新增的本地化时间日期API大大简化了日期时间和本地化的管理。

新时间日期API

java.time-包含值对象的基础包

java.time.chrono-提供对不同的日历系统的访问

java.time.format-格式化和解析时间和日期

java.time.temporal-包括底层框架和扩展特性java.time.zone-包含时区支持的类

LocaIDate、LocalTime、LocalDateTime类是其中较重要的几个类，它们的实例是不可变的对象，分别表示使用ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。
LocalDate代表IOS格式(yyyy-MM-dd）的日期,可以存储生日、纪念日等日期。
LocalTime表示一个时间，而不是日期。
LocalDateTime是用来表示日期和时间的，这是一个最常用的类之一。
注:ISO-8601日历系统是国际标准化组织制定的现代公民的日期和时间的表示法，也就是公历。

常用方法

方法	描述
now()/now(Zoneld zone)	静态方法，根据当前时间创建对象/指定时区的对象
of()	静态方法，根据指定日期/时间创建对象
getDayOfMonth()/getDayOfYear()	获得月份天数(1-31)/获得年份天数(1-366)
getDayofWeek()	获得星期几(返回一个DayOfWeek枚举值）
getMonth()	获得月份,返回一个Month枚举值
getMonthValue() l getYear()	获得月份(1-12)/获得年份
getHour()/getMinute()/getSecond()	获得当前对象对应的小时、分钟、秒
withDayOfMonth()/withDayOfYear()/	将月份天数、年份天数、月份、年份修改为指定的值并返回新的对象
plusDays(), plusWeeks(),plusMonths(), plusYears(),plusHours()	向当前对象添加几天、几周、几个月、几年、几小时
minusMonths() /minusWeeks()/minusDays()/minusYears()/minusHours()	从当前对象减去几月、几周、几天、几年、几小时

package com.time;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Demo01 {
    public static void main(String[] args) {
//        实例化
//        方式一：
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDate);//2021-10-19
        System.out.println(localTime); //20:31:34.173
        System.out.println(localDateTime);//2021-10-19T20:31:34.173
//        of方法 设置指定的时间
        LocalDate localDate1 = LocalDate.of(2020,10,9);
        System.out.println(localDate1);//2020-10-09
//        getxxx()获取年月日等等时间
        System.out.println(localDate1.getDayOfMonth());//9
//        with修改时间 体现其不可变性
        LocalDate localDate2 = localDate.withMonth(11);
        System.out.println(localDate);//2021-10-19
        System.out.println(localDate2);//2021-11-19

    }
}

瞬时：Instant

Instant:时间线上的一个瞬时点。这可能被用来记录应用程序中的事件时间戳。
在处理时间和日期的时候，我们通常会想到年,月,日,时,分,秒。然而，这只是时间的一个模型，是面向人类的。第二种通用模型是面向机器的，或者说是连续的。在此模型中，时间线中的一个点表示为一个很大的数，这有利于计算机处理。在UNIX中，这个数从1970年开始，以秒为的单位;同样的，在Java中，也是从1970年开始，但以毫秒为单位。
java.time包通过值类型Instant提供机器视图，不提供处理人类意义上的时间单位。Instant表示时间线上的一点，而不需要任何上下文信息，例如，时区。概念上讲，它只是简单的表示自1970年1月1日0时0分0（UTC）开始的秒数。因为java.time包是基于纳秒计算的，所以Instant的精度可以达到纳秒级。

DateTimeFormatter

java.time.format.DateTimeFormatter类:该类提供了三种格式化方法:
预定义的标准格式。如:

ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
本地化相关的格式。如: ofLocalizedDateTime(FormatStyle.LONG)

自定义的格式。如: ofPattern("yyyy-MM-dd hh:mm:ss"）

方法	描述
ofPattern(String pattern)	静态方法﹐返回一个指定字符串格式的DateTimeFormatter
format(TemporalAccessor t)	格式化一个日期、时间，返回字符串
parse(CharSequence text)	将指定格式的字符序列解析为一个日期、时间

package com.time;

import javax.swing.text.DateFormatter;
import java.text.DateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;

public class Demo03 {
    public static void main(String[] args) {
    //预定义的标准格式。如:ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
    //
    //本地化相关的格式。如: ofLocalizedDateTime(FormatStyle.LONG)
    //
    //自定义的格式。如: ofPattern("yyyy-MM-dd hh:mm:ss"）
//        方式一：
        DateTimeFormatter dateTimeFormatter=DateTimeFormatter.ISO_LOCAL_DATE_TIME;
//        格式化 日期--字符串
        LocalDateTime localDate = LocalDateTime.now();
        String str = dateTimeFormatter.format(localDate);
        System.out.println(localDate);//2021-10-19T21:24:51.345
        System.out.println(str);//2021-10-19T21:24:51.345
//        解析 字符串 -- 日期
        TemporalAccessor parse = dateTimeFormatter.parse("2021-10-19T21:24:51.345");//多态
        System.out.println(parse);//{},ISO resolved to 2021-10-19T21:24:51.345
//        方式二
//        格式化
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
        String str1 = formatter1.format(localDate);
        TemporalAccessor parse1 = formatter1.parse(str1);
        System.out.println(str1);//21-10-19 下午9:30
        System.out.println(parse1);//{},ISO resolved to 2021-10-19T21:30
//        方式三
        DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");

        String str2 = formatter2.format(localDate);
        TemporalAccessor parse2 = formatter2.parse(str2);
        System.out.println(str2);//2021-10-19 09:40:32
        System.out.println(parse2);//{MinuteOfHour=40, MilliOfSecond=0, HourOfAmPm=9, MicroOfSecond=0, SecondOfMinute=32, NanoOfSecond=0},ISO resolved to 2021-10-19
    }
}

其他API

Zoneld:该类中包含了所有的时区信息，一个时区的ID，如 Europe/Paris
ZonedDateTime:一个在ISO-8601日历系统时区的日期时间，如2007-12-03T10:15:30+01:00 Europe/Paris。
- 其中每个时区都对应着ID，地区ID都为“{区域}/{城市}”的格式，例如:Asia/Shanghai等
Clock:使用时区提供对当前即时、日期和时间的访问的时钟。
持续时间:Duration，用于计算两个“时间”间隔
日期间隔:Period，用于计算两个“日期”间隔
TemporalAdjuster :时间校正器。有时我们可能需要获取例如:将日期调整到“下一个工作日”等操作。
TemporalAdjusters :该类通过静态方法(firstDayOfXxx()/lastDayOfXxx()/nextXxx())提供了大量的常用TemporalAdjuster的实现。

Java比较器

在Java中经常会涉及到对象数组的排序问题，那么就涉及到对象之间的比较问题。
Java实现对象排序的方式有两种:
- 自然排序:java.lang.Comparable
- 定制排序:java.util.Comparator

方式一自然排序: java.lang.Comparable

Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。
实现Comparable 的类必须实现compareTo(Object obj)方法，两个对象即通过compareTo(Object obj)方法的返回值来比较大小。

如果当前对象this大于形参对象obj，则返回正整数，如果当前对象this小于形参对象obj，则返回负整数，如果当前对象this等于形参

对象obj，则返回零。
实现Comparable接口的对象列表（和数组）可以通过Collections.sort或Arrays.sort进行自动排序。实现此接口的对象可以用作有

序映射中的键或有序集合中的元素，无需指定比较器。
对于类C的每一个e1和 e2来说，当且仅当e1.compareTo(e2)==0与e1.equals(e2)具有相同的 boolean值时，类C的自然排序才叫做与equals一致。建议（虽然不是必需的）最好使自然排序与equals一致。
Comparable 的典型实现:(默认都是从小到大排列的)
- String:按照字符串中字符的Unicode值进行比较
- Character:按照字符的Unicode值来进行比较
- 数值类型对应的包装类以及BigInteger、BigDecimal:按照它们对应的数值大小进行比较
- Boolean: true 对应的包装类实例大于false 对应的包装类实例
- Date、Time等:后面的日期时间比前面的日期时间大
Comparable排序

//main类
package com.api;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        Goods[] goods = new Goods[]{
                new Goods("dell鼠标",25),
                new Goods("xiaomi鼠标",8),
                new Goods("华为鼠标",20),
                new Goods("菠萝鼠标",5)
        };
        Arrays.sort(goods);
        for (int i = 0; i < goods.length; i++) {
            System.out.println(goods[i].toString());;
        }
    }
}


//Goods类
package com.api;

public class Goods implements Comparable {
    private String name;
    private int price;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public Goods(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public Goods() {
    }

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        //方式一
        if (o instanceof Goods){
            Goods goods=(Goods)o;
//            //方式二
//            Integer.compare(this.price,goods.price);
           if (this.price>goods.price){
               return 1;
           }else if (this.price<goods.price){
               return -1;
           }else {
               return 0;
           }
        }else
            throw new RuntimeException("传入数据类型不一致");
    }
}

方式二定制排序:java.util.Comparator

当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当

前的操作，那么可以考虑使用Comparator的对象来排序，强行对多个对象进行整体排序的比较。
重写compare(Object o1,Object o2)方法，比较o1和o2的大小:如果方法返回正整数，则表示o1大于o2;如果返回0，表示相等;返回负整数，表示o1小于o2。
可以将Comparator传递给sort方法（如Collections.sort或Arrays.sort) ,从而允许在排序顺序上实现精确控制。
还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection提供排序。
Comparator和Comparable的比较

Comparable接口的方式一旦确定，保证Comparable接口实现类的对象在任何位置都可以比较大小。

Comparator接口属于临时性的比较。

package com.api;

import java.util.Arrays;
import java.util.Comparator;

public class Demo02 {
    public static void main(String[] args) {
         // 字符串排序
        String[] arr =new String[]{"aa","qq","dd","pp","rr"};
        Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                    String a = (String) o1;
                    String b = (String) o2;
                    return a.compareTo(b);
            }
        });
        System.out.println(Arrays.toString(arr));
    }
}

System类

System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。
由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。
成员变量
- System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。
成员方法
- native long currentTimeMillis():该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
- void exit(int status):该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。
void gc():
- 该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。
String getProperty(String key):
- 该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用如下表所示:

属性名	说明
java.version	Java运行时环境版本
java.home	Java安装目录
os.name	操作系统的名称
os.version	操作系统的版本
user.name	用户的账户名称
user.home	用户的主目录
user.dir	用户的当前工作目录

Math类

java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为double型。

abs绝对值

acos,asin,atan,cos,sin,tan三角函数sqrt平方根

pow(double a,doble b)a的b次幂iog自然对数

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)角度—>弧度

BigInteger与BigDecimal

Integer类作为int的包装类，能存储的最大整型值为231-1，Long类也是有限的，最大为263-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。
java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger提供所有Java的基本整数操作符的对应物，并提供java.lang.Math 的所有相关方法。另外，BigInteger还提供以下运算:模算术、GCD计算、质数测试、素数生成、位操作以及一些其他操作。
构造器
- igInteger(String val):根据字符串构建Biglnteger对象

常用方法

public BigInteger abs():返回此 Biglnteger的绝对值的 BigInteger。
Biglnteger add(Biglnteger 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。
BigIntegerdivideAndRemainder(BigInteger val):返回包含(this / val)后跟(this % val)的两个 Biglnteger的数组。
BigInteger pow(int exponent):返回其值为this^(exponent)的 BigInteger。
一般的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)除

posted @ 2021-10-20 21:32 beamsoflight 阅读(54) 评论(0) 收藏举报

刷新页面返回顶部

beamsoflight

Java常用类

字符串相关的类

String的特性

String对象的创建

字符串的特性

String使用陷阱

String常用方法

字符串简单运算方法

字符串查找方法

字符串其他方法（替换、正则...）

类型转换

字符串→基本数据类型、包装类

基本数据类型、包装类→字符串

字符数组→字符串

字符串→字符数组

字节数组→字符串

字符串→字节数组

StringBuffer类

扩容机制

StringBuffer类常用方法

字符串练习题

JDK8 之前的日期、时间API

java.lang.System类

java.util.Date类

java.text.SimpleDateFormat类

java.util.Calendar(日历)类

JDK8中新日期时间API

新日期时间API出现的背景

新时间日期API

新时间日期API

常用方法

瞬时：Instant

DateTimeFormatter

其他API

Java比较器

方式一 自然排序: java.lang.Comparable

方式二 定制排序:java.util.Comparator

System类

Math类

BigInteger与BigDecimal

方式一自然排序: java.lang.Comparable

方式二定制排序:java.util.Comparator