脚本宝典收集整理的这篇文章主要介绍了Java常用类,脚本宝典觉得挺不错的,现在分享给大家,也给大家做个参考。
Object类
File类
超类、基类,所有类的直接或间接父类,位于继承树的最顶层
任何类,如没有书写extends显示继承某个类,都默认直接继承Object类,否则为间接继承
Object类中所定义的方法,是所有对象都具备的方法
Object类型可以存储任何对象
作为参数,可接受任何对象
作为返回值,可返回任何对象
public final Class<?> getClass(){}
返回引用中存储的实际对象类型
应用:通常用于判断两个引用中实际存储对象类型是否一致
package com.tang.object;
public class testStudent {
public static void main(String[] args) {
Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb", 20);
//1.getClass方法
System.out.PRintln("--------------getClass方法--------------");
//判断s1和s2是不是同一个类型
Class c1 = s1.getClass();
Class c2 = s2.getClass();
if (c1.equals(c2)){
System.out.println("s1和s2是同一个类型");
}else {
System.out.println("s1和s2不是同一个类型");
}
}
}
public int hashCode(){}
返回该对象的哈希码值
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
一般情况下相同对象返回相同哈希码
package com.tang.object;
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb", 20);
//2.hashCode方法
System.out.println("--------------hashCode方法--------------");
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
}
}
public String toString(){}
返回该对象的字符串表示(表现形式)
可以根据程序需求覆盖该方法,如:展示对象各个属性值
@override
public String toString() {
return "Student{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
---------------------------------------
package com.tang.object;
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb", 20);
//3.toString方法
System.out.println("--------------toString方法--------------");
System.out.println(s1.toString());
System.out.println(s2);
}
}
public boolean equals(Object obj){}
默认实现为(this == obj),比较两个对象地址是否相等
可进行覆盖,比较两个对象的内容是否相同
package com.tang.object;
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb", 20);
//4.equals方法,判断两个对象是否相等
System.out.println("--------------equals方法--------------");
System.out.println(s1.equals(s2));
Student s3 = new Student("hhh", 19);
Student s4 = new Student("hhh", 19);
System.out.println(s3.equals(s4));
}
}
比较两个引用是否指向同一个对象
判断obj是否为null
判断两个引用指向的实际对象类型是否一致
强制类型转换
依次比较各个属性值是否相同
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列
垃圾对象:没有有效引用指向此对象时,为垃圾对象
垃圾回收:由GC销毁垃圾对象,释放数据存储空间
自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象
手动回收机制:使用System.gc();通知JVM执行垃圾回收
package com.tang.object;
import java.util.Objects;
/**
* 学生类
*/
public class Student {
private String name;
private int age;
public Student() {}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public int getAge() {return age;}
public void setAge(int age) {this.age = age;}
@Override
public String toString() {
return "Student{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
protected void finalize() throws Throwable {
System.out.println(this.name+"对象被回收了");
}
}
--------------------------------------
package com.tang.object;
public class TestStudent {
//5.finalize方法
new Student("hc", 18);
new Student("ic", 18);
new Student("gc", 18);
//回收垃圾
System.gc();
System.out.println("回收垃圾");
}
}
java.lang
random():生成[0,1)之间的随机数
max(a,b)/min(a,b):比较两个数的大小
pow(a,b):获取a的b次方
sqrt(a):求a的平方根
round(a):四舍五入取整
abs(a):获取绝对值(int、long、float、double)
package com.tang.math;
public class MathTest {
public static void main(String[] args) {
//ceil 天花板,向上取整
System.out.println(Math.ceil(3.57));//4
System.out.println(Math.ceil(-3.57));//-3
//floor 地板,向下取整
System.out.println(Math.floor(3.57));//3
System.out.println(Math.floor(-3.57));//-4
//round 四舍五入 取整返回一个long
System.out.println(Math.round(4.49));//4
System.out.println(Math.round(-4.49));//-4
System.out.println(Math.round(4.51));//5
//abs 绝对值
System.out.println(Math.abs(-3.45));
//求 x 的 y 次幂,返回一个double
System.out.println(Math.pow(3, 5));
//求 x 的 平方根
System.out.println(Math.pow(10, 0.5));
System.out.println(Math.sqrt(10));
//随机数 生成[0,1)之间的随机数
System.out.println(Math.random());
//生成指定区间的随机整数
// Math.random() * (max - main) + min
double rd = (Math.random() * 15 + 5);
long r = (long) rd;
System.out.println(rd);
System.out.println(r);
//sin30° 代表不是度数,参数代表的是弧度
//弧度 = PI / 180 * 度数
System.out.println(Math.sin(Math.PI / 180 * 30));
}
}
nextInt():随机产生一个整数
nextInt(n):随机产生一个[0,n)之间的浮点数
nextFloat/nextDouble():随机生成[0,1)的浮点数
nextBytes(byte[] b):生成随机数组,元素范围: byte范围
package com.tang.random;
import java.util.Arrays;
import java.util.Random;
/**
* 伪随机数
*/
public class RandomTest {
public static void main(String[] args) {
//所有的int整数
int r1 = new Random().nextInt();
//[0,10)的整数
int r2 = new Random().nextInt(10);
//[0,1)的浮点数
double r3 = new Random().nextDouble();
//[0,5)的浮点数
double r4 = new Random().nextDouble(5);
//生成随机数组,元素范围: byte范围
byte[] b = new byte[5];
new Random().nextBytes(b);
System.out.println(Arrays.toString(b));
System.out.println(r2);
}
}
SecureRandom安全随机数,密码学中安全的随机数非常重要
getInstancestrong()创建高强度安全随机数
new SecureRandom()创建普通安全随机数
package com.tang.random;
import java.securITy.NoSuchAlgorithmException;
import java.security.SecureRandom;
public class SecureRandomTest {
public static void main(String[] args) throws NoSuchAlgorithmException {
//普通的安全随机数
SecureRandom random = new SecureRandom();
SecureRandom rad = SecureRandom.getInstanceStrong();
System.out.println(random.nextInt(10));
}
}
基本数据类型所对应的引用数据类型
Object可统一所有数据,包装类的默认值是null
基本类型与包装类对应关系
@H_360_311@
package com.tang.wrap;
public class WrapTest {
public static void main(String[] args) {
Integer a = new Integer(333);
System.out.println(Integer.MAX_VALUE);//int类型的最大值
System.out.println(Integer.MIN_VALUE);//int类型的最小值
Integer b = new Integer(333);
//比较引用数据类型,代表比较地址是否相等
System.out.println(a == b);
// a 和 b 内容是否相等
System.out.println(a.equals(b));
//int比较
System.out.println(Integer.COMpare(a, b));
//比较Integer对象的值
System.out.println(a.compareTo(b));
//两个数的最大值
System.out.println(Integer.max(a, b));
//两个数的和
System.out.println(Integer.sum(a, b));
//基本类型-转-包装类型
System.out.println(Integer.valueOf("333"));
//包装类型-转-基本类型
System.out.println(a.floatValue());
//将数字以不同的进制形式 转成 字符串
//转-二进制
System.out.println(Integer.toBinaryString(a));
//转-八进制
System.out.println(Integer.toOctalString(a));
//转-十六进制
System.out.println(Integer.toHexString(a));
//将数字(其他进制)格式的字符串 转成对应的 十进制数字
System.out.println(Integer.valueOf("100", 8));
System.out.println(Integer.valueOf("100", 5));
//各个进制书写方式
System.out.println(0b1111);//二进制
System.out.println(017);//八进制
System.out.println(15);//十进制
System.out.println(0xf);//十六进制
}
}
8种包装类提供不同类型间的转换方式:
Number父类(整数与浮点数的包装类的父类)中提供的6个共性方法
装箱:Integer.valueOf(num);
拆箱:integer.intValue();
拆箱,会产生NullPointerException错误
int n = 0; //0可以装箱
Integer i = null; //null无法拆箱
int sum = i + 4; //产生NullPointerException错误
System.out.println(sum);
package com.tang.wrap;
/**
* JDK1.5之后,提供自动装箱和拆箱
*/
public class WrapDemo1 {
public static void main(String[] args) {
//1.类型转换:装箱,基本类型转换成引用类型的过程:Integer.valueOf(num);
int num1 = 18;
Integer integer1 = new Integer(num1);//过时
Integer integer2 = Integer.valueOf(num1);
//自动装箱
Integer integer3 = num1;
//2.类型转换:拆箱,引用类型转换成基本类型的过程:integer.intValue();
Integer integer4 = Integer.valueOf(18);
int num2 = integer4.intValue();
//自动拆箱
int num3 = integer4;
}
}
parseXXX()静态方法
valueOf()静态方法
注意:需要保证类型兼容,否则抛出NumberForMATException异常
package com.tang.wrap;
/**
* JDK1.5之后,提供自动装箱和拆箱
*/
public class WrapDemo1 {
public static void main(String[] args) {
//基本类型与字符串之间相互转换
//1 基本类型-->字符串
int n1 = 255;
//1.1使用+号
String s1 = n1+"";
//1.2使用Integer中的toString()方法
String s2 = Integer.toString(n1,16);//ff
String s3 = String.valueOf(n1);
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
//2 字符串-->基本类型
String str="150";
//使用Integer.parseXXX();
int n2 = Integer.parseInt(str);
System.out.println(n2);
//字符串转成boolean基本类型
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);//true
}
}
Java预先创建了256个常用的整数包装类型对象
在实际应用当中,对已创建的对象进行复用
package com.tang.wrap;
public class WrapDemo2 {
public static void main(String[] args) {
//面试题
Integer integer1 = new Integer(100);//过时
Integer integer2 = new Integer(100);
System.out.println(integer1 == integer2);//false
Integer integer3 = 127;//自动装箱
Integer integer4 = Integer.valueOf(127);
System.out.println(integer3 == integer4);//true
Integer integer5 = 128;//自动装箱
Integer integer6 = 128;//自动装箱
System.out.println(integer5 == integer6);//false
}
}
java.math
继承java.lang.Number
package com.tang.wrap;
import java.math.Biginteger;
public class TestBigInteger {
public static void main(String[] args) {
//构建一个BigInteger对象
BigInteger bd = new BigInteger("5");
//加法
BigInteger r1 = bd.add(new BigInteger("3"));
System.out.println(r1);
//减法
BigInteger r2 = bd.suBTract(new BigInteger("4"));
System.out.println(r2);
//乘法
BigInteger r3 = bd.multiply(new BigInteger("6"));
System.out.println(r3);
//除法
BigInteger r4 = bd.divide(new BigInteger("3"));
System.out.println(r4);
//求余
BigInteger r5 = bd.mod(new BigInteger("3"));
System.out.println(r5);
//将 基本数据类型 转换成 BigInteger
BigInteger bi = BigInteger.valueOf(3);
//将 BigInteger 转换成 基本数据类型
int i = bi.intValue();
System.out.println(i);
}
}
java.math
继承java.lang.Number
思考:以下程序输出结果是多少
public class TestBigDecimal {
public static void main(String[] args) {
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1-d2);
//0.09999999999999998
}
}
很多实际应用中需要精确运算,而double是近似值存储,不符合要求,需要借助BigDecimal。
位置:java.math包中
作用:精确计算浮点数
创建方式:BigDecimal bd = new BigDecimal("1.0");
方法:
public BigDecimal add(BigDecimal bd) 加
public BigDecimal subtract(BigDecimal bd) 减
public BigDecimal multiply(BigDecimal bd) 乘
public BigDecimal divide(BigDecimal bd, int scal, RoundingMode mode) 除
scale():获取小数个数
precision():获取有效数字个数
setScale(n, RoundingMode):保留小数个数,进制规则
第二个参数不设置,默认是ROUND_UNNECESSARY,保留n位小数,n位之后必须都为0,否则报错
RoundingMode.UP:绝对值向上取整
RoundingMode.DOWN(常用):直接截断
RoundingMode.HALF_UP(常用):四舍五入,相当于Math.round的用法
RoundingMode.CEILING:向上取整,相当于Math.ceil的用法
RoundingMode.FLOOR:向下取整,相当于Math.floor的用法
RoundingMode.HALF_DOWN:如果大于0.5,则舍入,否则舍弃
stripTrailingZeros():截取小数点尾部的0
package com.tang.wrap;
import java.math.BigDecimal;
import java.math.RoundingMode;
public class TestBigDecimal {
public static void main(String[] args) {
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1-d2);
//面试题
double result = (1.4-0.5)/0.9;
System.out.println(result);
//BigDecimal,大的浮点数精确计算
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//减法
BigDecimal r1 = bd1.subtract(bd2);
System.out.println(r1);
//加法
BigDecimal r2 = bd1.add(bd2);
System.out.println(r2);
//乘法
BigDecimal r3 = bd1.multiply(bd2);
System.out.println(r3);
//除法
BigDecimal r4 = bd1.divide(bd2,3, RoundingMode.HALF_UP);
System.out.println(r4);
//-------------------------------------
BigDecimal decimal = new BigDecimal("1.122133313213244434232");
decimal = decimal.multiply(new BigDecimal("1.234324545445653532"));
System.out.println(decimal);
//获取小数位数
System.out.println(decimal.scale());
//获取有效数字个数
System.out.println(decimal.precision());
//获取转换为字符串后的长度
System.out.println(decimal.toString().length());
System.out.println("-----------------------保留小数设置------------------------");
//保留小数个数
System.out.println(new BigDecimal("20.38000").setScale(2));
//RoundingMode.UP:绝对值向上取整
System.out.println(new BigDecimal("12.32243").setScale(2, RoundingMode.UP));
System.out.println(new BigDecimal("-12.32243").setScale(2, RoundingMode.UP));
//RoundingMode.DOWN(常用):直接截断
System.out.println(new BigDecimal("12.32243").setScale(2, RoundingMode.DOWN));
System.out.println(new BigDecimal("-12.32243").setScale(2, RoundingMode.DOWN));
//RoundingMode.HALF_UP(常用):四舍五入
System.out.println(new BigDecimal("12.35243").setScale(2, RoundingMode.HALF_UP));
System.out.println(new BigDecimal("-12.34243").setScale(2, RoundingMode.HALF_UP));
//RoundingMode.CEILING:向上取整
System.out.println(new BigDecimal("12.31").setScale(1, RoundingMode.CEILING));
System.out.println(new BigDecimal("-12.31").setScale(1, RoundingMode.CEILING));
//RoundingMode.FLOOR:向下取整
System.out.println(new BigDecimal("12.31").setScale(1, RoundingMode.FLOOR));
System.out.println(new BigDecimal("-12.31").setScale(1, RoundingMode.FLOOR));
//RoundingMode.HALF_DOWN:如果大于0.5,则舍入,否则舍弃
System.out.println(new BigDecimal("12.3500").setScale(1, RoundingMode.HALF_DOWN));
System.out.println(new BigDecimal("-12.3501").setScale(1, RoundingMode.HALF_DOWN));
//stripTrailingZeros:截取小数点尾部的0
BigDecimal i = new BigDecimal("3000000000000000000000.00000").stripTrailingZeros();
BigInteger j = new BigDecimal("3000000000000000000000.00000").stripTrailingZeros().toBigInteger();
BigDecimal k = new BigDecimal("3000000100000000000000.13000").stripTrailingZeros();
System.out.println(i);
System.out.println(j);
System.out.println(k);
}
}
除法:divide(BigDecimal bd, int scal, RoundingMode mode)
参数scal:指定精确到小数点后几位
参数mode:
指定小数部分的取舍模式,通常采用四舍五入的模式
取值为RoundingMode.HALF_UP
* 实现了 Comparable 接口,该类就可以比较大小
* 比较规则由 compareTo 方法来制定
* sort 可以直接对 基本数据类型 进行排序
* sort 如果要对 引用数据类型 进行排序,
那么 该引用类型必须要 实现Comparable接口
或者 在调用 sort 的时候,传入 自定义的排序规则
自定义排序规则由 Comparator 接口提供
* sort 默认按照 自然顺序 排列
* 实现了 Iterable 接口,该类就可以进行迭代
定义一个Integer[]数组,存放多个无序的数字
要求使用Array.sort完成升序排列
要求使用Array.sort完成降序排列
要求使用Array.sort完成随机排列
Comparator接口
package com.tang.wrap;
import java.util.Arrays;
import java.util.Comparator;
/**
* 定义一个Integer[]数组,存放多个无序的数字
* 1. 要求使用Array.sort完成升序排列
* 2. 要求使用Array.sort完成降序排列
* 3. 要求使用Array.sort完成随机排列
*/
public class Demo {
public static void main(String[] args) {
Integer[] array = {23,54,65,78,35};
//使用Array.sort完成降序排列
Arrays.sort(array, Comparator.reverseOrder());//降序
System.out.println(Arrays.toString(array));
//下面的Lambda表达式---就是重写了Comparator接口中的compare方法
Arrays.sort(array, (a,b)->{
return b.compareTo(a);
});//降序
System.out.println(Arrays.toString(array));
//使用Array.sort完成随机排列
Arrays.sort(array, (a,b)->{
return Math.random()<0.5 ? -1 : 1;
});
System.out.println(Arrays.toString(array));
}
}
package com.tang.wrap;
/**
* 枚举类
* 枚举类 用关键字 enum 进行定义
* 所有的枚举类都继承 Enum 类
* 枚举类 拥有 name , ordinal 属性
* name 用来获取 枚举值 对应的 字符串表示形式, 例如 M 是SexTyPE的值,他的字符串标识形式为"M"
* ordinal 用来获取 定义枚举值的 索引顺序, 默认从0开始,不推荐使用
*
* 枚举类 中 可以定义属性, 但属性推荐用 final 修饰
*/
public enum EnumGender {
M("男"),
F("女"),
S("保密");
public final String value;
private EnumGender(String value) {
this.value = value;
}
}
class Test{
public static void main(String[] args) {
EnumGender sex = EnumGender.M;
System.out.println(sex.name());
System.out.println(sex.value);
}
}
字符串是常量,创建之后不可改变
字符串字面值存储在字符串(常量)池中,可以共享
package com.tang.String;
public class Demo1 {
public static void main(String[] args) {
String name = "hello";//存储在常量池
name = "zhangsan";//重新开辟空间
String name2 = "zhangsan";
System.out.println(name==name2);//true
System.out.println(name.equals(name2));//true
//字符串的另一种创建方式
String str = new String("aaa");
String str2 = new String("aaa");
System.out.println(str==str2);//false
System.out.println(str.equals(str2));//false
}
}
public int length():返回字符串的长度
public char charAt(int index):根据下标获取字符
public boolean contains(String str):判断当前字符串中是否包含str
public char toCharArray():将字符串转换成数组
public int indexOf(String s):查找s首次出现的下标,存在,则返回该下标;不存在,则返回-1。
public int lastIndexOf(String s):查找字符串s在当前字符串中最后一次出现的索引
public String trim():去掉字符串前后的空格
public String toUpperCase():将小写转成大写
public boolean endWith(String s):判断字符串是否以s结尾
public String replace(char oldChar,char newChar):将旧字符串替换成新字符串
public String[] split(String s):根据s做拆分
String.join()方法:字符串拼接,与String.split()方法刚好相反
System.out.println(String.join(",", "e", "a", "h"));//e,a,h
补充:
equalsIgnoreCase(s):忽略大小写比较
compareTo():比较大小
package com.tang.String;
import java.util.Arrays;
public class Demo2 {
public static void main(String[] args) {
//字符串方法的使用
String str = "TangGuoTang糖果思雨淑敏";
//1.length():返回字符串的长度
System.out.println(str.length());
//2.charAt(int index):根据下标获取字符
System.out.println(str.charAt(8));
//3.contains(String str):判断当前字符串中是否包含str
System.out.println(str.contains("Tang"));
//4.toCharArray():将字符串转换成数组
System.out.println(Arrays.toString(str.toCharArray()));
//5.indexOf(String s):查找s首次出现的下标
System.out.println(str.indexOf("Tang"));
System.out.println(str.indexOf("Tang",2));
//6.lastIndexOf(String s):查找s最后一次出现的下标索引
System.out.println(str.lastIndexOf("Tang"));
//7.trim():去掉字符串前后的空格
String str2 = " Hello World ";
System.out.println(str2.trim());
//8.toUpperCase():将小写转成大写; toLowerCase():大转小
System.out.println(str2.toUpperCase());
System.out.println(str2.toUpperCase().toLowerCase());
//9.endWith(String s):判断字符串是否以s结尾
String str3 = "Hello World";
System.out.println(str3.endsWith("World"));
System.out.println(str3.startsWith("Hello"));
//10.replace(char oldChar,char newChar):将旧字符串替换成新字符串
System.out.println(str3.replace("World", "tangGuo"));
//11.split(String s):根据s做拆分
String s = "糖果 , 思雨, 淑敏 ,甜甜";
String[] as = s.split("[ ,]+");
for (String a : as) {
System.out.println(a);
}
//补充两个方法equals compareTo();比较大小
System.out.println("----------补充----------");
String s1 = "hello";
String s2 = "Hello";
System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写比较
String s3 = "abc";//97
String s4 = "xyz";//120
System.out.println(s3.compareTo(s4));//-23
String s5 = "abc";
String s6 = "abcxyz";
System.out.println(s5.compareTo(s6));//-3
}
}
需求:
已知String str = "this is a text";
将str中的单词单独获取出来
将str中的text替换为practice
在text前面插入easy
将每个单词的首字母改为大写
package com.tang.String;
import java.nio.charset.Charset;
public class Demo {
public static void main(String[] args) {
String str = "this is a text";
// 1.将str中的单词单独获取出来
String[] arr = str.split(" ");
for (String s : arr) {
System.out.println(s);
}
// 2.将str中的text替换为practice
System.out.println(str.replace("text", "practice"));
// 3.在text前面插入easy
System.out.println(str.replace("text", "easy text"));
// 4.将每个单词的首字母改为大写
str = "";
for (String s : arr) {
char First = s.charAt(0);
//把第一个字符转成大写
char upperFirst = Character.toUpperCase(first);
String s1 = upperFirst + s.substring(1);
str = str + " " + s1;
}
System.out.println(str.trim());
}
}
StringBuffer用法与StringBuilder一样
StringBuffer:可变长字符串,JDK1.0提供,运行效率慢、线程安全
StringBuilder:可变长字符串,JDK5.0提供,运行效率快、线程不安全,在多线程环境下,使用的时候,需要注意安全
package com.tang.StringBufferBuilder;
/**
* StringBuffer和StringBuilder的使用
* (1)比String效率高
* (2)比String节省内存
*/
public class Demo1 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
//1.append()追加
sb.append("tangGuo ");
System.out.println(sb);
sb.append("siYu ");
System.out.println(sb);
sb.append("shuMin");
System.out.println(sb);
//2.insert()添加
sb.insert(0,"friend: ");
System.out.println(sb);
//3.replace()
sb.replace(0,sb.length(),"very good");
System.out.println(sb);
//4.delete()删除
sb.delete(0,3);
System.out.println(sb);
//清空
sb.delete(0,sb.length());
System.out.println(sb.length());
}
}
package com.tang.StringBufferBuilder;
/**
* 验证StringBuilder效率高于String
*/
public class Demo2 {
public static void main(String[] args) {
//String用时
long start = System.currentTimeMillis();
String string = "";
for (int i = 0; i < 10000; i++) {
string+=i;
}
System.out.println(string);
long end = System.currentTimeMillis();
System.out.println("String用时"+(end-start));
//StringBuilder用时
start = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
sb.append(i);
}
System.out.println(sb);
end = System.currentTimeMillis();
System.out.println("StringBuilder用时"+(end-start));
}
}
StringBuffer用法与StringBuilder一样
package com.tang.StringBuilder;
/**
* StringBuilder
* 字符串构造器,可以创建长度可变的字符串
*/
public class Demo1 {
public static void main(String[] args) {
//创建对象,共3种方式
StringBuilder sb = new StringBuilder(10);//值为空字符串,不是null
//sb = new StringBuilder("abc");
//StringBuilder sb2 = new StringBuilder(sb);
sb.append("helloWorld");
sb.append("helloWorld");
//删除字符[2,4)
sb.delete(2,4);
//删除一个字符
sb.deleteCharAt(0);
System.out.println(sb);
//查找索引
//查找第一次出现的索引
System.out.println(sb.indexOf("l"));
//查找第二次出现的索引
System.out.println(sb.indexOf("l", sb.indexOf("l") + 1));
//反转字符串
System.out.println(sb.reverse());
System.out.println(sb);
System.out.println(sb.length());
//字符串转StringBuilder
String s = "abc";
StringBuilder sb2 = new StringBuilder(s);
//StringBuilder转字符串
String s1 = sb2.toString();
System.out.println(String.join(",", "e", "a", "gh", "h"));
}
}
按照相同的分隔符,拼接字符。与String.split()方法相反
package com.tang.StringJoiner;
import java.util.StringJoiner;
public class Demo {
public static void main(String[] args) {
//创建StringJoiner对象,?为分隔符
StringJoiner joiner = new StringJoiner("?");
//参数: 分隔符,前缀,后缀
StringJoiner joiner2 = new StringJoiner(",","H--","--W");
//如果字符串为空: 将设置成XXX
System.out.println("默认字符: "+joiner.setEmptyValue("XXX"));
//拼接元素
joiner.add("a");
joiner.add("b");
System.out.println(joiner);//a?b
joiner2.add("c");
joiner2.add("d");
System.out.println(joiner2);//H--c,d--W
//将两个Joiner合并成一个Joiner
joiner.merge(joiner2);
System.out.println(joiner);//a?b?c,d
joiner2.merge(joiner);
System.out.println(joiner2);//H--c,d,a?b?c,d--W
}
}
Date表示特定的瞬间,精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代
时间单位
1秒=1000毫秒
1毫秒=1000微秒
1微秒=1000纳秒
package com.tang.date;
import java.time.Instant;
import java.util.Date;
public class DateDemo1 {
public static void main(String[] args) {
//1.创建一个当前系统时间的日期对象
Date date1 = new Date();
System.out.println(date1);
Date date = new Date(0);
//东八区,和格林尼治时间,相差8个小时
System.out.println(date);
//2.方法after before
System.out.println(date1.after(date));
System.out.println(date.before(date1));
//比较compareTo()
System.out.println(date1.compareTo(date));//结果-1,0,1
//比较是否相等equals()
System.out.println(date1.equals(date));
//3.时间戳
System.out.println(date1.getTime());
//昨天
long ms = date1.getTime() - 1000 * 60 * 60 * 24;
//重置时间
date.setTime(ms);
//新建时间
System.out.println(new Date(ms));
System.out.println(date);
//jdk8新特性
Instant instant = date.toInstant();
System.out.println(instant);//格林尼治时间
Date d = Date.From(instant);
System.out.println(d);
}
}
Calendar提供了获取或设置各种日历字段的方法
月份:0-11代表1-12月
星期:1-7代表周日-周六
构造方法
protected Calendar():由于修饰符protected,所以无法直接创建该对象
其他方法
package com.tang.date;
import java.util.Calendar;
public class CalendarDemo1 {
public static void main(String[] args) {
//1.创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toInstant());
System.out.println(calendar.getTimeInMillis());//获取毫秒值
//2.获取时间信息
//年
int year = calendar.get(Calendar.YEAR);
System.out.println(year);
//月
int month = calendar.get(Calendar.MONTH);
System.out.println(month);
//日
int day = calendar.get(Calendar.DATE);
System.out.println(day);
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
//星期 , 1 代表周日 , 7 代表周六
System.out.println(calendar.get(Calendar.DAY_OF_WEEK));
//小时
int hour = calendar.get(Calendar.HOUR_OF_DAY);
//System.out.println(calendar.get(Calendar.HOUR));//12小时
System.out.println(hour);//24小时
//分钟
int minute = calendar.get(Calendar.MINUTE);
System.out.println(minute);
//秒
int second = calendar.get(Calendar.SECOND);
System.out.println(second);
System.out.println(year+"年"+(month+1)+"月"+day+"日 "+hour+"时"+minute+"分"+second+"秒");
//3.修改时间
Calendar calendar2 = Calendar.getInstance();//新建日期
calendar2.set(2021,3,5);//修改字段
//通过常量 设置 日历
calendar2.set(Calendar.DAY_OF_MONTH,22);//修改日期字段
calendar2.set(Calendar.MONTH,1);//修改日期字段
System.out.println(calendar2.getTime().toInstant());
//4.add方法修改时间
calendar2.add(Calendar.HOUR_OF_DAY,20);
System.out.println(calendar2.getTime().toInstant());
//5.补充方法:获取 月/日等的 最大/小值
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
int max1 = calendar2.getActualMaximum(Calendar.DATE);//同上面结果相同
int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
System.out.println(max);
System.out.println(max1);
System.out.println(min);
}
}
根据月份生成该月日历
package com.tang.date;
import java.util.Calendar;
public class DemoCalendar {
public static void main(String[] args) {
//5 代表5月份
showCalendar(2022,5);
}
public static void showCalendar(int year, int month){
System.out.println(year+"年"+month+"月");
//月份减一
--month;
// 第一行
String[] weeks = {"一","二","三","四","五","六","日"};
for (String week : weeks) {
System.out.print(week + "t");
}
System.out.println();
//构建一个日历对象
Calendar date = Calendar.getInstance();
//调用日历到 当月
date.set(year,month,1);
//获取当前 月最大的天数
int max = date.getActualMaximum(Calendar.DAY_OF_MONTH);
//获取当月的一号是星期几, 1-7 : 对应 : 周日 - 周六
int week = date.get(Calendar.WEEK_OF_MONTH);
//设置 1-7 : 对应 : 周一 - 周日
week = week==1?7:week-1;
/* System.out.println(year+"年"+(month+1)+"月"+"1"+"日, 是周"+week); */
//调用日历到 上月
date.set(Calendar.MONTH,month-1);
//获取上月 最大的天数
int d = date.getActualMaximum(Calendar.DAY_OF_MONTH);
dayOfMonth(max,week);/*显示当月的日历*/
// 第二行
//获取上月显示的日期
for (int i = 1; i < week; i++) {
System.out.print((d-(week-1-i))+"t");
}
int start = 1;//记录日历,从1号开始
//本月 开始行 显示的日期
for (int j = week; j <= 7; j++) {
System.out.print(start+"t");
start = start == max ? 0 : start;
start++;
}
System.out.println();
// 第3-7行 显示的日期
for (int i = 0; i < 5; i++) {
for (int j = 1; j <= 7; j++) {
System.out.print(start+"t");
start = start == max ? 0 : start;
start++;
}
System.out.println();
}
}
/**
* 显示当月的日历,结合上面的方法,可以作为显示日历的方法来用
* @param maxDay 当月最大天数
* @param week 当月1号是星期几
*/
public static void dayOfMonth(int maxDay, int week){
for (int i = 1; i < week; i++) {
System.out.print("t");
}
for (int i = 1; i <= maxDay; i++) {
System.out.print(i+"t");
if (8 - week == i % 7) {
System.out.println();
}
}
System.out.println("n");
}
}
TimeZone.getAvailableIDs():获取系统支持的所有时区
TimeZone.getTimeZone("Asia/Shanghai"):获取中国时区
toZoneId():TimeZone时区转ZoneId时区
package com.tang.date;
import java.time.ZoneId;
import java.util.Arrays;
import java.util.Calendar;
import java.util.TimeZone;
public class TimeZoneDemo {
public static void main(String[] args) {
//获取系统支持的所有时区
String[] availableIDs = TimeZone.getAvailableIDs();
System.out.println(Arrays.toString(availableIDs));
//获取时区
TimeZone timeZone = TimeZone.getTimeZone("Asia/Shanghai");
System.out.println(timeZone);
//日历设置时区
Calendar calendar = Calendar.getInstance();
calendar.setTimeZone(timeZone);
//JDK1.8新特性 转成新的ZoneId时区
ZoneId zoneId = timeZone.toZoneId();
System.out.println(zoneId);
}
}
java.time
ZoneId.systemdefault():获取系统默认时区
ZoneId.of("Asia/Shanghai"):构建时区
ZoneId.getAvailableZoneIds():获取可用的所有时区集合
package com.tang.date;
import java.time.ZoneId;
import java.util.Set;
public class ZoneIdDemo {
public static void main(String[] args) {
//1.ZoneId.systemDefault() 获取系统默认时区
ZoneId zoneId = ZoneId.systemDefault();
System.out.println(zoneId);
//2.ZoneId.of("Asia/Shanghai") 构建时区
ZoneId of = ZoneId.of("Asia/Shanghai");
System.out.println(of);
//3.ZoneId.getAvailableZoneIds() 获取可用的所有时区集合
Set<String> sets = ZoneId.getAvailableZoneIds();
System.out.println(sets.size());
}
}
LocalDateTime/LocalDate/LocalTime:获取本地的日期、时间
静态方法
now():获取当前系统时间
of(year,month,...):设置时间
from(TemporalAccessor):从一个LocalDateTime/LocalDate/LocalTime获取时间
parse(text,DateTimeFormatter):字符串解析成时间
package com.tang.date;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
public class LocalDateTimeDemo1 {
public static void main(String[] args) {
//获取当前系统日期时间
System.out.println(LocalDateTime.now());
System.out.println(LocalDate.now());
System.out.println(LocalTime.now());
//设置时间
System.out.println(LocalDate.of(2010, 6, 28));
System.out.println(LocalTime.ofNanoOfDay(23L*60*60*1000*1000*1000));//纳秒
//从LocalDateTime/LocalDate/LocalTime获取时间
System.out.println(LocalDate.from(LocalDateTime.now()));
System.out.println(LocalTime.from(LocalDateTime.now()));
//设置日期时间格式
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
//格式化时间
System.out.println(dtf.format(LocalDateTime.now()));
//字符串解析成日期, 要求严格按照格式, 不能少一个字符, 0也要写上, 否则编译不通过
LocalDateTime parse = LocalDateTime.parse("1997-03-05 08:44:32.545",dtf);
System.out.println(parse);
//不能用下面方法 将字符串解析成日期
//LocalDateTime parse2 = (LocalDateTime) dtf.parse("1997-03-05 08:44:32.545");
}
}
成员方法
format(DateTimeFormatter)
加法计算时间
plus(duration)
plusYears(years)
plusDays(days)
.....
减法计算时间
minus(duration)
minusMonths(months)
minusHours(hours)
.....
获取对应的日期属性值
getDayOfYear()
getYear()
getHour()
.....
重新设置对应的日期信息
withDayOfYear(day)
withHour(year)
package com.tang.date;
import java.time.Duration;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
public class LocalDateTimeDemo2 {
public static void main(String[] args) {
//获取当前系统时间
LocalDateTime date = LocalDateTime.now();
//格式化时间
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
System.out.println(date.format(dtf));
//加法 计算时间
//日期加3天
System.out.println(date.plusDays(3));
System.out.println(date.plus(3, ChronoUnit.DAYS));
System.out.println(date.plus(Duration.ofDays(3)));
//日期加3毫秒
System.out.println(date.plus(3, ChronoUnit.MILLIS));
//获取对应的日期属性值
System.out.println(date.getDayOfMonth());
//重新设置对应的日期信息
System.out.println(date.withDayOfYear(2));
System.out.println(date.withHour(7));
}
}
DateTimeFormatter.ofPattern(pattern)
format
parse
ZonedDateTime 带时区的日期和时间
package com.tang.date;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoField;
public class ZoneDateTimeDemo {
public static void main(String[] args) {
//创建一个 ZonedDateTime 对象
ZonedDateTime date = ZonedDateTime.now(ZoneId.of("America/Cuiaba"));
System.out.println(date);
//重置时间
date = date.with(ChronoField.YEAR, 2000)
.with(ChronoField.MONTH_OF_YEAR, 12)
.with(ChronoField.DAY_OF_MONTH, 22)
.withHour(11)
.withMinute(35)
.withSecond(55)
.withNano(123456789);
System.out.println(date);
//获取时间 - 年
System.out.println(date.get(ChronoField.YEAR));
// - 月
System.out.println(date.get(ChronoField.MONTH_OF_YEAR));
// - 日
System.out.println(date.getDayOfMonth());
// - 时
System.out.println(date.get(ChronoField.HOUR_OF_DAY));
// - 分
System.out.println(date.get(ChronoField.MINUTE_OF_HOUR));
// - 秒
System.out.println(date.get(ChronoField.SECOND_OF_MINUTE));
// - 毫秒
System.out.println(date.get(ChronoField.MILLI_OF_SECOND));
// - 微秒
System.out.println(date.get(ChronoField.MICRO_OF_SECOND));
// - 纳秒
System.out.println(date.get(ChronoField.NANO_OF_SECOND));
//获取时区
System.out.println(date.getZone());
}
}
Instant高精度时间戳
Instant instant = Instant.now()//创建高精度时间戳对象
instant.getEpochSecond()//获取秒
instant.toEpochMilli()//获取毫秒
package com.tang.date;
import java.time.Instant;
import java.time.temporal.ChronoField;
public class InstantDemo {
public static void main(String[] args) {
//创建 Instant 高精度时间戳对象
Instant instant = Instant.now();
System.out.println(instant);
//获取秒
System.out.println(instant.getEpochSecond());
//获取毫秒
System.out.println(instant.toEpochMilli());
//重置秒(从1970年1月1日算起), 毫秒微秒纳秒不会被重置
instant = instant.with(ChronoField.INSTANT_SECONDS, 1);
System.out.println(instant);
//重置毫秒微秒纳秒,只要重置一个, 另外两个将清零
System.out.println(instant.with(ChronoField.MILLI_OF_SECOND, 1));
System.out.println(instant.with(ChronoField.MICRO_OF_SECOND, 1));
System.out.println(instant.with(ChronoField.NANO_OF_SECOND, 1));
}
}
Duration时间间隔
package com.tang.date;
import java.time.Duration;
import java.time.LocalDateTime;
public class DurationDemo {
public static void main(String[] args) {
/*
* Duration.ofXXX ... 构建一个 间隔对象
* Duration.toXXX ... 获取间隔的 天秒等... 返回一个数字
* */
//创建时间对象
LocalDateTime d1 = LocalDateTime.of(2000,5,12,12,34,3);
LocalDateTime d2 = LocalDateTime.now();
//创建时间间隔对象, 计算间隔, d1 d2 必须有 时分秒
Duration duration = Duration.between(d1, d2);
System.out.println(duration);//输出结果: d2-d1
//获取间隔天数
System.out.println(duration.toDays());
//构建一个 三天的 时间间隔对象
Duration threeDays = Duration.ofDays(3);
//三天前的时间
d2 = d2.minus(threeDays);
System.out.println(d2);
}
}
ISO8601规范
ISO8601规定的日期和时间分隔符是T
日期:yyyy-MM-dd
时间:HH:mm:ss
带毫秒的时间:HH:mm:ss.SSS
日期和时间:yyyy-MM-dd'T'HH:mm:ss
带毫秒的日期和时间:yyyy-MM-dd'T'HH:mm:ss.SSS
SimpleDateFormat是一个(与语言环境有关的方式)格式化和解析日期的具体类
进行格式化(日期 → 文本)、解析(文本 → 日期)
常用的时间模式字母
package com.tang.date;
import java.text.SimpleDateFormat;
import java.util.Date;
public class FormatDemo1 {
public static void main(String[] args) {
//1.创建SimpleDateFormat对象
SimpleDateFormat sDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//2022-05-30 16:28:30
SimpleDateFormat sdF1 = new SimpleDateFormat("y-M-d H:m:s S");//2022-5-30 16:28:30 493
//2.创建Date
Date date = new Date();
//格式化date
String fDate = sdf.format(date);
System.out.println(fDate);
System.out.println(sdf1.format(date));
//字符串解析成日期
Date date2 = sdf.parse("1990-4-3 9:34:52");
System.out.println(sdf.format(date2));
//重新设置日期格式
sdf.applyPattern("yyyy-MM-dd");
date2 = sdf.parse("1990-4-3");
System.out.println(sdf.format(date2));
}
}
System系统类,主要用于获取系统的属性数据和其他操作,构造方法私有的
package com.tang.System;
import java.util.Arrays;
public class Demo1 {
public static void main(String[] args) {
//1.arraycopy数组复制
//原数组,开始索引,目标数组,开始索引,复制长度
int[] arr = {9,3,54,6,7,56,34,8,4};
int[] arrCopy = new int[4];
System.arraycopy(arr,3,arrCopy,0,4);
System.out.println(Arrays.toString(arrCopy));
//2.获取当前系统时间(时间戳)
System.out.println(System.currentTimeMillis());
long start = System.currentTimeMillis();
for (int i = 0; i < 2000000000; i++) {
for (int j = 0; j < 2000000000; j++) {
int result = i+j;
}
}
long end = System.currentTimeMillis();
System.out.println("用时: "+(end-start));
//3.System.gc();告诉垃圾回收器回收垃圾
Teacher teacher1 = new Teacher("aaa",25);//不回收
new Teacher("bbb",26);//不一定回收
new Teacher("ccc",27);//不一定回收
System.gc();
//4.退出JVM
System.exit(0);//退出JVM,程序结束
System.out.println("程序结束了....");//不执行
}
}
以上是脚本宝典为你收集整理的Java常用类全部内容,希望文章能够帮你解决Java常用类所遇到的问题。
本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ:384754419,请注明来意。