Object类
clone()克隆
notify()唤醒等待线程
wait()等待notify()唤醒
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的平方根
ceil(a)/floor(a):向上/下取整,返回double
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
基本类型与包装类对应关系
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("程序结束了....");//不执行 } }