五、日期类

一、Arrays类

Arrays类是对数组进行操作的类，在java.util包下。

常用方法：

Arrays.toString( )：将数组转化成字符串
Arrays.sort( )：将数组升序排序，使用的是快速排序法
Arrays.binarySearch( )：（前提：数组升序）查找元素，若存在则返回位置索引；若不存在则返回（插入点索引的负值 - 1）
Arrays.equals( )：相等比较，比较两个数组的类型、个数以及值
Arrays.copyOf( )：数组的复制

二、String、StringBuffer以及StringBuilder

1.String类

说明

表示字符串，字符序列，不可变类
什么是不可变类？一旦字符串对象确定了，此字符串对象的字符序列就不能更改了。

区别下面三种情况

String str1 = "abc";//有对象，有字符序列
String str2 = "";//空串，有对象，没有字符序列
String str3 = null;//没对象

创建字符串的3中方式：

String s1 = "hello";//直接用字符串常量赋值，编译器是能直接确定常量，是在方法区的常量池维护的。
String s2 = new String();//空串
//下面这句代码创建了几个对象？看池子有没有“hello”，若无则2个对象，若有则1个对象
String s3 = new String("hello");//和直接写字符串赋值是不一样的，只要new就在堆里分配空间。

“==” 判断的是否为同一对象，同一内存地址

String s1 = "hello";
String s3 = new String("hello");
String s4 = "hello";
String s6 = new String("hello");
System.out.println(s1 == s3);//false
System.out.println(s1 == s4);//true
System.out.println(s3 == s6);//false

equals 比较的是字符序列是否相等

String s1 = "hello";
String s3 = new String("hello");
System.out.println(s1.equals(s3));//true，区分大小写
System.out.println(s1.equalsIgnoreCase(s3));//true，不区分大小写

字符串连接方法concat( )

String st1 = "hello";//方法区创建hello对象
st1 = st1.concat("tom");//方法区，创建了个新对象 hellotom，且st1此刻指向堆中的对象

求字符串的长度length( )

String st1 = "hello";
System.out.println(str11.length());

转换大小写

System.out.println(str.toUpperCase());
System.out.println(str.toLowerCase());

查找参数字符串在当前字符串中第一次出现的位置索引

String st22 = "hellohelloabc";
System.out.println(st22.indexOf("he"));//包含返回索引值
System.out.println(st22.indexOf("hex"));//不包含返回-1

查找参数字符串在当前字符串中最后一次出现的位置索引

System.out.println(st22.lastIndexOf("he"));//5

取出某一个位置索引处的字符

String st22 = "hellohelloabc";
System.out.println(st22.charAt(0));

substring( )：取子串

String st33 = "hellotomabc";
System.out.println(st33.substring(8));//从起始位置取到字符串末尾
System.out.println(st33.substring(8, 9));// [ 起始位置，终止位置 )

trim( )

String st44 = " h e l l o ";
System.out.println(st44.trim());// 去除前后空格

replaceAll( )

String st55 = "helloTom";
System.out.println(st55.replaceAll("hello", "你好"));//使用第二个参数字符串替换第一个参数字符串
System.out.println(st44.trim().replaceAll(" ", ""));//去掉字符串中所有空格

endWith( )

String st66 = "Demo.java";
System.out.println(st66.endsWith("java"));//是否以指定参数的字符串为结尾，输出:true

startsWith( )

System.out.println(st66.startsWith("Demo"));//是否以指定参数的字符串为开头，输出true

compareTo( )：比较字符串大小

String st77 = "abc";
System.out.println(st77.compareTo("xyz"));//返回负值，//比较的对象在参数对象之前，结果是负数。比较的是Unicode的码值
System.out.println(st77.compareTo("abc"));//相等返回0
System.out.println("xyz".compareTo("abc"));//返回正数，比较的对象在参数对象之后，结果是正数。比较的是Unicode的码值

toCharArray()

String st88 = "hello";
char[] crs = st88.toCharArray();//把字符串转换成字符数组 char[]

split( )

String st99 = "aa bb cc dd ee";
String[] strs = st99.split(" ");//把当前字符串用参数字符串分割成一个字符串数组

contains( )

System.out.println(st99.contains("aa")); //参数字符串在当前字符串中是否存在，存在true，不包含false

2.StringBuffer和StringBuilder

说明

可变字符串类；
字符序列频繁更改可以使用
StringBuffer是线程安全的，数据准确但速度慢
StringBuilder是线程非安全的，数据不准确但速度快

常用方法（二者差不多，以StringBuffer为例）

capacity()：获取对象容量

StringBuffer sf = new StringBuffer();//默认16个字符大小的缓冲区
System.out.println(sf.);//16
StringBuffer ssf = new StringBuffer("hello");
System.out.println(ssf.capacity());//16 + 5 = 21
sf.append("hegfsgsgfgsgsfgsgfsgsdgsllo");
System.out.println(sf.capacity());//34,成倍扩容

trimToSize( )：

sf.trimToSize();//缩小容量为存储的字符大小
System.out.println(sf.capacity());//5

