Java:常用类

文章目录

  • 一、Object类
    • 1、概述
    • 1、hashcode()
    • 2、toString()
    • 3、clone()
    • 4、getClass()
    • 5、notify()
    • 6、wait()
    • 7、equals()
    • 8、finalize()
    • 9、Objects类
    • 9、面试问题
  • 二、Math类
  • 三、Random类
  • 四、File类
    • 1、构造方法
    • 2、添加文件
    • 3、查看文件
    • 4、修改文件
    • 5、删除文件
  • 五、包装类
    • 1、装箱与拆箱
    • 3、自动装箱拆箱
    • 4、基本类型与字符串转换
    • 5、整数缓冲区
  • 六、Date类
    • 1、Date
    • 2、SimpleDateFormat
    • 3、Calendar
    • 4、Timestamp
  • 七、String类
    • 可变字符串
    • 面试问题
  • 八、BigDecimal
  • 九、BigInteger
  • 十、System
  • 十一、正则表达式
  • 十二、编码表


学习视频来自于:秦疆(遇见狂神说)Bilibili地址
他的自学网站:kuangstudy

生活是属于每个人自己的感受,不属于任何别人的看法


一、Object类

1、概述

超类,基类、跟类,所有类的直接或间接父类,位于继承树的最顶层。
任何类,如果没有书写extends显示继承某个类,都默认直接继承Object,否则为间接继承。
在对象实例化的时候,最终找到的父类就是Object。
Object类提供无参构造方法 ,之所以提供这样的无参构造,是因为在子类对象实例化时都会默认调用父类中的无参构造方法,这样在定义类时即使没有明确定义父类为Object,读者也不会感觉代码的强制性要求。
Object类中所定义的方法,是所有对象都具备的方法。
Object类型可以储存任何对象
* 作为参数,可接收任何对象。
* 作为返回值,可返回任何对象。

1、hashcode()

public native int hashCode();
  • 返回该对象的哈希码值
  • 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的值
  • 一般情况下相同对象返回相同哈希码
// s1和s2对象指向不相同,hashCode不相同
s1.hashCode();
s2.hashCode();
// s1和s3对象指向相同,此时s3的hashCode与s1相同
Student s3 = s1;
  • 如果两个对象的哈希码值不同,那这两个对象一定不等;
  • 如果两个对象的哈希码值相同,不能确保这两个对象一定相等。

2、toString()

public boolean equals(Object obj) {
        return (this == obj);
 }
  • toString方法返回该对象的字符串表示,其实该字符串内容就是对象的类型+@+内存地址值。
  • 由于toString方法返回的结果是内存地址,而在开发中,经常需要按照对象的属性得到相应的字符串表现形式,因此也需要重写它。
  • 重写覆盖
public class Person {  
    private String name;
    private int age;
	// IDEA重写的快捷键:Alt + Insert
    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }

    // 省略构造器与Getter Setter
}

在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。

3、clone()

  • 克隆对象对应的类需要实现Cloneable接口,否则会报错:java.lang.CloneNotSupportedException
protected native Object clone() throws CloneNotSupportedException;

4、getClass()

@Contract(pure = true)
public final native Class<?> getClass();
  • 返回引用中存储的实际对象类型
  • 应用:通常用于判断两个引用中实际存储对象类型是否一致
// 判断s1 和 s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
// getClass返回 class类型

如何获取类的字节码文件对象?

类名.class 说明: JVM将使用类装载器, 将类装入内存(前提是:类还没有装入内存),不做类的初始化工作.返回Class的对象
Class.forName(“类名字符串”) (注:类名字符串是包名+类名) 说明:装入类,并做类的静态初始化,返回Class的对象
实例对象.getClass() 说明:对类进行静态初始化、非静态初始化; 返回引用o运行时真正所指的对象(因为:子对象的引用可能会赋给父对象的引用变量中) 所属的类的Class的对象

5、notify()

public final native void notify();

6、wait()

public final native void wait(long timeout) throws InterruptedException;

public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }
        if (nanos > 0) {
            timeout++;
        }
        wait(timeout);
    }

public final void wait() throws InterruptedException {
        wait(0);
    }

7、equals()

public boolean equals(Object obj) {
        return (this == obj);
 }
  • 默认实现为(this == obj), 比较两个对象地址是否相同
  • 可进行重写,比较两个对象的内容是否相同
