java常用类

最新推荐文章于 2024-08-04 11:07:52 发布

san疯

最新推荐文章于 2024-08-04 11:07:52 发布

阅读量119

点赞数

分类专栏： java高级文章标签： java

本文链接：https://blog.csdn.net/qq_42547635/article/details/119274205

版权

java高级专栏收录该内容

7 篇文章 1 订阅

订阅专栏

1、String、StringBuffer、StringBuilder

1.2、StringBuffer和StringBuilder

2.3、SimpleDateFormat类

2.4、Calendar日历类（抽象类）

3、java1.8中日期时间类

3.1、Date和Calendar使用缺点

3.2、LocalDate(日期)、LocalTime(时间)、LocalDateTime（日期+时间）

3.3、Instant

3.4、DateTimeFormatter类

4、Comparable接口和Comparator接口

5.3、BigInteger、BigDecimal

1、String、StringBuffer、StringBuilder

1.1、String

1.1.1、概念

a、不可变字符序列，底层被final修饰

b、实现了Serializable接口支持序列化，实现了Comparable接口可以比较大小

c、内部定义了final char[] value用于存储字符串数据

1.1.2、定义方式

a、字面量定义方式

// 字面量定义方式，以下情况都说明了String的不可变性。
 
/* == 引用类型比较的是s1和s2对象的地址
   s1中的"abc"声明时会存放在常量池中,常量池不会存放相同内容的字符串。
   当定义s2时发现常量池中有"abc"会将s1的地址赋值给s2,s2并且指向数据"abc"。
*/    
    String s1 = "abc";
    String s2 = "abc"; 
    System.out.println(s1 == s2); // true 

/* 因为底层通过final修饰,所以不可变。所以对对象重新赋值时
   会在常量池重新创建一块空间存放"hello",并且s2重新指向"hello",s1不变
*/
    s2 = "hello";
    System.out.println(s2); // hello
    System.out.println(s1); // abc 

// 当对现有字符串进行连接操作，相当于new操作，在堆中存放拼接值的地址。值存放在常量池中
    String s3 = "abc";
    s3 += "def";
    System.out.println(s3); // abcdef
    System.out.println(s1); // abc

// 使用replace
    String s4 ="abc"
    s4.replce('a','h');
    System.out.println(s4); // ahc
    System.out.println(s1); // abc

b、通过new + 构造器创建的方式

// 通过new String()方式创建,本质上是this.value = new char[0]存储

/*创建了2个对象,一个是堆空间new的结构,另一个是char[]对应常量池中的数据"abc"
*/
String s = new String("abc");

1.1.3、常见比较场景

final String s0 = "java"
String s1 = "java";
String s2 = "python";


String s3 = "javapython";
String s4 = "java" + "python";
String s5 = s1 + "python";
String s6 = "java" + s2;
String s7 = s1 +s2;
String s8 = s5.intern();
String s9 = s0 + "python";

// 常量和常量拼接的结果在常量池中。且常量池不会存在相同内容的常量
System.out.println(s3 == s4); //true    栈中s3和s4指向的都是常量池的地址

// 只要其中有一个是变量,结果就在堆空间   
System.out.println(s3 == s5); //false   栈中s3指向常量池的地址和栈中s5指向堆的地址不一致
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

// 如果拼接的结果调用inter()方法,返回值就在常量池中。
System.out.println(s3 == s8); //true

// 因为final修饰s0,s0变为常量。最后变成常量和常量的拼接
System.out.println(s3 == s9); //true

1.1.4、常用方法

和长度有关的方法
返回类型方法名作用
int length() 得到一个字符串的字符个数（一个中文是一个字符，一个英文是一个字符，一个转义字符是一个字符）

和数组有关的方法
返回类型方法名作用
byte[] getBytes() 将一个字符串转换成字节数组
char[] toCharArray() 将一个字符串转换成字符数组
String[] split(String) 将一个字符串按照指定内容劈开

和判断有关的方法
返回类型方法名作用
boolean equals(String) 判断两个字符串的内容是否一模一样
boolean equalsIgnoreCase(String) 忽略大小写的比较两个字符串的内容是否一模一样
boolean contains(String) 判断一个字符串里面是否包含指定的内容
boolean startsWith(String) 判断一个字符串是否以指定的内容开头
boolean endsWith(String) 判断一个字符串是否以指定的内容结尾

和改变内容有关的方法
和改变内容有关的方法，都不会直接操作原本的字符串
而是将符合条件的字符串返回给我们，所以注意接收
返回类型方法名作用
String toUpperCase() 将一个字符串全部转换成大写
String toLowerCase() 将一个字符串全部转换成小写
String replace(String,String) 将某个内容全部替换成指定内容
String replaceAll(String,String) 将某个内容全部替换成指定内容，支持正则
String repalceFirst(String,String) 将第一次出现的某个内容替换成指定的内容
String substring(int) 从指定下标开始一直截取到字符串的最后
String substring(int,int) 从下标x截取到下标y-1对应的元素
String trim() 去除一个字符串的前后空格

