常用API总结

最新推荐文章于 2024-03-19 17:20:14 发布

花、随风凋谢

最新推荐文章于 2024-03-19 17:20:14 发布

阅读量630

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/biguo_/article/details/122521686

版权

1. String

1.1概述

java.lang.String : 是字符串类,底层就是一个final修饰的char数组,所以String很多特性就是数组的特性, 比如一旦确定,长度不能更改。
1 字符串一旦创建,这个字符串对象不能再更改
2 为了提升字符串的访问和存储效率,java虚拟机采用了一种缓存机制,把字符串都保存在了字符串常量池中。
3 在程序执行过程中,假如要用到一个字符串a String s1 = “a”;先去字符串常量池中检索,是否有a, 如果没有就创建一份，假如有了 String s2 = “a”; 就不再创建,把已有的这个a 返回。所以导致String s1 = “a” String s2 = “a” 此时使用 s1 == s2 他也是true,因为他们指向同一个字符串对象就是a。

1.2 基本使用

//1
String a = “a”;
String b = “b”;
String str = “ab”;
// 字面量相加在编译阶段,就把+去掉了
String d = “a” + “b”;
System.out.println(d == str);//true
System.out.println(d.equals(str));//true
// 变量相加,因为变量的值是可变的,运算之前没有办法确定变量的值,
// 所以没有办法优化,只能转换为new的方式,重新创建并拼接字符串
String c = a + b;
System.out.println(c == str);//false
System.out.println(c.equals(str));//true
String e = a + “b”;
System.out.println(c == str);//false
System.out.println(c.equals(str));//true
// 上面相加因为变量的值无法确定 , 如果声明为常量,则可以优化
String str1 = “ab”;
final String a1 = “a”;
final String b1 = “b”;
String c1 = a1+b1;
System.out.println(c1==str1);//true
// 创建几个对象? 1个
String xx = “a”+“b” +“c”+“d”;

1.3不要频繁拼接

因为字符串创建之后不能更改,如果频繁拼接的话,效率很低,并且垃圾回收可能也会出现问题

1.4构造方法

	//1字面量
	String s1="abcd";
	//2 new 
	String s2=new String("xxx");
	//3字节数组
	byte[] bytes={97,98,99,100,101,102};
	String s3=new String(bytes);//abcdef
	System.out.println(s3);
	//4字节数组，只截取一部分，4表示起始下标（包含),2表示个数
	String s4=new String(bytes,4,2);
	System.out.println(s4);//ef
	//5字符数组
	char[] chars={ 'a', 'b', 'c', 'd'};
	String s5=new String(chars);
	System.out.println(s5);//abcd
	//6字符数组，只截取一部分，1表示起始下标(包含) , 2 表示个数
	String s6=new String(chars,1,2);
	System.out.println(s6);//bc

1.5常用方法

学习API : 1 功能2 入参和出参 3 怎么用
//1char charAt(index) 返回字符串中指定位置的字符
	String s1="woyidingkeyi";
	char c1=s1.charAt(2);//y
	System.out.println(c1);
	//2boolean endsWith(String suffix)判定该字符串是否以指定字符串结尾
	//3boolean startsWith(String prefix)判定该字符串是否以指定字符串开始
	System.out.println("Hello.java".endsWith(".java"));//true
	// 注意空格 , 有空格就匹配不上了
	System.out.println("Hello.java".endsWith(".java "));//false
	//4不区分大小写，比较两个字符串是否相等 boolean equalslgnoreCase(String str)
	System.out.println("abc".equalsIgnoreCase("AbC"));//true
	//5byte[] getBytes():把字符串转换为字节数组并返回。
	byte[] bytes="abc".getBytes();
	for (int i = 0; i < bytes.length; i++) {
		System.out.println(bytes[i]);
	}//97 98 99
	//6char[] toCharArray():把字符串转换为字符数组
	char[] chars="abc".toCharArray();
	for (int i = 0; i < chars.length; i++) {
		System.out.println(chars[i]);
	}//a b c
	//7从指定位置开始查找(包含),获取该字符串中指定字符串的起始索引,找不到返回-1
	System.out.println("askdhaqwbe".indexOf("a", 5)); // -1
	//int indexOf(String str,int index) : 从指定位置开始查找(包含),获取该字符串中指定字符串的起始索引,找不到返回-1
	System.out.println("askdhaqwbe".indexOf("a", 5)); // -1
	 //8 index lastIndexOf(String str) : 同上,最后一次出现的索引 找不到返回-1
	System.out.println("askdhaqwbe".lastIndexOf("a")); // 5
	// 9 int length() : 返回该字符串的长度
	System.out.println("abc".length());
	// 10 String replaceAll(String regex . String replacement);替换指定字符,支持正则表达式
	// 11String replace (String str . String replacement); 不支持正则表达式
	// 支持正则表达式,但是没有写正则表达式 是没有区别的

