一篇文章带你了解Java中的常用类

于 2022-01-21 17:45:19 发布
阅读量83 收藏 1
点赞数 4
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53190844/article/details/122622100
版权

Java中的常用类

一. String

String的特性

1.String声明为final的，不可被继承

2.String实现了Serializable接口，表名字符串是支持序列化的
String实现了Comparable接口，表示String可以比较大小

3.String内部定义了final char[] value用于存储字符串数据

4.String：代表不可变的字符串序列。简称：不可变性。

5.通过字面量的方式（区别于new）给一个字符串赋值，此时字符串的值声明在字符串常量池中

6.字符串常量池是不会重复存储相同内容的字符串的

例1

		String a = "abc";
        String b  = "abc";
        String c = new String("abc");
        String d = new String("abc");
        System.out.println(a==b);//true
        System.out.println(a==c);//false
        System.out.println(a==d);//false
        System.out.println(c==d);//false

说明：
1.String在用字面量创建的时候，是储存在常量池中。
在编译期，JVM会去常量池来查找是否存在“abc”，如果不存在，就在常量池中开辟一个空间来存储“abc”；如果存在，就不用新开辟空间。然后在栈内存中开辟一个空间，来存储“abc”在常量池中的地址值。

2.String在使用new的方式创建时，在编译阶段JVM先去常量池中查找是否存在“abc”，如果过不存在，则在常量池中开辟一个空间存储“abc”。在运行时期，通过String类的构造器在堆内存中new了一个空间，然后将String池中的“abc”复制一份存放到该堆空间中，在栈中开辟空间，存放堆中new出来的这个String对象的地址值。

例2

		String s1 = "hello";
        String s2 = "world";
        String s3 = "hello"+"world";
        String s4 = s1 + "world";
        String s5 = s1 + s2;
        String s6 = (s1 + s2).intern();

        System.out.println(s3 == s4);//false
        System.out.println(s3 == s5);//false
        System.out.println(s4 == s5);//false
        System.out.println(s3 == s6);//true

说明：在拼接的时候，常量与常量的拼接结果在常量池。且常量池中不会存在相同的常量。
只要有一个是变量，结果就在堆中
如果调用intern（）方法，意味着指向常量池。
在这里插入图片描述

String常用方法

int length()	//返回字符串的长度
char charAt(int index)		//返回某处索引的字符
boolean isEmpty()		//判断是否为空字符
String toLowCase()		//将Sting中的所有字符转换为小写
String toUpperCase()		//将String中的所有字符转换为大写
String trim()		//返回字符串的副本，忽略前导和尾部的空白
boolean equals(Object boj)		//比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString)		//忽略大小写的equal
String concat(String str)		//将指定的字符串连接到末尾，类似于“+”
int compareTo(String anotherString)		//比较俩字符串大小
String substring(int beginIndex)		//返回一个新的字符串，从beginIndex开始截取到最后一个
String substring(int beginIndex,int endIndex)		//从begindex开始到endIndex结束，不包括endIndex
boolean endsWith(String suffix)		//测试此字符串是否以指定的后缀结束
boolean startsWith(String suffix)		//测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix,int toffset)		//从指定的索引开始的字符串是否以确定的前缀开始
boolean contains(CharSequence s)		//当前字符串包含指定的char值序列时，返回true
int indexOf(String str)		//返回子字符串第一次出现的索引
int indexOf(String str，int fromIndex)		//	返回子字符串第一次出现的索引，从指定的索引开始
//注：indexOf未找到返回-1
String replace(char oldChar, char newChar)		//返回一个新的字符串，它是通过用 newChar 替换此字符串中出现
的所有 oldChar 得到的；
String replace(CharSequence target, CharSequence replacement)		//使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串；
String replaceAll(String regex, String replacement) 		// 使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串；
String replaceFirst(String regex, String replacement) 			//使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串；
boolean matches(String regex)		//告知此字符串是否匹配给定的正则表达式；
String[] split(String regex)		//根据给定正则表达式的匹配拆分此字符串；
String[] split(String regex, int limit)		//根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