// 判断两个对象是否相等
sout(s1.equals(s2)); // false

Student s4 = new Student("小明", 17);
Student s5 = new Student("小明", 17);
sout(s4.equals(s5)); // false 堆中地址不同

// 重写 改变其比较内容
/*
步骤  1. 比较两个应用是否指向同一个对象
     2. 判断obj是否为null
     3. 判断两个引用指向的实际对象类型是否一致
     4. 强制类型转换
     5. 依次比较各个属性值是否相同
*/
@override
public boolean equals(Object obj){
  // 1.
  if(this == obj){
    return true;
  }
  // 2.
  if(obj == null){
    return false;
  }
  // 3.
  // if(this.getClass() == obj.getClass()){
  //
  // }
  // instanceof 判断对象是否是某种类型
  if(obj instanceof Student){
    // 4.强制类型转换
    Student s = (Student)obj;
    // 5. 比较属性
    if(this.name.equals(s.getName()) && this.age == s.getAge()){
      return true;
    }
  }
  return false;
}

8、finalize()

protected void finalize() throws Throwable { }
  • 当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列
  • 垃圾对象:没有有效引用指向此对象时,为垃圾对象
  • 垃圾回收:由gc销毁垃圾对象,释放数据存储空间
  • 自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象
  • 手动回收机制:使用System.gc();通知JVM执行垃圾回收

9、Objects类

  • JDK1.7添加了一个Objects工具类,它提供了一些方法来操作对象,它由一些静态的实用方法组成,这些方法是null-save(空指针安全的)或null-tolerant(容忍空指针的),用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。
  • 在比较两个对象的时候,Object的equals方法容易抛出空指针异常,而Objects类中的equals方法就优化了这个问题。方法如下:
  • public static boolean equals(Object a, Object b):判断两个对象是否相等。
  • 源码
public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}

9、面试问题

说出一些你常用的方法
常覆写Object类的3个方法:toString(),equals(Object obj),hashCode()

克隆方法或者克隆接口一些问题
克隆对象对应的类需要实现Cloneable接口,否则会报错:java.lang.CloneNotSupportedException

为什么notify(), wait()等函数定义在Object中,而不是Thread中?
Object中的wait(), notify()等函数,和synchronized一样,会对“对象的同步锁”进行操作。
wait()会使“当前线程”等待,因为线程进入等待状态,所以线程应该释放它锁持有的“同步锁”,否则其它线程获取不到该“同步锁”而无法运行!
OK,线程调用wait()之后,会释放它锁持有的“同步锁”;而且,根据前面的介绍,我们知道:等待线程可以被notify()或notifyAll()唤醒。现在,请思考一个问题:notify()是依据什么唤醒等待线程的?或者说,wait()等待线程和notify()之间是通过什么关联起来的?答案是:依据“对象的同步锁”。

负责唤醒等待线程的那个线程(我们称为“唤醒线程”),它只有在获取“该对象的同步锁”(这里的同步锁必须和等待线程的同步锁是同一个),并且调用notify()或notifyAll()方法之后,才能唤醒等待线程。虽然,等待线程被唤醒;但是,它不能立刻执行,因为唤醒线程还持有“该对象的同步锁”。必须等到唤醒线程释放了“对象的同步锁”之后,等待线程才能获取到“对象的同步锁”进而继续运行。

总之,notify(), wait()依赖于“同步锁”,而“同步锁”是对象锁持有,并且每个对象有且仅有一个!这就是为什么notify(), wait()等函数定义在Object类,而不是Thread类中的原因。

二、Math类

Math类都是static修饰,直接使用

  • 成员方法
    • abs(int a):绝对值
    • ceil(double d):向上取整
    • floor(double d):向下取整
    • max(int a,int b):最大值
    • pow(double a,double b):a的b次幂
    • random():随机数[0.0,1.0]
    • round(float f):四舍五入
    • sqrt(double d):算术平方根

三、Random类

为什么说Random生成的随机数是伪随机数?
只要两个Random对象的种子相同,而且方法的调用顺序也相同,产生的随机数相同。

  • 构造方法
    • Random():以当前时间毫秒值作为种子,创建Random对象
    • Random(long seed):以指定种子创建Random对象
  • 成员方法
    • nextInt():生成1个int类型范围的随机数
    • nextInt(int n):产生1个[0,n-1]范围内的随机数
