运维做开发

这个屌丝很懒，什么也没留下！

热门标签

JavaSE - 常用Api_java se api

作者：运维做开发 | 2024-07-09 14:42:26

踩

java se api

1. String

1.1 概述

java.lang.String 字符串类

java 9 之前底层为字节数组(char[]),java 9 开始使用字节数组存储(byte[])

1. 字符串一旦确定，不能修改

2. 为了提高字符串的效率，java虚拟机使用了一种“缓存技术”，字符串常量池

3. 在以字面量形式创建一个字符串对象时，先看字符串常量池中是否已经存在相同的值，如果没有就创建一个，如果常量池中已经有了，就直接调用该对象即可。所以很多时候字符串类型的比较，也可以使用==，因为他们内存地址都一样(仅限于字面量)

4. 以new的方式创建时，会在堆内存创建字符串，同时也会在常量池中创建该字符串的对象。

1.2 基本使用


public class String_00 {
public static void main(String[] args) {
	
	// String字面量写法，只会在字符串常量池中创建一个对象
	String s1 = "123";
	String s2 = "123";
	String s3 = "1234";
	System.out.println(s1 == s2); //true
	System.out.println(s1.equals(s2)); // true
	System.out.println(s1.equals(s3)); // false
	
	// String创建对象写法，会在堆内存中创建不同对象，同时在常量池中创建对象
	// s4和s5会在堆内存中创建不同对象，同时在字符串常量池中创建一个字符串常量
	String s4 = new String("12345");
	String s5 = new String("12345");
	// s6指向常量池
	String s6 = "12345";
	System.out.println(s4 == s5); // false
	System.out.println(s4.equals(s5)); // true
	System.out.println(s4 == s6); // false
	System.out.println(s4.equals(s6)); // true
	// inter():将字符串添加到内部的字符串池中，并返回字符串池中的引用的方法
	System.out.println(s4.intern() == s5.intern());
	System.out.println(s4.intern() == s6.intern());
	}
}

1.3 构造方法


public static void main(String[] args) {
	// 1.字面量
	String s1 = "abc";
	
	// 2.new对象
	String s2 = new String("abc");
	
	// 3.字节数组
	byte[] bytes = {97,98,99,100};
	// 下标从0开始，传入3个字符
	String s3 = new String(bytes,0,3);
	System.out.println(s3);
	// 全部传入
	String s4 = new String(bytes);
	System.out.println(s4);
	
	// 4.字符数组
	char[] chars = {'a','c','d','f'};
	// 下标从0开始，传入2个字符
	String s5 = new String(chars,0,2);
	System.out.println(s5);
	// 全部传入
	String s6 = new String(chars);
	System.out.println(s6);
}

1.4 常用方法


public static void main(String[] args) {
		String str = "hello world";
		// 1. char charAt(int index) :获取字符串中对应索引的字符
		char c = str.charAt(0);
		System.out.println(c);
 
		
		// 2. boolean endWith(String str): 判断某个字符串是否以指定字符串结尾
		System.out.println(str.endsWith("ld"));
 
		
		// 3. byte[] getBytes():把该字符串转换为字节数组
		byte[] b = str.getBytes();
		
		
		// 4  char[] toCharArray() : 把字符串转换为字符数组
		char[] chars = str.toCharArray();
		
		// 5  int indexOf(String str) : 获取指定字符串在该字符串中的索引下标 , 如果不存在则返回-1
		// 从左到右的找,如果存在多个符合条件的,则返回第一个符合条件的下标
		System.out.println(str.indexOf("h"));
 
		
		// 传入3，表示从下标3开始往后找
		System.out.println(str.indexOf("m", 3));
 
		
		// 6  int lastIndexOf(String str) : 最后一次出现的索引,找不到返回-1
		// 从右往左找
		System.out.println(str.lastIndexOf("e"));
		
		// 7. int length():返回字符串长度
		System.out.println(str.length());
		
		str = "asdfghjkl deggrt ";
		System.out.println(str.length());
 
		// 8. String replace(String a,String b):替换，返回替换后的新字符串
		System.out.println(str.replace("g", "!"));
 
		
		//    replaceAll:支持正则表达式
		System.out.println(str.replaceAll("g", "!"));
				
		// 9. String[] split(String str):以特定字符串进行分割，返回字符串数组，支持正则表达式
		str = "2024-01-15";
		String[] strs = str.split("-");
		for(int i = 0; i < strs.length; i++) {
			System.out.println(strs[i]);
		}
		
		// 10.String subString(int index):截取字符串，获取指定索引开始(包含指定索引)到结束的字符串
		str = "asdfghjkl awsdd";
		// 左闭右开jkl awsdd
		System.out.println(str.substring(6));
		
		// 截取某下标到某下标的字符串，左闭右开
		System.out.println(str.substring(6, 9));
		
		// 11.String toUpperCase():转为大写并返回
		System.out.println(str.toUpperCase());
	
		
		// 12.String toLowerCase():转为小写并返回
		str = "ADGHJK jiann LO";
		
		System.out.println(str.toLowerCase());
 
		
		// 13.String trim():删除两边(首尾)空格并返回
		str = "  aws  weff  ";
		String str1 = "   aws  weff   ";
		System.out.println(str.trim());
		System.out.println(str1);
		
		
		// 删除所有空格并返回,使用替换把所有空格替换为空
		System.out.println(str.replace(" ", ""));
		
		
		// 14.equals():比较两个字符串是否相同
		System.out.println("asd".equals("aaa"));
 
		
		// 15.equalsIgnore():不区分大小写比较两个字符串是否相同
		System.out.println("ABC ij".equalsIgnoreCase("ABC ij"));
		
		// 16.static String valueOf(Object obj):调用对象的toString方法，并对null值进行处理，避免空指针
		Object obj = null;
		System.out.println(String.valueOf(obj));
		
		
 	}