String 与char[]之间的转换

String --> char[] :调用String的toCharArry（）
char[] --> String：调用String的构造器

String与字节的转换

字节数组 --> 字符串

  1. String(byte[])：通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
  2. String(byte[]，int offset，int length) ：用指定的字节数组的一部分，即从数组起始位置offset开始取length个字
    节构造一个字符串对象。

字符串 --> 字节数组

public byte[] getBytes(String charsetName) ：使用指定的字符集将此String编码到byte序列，并将结果存储到
新的 byte 数组。

StringBuffer 与 StringBuilder

StringBuffer的特点

StringBuffer类不同于String，其对象必须使用构造器生成。
	有三个构造器： 
		a): StringBuffer()：初始容量为16的字符串缓冲区。
		b): StringBuffer(int size)：构造指定容量的字符串缓冲区。
		c): StringBuffer(String str)：将内容初始化为指定字符串内容。

StringBuffer的常用方法

StringBuffer append(String str)：提供了很多的append()方法，用于进行字符串拼接；
StringBuffer delete(int start,int end)：左闭右开，删除指定位置的内容；
StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str；
StringBuffer insert(int offset, String str)：在指定位置插入str、；
StringBuffer reverse() ：把当前字符序列逆转；

StringBuffer，StringBuilder与String三者异同


String： 不可变字符序列，底层使用char[]存储
StringBuffer：可变的字符序列，线程安全，效率低，底层使用char[]存储
StringBuilder：可变的字符序列，jdk5.0新增，线程不安全，效率高，底层使用char[]储存

二.日期类

System类中的currentTimeMillis（）

long time = System.currentTimeMillis();
//返回当时时间与1970.1.1  0：0:0之间以毫秒为单位的时间差
//称为时间戳
System.out.println(time);

LocalDate,LocalTime,LocalDateTime

		LocalDateTime localDateTime = LocalDateTime.now();
        //获取当前时间
        LocalDateTime localDateTime1 = LocalDateTime.of(2022,1,19,11,43);
        //设置时间
        System.out.println(localDateTime.getDayOfMonth());
        //放回当前日期是当前月份中的第几天
        System.out.println(localDateTime.getDayOfWeek());
        //返回当前日期是当前星期中第几天
        LocalDateTime localDateTime2 = localDateTime.withDayOfMonth(20);
        //设置当前日期在月份中的某一天
        LocalDateTime localDateTime3 = localDateTime1.plusDays(5);
        //在当前日期在月份中的日期加五天
        LocalDateTime localDateTime4 = localDateTime1.minusDays(5);
        //在当前日期在月份中的日期减五天

在这里插入图片描述

DateTimeFormatter 类（格式化）

1. 预定义的标准格式。如：
	ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
2. 本地化相关的格式。如：ofLocalizedDateTime(FormatStyle.LONG)
*3. 自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)


		DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss" );
		//静态方法，返回一个指定格式字符串的DateTimeFormatter
        String s = dateTimeFormatter.format(LocalDateTime.now());
        //格式化一个日期，返回字符串
        TemporalAccessor parse = dateTimeFormatter.parse("2022-01-19 03:19:23");
        //将指定的格式的字符串解析为一个日期，时间

三.Java比较器

自然排序：java.lang.Comparable

1. Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。
2. 实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的
返回值来比较大小。如果当前对象this大于形参对象obj，则返回正整数，如果当前对象this小于形参对象obj，则返
回负整数，如果当前对象this等于形参对象obj，则返回零。
3. 实现Comparable接口的对象列表（和数组）可以通过 Collections.sort 或Arrays.sort进行自动排序。实现此接口
的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
4. 对于类 C 的每一个 e1 和 e2 来说，当且仅当 e1.compareTo(e2) == 0 与e1.equals(e2) 具有相同的 boolean 值
时，类 C 的自然排序才叫做与 equals 一致。建议（虽然不是必需的）最好使自然排序与 equals 一致。
5. Comparable 的典型实现：(默认都是从小到大排列的) 
	a): String：按照字符串中字符的Unicode值进行比较;
	b): Character：按照字符的Unicode值来进行比较;
	c): 数值类型对应的包装类以及BigInteger、BigDecimal：按照它们对应的数值大小进行比较;
	d): Boolean：true 对应的包装类实例大于 false 对应的包装类实例;
	e): Date、Time等：后面的日期时间比前面的日期时间大。