生成0~n之间的数
①(int)Math.random()*(n+1)
②Random r = new Random();
r.nextInt(m)表示生成[0,m-1]之间的随机数,也就是说random.nextInt(m+1),将生成[0,m]之间的随机整数。
r.nextInt(n+1)
生成n~m之间的随机数
①n+(int)(Math.random()*(m+1-n));
②Random r = new Random();
r.nextInt(m+1-n)+n;
  • UUID
// 用于做数据库的id
String uuid = UUID.randomUUID().toString();
// 效果:39eb10ce-e8be-49f5-a44b-bfd0aa8c8135

四、File类

Java文件类以抽象的方式代表文件名和目录路径名。
该类主要用于文件和目录的创建、文件的查找和文件的删除等。
File对象代表磁盘中实际存在的文件和目录。

1、构造方法

  • 通过给定的父抽象路径名和子路径名字符串创建一个新的File实例。
File(File parent, String child);
  • 通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。
File(String pathname);
  • 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
File(String parent, String child);
  • 通过将给定的 file: URI 转换成一个抽象路径名来创建一个新的 File 实例。
File(URI uri) 

2、添加文件

public boolean mkdir()
创建此抽象路径名指定的目录。
public boolean mkdirs()
创建此抽象路径名指定的目录,包括创建必需但不存在的父目录。

3、查看文件

public File[] listFiles()
返回一个抽象路径名数组,这些路径名表示此抽象路径名所表示目录中的文件。

4、修改文件

public boolean renameTo(File dest)
重新命名此抽象路径名表示的文件。

5、删除文件

public boolean delete()
删除此抽象路径名表示的文件或目录。

五、包装类

Java提供了两个类型系统,基本类型与引用类型,使用基本类型在于效率,然而很多情况,会创建对象使用,因为对象可以做更多的功能。
如果想要我们的基本类型像对象一样操作,就可以使用基本类型对应的包装类,如下:

基本类型 对应的包装类(位于java.lang包中)
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

1、装箱与拆箱

  • 基本类型与对应的包装类对象之间,来回转换的过程称为”装箱“与”拆箱“:
  // 装箱, 基本类型 → 引用类型
  // 基本类型
  int num1 = 18;
  // 使用Integer类创建对象
  Integer integer1 = new Integer(num1);
  Integer integer2 = Integer.valueOf(num1);
  // 拆箱, 引用类型 → 基本类型
  Integer integer3 = new Integer(100);
  int num2 = integer3.intValue();

3、自动装箱拆箱

  • 由于我们经常要做基本类型与包装类之间的转换,从JDK 1.5开始,基本类型与包装类的装箱、拆箱动作可以自动完成。例如:
  int age = 30;
  // 自动装箱
  Integer integer4 = age;
  // 自动拆箱
  int age2 = integer4;

4、基本类型与字符串转换

  // 1. 基本类型转成字符串
  int n1 = 100;
  // 1.1 使用+号(推荐)
  String s1 = n1 + "";
  // 1.2 使用Integer中的toString()方法
  String s2 = Integer.toString(n1);
  // 1.3 x为进制要求
  String s2 = Integer.toString(n1, x); 
  
  // 2. 字符串转成基本类型
  String str = "150";
  // 2.1使用Integer.parseXXX();(推荐)
  int n2 = Integer.parseInt(str);
  // 2.2包装类型的构造器
  Integer i = new Integer("2");
  // 2.3返回保存指定的 String 的值的 Integer 对象
  Integer integer2 = Integer.valueOf(num1);
  
  // boolean 字符串形式转成基本类型,"true" ---> true 非“true ———> false
  String str2 = "true";
  boolean b1 = Boolean.parseBoolean(str2);

除了Character类之外,其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型:

  • public static byte parseByte(String s):将字符串参数转换为对应的byte基本类型。
  • public static short parseShort(String s):将字符串参数转换为对应的short基本类型。
  • public static int parseInt(String s):将字符串参数转换为对应的int基本类型。
  • public static long parseLong(String s):将字符串参数转换为对应的long基本类型。
  • public static float parseFloat(String s):将字符串参数转换为对应的float基本类型。
  • public static double parseDouble(String s):将字符串参数转换为对应的double基本类型。
  • public static boolean parseBoolean(String s):将字符串参数转换为对应的boolean基本类型。