1.5 注意：

字符串不能频繁的做拼接操作，因为字符串一旦确定不能修改，频繁的拼接字符串效率较低且不利于垃圾回收。

2. StringBuffer和StringBuilder

2.1 概述

StringBuffer和StringBuilder是什么

底层都是char数组，只不过数组可变长，所以当我们需要进行频繁的字符串拼接时可以使用

原理：

预先在内存空间中申请一块空间，足够容纳更多字符，如果预留空间不足，会自动进行扩容，默认初始化长度为16.扩大容量为 length*2 + 2 , 源码是 ( (value.length << 1) + 2;)

StringBuffer 和 StringBuilder的区别:

StringBuffer : 线程安全,在多线程环境下不会出现问题,常用于类中。

StringBuilder : 线程不安全,在多线程环境下,可能出现问题,常用于方法中。

2.2 基本使用


public static void main(String[] args) {
		// 创建对象
		// StringBuilder sb = new StringBuilder("a");
		StringBuilder strBulider = new StringBuilder();
 
		// 尾部添加
		strBulider.append("a");
		strBulider.append("b").append("c");
 
		// 添加到指定位置
		strBulider.insert(2, "c");
 
		// 反转
		strBulider.reverse();
 
		// 添加元素个数
		System.out.println(strBulider.length());
 
		// 当前容量
		System.out.println(strBulider.capacity());
 
		// 转化为String类型
		String str = strBulider.toString();
		System.out.println(str);
}

3. 包装类

3.1 概述

想要对基本数据类型进行更多操作，怎么办

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

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

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

3.2 使用(八种包装类,都覆写了equals 和 toString 及 hashCode方法)


public static void main(String[] args) {
		// 基本类型
		byte b1 = 10;
		short s1 = 4;
		int a1 = 11;
		long l1 = 123456L;
		float f1 = 1.23f;
		double d1 = 12.3;
		boolean flag1 = true;
		char ch = 'a';
		// 包装类类型
		Byte b2 = new Byte(b1);
		Byte b3 = new Byte(b1);
		System.out.println(b2.equals(b3));
		Short sh = new Short(s1);
		Integer a2 = new Integer(a1);
		Long l2 = new Long(l1);
		Float f2 = new Float(f1);
		Double d2 = new Double(d1);		
		Boolean flag2 = new Boolean(flag1);
		Character c = new Character(ch);
		
		m1(b2);
		m1(b3);
		m1(sh);
		m1(a2);
		m1(l2);
		m1(f2);
		m1(d2);
		m1(flag2);
		m1(c);
		
		
	}
	
	public static void m1(Object obj) {
		System.out.println(obj);
	}

3.3 Integer

3.3.1 基本使用


