Java常用类

关注

原创最新推荐文章于 2026-09-10 16:00:00 发布 774 阅读 AI 写同款· GEO 优化 ›

Java常用类和基础API 获取"ab"在"abkkcadkabkebfkabkskab"中出现的次数。(1)定义用户类，属性为用户名和密码，提供相关的getter和setter方法，构造器，tostring()使用LocalDateTime获取当前时间，把这个时间设置为你的生日，再获取你的百天(出生后100天)日期。使用Calendar获取当前时间，把这个时间设置为你的生日，再获取你的百天(出生后100天)日期。//存储字符串数据的容器。字符串常量池，在不同的jdk版本中，存放位置不同。字符串常量池不允许存放两个相同的字符串常量。阅读详情

Java常用类

Integer

Java为每种基本数据类型，提供对应的类，来描述对应基本数据类型的这一类事物 int Integer 其实都表示一个整数，并且范围是一样的基本数据类型其对应的包装类(可以在API文档中查询到) byte Byte short Short int Integer long Long float Float double Double char Character boolean Boolean 创建对象，使用包装类的构造方法 Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。 Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。自动编译，完成了ctrl+s，完成了编译，检查语法，检查是否符合规定

	Integer integer = new Integer(0);
	int maxValue = Integer.MAX_VALUE;
	int minValue = Integer.MIN_VALUE;
	System.out.println(maxValue);
	System.out.println(minValue);
	String string = integer.toString();
	System.out.println(string);
	int i = 12;
	byte byteValue = integer.byteValue();
	System.out.println(byteValue);

享元模式

享元模式：有些常用的，缓存好了，直接引用

Integer 类型：-128~127 这些值，非常常用的

这些值：对象

需要使用的时候每次都去new对象，new等于新的一个对象消耗内存，增加CPU的计算负担

Integer i1 = new Integer(1);
Integer i2 = new Integer(1);

	System.out.println(i1==i2);//比较地址值false
	
	//比较对象应该用equals
	System.out.println(i1.equals(i2));//true
	//自动装箱
	Integer i3 = 10;
	Integer i4 = 10;
	System.out.println(i3==i4);//true，说明两个对象的地址值一样的
	System.out.println(i3.equals(i4));//true，说明两个对象的地址值一样的
	
	Integer i5 = 128;
	Integer i6 = 128;
	System.out.println(i5==i6);//false,超过了范围-128--127
	System.out.println("i5.equals(i6):"+i5.equals(i6));//true，说明两个对象的地址值一样的

System

System 类包含一些有用的类字段和方法。它不能被实例化。

/*static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。 */
int[] src={1,2,3,4,5,6};
int[] dest=new int[10];
//System静态方法arraycopy拷贝数组,src拷贝到dest
System.arraycopy(src, 2, dest, 6, 1);
String string = Arrays.toString(dest);
System.out.println(string);
/*static long currentTimeMillis()
返回以[毫秒为单位的当前时间]。方法名字 */

	long currentTimeMillis = System.currentTimeMillis();
	System.out.println(currentTimeMillis);
	
	/*static void exit(int status) 
    终止当前正在运行的 Java 虚拟机。JVM */
	System.exit(0);
	
	/*static void gc() 
    运行垃圾回收器。 */
	System.gc();//执行了垃圾回收机制...只是做出了一些努力而已【自动垃圾回收...】
	
	/*static Map getenv() 
    返回一个不能修改的当前系统环境的字符串映射视图。 */
	Map getenv = System.getenv();
	System.out.println(getenv);

Runtime

每个 Java 应用程序都有一个 Runtime 类实例，【巩固面向对象…学了会操作…JavaSE】 Runtime描述了应用程序这一类事物，具体的一个Runtime对象，就是一个具体的应用程序 Student类，描述了学生这一类的事物，具体的一个Student对象，就是一个具体的学生使应用程序能够与其运行的环境相连接。获得系统环境信息，JVM环境信息【Java代码都在JVM中】可以通过 getRuntime 方法获取当前运行时。获得对象,Runtime对象

