常用类的使用-CSDN博客

本文链接：https://blog.csdn.net/m0_74163755/article/details/129657625

包装类

分类

基本数据类型	包装类
boolean	Boolean
char	Character
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double

/**
*装箱拆箱演示
*/
public class Integer01 {
    public static void main(String[] args) {
        //手动装箱 int->Integer
        int n1 = 100;
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);
        //手动拆箱Integer -> int
        int i = integer.intValue();
        int n2 = 200;
        //自动装箱 int->Integer
        Integer integer2 = n2;
        //自动拆箱 Integer->int
        int n3 = integer2; 
    }
}

包装类与String类型的相互转换

/**
*包装类与String类型相互转换
*/
public class WrapperVSString {
    public static void main(String[] args) {
        //包装类(Integer)->String
        Integer i = 100;

        String str1 = i + "";

        String str2 = i.toString();

        String str3 = String.valueOf(i);
        //String -> 包装类(Integer)
        String str4 = "12345";
        Integer i2 = Integer.parseInt(str4);
        Integer i3 = new Integer(str4);
        System.out.println("ok~~");
    }
}

Integer类与Character类的常用方法

/**
*Integer类与Character类的常用方法
*/
public class WrapperMethod {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE); //返回最小值
        System.out.println(Integer.MAX_VALUE);//返回最大值
        System.out.println(Character.isDigit('a'));//判断是不是数字
        System.out.println(Character.isLetter('a'));//判断是不是字母
        System.out.println(Character.isUpperCase('a'));//判断是不是大写
        System.out.println(Character.isLowerCase('a'));//判断是不是小写
        System.out.println(Character.isWhitespace('a'));//判断是不是空格
        System.out.println(Character.toUpperCase('a'));//转成大写
        System.out.println(Character.toLowerCase('A'));//转成小写
    }
}

String类

创建String对象的两种方式

直接赋值String s = "Rillia"

调用构造器String s = new String("Rillia")

字符串的特性

String类是一个final类，代表不可变的字符序列

字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的

String类的常见方法

equals//区分大小写，判断内容是否相等

equalslgnoreCase//忽略大小写的判断内容是否相等

length//获取字符的个数，字符串的长度

indexOf//获取字符在字符串中第1次出现的索引，索引从0开始，如果找不到，返回－1

lastlndexOf//获取字符在字符串中最后1次出现的索引，索引从0开始，如找不到，返回－1

substring//截取指定范围的子串

trim//去前后空格

charAt:获取某索引处的字符，注意不能使用Str[index] 这种方式。

toUpperCase

toLowerCase

concat

replace 替换字符串中的字符

split 分割字符串，对于某些分割字符，我们需要转义比如| \ \等

案例：String poem ="锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦＂；和文

件路径。

compareTo//比较两个字符串的大小

toCharArray//转换成字符数组

format//格式字符串， %s 字符串 %c 字符 %d 整型 %.2f 浮点型

案例，将一个人的信息格式化输出。

StringBuffer类

java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。

很多方法与String相同，但StringBuffer是可变长度的。

StringBuffer是一个容器

/**
*StringBuffer
*/
public class StringBuffer01 {
    public static void main(String[] args) {

        StringBuffer stringBuffer = new StringBuffer("hello");
    }
}

String vs StringBuffer
String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低//private final char value[];
StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更新地址，效率较高
//char[] value;//这个放在堆。

String 和 StringBuffer 相互转换

/**
*String 和 StringBuffer 相互转换
*/
public class StringAndStringBuffer {
    public static void main(String[] args) {
        // String——>StringBuffer
        String str = "hello tom";
        //方式 1 使用构造器
        //返回的才是 StringBuffer 对象，对 str 本身没有影响
        StringBuffer stringBuffer = new StringBuffer(str);
        //方式 2 使用的是 append 方法
        StringBuffer stringBuffer1 = new StringBuffer();
        stringBuffer1 = stringBuffer1.append(str);
        StringBuffer stringBuffer3 = new StringBuffer("hh");
        //方式 1 使用 StringBuffer 提供的 toString 方法
        String s = stringBuffer3.toString();
        //方式 2: 使用构造器来搞定
        String s1 = new String(stringBuffer3);
    }
}