System.out.println(“hucgasdqweasd”.replaceAll(“a”, “1”));
System.out.println(“hucgasdqweasd”.replace(“a”, “1”));
// 因为 . 在正则表达式中,代表任意字符
System.out.println(“qwe.rty.yui.uio”.replaceAll(".", “,”));
// 可以使用 \ 转义
System.out.println(“qwe.rty.yui.uio”.replaceAll("\.", “,”));
System.out.println(“qwe.rty.yui.uio”.replace(".", “,”));
// 11 String[] split(String regex) : 分割字符串,返回字符串数组,支持正则表达式,注意 …
// 点,需要转义
String s2 = “2022.1.14”;
String[] arr = s2.split("\.");
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
// 12 String substring(int begin);获取该字符串中,以某个下标起始的子字符串(包含)
System.out.println(“abcdef”.substring(2));// cdef
// 12 String substring(int begin);获取该字符串中,以某个下标起始的子字符串(包含)
System.out.println(“abcdef”.substring(2));// cdef
// 13 String substring(int begin, int end) :
// 获取该字符串中,以某个下标起始(包含)到某个下标结束的子字符串(不包含)
System.out.println(“abcdef”.substring(2, 4));// cd
// 14 String trim() : 去除字符串两边的空格
System.out.println(" a d sadasd “);
System.out.println(” a d sadasd ".trim());
// 15 String toUpperCase() : 转大写
// String toLowerCase() : 转小写
System.out.println(“asd”.toUpperCase());
// 16 static String valueOf(Object obj) :
// 调用该对象的toString方法,如果为null,则不再调用toString而是返回字符串null
String_04 s = null;
// 打印一个引用类型的时候,会自动调用String的valueOf 所以会自动调用toString方法
System.out.println(s);

2.StringBuffer和StringBuilder

2.1概述

StringBuffer和StringBuilder : 都是字符串缓冲区,可以做拼接操作
1.StringBuffer和StringBuilder和String区别
String : 底层是char数组,定长,一旦创建,不可更改,不合适做字符串拼接操作.
StringBuffer和StringBuilder : 底层是char数组,变长,预先在内存中申请一块空间,用来保存很多字符。如果预留空间不够了,会进行自动扩容。默认容量为 16,扩大容量 (当前容量+1)*2 16->34->70
2.StringBuffer和StringBuilder 的区别
StringBuffer 线程安全,在多线程环境下,不会出现问题。
StringBuilder 非线程安全,在多线程环境下,可能会出现问题。

2.2 基本使用

public static void main(String[] args) {
	// 创建一个对象
	StringBuilder sb = new  StringBuilder();
	String[] arr = {"a","b","c"};
	for (int i = 0; i < arr.length; i++) {
		// append 就是添加数据,做拼接操作
		// 可以链式调用
		sb.append(arr[i]).append(",");
	}
	// toString可以把StringBuilder转换为String类型
	String str = sb.toString();
	System.out.println(str);
}

2.3 常用方法

// append 就是添加数据,做拼接操作
		// 可以链式调用
		sb.append(arr[i]).append(",");
	}
	// 反转
	sb.reverse();
	// 获取已有元素个数
	System.out.println(sb.length());
	// 当前容量(数组长度)
	System.out.println(sb.capacity());
	// toString可以把StringBuilder转换为String类型
	String str = sb.toString();
	System.out.println(str);

3. 包装类

3.1 概述

想要对基本类型数据进行更多的操作，怎么办？
最方便的方式就是将其封装成对象。因为在对象描述中就可以定义更多的属性和行为对该基本数据类型进行操作。我们不需要自己去对基本类型进行封装，JDK已经为我们封装好了。

3.1.1概念

装箱就是自动将基本数据类型转换为包装器类型
拆箱就是自动将包装器类型转换为基本数据类型

3.2 使用

public static void main(String[] args) {
// 基本类型
byte b1 = 12;
// 封装为包装类
Byte b2=new Byte(b1);
m1(b2);
long l1 = 123L;
Long l2 = new Long(l1);
}
public static void m1(Object o){
}
## 3.3 Integer
## 3.3.1 基本使用
public static void main(String[] args) {
// 最大值
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
System.out.println(Long.MAX_VALUE);
System.out.println(Double.MAX_VALUE);
// 创建对象
Integer i1 = new Integer(123);
// 传递字符串也可以,但是必须是纯数字
Integer i2 = new Integer(“1231”);
// 报错 java.lang.NumberFormatException: For input string: “1231a”
//Integer i3 = new Integer(“1231a”);
}
## 3.3.2 相互转换
public static void main(String[] args) {
// int —> Integer
Integer i1 = new Integer(123);
i1 = Integer.valueOf(123);

	// Integer --> int
	int i2 = i1.intValue();
	
	// String --> integer
	Integer i3 = new Integer("123");
	i3 = Integer.valueOf("123");
	
	// Integer --> String 
	String string = i3.toString();
	
	// int --> String
	String string1 = 123+"";
	
	// String --> int 
	// 重要 static int parseInt(String str) : 把纯数字的字符串转换为int类型
	int i4 = Integer.parseInt("123");
	double d1 = Double.parseDouble("2.4");
	
	// 把数字以二进制的字符串形式,并返回
	String s1 = Integer.toBinaryString(10);
	// 同上,八进制
	s1 = Integer.toOctalString(10);
	// 同上,十六进制
	s1 = Integer.toHexString(10);
	System.out.println(s1);
}
## 3.3.3 常用方法
	// String --> int 
	// 重要 static int parseInt(String str) : 把纯数字的字符串转换为int类型
	int i4 = Integer.parseInt("123");
	double d1 = Double.parseDouble("2.4");
	// 把数字以二进制的字符串形式,并返回
	String s1 = Integer.toBinaryString(10);
	// 同上,八进制
	s1 = Integer.toOctalString(10);
	// 同上,十六进制
	s1 = Integer.toHexString(10);
	System.out.println(s1);
	## 3.3.4 自动装箱和自动拆箱
	java1.5新特性 自动装箱和自动拆箱
		 装箱 : 基本类型 到 包装类类型
		 拆箱 : 包装类类型 到 基本类型
	八种包装类 都覆写了 toString 和 equals()方法
	public static void main(String[] args) {
	// 1.5 之前这么写
	Integer i1 = Integer.valueOf(123);
	int i2 = i1.intValue();
	// 1.5 开始
	Integer i3 = 123; // 编译之后 就等于 Integer i3 = Integer.valueOf(123);
	int i4 = i3; // 编译之后 就等于 int i4 = i3.intValue(); 
	m1(i3);
	// 1234为int类型,会先进行自动装箱为 Integer类型,然后再发生多态转型为Object类型
	m1(1234);
}
public static void m1(Object obj){
	System.out.println(obj);
}
##3.3.5 深入整型常量池
简单来说,常量池就是提前准备好一些对象,当我们要保存数据的时候,发现已经创建好了,就直接拿走,不需要重新创建

总结 :
当我们通过 new Integer(xx) 创建对象的时候, 不管值是多少,. == 永远是false
当我们使用 Integer i1 = xxx; 这种方式的时候,编译之后会转换为Integer.valueOf() ; 这种方式会经过整型常量池.
假如 xxx这个值在 -128 到127之间则不需要new对象,而是使用常量池中已创建好的对象.
否则不再范围内, 则还是等于 new Integer(xxx) 这种方式.
因此:Integer i1 = xxx;
Integer i2 = xxx; 如果 xxx 在-128 ~ 127 之间则 i1 == i2 是 true
但是注意 Integer类型之间的比较还是要用 equals 进行比较才最好
public static void main(String[] args) {
int i = -128;
System.out.println(-i);
Integer i1 = new Integer(10);
Integer i2 = new Integer(10);
// false
System.out.println(i1 == i2);
// true
System.out.println(i1.equals(i2));
Integer i3 = Integer.valueOf(-126);
Integer i4 = Integer.valueOf(-126);
// true
System.out.println(i3 == i4);

	Integer i5 = 12; // 编译之后 Integer.valueOf(12);
	Integer i6 = 12;
	// true
	System.out.println(i5 == i6);

	Integer i7 = 222; // 就等于 new Integer(222)
	Integer i8 = 222;
	// false , 因为整型常量池的范围在 -128 ~ 127之间
	System.out.println(i7 == i8);
}

4. System

4.1 概述

System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
此方法适于计算时间差。

System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。
由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。
成员变量
System类内部包含in、out和err三个成员变量，分别代表标准输入流
(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。
成员方法
native long currentTimeMillis()：
该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时
间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
void exit(int status)：
该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表
异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。

4.2 常用方法

public static void main(String[] args) {
	// 标准输出 -- > 打印到控制台
	System.out.println(123);
	// 表示错误, 以红色字体 展示到控制台
	System.err.println(123);
	// in 表示标准输入,接收控制台输入的信息
	new Scanner(System.in);
	
	// 获取时间原点到当前时间的毫秒数(1970.1.1 8:0:0)
	long startTime = System.currentTimeMillis();
	System.out.println("正在执行");
	long endTime = System.currentTimeMillis();
	System.out.println("耗时 : "+(endTime-startTime));
	// 退出JVM虚拟机,0表示正常关闭,1 表示异常关闭 , 一般用于图形界面 关闭窗口
	System.exit(0);
	// 执行不到
	System.out.println("==============");
}

5. Date

5.1 概述

获取时间和时间操作

5.2 构造方法

// 获取当前系统时间
Date d1 = new Date();
// 传入毫秒数,获取时间原点到指定毫秒数的世界
Date d2 = new Date(1000);
// Fri Jan 14 16:15:57 CST 2022
System.out.println(d1);
// Thu Jan 01 08:00:01 CST 1970
System.out.println(d2);
## 5.3 常用方法
// 1642148327849 获取指定时间的毫秒数
System.out.println(d1.getTime());
// 把时间转换为字符串类型
System.out.println(d1.toString());
## 5.4 格式化
/**
* 年 y
* 月 M
* 日 d
* 时 H
* 分 m
* 秒 s
* 毫秒 S
*/
// 创建时间格式化对象
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss SSS”);
// 格式化,返回字符串
String string = sdf.format(d1);
System.out.println(string);

	// 时间格式的字符串  转换为Date对象
	String strDate = "2022/01/14 16:21:36";
	// 格式化对象的时间格式  要和字符串的格式 一致
	sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
	// 转换  返回Date对象
	Date date = sdf.parse(strDate);
	System.out.println(date);

5.5 Calendar

public static void main(String[] args) {
// 获取当前日历
Calendar c = Calendar.getInstance();
// 获取当前是本周第几天 , 周日是第一天
System.out.println(c.get(Calendar.DAY_OF_WEEK));
// 年
System.out.println(c.get(Calendar.YEAR));
// 月 , 0 是1月 , 11是12月, 所以结果 +1 才是正确的
System.out.println(c.get(Calendar.MONTH)+1);
// 日获取今天是当前月中第几天
System.out.println(c.get(Calendar.DAY_OF_MONTH));
// 时 12小时制 System.out.println(c.get(Calendar.HOUR));
// 24小时制 System.out.println(c.get(Calendar.HOUR_OF_DAY));
// 分 System.out.println(c.get(Calendar.MINUTE));
// 秒 System.out.println(c.get(Calendar.SECOND));
}

6. Random

6.1 概述

	随机数 从 0 开始

6.2 使用

public static void main(String[] args) {
// 创建随机数生成器
Random r = new Random();
// 在int范围内随机生成一个数字
int i = r.nextInt();
System.out.println(i);
// 传入10 说明要在 0~9之间生成
i = r.nextInt(10);
System.out.println(i);
// 生成 10~22
// nextInt(最大值 - 最小值 + 1) + 最小值
int result = r.nextInt(100 - 20 + 1) + 20;
System.out.println(result);
}

花、随风凋谢

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
常用API总结

1. String1.1概述java.lang.String : 是字符串类,底层就是一个final修饰的char数组,所以String很多特性就是数组的特性, 比如一旦确定,长度不能更改。1 字符串一旦创建,这个字符串对象不能再更改2 为了提升字符串的访问和存储效率,java虚拟机采用了一种缓存机制,把字符串都保存在了字符串常量池中。3 在程序执行过程中,假如要用到一个字符串a String s1 = “a”;先去字符串常量池中检索,是否有a, 如果没有就创建一份，假如有了 String s
复制链接

扫一扫