Java常用类

2022/6/2 5:20:21

编程Tag： string new 常用 Java out system public println

本文主要是介绍Java常用类，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Java常用类

Object类

clone()克隆
notify()唤醒等待线程
wait()等待notify()唤醒

File类

Object类

超类、基类，所有类的直接或间接父类，位于继承树的最顶层
任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
Object类中所定义的方法，是所有对象都具备的方法
Object类型可以存储任何对象
- 作为参数，可接受任何对象
- 作为返回值，可返回任何对象

getClass()方法

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不是同一个类型");
        }
    }
}

hashcode()方法

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());
    }
}

toString()方法

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);
    }
}

equals()方法

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));
    }
}

equals()方法覆盖步骤

比较两个引用是否指向同一个对象
判断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);
}

finalize()方法

当对象被判定为垃圾对象时，由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("回收垃圾");
    }
}

Math类

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));
    }
}

Random类

伪随机数

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安全随机数

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()静态方法
- 引用类型-->基本类型：int n = Integer.parseInt("234");
valueOf()静态方法
- 基本类型-->引用类型：String s = String.valueOf(20);
注意：需要保证类型兼容，否则抛出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
    }
}

BigInteger类

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);
    }
}

BigDecimal类

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

练习3

比较器

* 实现了 Comparable 接口,该类就可以比较大小
* 比较规则由 compareTo 方法来制定
* sort 可以直接对 基本数据类型 进行排序
* sort 如果要对 引用数据类型 进行排序,
	那么 该引用类型必须要 实现Comparable接口
    或者 在调用 sort 的时候，传入 自定义的排序规则
        自定义排序规则由 Comparator 接口提供
* sort 默认按照 自然顺序 排列
* 实现了 Iterable 接口,该类就可以进行迭代

Integer数组排序

定义一个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);
    }
}

String类

字符串是常量，创建之后不可改变
字符串字面值存储在字符串(常量)池中，可以共享

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());
    }
}

Buffer与Builder、Joiner

StringBuffer用法与StringBuilder一样
StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全
StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全，在多线程环境下，使用的时候，需要注意安全

StringBuffer

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));
    }
}

StringBuilder

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"));
    }
}

StringJoiner

按照相同的分隔符，拼接字符。与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表示特定的瞬间，精确到毫秒。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日历(建议使用)

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

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);
    }
}

JDK1.8新特性(建议用)

java.time

ZoneId时区

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

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类

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("程序结束了....");//不执行
    }
}

IDEA快捷键

Ctrl+N：搜索
Ctrl+H：搜索子类

这篇关于Java常用类的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java常用类

Java常用类

Object类

getClass()方法

hashcode()方法

toString()方法

equals()方法

equals()方法覆盖步骤

finalize()方法

Math类

Random类

伪随机数

SecureRandom安全随机数

包装类

类型转换与装箱、拆箱

整数缓冲区

BigInteger类

BigDecimal类

练习3

比较器

Integer数组排序

枚举类

String类

常用方法

案例演示

Buffer与Builder、Joiner

StringBuffer

StringBuilder

StringJoiner

日期时间类

Date日期

Calendar日历(建议使用)

练习

时区

TimeZone

JDK1.8新特性(建议用)

ZoneId时区

本地日期和时间

SimpleDateFormat

System类

IDEA快捷键

相关编程文章