StringBuffer 类常见方法

/**
*StringBuffer 类常见方法
*/
public class StringBufferMethod {
    public static void main(String[] args) {
        StringBuffer s = new StringBuffer("hello");
        s.append(',');
        s.append("ll");
        s.append("tt").append(100).append(true).append(10.5);
        s.delete(11, 14);
        System.out.println(s);
  
        s.replace(9, 11, "rr");
        System.out.println(s);
        int indexOf = s.indexOf("ll");
        System.out.println(indexOf);//6
        s.insert(9, "tt");
        System.out.println(s);
        
        System.out.println(s.length());
        System.out.println(s);
    }
}

StringBuilder

基本介绍

一个可变的字符序列。此类提供一个与StringBuffer 兼容的API,但不保证同步（StringBuilder 不是线程安全）。该类被设计用作 StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类因为在大多数实现中，它比 StringBuffer 要快。

在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。

/**
*StringBuilder 类
*/
public class StringBuffer01 {
    public static void main(String[] args) {

        StringBuffer stringBuffer = new StringBuffer("hello");
    }
}

StringBuilder 常用方法

/**
*StringBuilder 常用方法
*/
public class StringBuilder01 {
public static void main(String[] args) {

        StringBuilder stringBuilder = new StringBuilder();
	}
}

String、StringBuffer 和 StringBuilder 的比较
StringBuilder和 StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
String:不可变字符序列，效率低，但是复用率高。
StringBuffer:可变字符序列、效率较高（增删）、线程安全，看源码
StringBuilder:可变字符序列、效率最高、线程不安全
String使用注意说明：string s="a";//创建了一个字符串s+="b";//实际上原来的＂a"字符串对象已经丢弃了，现在又产生了一个字符串s+"b”（也就是＂ab").如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能 =>结论：如果我们对String 做大量修改，不要使用String

String、StringBuffer 和 StringBuilder 的选择
如果字符串存在大量的修改操作，一般使用 StringBuffer 或StringBuilder
如果字符串存在大量的修改操作，并在单线程的情况，使用 StringBuilder
如果字符串存在大量的修改操作，并在多线程的情况，使用 StringBuffer
如果我们字符串很少修改，被多个对象引用，使用String,比如配置信息等

Math类

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

/**
*Math 类常见方法应用案例
*/
public class MathMethod {
    public static void main(String[] args) {

        //1.abs 绝对值
        int abs = Math.abs(-9);
        System.out.println(abs);//9
        //2.pow 求幂
        double pow = Math.pow(2, 4);//2 的 4 次方
        System.out.println(pow);//16
        //3.ceil 向上取整,返回>=该参数的最小整数(转成 double);
        double ceil = Math.ceil(3.9);
        System.out.println(ceil);//4.0
        //4.floor 向下取整，返回<=该参数的最大整数(转成 double)
        double floor = Math.floor(4.001);
        System.out.println(floor);//4.0
        //5.round 四舍五入 Math.floor(该参数+0.5)
        long round = Math.round(5.51);
        System.out.println(round);//6
        //6.sqrt 求开方
        double sqrt = Math.sqrt(9.0);
        System.out.println(sqrt);//3.0
        //7.random 求随机数
        // random 返回的是 0 <= x < 1 之间的一个随机小数
        for(int i = 0; i < 100; i++) {
        System.out.println((int)(2 + Math.random() * (7 - 2 + 1)));
        }
        //max , min 返回最大值和最小值
        int min = Math.min(1, 9);
        int max = Math.max(45, 90);
        System.out.println("min=" + min);
        System.out.println("max=" + max);
    }
}

Arrays类

Arrays里面包含了一系列静态方法，用于管理或操作数组（比如排序和搜索）

toString 返回数组的字符串形式

Arrays.toString(arr)

sort排序（自然排序和定制排序）

Integer arr[] = {1, -1, 7, 0, 89};

ArraysSortCustom.java

ArraysMethod02.java

binarySearch 通过二分搜索法进行查找，要求必须排好序

int index= Arrays.binarySearch(arr, 3);

ArraysMethod02.java