指定容量：

StringBuffer sf1 = new StringBuffer(100);//可以指定容量的大小

append( )：追加方法

sf1.append("hello");//追加
System.out.println(sf1);
char[] crs = {'a','b','c','d'};
sf1.append(crs,1,2);//执行追加方式
System.out.println(sf1);

insert( )：

sf1.insert(5,"tom");//向参数索引位置插入一个字符串
System.out.println(sf1);

setCharAt( )：

sf1.setCharAt(5, 'a');//修改某个索引位置的字符
System.out.println(sf1);

deleteCharAt( )：

sf1.deleteCharAt(5);//删除索引位置的字符
System.out.println(sf1);
sf1.delete(4, 6);//范围删除：左闭右开
System.out.println(sf1);

reverse( )：

StringBuffer sr = new StringBuffer();
sr.append("123");
System.out.println(sr);
sr.reverse();//返转
System.out.println(sr);

toString( )：

String str = sr.toString();//将StringBuffer类型转换成String类型

3.字符串常量值的存储原理

字符串常量是是编译器能够识别的，是存储在方法区中的常量池中的字符串对象。而且同一字符串常量值只会在该内存区域存储一份，所有需要引用该常量值得引用变量都存储的同一份地址。

三、正则

1.正则表达式符号

符号	描述
\D	除了数字之外的任何字符，等价于[^0-9]
\d	匹配一个数字字符，等价于[0-9]
\W	任何非单词字符，等价于[^a-zA-Z0-9]
\w	任何单词字符，等价于[a-zA-Z0-9]
.	除了换行符以外的任意字符

符号	描述
{n}	匹配前一项n次
{n, m}	匹配前一项至少n次，但是不能超过m次
*	匹配前一项0次或多次，等价于{0, }
+	匹配前一项1次或多次，等价于{1, }
?	匹配前一项0次或1次，也就是说前一项是可选的，等价于{0, 1}

2.正则表达式（Pattern、Matcher）

正则表达式一个描述字符模式的对象。语法格式如下：

定义正则表达式：Pattern ptn = Pattern.compile(regString);
表示的模式：Matcher mr = ptn.matcher("需要匹配的数据");
验证：mr.matches( );

例子：

Pattern ptn = Pattern.compile("\\d{6}");//1.指定正则表达
Matcher mr = ptn.matcher("345653"); //2.指定用于验证的字符串
System.out.println(mr.matches());//3.验证

四、包装类（装箱与拆箱）

1.定义

JDK提供了对所有基本数据类型的包装类。包装类是不可变类，也是存放在常量池中的。
什么是装箱？把基本类型包装成对象，即基本类型转换成引用类型。
什么是拆箱？把对象的值取出来，即引用类型转换成基本类型。

2.自动装箱/拆箱

自动装箱和拆箱的原因？是因为除了Float和Double外，其他包装类都是有缓冲区的，缓冲范围为-128 到 127，其中Boolean 都缓冲，而Character 缓冲0-127。

int n = 11;
Integer i = new Integer(n);//装箱：把基本数据类型包装成对对象
i = Integer.valueOf(n);
i = n;//自动装箱，系统在调用Integer.valueOf(n)方法
n = i.intValue();//拆箱：把对象中的值取出来
n = i;//自动拆箱，系统调用了i.intValue()
Integer i1 = 23;//Integer.valueOf(23);
Integer i2 = 23;//Integer.valueOf(23);
System.out.println(i1 == i2);//输出true，因为方法区的常量池中缓冲了-128 到 127的整数
Integer i3 = 233;//new Integer(233);//因为方法区的常量池中只缓冲了-128 到 127的整数，超范围了。
Integer i4 = 233;//new Integer(233);
System.out.println(i3 == i4);//输出false

查看范围

System.out.println(Byte.MAX_VALUE);
System.out.println(Byte.MIN_VALUE);
System.out.println(Character.MAX_VALUE);
System.out.println(Character.MAX_VALUE);

进制转换

System.out.println(Integer.toBinaryString(5));//10 -> 2
System.out.println(Integer.toOctalString(5));//10 -> 8
System.out.println(Integer.toHexString(15));//10 -> 16
System.out.println(Integer.valueOf("101",2));//2 -> 10
System.out.println(Integer.valueOf("14",8));//8 -> 10
System.out.println(Integer.valueOf("f",16));//16 -> 10

字符串和数值相互转换

数值转字符串：

int x = 22;
String str = x + "";
str = String.valueOf(x);

字符串转数值：

String str1 = "123";
int y = new Integer(str1).intValue();
y = Integer.parseInt(str1);
y = Integer.valueOf(str1);

五、日期类

掌握方法：针对常见的用法，多做些练习题，方能有效掌握。