和位置有关的方法
返回类型方法名作用
char charAt(int) 得到指定下标位置对应的字符
int indexOf(String) 得到指定内容第一次出现的下标
int lastIndexOf(String) 得到指定内容最后一次出现的下标

1.2、StringBuffer和StringBuilder

1.2.1、使用原因

如果每次通过String s = "Hello"; s = s+"World" 方式拼接字符串。会造成很大的内存开销，可以通过StringBuffer和StringBuild解决内存开销的问题。

1.2.2、性能比较

	String	StringBuffer	StringBuilder
可变性	不可变字符序列	可变字符序列	可变字符序列
安全性	线程安全原因:被final修饰，常量线程安全	线程安全原因：调用方法加了synchronized锁	线程不安全
效率	效率最低	效率低（适用多线程）	效率高(适用单线程)
底层存储	char[]数组	char[]数组	char[]数组

源码分析：
String str = new String()  ====> char[]  value  = new char[0];
String str1 = new String("abc")   ====> char[] value = new char[]{'a','b','c'};

StringBuffer sb = new StringBuffer(); ===> char[] value = new char[16];
sb.append('a'); ===> value[0] = 'a';
StringBuffer sb1 = new StringBuffer("abc"); ===> char[] value = new char["abc".length()+16];

// 扩容问题：如果添加的数据底层数组装不下，则需扩容底层的数组。默认扩容为原来的2倍+2,同时将原有数组中的数据复制到新的数组中。

1.2.3、常用方法

str.append(str1)           将指定的字符串str1追加到字符串序列str中

str.reverse()                             将字符串反转

str.delete(int start,int end) 删除指定位置的内容

str.insert(int offset,String str1)                在指定位置插入str1

str.replace(int start,int end,String str1) 把[start,end)位置替换为str1

public int indexof(String str) 返回当前字符串首次出现的位置

public String subString(int start,int end) 返回从start开始到end索引结束左闭右开的子集

public int length() 字符串长度

public char charAt(int n)   得到指定下标位置对应的字符

2、jdk1.8以前日期时间类

2.1、System类

System.currentTimeMillis();返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间戳

2.2、Date类

1、java.util.Date

创建对象：

Date date = new Date();

Date date = new Date(毫秒数)；

方法：

date.toString()   返回当前时间的年月日时分秒

date.getTime()   返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间戳

2、java.sql.Date    对应着数据库中的日期类型的变量

创建对象：java.sql.Date date = new Date(毫秒数)；

3、java.sql.Date转java.util.Date (java.sql.Date是java.util.Date的子类)

Date date = new java.sql.Date()；//多态概念

4、java.util.Date转java.sql.Date

date date = new Date();

java.sql.Date date1 = new java.sql.Date(date.getTime());

2.3、SimpleDateFormat类

创建对象：

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");HH为24小时制，hh为12小时制

1、日期转字符串

String format = sdf.fomat(new Date()); // 使用java.util.date(它能满足它的子类肯定能)

2、字符串转日期

Date date = sdf.parse("2021-08-01 13:53:59"); //传入的字符串应和定义的格式一致

2.4、Calendar日历类（抽象类）

创建对象：Calendar calendar = Calendar.getInstance();

常用方法：参数使用Calendar.DayOF_MONTH为例子

get()        int days =  calendar.get(Calendar.DayOF_MONTH)；//获取当月的第几天

set()        calendar.set(Calendar.DayOF_MONTH,22);//将这个月的这天改为22。没有返回值，原来的对象被覆盖。所以原来对象是可变的。

add() calendar.add(Calendar.DayOF_MONTH,3);//当天往后加3天(减3天用-3)

getTime()：日历类转date Date date = calendar.getTime();

setTime(): date转日历类 calendar.setTime(new Date);

注意点

获取月份时：1月是0，2月是1 --- 12月是11

获取星期时：周日是1，周一是2 --- 周六是7

3、java1.8中日期时间类

3.1、Date和Calendar使用缺点

3.1.1、可变性：Calendar中的方法导致本身的日期时间类可变

3.1.2、偏移性：Date中的年份是从1900开始的，而月份是从0开始的

3.1.3、格式化：格式化只对Date有用，Calendar需转为Date才能格式化

3.1.4、安全性：都是线程不安全的

3.2、LocalDate(日期)、LocalTime(时间)、LocalDateTime（日期+时间）

创建对象：以LocalDateTime举例,其它类似

LocalDateTime.now(); //获取当前日期+时间

LocalDateTime.of(2021,08,01,10,15,59); //设置指定年月日时分秒，没有偏移量

方法： 获取月份和星期不会存在偏差。