copyOf 数组元素的复制

Integer[] newArr = Arrays.copyOf(arr,arr.length);

fill 数组元素的填充

Integer[] num = new Integer[]{9,3,2};

Arrays.fill(num, 99);

equals 比较两个数组元素内容是否完全一致

boolean equals = Arrays.equals(arr, arr2);

asList 将一组值，转换成list

List< Intege r> asList = Arrays,asList(2,3,4,5,6,1);

System.out.println("asList="+ asList);

/**
*Arrays类常见方法
*/
public class ArraysMethod02 {
	public static void main(String[] args) {
        Integer[] arr = {1, 2, 90, 123, 567};
        // binarySearch 通过二分搜索法进行查找，要求必须排好
     int index = Arrays.binarySearch(arr, 567);
        System.out.println("index=" + index);
    
        Integer[] newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("==拷贝执行完毕后==");
        System.out.println(Arrays.toString(newArr));

        Integer[] num = new Integer[]{9,3,2};

        Arrays.fill(num, 99);
        System.out.println("==num 数组填充后==");
        System.out.println(Arrays.toString(num));

        Integer[] arr2 = {1, 2, 90, 123};

        boolean equals = Arrays.equals(arr, arr2);
        System.out.println("equals=" + equals);

        List asList = Arrays.asList(2,3,4,5,6,1);
        System.out.println("asList=" + asList);
        System.out.println("asList 的运行类型" + asList.getClass());
     }
}

System类

System 类常见方法

exit 退出当前程序

arraycopy:复制数组元素，比较适合底层调用，一般使用

Arrays.copyOf完成复制数组。

int[] src={1,2,3};

int[] dest = new int[3];

System.arraycopy(src, 0, dest, 0, 3);

currentTimeMillens:返回当前时间距离1970-1-1的毫秒数

gc:运行垃圾回收机制 System.gc();

/**
*System 类案例
*/
public class System_ {
    public static void main(String[] args) {

        int[] src={1,2,3};
        int[] dest = new int[3];

        System.out.println("dest=" + Arrays.toString(dest));

        System.out.println(System.currentTimeMillis());
    }
}

BigInteger 和 BigDecimal 类

应用场景

Biglnteger适合保存比较大的整型

BigDecimal适合保存精度更高的浮点型（小数）

BigInteger 和 BigDecimal 类常见方法

add加

subtract减

multiply乘

divide除

/**
*常见方法
*/
public class BigInteger_ {
    public static void main(String[] args) {

        BigInteger bigInteger = new BigInteger("23788888899999999999999999999");
        BigInteger bigInteger2 = new
        BigInteger("10099999999999999999999999999999999999999999999999999999999999999999999999999999999");
        System.out.println(bigInteger);

        BigInteger add = bigInteger.add(bigInteger2);
        System.out.println(add);
        BigInteger subtract = bigInteger.subtract(bigInteger2);
        System.out.println(subtract);
        BigInteger multiply = bigInteger.multiply(bigInteger2);
        System.out.println(multiply);
        BigInteger divide = bigInteger.divide(bigInteger2);
        System.out.println(divide);
    }
}

public static void main(String[] args) {

    BigDecimal bigDecimal = new BigDecimal("1999.11");
    BigDecimal bigDecimal2 = new BigDecimal("3");
    System.out.println(bigDecimal);

    System.out.println(bigDecimal.add(bigDecimal2));
    System.out.println(bigDecimal.subtract(bigDecimal2));
    System.out.println(bigDecimal.multiply(bigDecimal2));
 
    System.out.println(bigDecimal.divide(bigDecimal2, BigDecimal.ROUND_CEILING));
    }
}

日期类

第一代日期类

Date:精确到毫秒，代表特定的瞬间

SimpleDateFormat 格式化和解析日期的具体类。它允许进行格式化（日期－＞文本）解析（文本 -> 日期）和规范化