public static void main(String[] args) {
		// 最大值
		System.out.println(Integer.MAX_VALUE);
		// 最小值
		System.out.println(Integer.MIN_VALUE);
		// 创建对象
		Integer i1 = new Integer(11);
		// 传入纯数字字符串
		Integer i2 = new Integer("12");
		// 必须纯数字，否则运行会报错
		// Integer i3 = new Integer("12ss");
}

3.3.2 相互转换


public class Integer_02 {
	
	// int --> Integer
	Integer i1 = Integer.valueOf(11);
	
	// Integer --> int
	int i2 = i1.intValue();
	
	// String --> Integer
	Integer i3 = Integer.valueOf("1234");
	
	// Integer --> String
	String s1 = i3.toString();
	
	// int --> String
	String s2 = 12 + "";
	
	// String --> int
	int i4 = Integer.parseInt("1234");
	
	}

3.3.3 常用方法


public static void main(String[] args) {
		// 创建对象,可以把int 封装为 Integer类型
		Integer i1 = new Integer(11);
		// 通过intValue 把包装类 转换为 基本类型
		int i2 = i1.intValue();
		// 重要 : static int parseInt(String s ) : 把纯数字的字符串转换为int类型
		i2 = Integer.parseInt("1234");
		double d = Double.parseDouble("112.22");
		// static String toBinaryString(int value) : 转换为字符串类的二进制表示法
		System.out.println(Integer.toBinaryString(15));
		// 转十六进制
		System.out.println(Integer.toHexString(15));
		// 转八进制
		System.out.println(Integer.toOctalString(15));
		// 重要 static Integer valueOf(int value) : 把int类型转换为Integer类型
		Integer i4 = Integer.valueOf(1234);
		Integer i5 = Integer.valueOf("1234");
}

3.3.4 自动装箱和自动拆箱

装箱 : 基本类型到引用类型

拆箱 : 引用类型到基本类型

1.5开始引入自动装箱和自动拆箱


public static void main(String[] args) {
		// 1.5之前装箱
		Integer i1 = new Integer(11);
		i1 = Integer.valueOf(11);
		// 1.5之后拆箱
		Integer i2 = 12;
 
		// 1.5之前的拆箱
		int i3 = i2.intValue();
		// 1.5及以后的拆箱
		int i4 = i2;
		// 此时 15为int类型,会先自动装箱为Integer类型,然后在向上转型发生多态
		m1(15);
}
public static void m1(Object obj) {
		System.out.println(obj);
	}

3.3.5 深入整形常量池

IntegerCache.cache 是整型常量池,是个保存了256个Integer对象的数组,分别是 -128~127，当我们进行自动装箱或手动调用Integer.valueOf()方法时,会先判断是否符合整型常量池

，如果符合范围,则直接在整形常量池中把提前创建好的对象引用,赋值给他即可,不用再次创建。


public static void main(String[] args) {
		// 直接在堆内创建对象
		Integer a1 = new Integer(11);
		Integer a2 = new Integer(11);
		System.out.println(a1 == a2);
		System.out.println(a1.equals(a2));
		// 自动装箱, 会转型为 Integer.valueOf()
		// valueOf 中 进行了整形常量池从操作
		// 如果 值 -128~127之间,则不需要创建对象 , 否则 就在堆内存创建对象(new Integer())
		Integer a3 = 15;
		Integer a4 = 15;
		System.out.println(a3 == a4);
 
		Integer a5 = 555;// 等同于 i5 = new Integer(555)
		Integer a6 = 555;// 等同于 i5 = new Integer(555)
		System.out.println(a5 == a6);
}

4. System

4.1 概述

System类代表系统，系统的很多属性和控制方法都放置在该类中。该类位于java.lang包，由于该类的构造器是private的，所以无法创建该类对象，也就无法实例化该类。其内部的变量和方法都是静态的，所以可以很方便的调用。

1. System类内部包含in，out，err三个静态变量，分别代表标准输入流，标准输出流和标准错误输出流

2. System类提供的public static long currentTimeMillis()，

用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。

3. void exit(int atatus):该方法的作用是退出程序，参数为0为正常退出，

非0代表异常退出，使用该方法可以在图形页面编程中实现程序的退出功能。

4.2 常用方法


