【JavaSE】常用类3[String类、StringBuffer、StringBuilder]

①.String类

• 字符串是常量，在创建之后“不可改变”。
• 字符串字面值存储在字符串池(常量池)中(位于方法区中)，可以共享。
• String s = “iFinder”;产生一个对象"iFinder"在字符串池中存储 s → “iFinder”
  String s = new String(“iFinder”); 产生两个对象，一个new … 存在堆中，一个"iFinder"对象存在字符串池中
  s → new … → “iFinder”

public class StringTest1 {
    public static void main(String[] args) {
        //name1现在为引用类型，它指向字符串池中的"iFinder"常量
        String name1 = "iFinder";  //"iFinder"是一个常量，存储在字符串池(常量池)当中

        //底层没有将"iFinder"改为"Bobjoy"，而是在字符串池中重新开辟了一个空间存储"Bobjoy"
        //原先的"iFinder"一段时间后就会被当作垃圾被回收
        name1 = "Bobjoy";
        String name2 = "Bobjoy";  //这里name2直接指向常量池中的"Bobjoy"
        System.out.println(name1 == name2);  //输出：true 二者都直接指向同一个常量

        //new String 方法新建字符串对象
        String str1 = new String("Bobmile");
        String str2 = new String("Bobmile");
        System.out.println(str1 == str2);  //输出：false
        //str1与str2分别指向新建的String对象，虽然New的对象都指向"Bobmile"，但是在堆中的地址是不同的
        System.out.println(str1.equals(str2));  //输出：true
        //String类对equals方法做了重写，只进行比较具体引用值，所以输出true
    }
}

-String常用方法

方法	作用
public int length( );	返回字符串的长度
public char charAt(int index);	根据下标获取字符
public boolean contains(String str);	判断当前字符当中是否有str
public char[ ] toCharArray();	将字符串转化成数组
public int indexOf(String str);	查找str首次出现的下标，存在则返回该下标，不存在则返回-1
public int lastIndexOf(String str);	查找str在当前字符串中最后一次出现的下标，无则返回-1
public String trim();	去掉字符串前后的空格
public String toUpperCase();	将小写转成大写
public String toLowerCase();	将小写转换为大写
public boolean endsWith(String str);	判断字符串是否以str结尾
public boolean startsWith(String str);	判断字符串是否以str开头
public String replace(char oidChar,char newChar)；	将旧字符串替换成新字符串
public String[ ] split(String str);	根据str做拆分
public boolean equals(String str);	比较当前字符串与str是否相等
public boolean equalsIgnoreCase(String str);	忽略字符串大小写的比较，是否相等

public class Main{
    public static void main(String[] args) {
        //字符串用法说明
		String str = "iFinder will get a job";
		//1.length() 返回字符串的长度
		System.out.println(str.length());  //输出:22(任何字符,包括空格都算入长度)
		//2.charAt(int index) 返回某一个位置的字符
		System.out.println(str.charAt(3));   //输出:n
		System.out.println(str.charAt(str.length() - 1));  //输出:b  (超出最大角标会报数组越界错误)
		//3.contains(String str) 判断字符串中是否包含某一个子字符串
		System.out.println(str.contains("job"));   //输出:true
		System.out.println("java");    //输出:false
		
		//4.toCharArray()将字符串转成数组
		System.out.println(Arrays.toString(str.toCharArray()));   //输出:[i, F, i, n, d, e, r,  , w, i, l, l,  , g, e, t,  , a,  , j, o, b]
		//5.indexOf(String str)查找str首次出现的下标,存在则返回该下标,不存在则返回-1
		System.out.println(str.indexOf("will"));   //输出:8
		System.out.println(str.indexOf("java"));   //输出:-1
		System.out.println(str.indexOf("java",4));   //第二个参数的作用为,从第几个开始找
				
		//6.lastIndexOf(String str)查找str在字符串中最后一次出现的下标
		System.out.println(str.lastIndexOf("a"));  //输出:17
		
		//7.trim() 去掉字符串前后的空格
		String str1 = "   iFinder will study hard !   ";
		System.out.println(str1.trim());   //输出:iFinder will study hard !
		//8.toUpperCase()/toLowerCase() 将字符串转换为大写/小写
		System.out.println(str.toUpperCase());   //输出:IFINDER WILL GET A JOB
		System.out.println(str.toLowerCase());   //输出:ifinder will get a job
		
		//9.endsWith(String str)/startsWith(String str) 判断字符串是否以str结尾 /开头
		System.out.println(str.endsWith(" "));   //输出:false
		System.out.println(str1.startsWith(" "));   //输出:false
		
		//10.replace(char old,char new) 将旧字符串替换为新字符串
		System.out.println(str1.replace(" ","#"));   //输出:###iFinder#will#study#hard#!###
		
		//11.split(String str) 根据str对字符串做拆分,返回一个String数组 
		System.out.println(Arrays.toString(str.split(" ")));   //输出:[iFinder, will, get, a, job]
		//split()支持正则表达式
		String str2 = "  iFinder,tom,,will   ";
		System.out.println(Arrays.toString(str2.split("[ ,]+")));   //输出:[, iFinder, tom, will]
		
		//12.两个相等判断 equals()--比较相等,compareTo()--比较大小(字典表的顺序)
		String str3 = "hello";
		String str4 = "HELLO";
		System.out.println(str3.equalsIgnoreCase(str4));   //输出:true--忽略大小写的比较
		
		System.out.println(str3.compareTo(str4));   //输出:32--首字母大小写相距32字符远(直到比较到不相同的字符才进行字符的相减比较)
		//如果长度不一致则比较长度
		System.out.println("123".compareTo("123456"));   //输出:-3
		System.out.println("123456".compareTo("123"));   //输出:-3
		
		
    }
}