注意:需保证类型兼容,否则抛出NumberFormatException异常。

5、整数缓冲区

  • Java预先创建了256个常用的证书包装类型对象
  • 实际应用当中,对已创建的对象进行复用
  Integer integer3 = new Integer(100);// 自动装箱
  // 相当于调用 Integer.valueOf(100);
  Integer integer4 = new Integer(100);
  sout(integer3 == integer4); // true
  
  Integer integer5 = new Integer(200);// 自动装箱
  Integer integer6 = new Integer(200);
  sout(integer5 == integer6); // false
  
  // 因为缓存区数组 [-128, 127] 在这之内地址一样

六、Date类

1、Date

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

  • 构造方法
    • Date():以当前时间毫秒值创建Date对象
    • Date(long time):以指定的毫秒值创建Date对象,0:1970:01:01 08:00:00,小时不是0,是因为我们处于东八区
  • 成员方法
    • long getTime():获取Date对象的毫秒值
    • setTime(long time):设置Data对象的毫秒值

2、SimpleDateFormat

将日期时间类Date转换为自定义日期时间格式(格式化)

  • 构造方法

    • SimpleDateFormat():以默认模式创建对象
    • SimpleDateFormat(String pattern):以指定模式创建对象
  • 常用的格式规则为:

标识字母(区分大小写) 含义
y
M
d
H
m
s
  • 常成员方法
    • String format(Date date):格式化
    • Date parse(String time):解析
      格式化
// 创建日期对象
Date date = new Date();
// 创建日期格式化解析对象
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 调用格式化方法
String time = format.format(date);
// 打印结果
System.out.println(time);// 结果:2022-05-10 09:46:15

解析

// 创建日期格式化解析对象
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 自定义时间
String str = "2020-05-10 09:46:15";
// 调用解析方法,返回date对象,抛出ParseException异常
Date date = format.parse(str);
// 打印结果
System.out.println(date);// 结果:Sun May 10 09:46:15 CST 2020
  • 练习:请使用日期时间相关的API,计算出一个人已经出生了多少天。
  • 思路:

1.获取当前时间对应的毫秒值

2.获取自己出生日期对应的毫秒值

3.两个时间相减(当前时间– 出生日期)

public static void function() throws Exception {
	System.out.println("请输入出生日期 格式 YYYY-MM-dd");
	// 获取出生日期,键盘输入
	String birthdayString = new Scanner(System.in).next();
	// 将字符串日期,转成Date对象
	// 创建SimpleDateFormat对象,写日期模式
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
	// 调用方法parse,字符串转成日期对象
	Date birthdayDate = sdf.parse(birthdayString);	
	// 获取今天的日期对象
	Date todayDate = new Date();	
	// 将两个日期转成毫秒值,Date类的方法getTime
	long birthdaySecond = birthdayDate.getTime();
	long todaySecond = todayDate.getTime();
	long secone = todaySecond-birthdaySecond;	
	if (secone < 0){
		System.out.println("还没出生呢");
	} else {
		System.out.println(secone/1000/60/60/24);
	}
}

3、Calendar

该类是一个抽象类,不可以实例化
它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等
日历类,用于获取或者操作日历字段(年月日)
日历字段之间的转换提供了一些方法,并为操作日历字段(例如获得下星期的日期)提供了一些方法。

  • 成员方法
    • static Calender getInstance():以默认时区和语言创建日历
    • int get(int field):获取指定字段的日历值
    • set(int field,int value):给指定的日历字段设置指定的值
    • set(int year,int month,int date):设置年月日
    • Date getTime():获取日历对象的日期
    • setTime(Date d):设置日历对象的日期
    • add(int field,int amount):对指定的日历字段添加指定的值
字段值 含义
YEAR
MONTH 月(从0开始,可以+1使用)
DAY_OF_MONTH 月中的天(几号)
HOUR 时(12小时制)
HOUR_OF_DAY 时(24小时制)
MINUTE
SECOND
DAY_OF_WEEK 周中的天(周几,周日为1,可以-1使用)

get/set