getXXX() LocalDateTime.now().getDayOfMonth(); //获取当月的第几天

withXXX() LocalDateTime t = LocalDateTime.now().withDayOfMonth(22); //这个月的当前天设置为22。但是原来创建的LocalDateTime.now()对象不会改变。体现了不可变性

plusXXX() 添加，不可变性

minusXXX() 减少，不可变性

3.3、Instant

概念：用来记录应用程序中的事件时间戳

创建对象：

Instant instant = Instant.now(); // 默认获取本初子午线对应的标准时间(伦敦时间)

方法：

instant.atOffset(ZoneOffset.ofHours(8)) ; 添加8小时偏移量(北京时间)

instant.toEpochMilli(); // 获取1970年1月1日0时0分0秒(UTC)开始的毫秒数

Instant.sEpochMilli(毫秒数);// 毫秒数获取Instance实例

3.4、DateTimeFormatter类

创建对象：方式很多以其中一种为例

DateTimeFormatter d = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")；HH为24小时制，hh为12小时制

1、日期转字符串

String format = d.format(LocalDateTime.now());

2、字符串转日期

TemporalAccessor s = d.parse("2021-08-01 13:53:59"); //传入的字符串应和定义的格式一致

4、Comparable接口和Comparator接口

4.1、Comparable接口

定义：java中的对象默认只能进行 == 或者 != 进行比较。不能使用 > 或 <。实际开发中如果对对象进行排序(就是比较大小)。需要使用Comparable接口或者Comparator中的一个。

4.1.1、自然排序

a、String类、包装类等实现了Comparable接口，重写了compareTo()方法。进而可以比较两个对象的大小。(Arrays.sort()中Arrays就是实现了Comparable接口)

b、重写compareTo(obj)规则：如果当前对象this>形参对象obj，则返回正数。如果当前对象this<形参obj，则返回负整数。如果相等则返回0

4.1.2、自定义类实现自然排序

自定义的类实现Comparable接口。重写compareTo()方法。在方法对需要排序的属性进行相应的逻辑判断比较。

4.2、Comparator接口

定义：当我们java中的某些类没有实现comparable接口但我们需对它排序，或者当comparable接口的排序规则不适合当前的操作。可以考虑使用comparator接口进行定制排序。

4.2.1、使用规则

重写compare(Object o1，Object o2)方法，比较o1和o2的大小。如果返回的是正整数，则o1>o2。如果返回0则相等。如果返回的是负整数，则o1<o2

        String[] arr = new String[]{"a","c","d","b"};
        // 只能从小到大排序
        Arrays.sort(arr); //本身实现了Comparable接口
        System.out.println(Arrays.toString(arr)); // [a, b, c, d]

        // 如果希望其它排序规则，如从大到小排序则需实现comparator接口
        // 如果是对象做法类似，比较需要的属性即可
        Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                if(o1 instanceof String && o2 instanceof String) {
                    String s1 = (String) o1;
                    String s2 = (String) o2;
                    return -s1.compareTo(s2);
                }
                // return 0;
                throw  new RuntimeException("输入的数据类型不一致");
            }
        });
        System.out.println(Arrays.toString(arr)); // [a, b, c, d]

5、其它

5.1、System类

navite long currentTimeMillis() 返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间戳

void exit(int status) status为0表示正常退出程序，非零表示异常退出程序

void gc() 请求系统进行垃圾回收

String getPropery(String key) 获取系统中属性名对应的key值

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

5.2、Math类

取整运算

Math.ceil(double x) //向上取整，返回大于该值的最近 double 值

Math.floor(double x) //向下取整，返回小于该值的最近 double 值

Math.round(double x) //四舍五入取整，参数类型：double、float

随机运算

Math.random() //内部调用了 Random.nextDouble() 方法，生成一个伪均匀分布在 [0,1)之间的 double 值

符合运算

Math.abs(int x) //计算绝对值，参数类型：int、long、float、double

Math.negateExact(int x) //计算相反值，参数类型：int、long

大小运算

Math.max(int x, int y) //获取两个参数中的最大值，参数类型：int、long、float、double

Math.min(int x, int y) //获取两个参数中的最小值，参数类型：int、long、float、double

Math.rint(double x) //获取与参数最接近的double值

5.3、BigInteger、BigDecimal

5.3.1、BigInteger：可以表示不可变的任意精度的整数（ int最大整型值2的31次方-1，long的最大整型值2的63次方-1）

5.3.2、BigDecimal：用于精度比较高的浮点类型的数据

san疯

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java常用类

目录1、String、StringBuffer、StringBuilder 1.1、String 1.1.1、概念 1.1.2、定义方式 1.1.3、常见比较场景 1.1.4、常用方法 1.2、StringBuffer和StringBuild 1.2.1、使用原因 1...
复制链接

扫一扫

专栏目录

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