/*static Runtime getRuntime()
返回与当前 Java 应用程序相关的运行时对象。 */
Runtime runtime = Runtime.getRuntime();
/*int availableProcessors()
向 Java 虚拟机返回可用处理器的数目。 */
int i = runtime.availableProcessors();
System.out.println(i);
/*Process exec(String command)
在单独的进程中执行指定的字符串命令。异常，抛出,鼠标放在上面选择 */
/runtime.exec(“mspaint”);
runtime.exec(“calc”);/

	/*void exit(int status) 
    	通过启动虚拟机的关闭序列，终止当前正在运行的 Java 虚拟机。 */
	//runtime.exit(0);
	
	/*long freeMemory() 
    	返回 Java 虚拟机JVM中的空闲内存量。 byte 0000 1111*/
	long freeMemory = runtime.freeMemory();
	System.out.println(freeMemory);
	
	/*void gc() 
    	运行垃圾回收器。 */
	runtime.gc();

垃圾回收机制

public class Junk {
String name;
@Override
protected void finalize() {
System.out.println(name+" 这个垃圾被回收了…");
}
Junk(String name){
this.name = name;
}
/*垃圾回收机制的演示
* 对象被回收，有时候5个，有时候1个
* 代码的时间很短暂自动回收
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Junk i1 = new Junk(“小弟弟”);
Junk i2 = new Junk(“小姐姐”);
Junk i3 = new Junk(“小哥哥”);
Junk i4 = new Junk(“小舔狗”);
Junk i5 = new Junk(“小奶狗”);
i1 = null;
i2 = null;
i3 = null;
i4 = null;
i5 = null;
System.gc();
}

}
字符串相关类

String

字符串类String "ABC"一个字符串 String非常重要的类 *1.String 类代表字符串。 * String 类描述了字符串的这一类事物 *2.Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。 * “ABC” String类型的对象 *3. 字符串是常量；它们的值在创建之后不能更改。 * “ABC” 不能改变…[堆中] public final char value[]//堆中，不能改变值 *4.字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享 * 栈就是缓冲区… * String str = “abc”;//持有地址值 * str = “cccccc”;//str缓冲区已经变了

/构造方法
* String() 初始化一个新创建的 String 对象，使其表示一个空字符序列。
* String(String original) //传入要初始化一个String类型的对象
* /
/
* “” 一个字符串，没有字符也是字符串…
* class String{
* private final char value[];//内部设置一个char数组来存所有的字符…
* public String() {
this.value = “”.value;//空字符串，解析到了char数组
}
* }/
String string = new String();//""
System.out.println(string);

	String string2 = new String("ABC");//new的一份...
	System.out.println(string2);
	
	/*关于字符串，空字符串的概念认识
	 * 一个字符串没有字符就叫做空
	 * */
	String str = "";//空
	String str1 = new String();//与第一种很类似""
	String str2 = null;//判断为空..str2没有持有对象的地址值
	System.out.println(str1);
	System.err.println(str2);
	