// 获取日历类对象
Calendar time = Calendar.getInstance();
// 获取年
int year = time.get(Calendar.YEAR);
// 获取月
int month = time.get(Calendar.MONTH);
// 获取日
int day = time.get(Calendar.DAY_OF_MONTH);
// 获取时
int hour = time.get(Calendar.HOUR_OF_DAY);
// 获取分
int minute = time.get(Calendar.MINUTE);
// 获取秒
int second = time.get(Calendar.SECOND);
// 打印结果:2022-4-10	10:3:59
System.out.println(year+"-"+month+"-"+day+"\t"+hour+":"+minute+":"+second);// 更改时间
time.set(Calendar.YEAR,2003);
// 打印结果:​2003-4-10	10:6:25
     }
 }

add
add方法可以对指定日历字段的值进行加减操作,如果第二个参数为正数则加上偏移量,如果为负数则减去偏移量。代码如:

import java.util.Calendar;

public class Demo08CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2018年1月17日
        // 使用add方法
        cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
        cal.add(Calendar.YEAR, -3); // 减3年
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2015年1月18日; 
    }
}

getTime
Calendar中的getTime方法并不是获取毫秒时刻,而是拿到对应的Date对象。

import java.util.Calendar;
import java.util.Date;

public class Demo09CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        Date date = cal.getTime();
        System.out.println(date); // Tue Jan 16 16:03:09 CST 2018
    }
}

注意:
西方星期的开始为周日,中国为周一。
在Calendar类中,月份的表示是以0-11代表1-12月。
日期是有大小关系的,时间靠后,时间越大。

4、Timestamp

七、String类

表示的是字符串,字符串是常量(值定义了之后,不可修改)
字符串可以看出是多个字符的连接

  • 构造方法
    • String():创建一个空的字符串
    • String(byte[] bys):通过字节数组创建字符串
    • String(char[] chs):通过字符数组创建字符串
    • String(byte[] bys,int offset,int length):通过字节数组一部分创建字符串
    • String(char[] chs,int offset,int length):通过字符数组一部分创建字符串
    • String(String original):通过字符串常量值创建字符串
  • 成员方法
    • 判断功能

      • equals(Object obj):比较两个字符串是否相等
      • equalsIngnoreCase(Object obj):忽略大小写比较两个字符串是否相等
      • contains(String str):是否包含指定字符串
      • startsWith(String str):是否以指定的字符串开头
      • endWith(String str):是否以指定的字符串结尾
      • isEmpty():是否为空
      • matches(String regex):判断字符串是否匹配给定的正则表达式。
    • 获取功能

      • length():获取长度
      • charAt(int index): 获取指定索引位置处的字符
      • indexOf(int ch):获取指定字符第一次出现的索引值(从0开始)
      • indexOf(int ch,int fromIndex):获取从指定索引位置开始,获取指定字符第一次出现的索引值
      • indexOf(String s):获取指定字符串第一次出现的索引值
      • indexOf(String s,int fromIndex):获取从指定索引位置开始,获取指定字符串第一次出现的索引值
      • lastIndexOf(int ch):获取指定字符最后一次出现的索引值
      • substring(int start):从指定位置开始一直截取到末尾
      • substring(int start,int end):截取[start,end-1]范围
    • 转换功能

      • byte[] getBytes():将字符串转成字节数组
      • char[] toCharArray():将字符串转成字符数组
      • static valueOf(char[] chs):将char[]转成字符串
      • static valueOf(int num):将int类型转成字符串
      • static valueOf(Object obj):将任意类型转成字符串
      • toLowerCase():转成小写
      • toUpcase():转成大写
      • concat(String str):字符连接
    • 其他功能

      • replace(char old,char new):将old字符替换成new字符
      • replace(String old,String new):将old字符串替换成new字符串
      • trim():去除两边空格
      • int compareTo(String s):字典比较,如果前面值小于后面值返回负数,否则返回正数,先比较第一个元素,如果相等再比较第二个元素…返回元素之间的差值;如果比较字符串有包含关系,返回的值是它们长度的差值
      • int compareToIgnoreCase(String s):忽略大小写字典比较
      • String replaceAll(String regex, String replacement):使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
      • String replaceFirst(String regex, String replacement):使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
      • String[] split(String regex): 根据给定正则表达式的匹配拆分此字符串。
      • String[] split(String regex, int limit): 根据匹配给定的正则表达式来拆分此字符串。