/**
*第一代日期类
*/
public class Date01 {
    public static void main(String[] args) throws ParseException {
       
        Date d1 = new Date();
        System.out.println("当前日期=" + d1);
        Date d2 = new Date(9234567); 
        System.out.println("d2=" + d2); 
    
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy 年 MM 月 dd 日 hh:mm:ss E");
        String format = sdf.format(d1); 
        System.out.println("当前日期=" + format);

        String s = "1996 年 01 月 01 日 10:20:30 星期一";
        Date parse = sdf.parse(s);
        System.out.println("parse=" + sdf.format(parse));
    }
}

第二代日期类

第二代日期类，主要就是 Calendar类（日历）。

public abstract class Calendar extends Object implements Serializable,

Cloneable, Comparable< Calendar>

Calendar 类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY OF MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

/**
*第二代日期类
*/
public class Calendar_ {
    public static void main(String[] args) {
   
        Calendar c = Calendar.getInstance(); 
        System.out.println("c=" + c);
    
        System.out.println("年：" + c.get(Calendar.YEAR));

        System.out.println("月：" + (c.get(Calendar.MONTH) + 1));
        System.out.println("日：" + c.get(Calendar.DAY_OF_MONTH));
        System.out.println("小时：" + c.get(Calendar.HOUR));
        System.out.println("分钟：" + c.get(Calendar.MINUTE));
        System.out.println("秒：" + c.get(Calendar.SECOND));

        System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) + "-" +
        c.get(Calendar.DAY_OF_MONTH) +
        " " + c.get(Calendar.HOUR_OF_DAY) + ":" + c.get(Calendar.MINUTE) + ":" + c.get(Calendar.SECOND) );
    }
}

第三代日期类

前面两代日期类不足的分析

JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入

Calendar类之后被弃用了。而Calendar也存在问题是：

可变性：像日期和时间这样的类应该是不可变的。

偏移性：Date中的年份是从1900开始的，而月份都从0开始。

格式化：格式化只对Date有用，Calendar则不行。

此外，它们也不是线程安全的；不能处理闰秒等（每隔2天，多出1s).

LocalDate(日期／年月日）、LocalTime(时间／时分秒）、LocalDateTime(日期时间／年月日时分秒）JDK8加入

LocalDate只包含日期，可以获取日期字段

LocalTime只包含时间，可以获取时间字段

LocalDateTime包含日期＋时间，可以获取日期和时间字段

/**
*第三代日期类
*/
public class LocalDate_ {
    public static void main(String[] args) {
  
        LocalDateTime ldt = LocalDateTime.now(); 
        System.out.println(ldt);
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format = dateTimeFormatter.format(ldt);
        System.out.println("格式化的日期=" + format);
        System.out.println("年=" + ldt.getYear());
        System.out.println("月=" + ldt.getMonth());
        System.out.println("月=" + ldt.getMonthValue());
        System.out.println("日=" + ldt.getDayOfMonth());
        System.out.println("时=" + ldt.getHour());
        System.out.println("分=" + ldt.getMinute());
        System.out.println("秒=" + ldt.getSecond());
        LocalDate now = LocalDate.now(); 
        LocalTime now2 = LocalTime.now();

        LocalDateTime localDateTime = ldt.plusDays(890);
        System.out.println("890 天后=" + dateTimeFormatter.format(localDateTime));
      
        LocalDateTime localDateTime2 = ldt.minusMinutes(3456);
        System.out.println("3456 分钟前 日期=" + dateTimeFormatter.format(localDateTime2));
    }
}

第三代日期类更多方法

LocalDateTime类

MonthDay类：检查重复事件

是否是闰年

增加日期的某个部分

使用plus方法测试增加时间的某个部分

使用minus方法测试查看一年前和一年后的日期

其他的方法，老师就不说，使用的时候，自己查看API使用即可

DateTimeFormatter 格式日期类

类似于SimpleDateFormat

DateTimeFormat dtf DateTimeFormatter.ofPattern(格式)

String str dtf.format(日期对象)

Instant 时间戳

类似于Date

提供了一系列和Date类转换的方式

Instant-->Date:

Date date = Date.fr0m(instant);

Date-->Instant:

Instant instant = date.toInstant();

/**
*Instant 
*/
public class Instant_ {
    public static void main(String[] args) {
        Instant now = Instant.now();
        System.out.println(now);
        Date date = Date.from(now);
        Instant instant = date.toInstant();
    }
}