-String案例演示

需求:已知String str = “this is a text”,1.将str中的单词获取出来 2.将str中的text替换为practice 3.在text前面插入一个easy 4.将每一个单词的首字母改为大写

public class Main{
	public static void main(String[] args){
		String str = "this is a text";
		//1.将每一个单词获取出来--只用split方法
		String[] word = str.split(" ");
		System.out.println(Arrays.toString(word));   //输出：[this, is, a, text]
		
		//2.将str中的text替换为practice
		System.out.println(str.replace("text","practice"));   //输出：this is a practice
		
		//3.在text前面插入一个easy
		System.out.println(str.replace("text","easy text"));   //输出:this is a easy text
		
		//4.将单词的首字母改为大写
		StringBuilder sb = new StringBuilder();
		for(int i = 0;i < word.length;i++){
			for(int j = 0;j < word[i].length();j++){
				if(j == 0){
					word[i] = (char)(word[i].charAt(0) - 32)+word[i].substring(1);
					/*变为大写可以利用包装类
					char upper = Character.toUpperCase(char ch);
					*/
				}
			}
			sb.append(word[i]).append(" ");
		}
		System.out.println(sb.toString().trim());   //输出:This Is A Text
		
	}
}

②StringBuffer和StringBuilder

-StringBuffer

可变长字符串,由JDK1.0提供,运行效率慢,线程安全

-StringBuilder

可变长字符串,JDK1.5提供,运行效率快,线程不安全

/**
	StirngBuffer和StringBuilder和String的区别
	(1)效率比String高
	(2)相比String节省内存
	
*/
//常用方法
public class Main{
	public static void main(String[] args){
		StringBuffer sbf = new StringBuffer();
		//1.append(); 追加内容
		sbf.append("iFinder").append(" ").append("good");
		sbf.append(" job");
		System.out.println(sbf.toString());   //输出:iFinder good job
		
		//2.insert(int offset,E insert);通过偏移量插入值
		sbf.insert(0,"Xidian's ");
		System.out.println(sbf.toString());
		
		//3.replace(int start,int end,String str);指定开始结束的偏移量来进行替换
		sbf.replace(0,6,"BOE");
		System.out.println(sbf.toString());   //输出:BOE's iFinder good job
		
		//4.delete(int start,int end); 指定开始结束的偏移量来进行删除操作
		sbf.delete(0,6);
		System.out.println(sbf.toString());   //输出:iFinder good job
		
		//5.reverse(); 反转缓冲区中的内容
		//6.清空缓冲区.delete(0,sbf.length());
		
		
	}
}

-String、StringBuffer、StringBuilder效率对比

public class Main{
	public static void main(String[] args){
		long start = System.currentTimeMillis();
		String str = "";
		for(int i = 0;i <= 99999;i++){
			str+=i;
		}
		long end = System.currentTimeMillis();
		System.out.println("用时:" + (end - start));  //用时:3085
		
		start = System.currentTimeMillis();
		StringBuffer sbf = new StringBuffer();
		for(int i = 0;i <= 999999;i++){
			sbf.append(i);
		}
		end = System.currentTimeMillis();
		System.out.println("用时:" + (end - start));  //用时:40 效率提升巨大
		
		start = System.currentTimeMillis();
		StringBuilder sbd = new StringBuilder();
		for(int i = 0;i <= 999999;i++){
			sbd.append(i);
		}
		end = System.currentTimeMillis();
		System.out.println("用时:" + (end - start));  //用时:29 效率提升
	}
}

③BigDecimal的使用