/*
* 字符串做连接操作
* 如果是两个变量进行连接,先开辟空间,再连接
* 如果是两个常量进行连接,先连接,获取连接结构值。然后在常量池里面查找有没有这个结果值,如果有,直接给地址值;没有,开辟空间
*/
public class StringTest02 {
	public static void main(String[] args) {
	String s1 = "hello";
	String s2 = "world";
	String s3 = "helloworld";

	System.out.println(s3 == s1+s2); //false
	System.out.println(s3.equals(s1+s2)); //true

	System.out.println(s3 == "hello"+"world"); //true
	System.out.println(s3.equals("hello"+"world")); //true
	}
}
  • 练习
// 1. length(); 返回字符串长度
// 2. charAt(int index); 返回某个位置的字符
// 3. contains(String str); 判断是否包含某个字符串

String content = "java是最好的语言, java no1";
sout(content.length()); // 10
sout(content.charAt(content.length() - 1)); // 言
sout(content.contains("java")); // true

// 4. toCharArray(); 返回字符串对应数组 
// 5. indexOf(); 返回子字符串首次出现的位置
// 6. lastIndexOf(); 返回字符串最后一次出现的位置

sout(content.toCharArray());
sout(content.indexOf"java")); // 0
sout(content.indexOf("java", 4)); // 从索引4开始找 返回12
sout(content.lastIndexOf("java")); // 12

// 7. trim(); //去掉字符串前后空格
// 8. toUpperCase(); toLowerCase(); 转换大小写
// 9. endWith(str); startWith(str);  判断是否以str 结尾、开头

String ct = " hello world ";
sout(ct.trim()); // "hello world"
sout(ct.toUpperCase()); // HELLO WORLD
sout(ct.toLowerCase()); // hello world
sout(ct.endWith("world")); // true
sout(ct.startWith("hello")) // true
  
// 10. replace(char old, char new); 用心的字符或字符串替换旧的字符或字符串
// 11. split(); 对字符串拆分

sout(content.replace("java", "php")); // php是最好的语言, php no1

String say = "java is the best language";
String[] arr = arr.say.split(" "); // "[ ,]+" 表示空格 逗号切分 +号表示切分可以多个 比如多个空格
sout(arr.length); // 5
for(String string : arr){
  sout(string);
}
// 打印出 
//java
//is
//the 
//best
//language

// 补充两个equals/compareTo();比较大小
String s1 = "hello";
String s2 = "HELLO";
sout(s1.equalsIgnoreCase(s2));// 忽略大小写比较true

// compareTo(); 两字符不同时比较字符字典序的ascii码
// 字符相同时比较长度 返回差值

可变字符串

StringBuffer:多线程数据量多使用,线程安全
StringBuider:单线程数据量较多使用,线程不安全
效率都比String高且节省内存

  • 构造方法
    • StringBuilder():以默认容量创建空的StringBuilder对象
    • StringBuilder(int capacity):以指定容量创建空的StringBuilder对象
    • StringBuilder(String str):以指定的字符串创建StringBuilder对象
  • 成员方法
    • 获取功能
      • int capacity():获取容量
      • int length():获取长度
    • 添加功能
      • append(int value):追加。可以追加多种类型
      • insert(int offset,String s):在指定的位置插入指定数据
    • 删除功能
      • deleteCharAt(int index):删除指定索引处的元素
      • delete(int start,int end):删除[start,start-1]范围内的元素
    • 替换功能
      • replace(int start,int end,String s):将[start,end-1]范围内的元素替换成指定字符串
    • 反转功能
      • reverse():元素反转
    • 截取功能
      • String subString(int start):截取指定位置一直到末尾
      • String subString(int start,int end):截取[start,end-1]范围
  // StringBuffer 和 StringBuilder 用法一致
  StringBuffer sb = new StringBuffer();
  // 1. append(); 追加
  sb.append("java no1");
  // 2. insert(); 添加、插入
  sb.insert(0, "在第一个位置插入");
  // 3.replace(); 替换
  sb.replace(0, 9, str); // 左闭右开
  // 4. delete(); 删除
  sb.delete(0, 5); // 左闭右开
  // 5. 清空
  sb.delete(0, sb.length());

面试问题

String、StringBuilder和StringBuffer的区别?

  1. String内容不可改变
  2. StringBuilder和StringBuffer内容可变
  3. StringBuilder是线程不安全的,不同步,效率高
  4. StringBuffer是线程安全的,同步,效率低