	/*空指针,引用类型的，对象，数组，指向的对象根本不存在，null*/
	char[] charArray = str.toCharArray();
	System.out.println(charArray);
	//charArray = str2.toCharArray();//java.lang.NullPointerException
	int[] arr = {1,2,3};
	System.out.println(arr.length);
	arr = null;
	//System.out.println(arr.length);

StringBuffer/StringBuilder

String/StringBuffer/StringBuiler : 字符序列 * * 接口CharSequence char 值的一个可读序列 ‘A’ “ABCDEF”—字符序列 * |----String ：字符串，字符序列 * |----StringBuffer : 处理字符序列 * |----StringBuilder * 1.对于字符序列的处理，增删改查 * 2.String效率不是很好—面试题String StringBuffer StringBuilder有什么区别联系 * StringBuffer效率更高【提供的操作的方法，基本一样】线程安全的 * StringBuilder效率更高线程不安全的

public class Stringbuilder2 {

public static void main(String[] args) {
	String str = "ABCDE";
	char charAt = str.charAt(2);
	System.out.println(charAt);
	
	/*String concat(String str) 
      将指定字符串连接到此字符串的结尾。 */
	String c = str.concat("so");
	System.out.println(c);
	/* boolean endsWith(String suffix) 
      测试此字符串是否以指定的后缀结束。 */
	boolean endsWith = str.endsWith("D");
	System.out.println(endsWith);
	
	/*boolean isEmpty() 
      当且仅当 length() 为 0 时返回 true。 */
	
	/*int length() 
      返回此字符串的长度。 */
	str = "ABCRF";
	int length = str.length();
	System.out.println(length);
	
	/*boolean startsWith(String prefix) 
      测试此字符串是否以指定的前缀开始。 */
	
	/*String substring(int beginIndex) 
      返回一个新的字符串，它是此字符串的一个子字符串。
	 * */
	String substring = str.substring(0, 3);
	System.out.println(substring);
	/*char[] toCharArray() 
      将此字符串转换为一个新的字符数组。 */
	char[] charArray = str.toCharArray();
	System.out.println(charArray);
	/*String trim() 
      返回字符串的副本，忽略前导空白和尾部空白。 */
	
	str = " ABC DEF ";
	//字符串对象str
	String trim = str.trim();
	System.out.println(trim);
	
	String trim2 = " ABC DEF ".trim();
	System.out.println(trim2);
	
	StringBuilder sb = new StringBuilder();
	//链式写法....
	//sb.append(true).append("小姐姐").append("小舔狗");
	//下面用的一个sb对象...
	sb.append(true);
	sb.append("小哥哥");
	sb.append("小弟弟---------");
	System.out.println(sb);
	
	Student stu = new Student();
	//this所在的函数正在被谁调用，this，就指代谁
	//stu.add(10).add(15).add(15);
	for(int i=1;i<=100;i++){
		stu=stu.add(i);
	}
	System.out.println(stu);
	
	/*int capacity() 返回当前容量。 内部装字符，都是数组.... */
	int capacity = sb.capacity();
	System.out.println(capacity);
	
	/*StringBuilder delete(int start, int end) 
      移除此序列的子字符串中的字符。 */
	System.out.println(sb);
	StringBuilder delete = sb.delete(2, 4);//左闭右开..原则
	System.out.println(delete);
	
	/*StringBuilder insert(int offset, String str) 
      将字符串插入此字符序列中。 */
	StringBuilder insert = delete.insert(8, "小姐姐");
	System.out.println(insert);
	
	

}

}
class Student{
	Student add(int a){
		System.out.println(a);
		return this;
	}
}

随机数

1.Math类中有一个方法 random double [0.0,1.0)

2.Random类（有很多方法） boolean double int … [0,n)

3.从1.7开始Random的子类 [n,m) ThreadLocalRandom

4.UUID 经常用来做唯一标识ID

/*Math类的,static double random() 
    返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。 */
	double random = Math.random();//random()为Math类下的方法
	System.out.println(random);
	
	
	/*int nextInt() 
    返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。  整个int范围随机取值 */
	Random r = new Random();
	int i = r.nextInt();//整个int范围随机取值
	System.out.println(i);
	
	/*void setSeed(long seed) 
    使用单个 long 种子设置此随机数生成器的种子。 */
	r.setSeed(2L);
	int j = r.nextInt();
	System.out.println(j);
	System.out.println(j);
	
	/*int nextInt(int origin, int bound) 
	返回一个指定的起点之间的伪随机 int值（含）与指定的绑定（独家）。[origin,bound)  */
	r = new Random();
	int k = r.nextInt(9);//返回[0,9)之间的随机数
	System.out.println(k);
	ThreadLocalRandom current = ThreadLocalRandom.current();//ThreadLocalRandom类,jdk1.7以后有的
	int nextInt = current.nextInt(5, 10);//nextInt(int origin, int bound)方法是ThreadLocalRandom类下的
	System.out.println(nextInt);