//以下程序运行时会出现错误
public class Main{
	public static void main(String[] args){
		double d1 = 1.0;
		double d2 = 0.9;
		System.out.println(d1 - d2);   //0.09999999999999998
	}
}

在进行对精度要求比较高的运算的时候,就需要引入BigDecimal类进行运算
包:java.math
作用:进行精确的浮点运算
创建方式:BigDecimal bd = new BigDecimal(“0.1”);

import java.math.BigDecimal;
public class Main{
	public static void main(String[] args){
		BigDecimal bd1 = new BigDecimal("1.0");
		BigDecimal bd2 = new BigDecimal("0.9");
		//1.减法 subtract();
		System.out.println(bd1.subtract(bd2));   //0.1
		
		//2.加法  add() 
		System.out.println(bd1.add(bd2));   //1.9
		
		//3.乘法  multiply()
		System.out.println(bd1.multiply(bd2));   //0.90
		
		//4.除法  divide(data,int scale,int roundingMode) 可规定保留的数据位数与取整的形式
		System.out.println(bd1.divide(bd2,4,BigDecimal.ROUND_HALF_UP));   //1.1111
	}
}

④Date类

表示特定的瞬间,精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。
时间单位：

• 1s = 1000 ms
• 1ms = 1000 μm
• 1μm = 1000 nm

构造方法

• Date() 分配Date对象,并初始化此对象,以表示分配它的时间.
• Date(long date)从基准时间(1970.1.1 00:00:00)开始以来的毫秒数

常用方法

方法	作用
boolean after(Date when)	测试日期是否在指定日期之后
boolean before(Date when)	测试日期是否在指定日期之前
Object clone()	返回此对象的副本
int compareTo(Date anotherDate)	比较两个日期的顺序
boolean equals(Object obj)	比较两个日期的相等性
long getTime()	返回自基准时间(1970.1.1)以来的毫秒数
void setTime(long time)	设置time为基准时间点
String toString()	把Date转为字符串输出

import java.util.Date;

public class Main{
	public static void main(String[] args){
		//1.创建Date对象
		Date date1 = new Date();
		System.out.println(date1.toString());  //Tue Apr 20 11:22:47 CST 2021
		System.out.println(date1.toLocaleString());  //2021年4月20日 上午11:23:40
		//昨天
		Date date2 = new Date(date1.getTime() - 60*60*24*1000);
		System.out.println(date2.toLocaleString());  //2021年4月19日 上午11:26:30
		
		//2.after,before
		System.out.println(date1.after(date2));   //true
		
		//3.compareTo();  前比后,大则1  小则-1  等则0
		System.out.println(date1.compareTo(date2));   //1
		
		//4.equals();
		System.out.println(date1.equals(date2));   //false
	}
}

⑤Calendar类

提供了获取或者设置各种日历字段的方法
构造方法 protected Calendar();由于有protected修饰,无法直接创建对象

方法	作用
static Calendar getInstance()	使用默认时区和区域获取日历
void set(int year,int date,int hourofday,int minute,int second)	设置日历的 年,月,日,时,分,秒
int get(int field)	返回给定日历字段的值.字段比如 年,月,日等
void setTime(Date date)	用给定的Date设置此日历的时间----Date→Calendar
Date getTime()	返回一个Date表示此日历的时间
void add(int field,int amount)	按照日历的规则,给指定字段添加或减少时间量
long getTimeInMillies()	以毫秒为单位返回该日历的时间值

import java.util.Calendar;

public class Main{
	public static void main(String[] args){
		//1.获取Calender类
		Calendar cl = Calendar.getInstance();
		System.out.println(cl.getTime().toLocaleString());   //2021年4月20日 上午11:49:00
		
		//2.获取时间信息
		//年
		int year = cl.get(Calendar.YEAR);
		System.out.println(cl.get(Calendar.YEAR) + "年");   //2021年4月20日
		//月
		int month = cl.get(Calendar.MONTH);
		System.out.println(cl.get(Calendar.MONTH) + 1 + "月");   //4月--从0开始记月份
		//日
		int day = cl.get(Calendar.DATE);//DAY_OF_MONTH
		System.out.println(cl.get(Calendar.DATE) + "日");   //20日
		//时
		int hour = cl.get(Calendar.HOUR_OF_DAY);//HOUR--12小时制  HOUR_OF_DAY--24小时制
		System.out.println(cl.get(Calendar.HOUR_OF_DAY) + "时");   //12时
		//分
		int minute = cl.get(Calendar.MINUTE);
		System.out.println(cl.get(Calendar.MINUTE) + "分");   //8分
		//秒
		int second = cl.get(Calendar.SECOND);
		System.out.println(cl.get(Calendar.SECOND) + "秒");   //10秒
		System.out.println(year + "年" + month + "月" + day + "日" + hour + "时" + minute + "分" + second + "秒");
		
		//3.修改时间
		Calendar cl2 = Calendar.getInstance();
		cl2.set(Calendar.DAY_OF_MONTH,8);
		System.out.println(cl2.getTime().toLocaleString());   //输出:2021年4月8日 下午12:15:33
		
		//4.add()方法修改时间
		cl2.add(Calendar.HOUR,3);
		System.out.println(cl2.getTime().toLocaleString());   //输出:2021年4月8日 下午3:18:18
		
		//5.补充方法  获取该月的最大与最小天的具体数字
		int max = cl2.getActualMaximum(Calendar.DAY_OF_MONTH);
		int min = cl2.getActualMinimum(Calendar.DAY_OF_MONTH);
		System.out.println("max = " + max + "  min = " + min);   //输出:max = 30  min = 1
		
	}
}