public static void main(String[] args) {
		
		// out,err,in 都是System中提供的打印方法
		// out 标准输出，默认打印在控制台
		System.out.println("控制台打印");
		
		// in 标准输入，默认接受控制太输入
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一个整数");
		int n = scanner.nextInt();
		
		// err 错误输出，打印颜色为红色，异步打印
		System.err.println("控制台错误形式的输出");
		
		// 获取当前系统对应的毫秒数，可用于统计时间
		// 从1970-1-1 8:00:00 到当前时间的毫秒数
		long startTime = System.currentTimeMillis();
		// 其它事务代码
		long endTime = System.currentTimeMillis();
		// 耗时
		System.out.println(endTime - startTime);
		
		// 建议垃圾回收
		System.gc();
		
		// 关闭JVM，0 表示正常退出，一般用于图形化界面
		System.exit(0);
	}

5. Date

5.1 概述

获取时间和时间操作

java 8之前使用Date，java 8中新引入了LocalDateTime，java 8 之后的版本推荐使用LocalDateTime。

Date和LocalDateTime的区别：

1. Date是java早期引入的日期时间类，位于java.util包中，LocalDateTime是java 8中新引入日期时间类，位于java.time包中。

2. Date是可变类，可以直接修改Date对象的值，而LocalDateTime是不可变类，一旦确定不能修改，如果要修改必须重新创建对象。

3. Date在表示日期和时间时会考虑系统时区，而LocalDateTime只表示日期和时间，不会考虑系统时区，如果需要考虑时区可以使用ZonedDateTime实现。

4. Date类精确到毫秒级，但设计存在问题，容易产生线程安全问题，而LocalDateTime类提供了更好的精确度，可以表示纳秒的时间。

5. Date类Api设计过于老旧，一些方法已经过时，LocalDateTime设计更现代化，直观易用。

5.1 构造方法


public class Date_01 {
	public static void main(String[] args) {
		// 注意导入的包为java.util.Date;
		// 使用Date获取当前系统时间
		Date date = new Date();
		// Date:Tue Jan 16 19:15:09 CST 2024
		System.out.println("Date:" + date);
		
		// 注意导入的包为ava.time.LocalDateTime;
		// 使用LocalDateTime获取当前系统时间
		LocalDateTime localDateTime = LocalDateTime.now();
		// localDateTime:2024-01-16T19:17:34.703
		System.out.println("localDateTime:" + localDateTime);
		
		// 创建指定日期和时间的Date对象(年的参数是指需设定的年份减去1900的结果,月的参数是从0开始计数的，所以0表示1月)
		// 当前构造方法以过时，不推荐使用
		Date specifyDate = new Date(124, 0, 16, 19, 23, 12);
		// specifyDate:Tue Jan 16 19:23:12 CST 2024
		System.out.println("specifyDate:" + specifyDate);
		
		// 创建指定日期时间的LocalDateTime对象
		LocalDateTime specifyLocalDateTime = LocalDateTime.of(2014, 1, 16, 19, 23, 12);
		// specifyLocalDateTime:2014-01-16T19:23:12
		System.out.println("specifyLocalDateTime:" + specifyLocalDateTime);
		
		// 修改Date对象的时间，Date对象是可变的
		date.setHours(12);// 方法已过时
		// Date:Tue Jan 16 12:32:32 CST 2024
		System.out.println("Date:" + date);
		
		// 修改LocalDateTime对象的时间，LocalDateTime是不可变的，需要创建新对象
		LocalDateTime reviseLocalDateTime = LocalDateTime.now().withHour(12).withMinute(24);
		// reviseLocalDateTime:2024-01-16T12:24:01.980
		System.out.println("reviseLocalDateTime:" + reviseLocalDateTime);
		
	}
	
}

5.2 格式化


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
 
// 格式化
// y年 M月 d日 H时 m分 s秒 S毫秒
public class Date_02 {
	public static void main(String[] args) throws Exception {
		// 将Date对象格式化为字符串
		// 创建一个Date类时间对象
		Date dateTime = new Date();
		// 创建一个SimpleDateFormat对象，指定日期时间的格式
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS");
		// format方法：把时间对象按照对应的格式 进行转换，返回转换后的字符串
		String strTime = sdf.format(dateTime);
		System.out.println(strTime);	
		
		// 将字符串解析为Date对象
		// 注：时间格式的字符串必须和SimpleDateFormat指定的格式一致.
		strTime = "2024-01-16 11:48:24:316";
		// parse方法:把时间格式的字符串转换为Date对象
		Date newDate = sdf.parse(strTime);
		System.out.println(newDate);
		
		
		// 将LocalDateTime对象格式化为字符串
		// 创建一个LocalDateTime类的时间对象
		LocalDateTime now = LocalDateTime.now();
		// 创建一个DateTimeFormatter对象，表示要使用的格式
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss:SS");
		// 调用format()方法，将LocalDateTime对象格式化为字符串
		String str = now.format(formatter);
		System.out.println(str);
		
		
		// 将字符串解析为LocalDateTime对象
		// 创建一个字符串，表示日期和时间
		strTime = "2024-01-16 19:52:38:92";
		// 调用parse()方法，将字符串解析为LocalDateTime对象
		LocalDateTime localTime = LocalDateTime.parse(strTime,formatter);
		System.out.println(localTime);
		
		
	}
}