public class Goods implements Comparable {
    private String name;
    private double price;
    private Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public int compareTo(Object o) {
        if (o instanceof Goods) {
            Goods other = (Goods) o;
            if (this.price > other.price) {
                return 1;
            } else if (this.price < other.price) {
                return -1;
            }
            return 0;
        }
    }

定制排序：java.util.Comparator

1. 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口
的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序，强行对多个对象进行整体排序的比
较。
2. 重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返
回0，表示相等；返回负整数，表示o1小于o2。
3. 可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控
制。
4. 还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对
象 collection 提供排序。


		Arrays.sort(p,Comparator.comparing(people::getName,(s,t)->Integer.compare(s.length(),t.length())));
		//使用lambda表达式
		//-----------------------------------------------------
		//使用匿名内部类
        Arrays.sort(p, new Comparator<Comparator.people>() {
            @Override
            public int compare(Comparator.people o1, Comparator.people o2) {
                return compare(o1,o2);
            }
        });

四.System类

1. System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。
2. 由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和
成员方法都是static的，所以也可以很方便的进行调用。
3. 成员变量
		System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准
	错误输出流(显示器)。
4. 成员方法
	a); native long currentTimeMillis()： 
			该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)
		1970年1月1号0时0分0秒所差的毫秒数。
	b): void exit(int status)： 
			该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在
		图形界面编程中实现程序的退出功能等。
	c): void gc()： 
			该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现
		以及系统执行时的情况。
	d): String getProperty(String key)： 
			该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用

五.Math类

abs 绝对值
acos,asin,atan,cos,sin,tan 三角函数
sqrt 平方根
pow(double a,doble b) a的b次幂
log 自然对数
exp e为底指数
max(double a,double b)
min(double a,double b)
random() 返回0.0到1.0的随机数
long round(double a) double型数据a转换为long型（四舍五入）
toDegrees(double angrad) 弧度—>角度
toRadians(double angdeg) 角度—>弧度

六.BigInteger与BigDecimal

BigInteger类

1. Integer类作为int的包装类，能存储的最大整型值为2^31-1，Long类也是有限的，最大为2^63-1。如果要
表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。
2. java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供所有 Java 的基本整数操作
符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD
计算、质数测试、素数生成、位操作以及一些其他操作。
3. 构造器
	BigInteger(String val)：根据字符串构建BigInteger对象

常用方法

 public BigInteger abs()		//返回此 BigInteger 的绝对值的 BigInteger；
 BigInteger add(BigInteger val) 		//返回其值为 (this + val) 的 BigInteger；
 BigInteger subtract(BigInteger val) 		//返回其值为 (this - val) 的 BigInteger；
 BigInteger multiply(BigInteger val) 		//返回其值为 (this * val) 的 BigInteger；. BigInteger divide(BigInteger val) 		//返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分；
 BigInteger remainder(BigInteger val) 		//返回其值为 (this % val) 的 BigInteger；
 BigInteger[] divideAndRemainder(BigInteger val)		//返回包含(this / val)后跟(this % val)的两个BigInteger的数组；
 BigInteger pow(int exponent) 		//返回其值为 (this^exponent) 的 BigInteger。

BigDecimal类

1. 一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到
java.math.BigDecimal类；
2. BigDecimal类支持不可变的、任意精度的有符号十进制定点数；
3. 构造器
	public BigDecimal(double val)
	public BigDecimal(String val)

常用方法

	public BigDecimal add(BigDecimal augend)
	public BigDecimal subtract(BigDecimal subtrahend)
	public BigDecimal multiply(BigDecimal multiplicand)
	public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
Zlxc_
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值