⑥SimpleDateFormat类

SimpleDateFormat时一个与语言环境有关的,来格式化和解析日期的具体类

• 进行格式化(日期→文本)
• 进行解析(文本→日期)

常用时间模式字母

字母	日期或时间	示例
y	年	2019
M	年中月份	08
d	月中天数	10
H	1天中的小时数(0-23)	22
m	分钟	18
s	秒	45
S	毫秒	345

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

public class Main{
	public static void main(String[] args)throws Exception{
		String pattern = "yyyy年MM月dd日--HH:mm:ss";
		//String pattern = "HH:mm:ss";
		
		//格式化日期转为字符串
		//1.实例化SimpleDateFormat对象
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		//2.创建Date
		Date date = new Date();
		//3.格式化date
		String str = sdf.format(date);
		System.out.println(str);   //输出:2021年04月20日--12:37:26
		
		//字符串转为时间
		Date date2 = sdf.parse("1997年07月24日--12:23:46");
		System.out.println(date2.toLocaleString());
	}
}

⑦System类

系统类,主要用于获取系统的属性数据和进行其它操作,构造方法时静态私有的,使用时不需要创建对象.

方法名	作用
static void arraycopy(…)	复制数组
static long currentTimeMillisecond()	获取当前系统时间(毫秒值)
static void gc()	建议JVM启动垃圾回收器
static void exit(int status)	退出JVM,参数0为正常退出,非0为异常退出

import java.text.SimpleDateFormat;
import java.util.*;

public class Main{
	public static void main(String[] args)throws Exception{
		/**
			src:源数组
			srcPos:从哪个位置开始复制
			dest:目标数组
			destPos:目标数组的位置
			length:复制的长度
		*/
		//1.arraycopy(Object src,int srcPos,Object dest,int desPos,int length); 实现数组的复制
		int[] arr1 = {12,13,14,15,16,17,18,29};
		int[] arr2 = new int[10];
		System.arraycopy(arr1,0,arr2,1,arr1.length);
		System.out.println(Arrays.toString(arr2));   //输出:[0, 12, 13, 14, 15, 16, 17, 18, 29, 0]
		//Arrays.copyOf(original,newLength)之中使用的就是arraycopy()方法
		
		//2.currentTimeMillis() 实现简单计时功能
		long start = System.currentTimeMillis();
		for(int i = 0;i < 99999;i++){
			for(int j = 0;j < 9999;j++){
				for(int k = 0;k < 100;k++){
					int reault = i+j+k;
				}
			}
		}
		long end = System.currentTimeMillis();
		System.out.println("用时:" + (end - start)); //用时:3420
		
		//3.gc() 通知垃圾回收器回收垃圾
		/*
			不是强制执行的,只起到"通知"作用,在系统将某一个对象判断为垃圾的时候,才会将其回收
			特别是创建了匿名类的时候
			可以通过在类中重写finalize方法,在其中添加输出语句来观察是否被回收
			
		*/
		
		//4.exit(int status)
		System.exit(0);
		
		System.out.println("aaaa");  //程序已经退出,该语句不会执行
	}
}

⑧总结

内部类

• 在一个类的内部再定义一个完整的类
• 成员内部类、静态内部类、局部内部类、匿名内部类

Object类

• 所有类的父类，所有类都直接或间接的继承了Object类
• 可以存储任何对象

包装类

• 基本数据类型所对应的引用数据类型，可以使Object统一所有数据

String类

• 字符串是常量，创建之后不可以改变，字面值保存在字符串常量池中，可以共享。

BigDecimal

• 可实现精确的浮点数运算

Date类

• 获取特定时间

Calendar类

• 对Date的功能扩充
• 获取、编辑时间

SimpleDateFormat类

• 格式化时间
• 将获取的str转为Date

System类

• 系统类，实现系统内部的一些方法