常用类3
①.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类
- 系统类,实现系统内部的一些方法