public class TestDate {
	public static void main(String[] args) {
		//系统的日期时间
		//util包下下父类，sql包下是子类，使用父类
		java.util.Date date = new java.util.Date();
		System.out.println(date);
		//毫秒数
		System.out.println(date.getTime());
		System.out.println(System.currentTimeMillis());
		//1537320638674 Wed Sep 19 09:30:38 CST 2018,对某一个时刻进行记录和操作，用毫秒封装一个Date即可
		java.util.Date date1 = new java.util.Date(1537320638674L);
		System.out.println(date1);
		
		System.out.println(date.getYear() + 1900);//过时了
		System.out.println(date.getMonth() + 1);
		System.out.println(date.getDay());
		
		//研究Date的子类：对应sql包下的Date，你只需记住日期转字符串和字符串转日期即可
		//Date
		Date d1 = new Date(date.getTime());
		System.out.println(d1);
		//日期转字符串
		String sd1 = d1.toString();
		//字符串转日期
		d1 = Date.valueOf(sd1);
		//时间Time
		Time t1 = new Time(date.getTime());
		String st1 = t1.toString();
		System.out.println(st1);
		//日期时间 时间戳 Timestamp
		Timestamp tp1 = new Timestamp(date.getTime());
		System.out.println(tp1);
		
		//格式化
		System.out.println(date);//父类的
		//数字格式化
		DecimalFormat df1 = new DecimalFormat("000.000");//位数不够，用0补位
		DecimalFormat df2 = new DecimalFormat("###.###");//位数不够，不会补位
		System.out.println(df1.format(22.34566));
		System.out.println(df2.format(22.34566));
		//日期格式化
		//格式：yyyy MM dd hh mm ss SSS
		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss.SSS");
		System.out.println(sdf1.format(date));
		
		//对日期的操作
		//日历
		Calendar c = Calendar.getInstance();
		//日历表示的系统时间
		System.out.println(c.getTime());
		//获得年，月，日
		System.out.println(c.get(Calendar.YEAR));
		System.out.println(c.get(Calendar.MONTH) + 1);
		System.out.println(c.get(Calendar.DATE));
		
		//10年后、前的时间
		c.add(Calendar.YEAR, -10);
		System.out.println(c.getTime());
		
		//设置一个时间
		Calendar c1 = Calendar.getInstance();
		c1.set(2012, 4, 6);
		Calendar c2 = Calendar.getInstance();
		c2.set(2016, 7, 8);
		//一个日期是否在参数日期前
		System.out.println(c1.before(c2));//true
		System.out.println(c1.after(c2));//false
		
		//jdk8.0的日期和时间
		//日期LocalDate,时间LocalTime,日期时间LocalDateTime,对日期和时间进行操作的类Duration
		//日期
		LocalDate ldate1 = LocalDate.now();
		ldate1 = LocalDate.of(2012,5,23);
		System.out.println(ldate1);
		System.out.println(ldate1.getYear());
		System.out.println(ldate1.getMonthValue());
		System.out.println(ldate1.getDayOfMonth());//一个月中的第几天
		System.out.println(ldate1.getDayOfYear());//一年中的第几天
		System.out.println(ldate1.getDayOfWeek());//一星期中的第几天
		//后
		System.out.println(ldate1.plusYears(10));
		System.out.println(ldate1.plusMonths(10));
		System.out.println(ldate1.plusDays(10));
		//前
		System.out.println(ldate1.minusYears(10));
		System.out.println(ldate1.minusMonths(10));
		System.out.println(ldate1.minusDays(10));
		
		//时间
		LocalTime ltime1 = LocalTime.now();
		ltime1 = LocalTime.of(9, 2, 34);
		System.out.println(ltime1);
		//秒 毫秒 微妙 纳秒 皮秒
		System.out.println(ltime1.getHour());
		//后
		System.out.println(ltime1.plusHours(10));
		//前
		System.out.println(ltime1.minusHours(10));
		
		//日期时间
		LocalDateTime ldt = LocalDateTime.now();
		ldt = LocalDateTime.of(2012, 2, 12, 3, 45, 34);
		System.out.println(ldt);
		//Duration
		LocalDateTime ldt1 = LocalDateTime.of(2012, 2, 12, 5, 56, 56);
		LocalDateTime ldt2 = LocalDateTime.of(2013, 2, 12, 4, 56, 34);
		Duration d = Duration.between(ldt1, ldt2);
		System.out.println(d.toDays());
	}
}

补充知识点：

Arrays.sort(arr, 0, 3); //对指定范围内的元素进行排序，左闭右开
Arrays.binarySearch(arr, 0, 3, 45); //在指定范围内进行查找，左开右闭
Arrays.copyOfRange(arr, 1, 3); //指定复制范围，左闭右开
int [ ] arr = {11,22,33,44};
Arrays.fill(arr, 222); //把所有元素进行替换，结果：{222，222，222，222}
Arrays.fill(arr, 0, 2, 888); //指定范围进行填充，左闭右开，结果：{888，888，33，44}
对应编译器能够确定的常量值，都是在常量池中维护。常量池的好处，就是重复使用已经存在的常量值对象，避免频繁的创建对象。

JavaSE之常用API

一、Arrays类

二、String、StringBuffer以及StringBuilder

三、正则

四、包装类（装箱与拆箱）

五、日期类

猜你喜欢