八、BigDecimal

位于java.math.BigDecimal,不可变的、任意精度的有符号十进制数。(精确的十进制小数)
用于金融行业浮点数计算

  • 构造方法
    BigDecimal(String s):通过字符创建BigDecimal对象
  • 成员方法
    add(BigDecimal bi):+
    subtract(BigDecimal bi):-
    multiply(BigDecimal bi)
    divide(BigDecimal bi, x, BigDecimal.ROUND_HALF_UP)
// 参数一
BigDecimal b1 = new BigDecimal(1.0);
// 参数er
BigDecimal b2 = new BigDecimal(0.9);
// 结果
BigDecimal sum = null;
// 加
sum = b1.add(b2);
System.out.println("1.0 + 0.9 = " + sum);
// 减
sum = b1.subtract(b2);
System.out.println("1.0 - 0.9 = " + sum);
// 乘
sum = b1.multiply(b2);
System.out.println("1.0 * 0.9 = " + sum);
// 除 除不尽时 x填保留位数 后面为四舍五入之意
sum = b1.divide(b2, 2, BigDecimal.ROUND_HALF_UP);
System.out.println("1.0 / 0.9 = " + sum);

九、BigInteger

位于java.math.BigInteger,不可变的任意精度的整数。

  • 构造方法
    • BigInteger(String s):通过字符串创建BigInteger对象
  • 成员方法
    • add(BigInteger bi):+
    • subtract(BigInteger bi):-
    • multiply(BigInteger bi)
    • divide(BigInteger bi)

十、System

System类代表当前Java程序的运行平台,程序不能创建System类的对象, System类提供了一些类变量 和类方法,允许直接通过System类来调用这些类变量和类方法。

  • 没有构造方法
  • 成员方法
    • currentTimeMills():获取当前时间毫秒值
    • exit(int status):退出JVM,0表示非异常退出
    • gc():运行垃圾回收处理机制(系统会在某个不确定的时间调用该方法),会调用finalize(),进行垃圾回收
    • getProperty(String key):获取指定键指示的系统属性
    • arrayCopy(Object[] srcArr,int srcPos,Object[] desArr,int destPos,int len):数组复制

十一、正则表达式

负责字符串的匹配处理(一般用于校验字符串格式)

  • 规则
    • 字符
      • x:x字符,a表a字符
        
      • \\:反斜线字符
        
      • \n:换行符
        
      • \r:回车符
        
    • 字符类
      • [abc]:表示a、b、c中的一个字符
        
      • [^abc]:表示除了a、b、c之外的任意一个字符
        
      • [a-zA-Z]:表示a~z或A~Z中的一个字符
        
      • [0-9]:表示数字
        
    • 预定义字符类
      • .:表示任意字符
        
      • \.:表示'.'字符
        
      • \d:表示数字字符,[0-9]
        
      • \w:表示单词字符,[a-zA-Z_0-9]
        
    • 边界匹配器
      • ^:表示行的开头
        
      • $:表示行的结尾
        
      • \b:表示单词的边界
        
    • 数量词
      • ?:表示0次或者1次
        
      • *:表示0次或者多次
        
      • +:表示1次或者多次
        
      • {n}:表示n次
        
      • {n,}:表示至少n次
        
      • {n,m}:n~m次
        

十二、编码表

编码表:由现实世界的字符和对应的数值组成的一张表

  • 常见的有:
  1. ASCII码:最高为是符号为,其他是数值位
  2. ISO-8859-1:拉丁码表
  3. BG2312:中文编码表
  4. GBK:GB2312的升级版,1个汉字对应2个字节
  5. GB18030:GBK的升级版
  6. BIG-5:中文繁体编码表,俗称"大5码"
  7. Unicode:国际标注码。所有字符都有两个字节表示
  • Java默认使用该编码表
    • UTF-8:万国码,一个汉字对应3个字节

tips:所有编码表都兼容ASCII码表

  • String中与字符集相关的方法
    • String(byte[] by,String charset):通过指定的字符集,将指定的字节数组转成字符串(解码)
    • byte[] getBytes(String charset):通过指定的字符集,将字符串转成字节数组(编码)

你可能感兴趣的:(JavaSE,java,开发语言)