	/*类 UUID
	 *表示通用唯一标识符 (UUID) 的类。 UUID 表示一个 128 位的值
	 *
	 *UUID描述了，唯一标识 的这一类事物
	 *具体的一个UUID对象，就是一个具体的唯一标识
	 *static UUID randomUUID() 
	 * */
	UUID randomUUID = UUID.randomUUID();
	System.out.println(randomUUID);

随机验证码 * 从一个字符串或者数组中随机选择元素 * String[] arr={“j”,“1”,“2”,“3”,“4”,“5”,“m”,"!","$","#"} * String charAt(int index)//通过索引找到对应的值,那么索引随机,就可以使值随机,生成随机验证码

String[] arr={“j”,“1”,“2”,“3”,“4”,“5”,“m”,"!","$","#"};
Random random = new Random();
int length=arr.length;
String dom="";//接收随机元素
for (int i = 0; i < 6; i++) {
int nextInt = random.nextInt(length);//[0,length)就是索引之间的随机值
String str=arr[nextInt];//arr[索引]就是数组元素
dom+=str;//拼接随机值
}
System.out.println(dom);
Date

Date描述时间日期这一类事物，具体的一个对象，具体的一个时间日期【根据当前系统，获取时间】
Date()
分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
Date(long date)
分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，
即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
Date date = new Date(10000000000000L);
System.out.println(date);
long timeMillis = System.currentTimeMillis();
System.out.println(timeMillis);
SimpleDateFormat() 对象格式器对象

用【默认的模式】和【默认语言】环境的日期格式符号构造 SimpleDateFormat

	Date date = new Date();
	SimpleDateFormat dateFormat = new SimpleDateFormat();
	System.out.println(dateFormat.format(date));
	//SimpleDateFormat("y-M-d H:m:s E")自定义输出格式
	dateFormat=new SimpleDateFormat("y-M-d H:m:s E");
	dateFormat=new SimpleDateFormat("y年M月d日 H:m:s E");
	System.out.println(dateFormat.format(date));

注意：文本到日期，格式匹配.比如不要多空格

格式长度，大于字符串长度，没法解析的

格式长度，小于字符串长度，可以解析的

	dateFormat=new SimpleDateFormat("y年M月d日");
	System.out.println(dateFormat.format(date));
	String st="2019年4月20日 13时12:30 星期六";
	Date parse = dateFormat.parse(st);
	System.out.println(parse);

Calendar

Calendar 日历类：

1.提供这个类的目的：对时间日期，字段值设置，修改操作…

2.Date SimpleDateFormat都不要去修改时间，单独的年月日,都不好修改

/*static Calendar getInstance()
使用默认时区和语言环境获得一个日历。
* */
Calendar instance = Calendar.getInstance();
/*操作字段：一般字段，提供getset方法
*提供了一个方法，get(int filed)//根据传入的值，决定拿年份的，还是月份…值…
*int get(int field)
返回给定日历字段的值。

     	参数：       field - 给定的日历！【字段}。 在自己的这个类中搞一些字段，取那些字段的值，代表年月日了...
     	static int YEAR
     	class  Calendar{
     		public static final int MOUTH = 2;//只写在类的结构体的一个   数据类型   变量名 = 值；
     	}*/
	int i = instance.get(Calendar.YEAR);
	int j = instance.get(Calendar.MONTH);//美国0-11月;
	System.out.println(j+1);
	System.out.println(i);
	
	//调用方法set(field, value)，对日期，字段修改
	instance.set(Calendar.YEAR, 2020);
	int k = instance.get(Calendar.YEAR);
	System.out.println(k);
	//add(field, amount)修改年份或者月份
	//getTime()通过日历对象，修改了日期，字段，获得日期对象
	instance.add(Calendar.YEAR, -2);
	Date time = instance.getTime();
	System.out.println(time);