5.3 Calendar（获取当前系统日历）


import java.util.Calendar;
 
public class Calenar_01 {
	public static void main(String[] args) {
		// 获取当前系统日历
		Calendar c = Calendar.getInstance();
		// 获取当天是本周的第几天，周日为第一天
		int i = c.get(Calendar.DAY_OF_WEEK);
		// 获取年
		System.out.print(c.get(Calendar.YEAR) + "年");
		// 获取月，从0开始，0是一月
		System.out.print(c.get(Calendar.MONTH)+ 1 + "月");
		// 获取日
		System.out.print(c.get(Calendar.DAY_OF_MONTH) + "日" + " ");
		// 获取时
		System.out.print(c.get(Calendar.HOUR_OF_DAY) + "时");
		// 获取分
		System.out.print(c.get(Calendar.MINUTE)+ "分");
		// 获取秒
		System.out.print(c.get(Calendar.SECOND)+ "秒");
	}
 
	
}

6. Random

6.1 概述

random: 从0开始生成随机数

6.2 使用


public class Random_01 {
	public static void main(String[] args) {
		// 创建生成器对象
		Random random = new Random();
		// 在int范围内随机生成一个数
		int i = random.nextInt();
		System.out.println(i);
		// 在10个数内随机生成一个，0~9，不包含10
		int result = random.nextInt(10);
		System.out.println(result);
		// 在10~20间随机生成一个数，包含10和20
		result = random.nextInt((20 - 10 + 1)) + 10;
		System.out.println(result);
		// 在100~150之间随机生成一个数，包含100和150
		result = random.nextInt((150 - 100 + 1)) + 100;
		System.out.println(result);
		// 生成a~z之间的字母
		char c = (char)((random.nextInt('z' - 'a' + 1)) + 'a');
		System.out.println(c);
	}
 
}

7. BigInteger

7.1 概述

1. Integer作为Java的包装类，能存储的最大整型值为2^31-1,Long类也是有限的，最大为2^61-1，如果要表示再大的整数，不管基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。

2. java.math包的BigInteger可以表示不可变的任意精度整数。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。

7.2 常用方法

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) ：返回其值为 (thisexponent) 的 BigInteger。

7.3 使用


public class BigInteger_00 {
	public static void main(String[] args) {
		// 两种对象的创建
		BigInteger big = new BigInteger("12");	
		BigDecimal bigNum = new BigDecimal(15);
		// 运算操作
		BigDecimal b1 = new BigDecimal(12);
		BigDecimal b2 = new BigDecimal(36);
		// 结果
		BigDecimal b3 = null;
		// 加
		b3 = b1.add(b2);
		System.out.println(b3);
		// 减
		b3 = b1.subtract(b2);
		System.out.println(b3);
		// 乘
		b3 = b1.multiply(b2);
		System.out.println(b3);
		// 除(BigDecimal要求除法运算结果必须是一个精确的十进制数，如果结果出现循环小数需要做精度处理)
		b3 = b1.divide(b2,2, RoundingMode.HALF_UP);
		System.out.println(b3);
		// 取余
		b3 = b1.remainder(b2);
		System.out.println(b3);
		
	}
}

7.4 阶乘（例子）


import java.math.BigDecimal;
 
public class Number_00 {
	public static void main(String[] args) {
		System.out.println(test(100));
	}
	// 100的阶乘
	public static BigDecimal test(int n) {
		BigDecimal result = new BigDecimal(1);
		for (int i = 1; i <= n; i++) {
			result = result.multiply(new BigDecimal(i));
		}
		return result;
	}
}

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/运维做开发/article/detail/802710