java中的几个常用类-CSDN博客

本文链接：https://blog.csdn.net/m0_73050509/article/details/126271174

u’y’t常用类：

1、 StringBuffer类

【就是一个字符串类型的容器】

线程安全的，可变的字符序列

功能就是将数据以字符串的形式存入

与它相同功能的还有String、StringBuilder
三者的区别：
String：
	运行效率低，低的离谱，不常用。

StringBuilder：
	运行效率跟StringBuffer快一点点，但没有安全性。

StringBuffer：
	安全且运行较快。

语法格式：

main：
        StringBuffer sb = new StringBuffer();
        System.out.println(sb);
		//基本格式append追加数据
        sb.append("sb");
        sb.append(3.45);
        sb.append(10);
        sb.append(false);
        System.out.println(sb);
        //字符串反转
        System.out.println(sb.reverse());

//测试String、StringBuffer、StringBuilder的运行效率
main：
//String 连接10000次消耗1127ms
        //StringBuffer 连接10000次消耗5ms
        //StringBuilder 连接10000次消耗3ms
        StringTest(10000);
        StringBufferTest(10000);
        StringBuilderTest(10000);
    }
    public static void StringTest(int n){
        String str = "";
        //获取当前系统的时间  还没有执行下面for循环的时候的时间
        Long startTime = System.currentTimeMillis();
        //使用for循环来拼接！！！
        for(int i=0;i<n;i++){
            str += i;
        }
        //获取当前系统的时间  执行下面for循环的时候的时间
        Long endTime = System.currentTimeMillis();
        System.out.println("String 连接"+ n +"次消耗"+(endTime-startTime)+"ms");
    }
    public static void StringBufferTest(int n){
        StringBuffer str = new StringBuffer();
        Long startTime = System.currentTimeMillis();
        for(int i=0;i<n;i++){
            str.append(i);
        }
        Long endTime = System.currentTimeMillis();
        System.out.println("StringBuffer 连接"+ n +"次消耗"+(endTime-startTime)+"ms");
    }
    public static void StringBuilderTest(int n){
        StringBuilder str = new StringBuilder();
        Long startTime = System.currentTimeMillis();
        for(int i=0;i<n;i++){
            str.append(i);
        }
        Long endTime = System.currentTimeMillis();
        System.out.println("StringBuilder 连接"+ n +"次消耗"+(endTime-startTime)+"ms");
    }

总结：

1.String为固定长度的字符串，StringBuilder和StringBuffer为变长字符串；
2.stringBuffer是线程安全的，StringBuilder是非线程安全的；
3.StringBuffer和StringBuilder的默认初始容量是16，可以提前预估好字符串的长度，进一步减少扩容带来的额外开销

2、枚举类

语法格式

public enum 枚举类名 {
	//下面写常量，常量之间使用逗号隔开
	//常量是全大写的，且没有任何数据类型
    RED, GREEN, BLUE
}

枚举的实例用法

//values();枚举类中所有的值
//ordinal();可以找到每个枚举类中常量的索引
//valueOf();返回值的是指定字符串的枚举常量
 Color4[] values = Color4.values();//返回是数组
        //遍历
        for (Color4 value : values) {
            System.out.println(value + "对应的索引:" + value.ordinal());
        }
        //valueOf返回的是字符串的枚举常量对象
        //只是换了一种写法而已。
        //通过常量所对应的字符串获取常量的对象
        Color4 red = Color4.valueOf("RED");
        //一般开发使用Color4.RED;
        Color4 red1 = Color4.RED;
        System.out.println(red);
        System.out.println(red.hashCode());
        System.out.println(red1);
        System.out.println(red1.hashCode());
    }

枚举在真实的开发中使用：

在很多时候我们定义一些状态量都是使用0或者1，-1这样在数据库中定义，这样的数据存放在数据库的相应字段中方便数据读取，但是只存储数字，如果定义的表很多，对应的字段也很多，设计的状态就非常多，编码很容易分辨不清楚，一方面去数据库中查看相应字段的注释非常费时间，而且容易产生差错，如果我们使用枚举类，这个问题就很好的解决了。

比如当我们定义了许多状态量，比如订餐支付，未支付，订单的完结，派送，制作等有许多状态，如果不使用枚举，我们在代码层进行判断的时候总是要去思考这个状态是定义的什么呢，0还是-1呢，当项目比较大的时候，光靠我们记是不行的，干脆我们就使用枚举来简化我们的编程，而且还较少了逻辑上出错的可能。

package com.qfedu.b_enum;


enum ProductEnum {
    UP(0, "在架"),
    DOWN(1, "下架");
    private Integer code;
    private String message;
    ProductEnum(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}
public class Demo5 {
    public static void main(String[] args) {
        System.out.println(ProductEnum.UP.getCode());
        System.out.println(ProductEnum.UP.getMessage());
        System.out.println(ProductEnum.DOWN.getCode());//1
        System.out.println(ProductEnum.DOWN.getMessage());//"下架"
    }
}

3、包装类

Java有八大基本数据类型，都有与之对应的包装类

为啥会有八大基本数据类型的包装类?

包装类能被实例化，封装了很多方法，可以使用，这样操作八大基本数据类型就比较方便了

所以开发中的实体类都是写的包装类

int age====>Integer age;

int->Integer

byte->Byte

short->Short

long->Long

float->Float

double->Double

boolean->Boolean

char->Character

【重点】:

1.自从JDK1.5之后，有拆箱和装箱

自动装箱:将基本数据类型转为包装类

自动拆箱:将包装类转为基本数据类型

2.***Value();将包装类转为基本数据类型

3.toString();将基本数据类型转为字符串

4.parse***();将字符串类型的数据转为基本数据类型【以后开发用】

5.valueOf（）；将基本数据类型转为包装类类似手动装箱

package com.qfedu.c_baozhuang;

public class Demo1 {
    public static void main(String[] args) {
        //自1.5以后 有自动装箱和自动拆箱
        //自动装箱:  将int转为Integer
        //自动拆箱:  将Integer转为int
        //毫无违和感  都是自动的！！！特别方便
        System.out.println(Integer.MAX_VALUE);//2147483647
        System.out.println(Integer.MIN_VALUE);//-2147483648

        //自动装箱 45本身是int类型的数据，现在是Integer
        //int  变成了Integer  报错没？没有就证明可以自动的装箱

        Integer i1 = 45;
        //自动拆箱  没有报错  就证明自动的在拆箱
        int i2 = i1;
        System.out.println(i1);
        System.out.println(i2);
        //除了自动装箱和拆箱外，Java还给咱们提供了方法。让咱们装箱和拆箱

        Boolean b1 = true;//b1 是包装类
        //***Value();将包装类转为基本数据类型
        //intValue()  booleanValue()  floatValue() doubleValue()
        //b是基本数据类型
        //有自动拆箱，还有必要使用***Value吗？没有！！！
        boolean b = b1.booleanValue();
        System.out.println(b);

        //toString();将基本数据类型转为字符串【重要】
        int i3 = 45;
        String s = Integer.toString(i3);
        System.out.println(s);//"45"
        String s1 = Double.toString(67.8);
        System.out.println(s1);//"67.8"
        //以后做银行项目的时候，double 和float 有可能数据丢失
        //可以转为字符串操作！！！绝对不会
        //parse***();将字符串类型的数据转为基本数据类型【以后开发用】
        //parsetInt(); parseDouble(); parseFloat();parseByte()
        int i = Integer.parseInt("250");
        System.out.println(i);//250
        //开发中  分页  前段URL传一个字符串值过来 pageNo=2 这个2传
        //到Java代码中，是字符串类型的数据，将字符串转为int类型的数据
        //然后操作数据库

        //valueOf（）；将基本数据类型转为包装类类似手动装箱
        byte b2 = 34;//b2 基本数据类型
        Byte aByte = Byte.valueOf(b2);
        System.out.println(aByte);//aByte 就是包装类
        //有没有必要写这个方法？没有  因为会自动装箱


    }
}

4、Math

Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。

专门处理数学运算的一个类

绝对值 abs()

最大值 max()

最小值 min()

向上取整 ceil()

向下取整floor()

四舍五入round()

随机数random()

package com.qfedu.d_math;

public class Demo1 {
    public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println(Math.E);
        //以上是两个常量
        System.out.println(Math.abs(-89));//绝对值 89
        System.out.println(Math.max(34, 56));//最大值 56
        //求三个数的最大值？咋办？
        System.out.println(Math.max(23, Math.max(45,12)));//45

        //最小值
        System.out.println(Math.min(34, 12));//12
        //向上取整
        System.out.println(Math.ceil(45.2));//46.0
        //向下取整
        System.out.println(Math.floor(89.8));//89.0
        //四舍五入
        System.out.println(Math.round(45.5));//46
        //随机数大于等于 0.0 ，小于 1.0   double
        System.out.println(Math.random());
        //随机1-100之间的整数int 0.45 * 100=45 int
        int i1 = (int)(Math.random() * 100);
        System.out.println(i1);


    }
}

5、Random

专门处理随机数的类

package com.qfedu.e_random;

import java.util.Random;

public class Demo1 {
    public static void main(String[] args) {
        Random random = new Random();
        System.out.println(random.nextInt());
        System.out.println(random.nextInt(100));//[0,100);
        System.out.println(random.nextFloat());
        System.out.println(random.nextDouble());
        System.out.println(random.nextBoolean());



    }
}

6、System类

字面意思就是【系统的】

package com.qfedu.f_system;

import java.io.PrintStream;
import java.util.Properties;
import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {

        PrintStream out = System.out;//是一个流 PrintStream 打印流
        out.println("goudan");
        System.out.println("goudan");//标准输出流打印的东西
        System.err.println("xixi");//错误输出流打印的东西
        new Scanner(System.in);//输入流
        //你把控制台想象成一个磁盘。就是输入流和输出流
        //用的很多
        // 在1970年1月1日UTC之间的当前时间和午夜之间的差异，以毫秒为单位
        long l = System.currentTimeMillis();
        //2022年到1970年 是不是52
        System.out.println(l/1000/60/60/24/365);

        //获取系统的东西  System 英文单词就是系统的意思
        Properties properties = System.getProperties();
        //os.name 系统的名字
        System.out.println(properties.get("os.name"));
        System.out.println(properties.get("os.version"));
        System.out.println(properties.get("user.name"));
        System.out.println(properties.get("user.dir"));
        System.out.println(properties.get("java.version"));
//Windows 10
//10.0
//bowang
//C:\Users\bowang\IdeaProjects\day21_wb
//1.8.0_241



    }
}

7、Runtime【不重要】

用代码执行exe应用程序

package com.qfedu.g_runtime;

import java.io.IOException;

public class Demo1 {
    public static void main(String[] args) throws IOException {
        //1.获取runtime对象
        Runtime runtime = Runtime.getRuntime();
        //runtime对象可以启动咱们电脑上面任意的一个软件
        //使用代码启动软件
        runtime.exec("C:\\Program Files (x86)\\Notepad++\\notepad++.exe");
        //返回Java虚拟机将尝试使用的最大内存量。字节数
        System.out.println(runtime.maxMemory() / 1024 / 1024);//MB
        //返回Java虚拟机中的可用内存量 字节数
        System.out.println(runtime.freeMemory()/1024/1024);
        //返回Java虚拟机中的内存总量 字节数
        System.out.println(runtime.totalMemory()/1024/1024);
    }
}

8、Date类

专门处理日期的一个类，但它的很多方法都已经过期了

关键字及语法格式：

Date date = new Date();
//Tue Aug 09 16:11:11 IRKT 2022
sout(data);
//获取年份,这个方法年份默认-1900，我们加上就对了
data.getYear() + 1900
//获取月份，这个方法默认-1.我们+1就对了
data.getMonth() + 1
//日
date.getDate()；
//星期
date.getDay()；
//时
date.getHours()；
//分
date.getMinutes()
//秒
date.getSeconds()

在类的所有方法Date接收或返回年、月、日、小时、分钟、秒值，在以下表述中合理使用：

//y年，代表整数y-1900，我们使用的时候要加上1900

//月，一个月由0到11的正数表示，0一月、1二月、2三月...，

//日，通常以（月的一天）的方式从1-31的整数表示

//一小时由0-23之间的整数表示。从午夜到凌晨1点的时间是小时是0，从中午到下午一点的小时是12。

//分，一般以0-59的整数表示

//第二个由0-61的整数表示；值60和61进发生在闰秒上，甚至尽在实际上正确跟踪闰秒的Java实现中发生。由于目前进入闰秒的方式，在用一分钟内不会发生两个闰秒，但是本规范遵循ISO C的日期和事件约定

package com.qfedu.h_date;

import java.util.Date;

public class Demo1 {
    public static void main(String[] args) {
        Date date = new Date();
        //Tue Aug 09 16:11:11 IRKT 2022
        System.out.println(date);
        //获取年份 这个年份是减去1900以后的值，所以得加上1900
        System.out.println(date.getYear() + 1900);
        //7
        //2
        //16
        //15
        //42
        //获取月份
        System.out.println(date.getMonth() + 1);//7
        //这个日期的星期几。
        System.out.println(date.getDay());//2
        System.out.println(date.getHours());//16
        System.out.println(date.getMinutes());//15
        System.out.println(date.getSeconds());//42


    }
}

9、Calendar

现在国际通用的时间是Calendar类

语法格式：

main：
//用这个方法获取一个计算机默认的日历(时间),也可以说把一个日历(时间)赋值给calendar，
Calendar calendar = Calendar.getInstance();
//获取当前的年份
calendar.get(Calendar.YEAR);
//获取月份  需要加1的
calendar.get(Calendar.MONTH) + 1
//获取当月的第几天
calendar.get(Calendar.DAY_OF_MONTH)
//获取这周的第几天  漂亮国的周日是第1天 -1
calendar.get(Calendar.DAY_OF_WEEK) - 1
//获取这一年的第几天
calendar.get(Calendar.DAY_OF_YEAR);
//获取时
calendar.get(Calendar.HOUR)
//获取分
calendar.get(Calendar.MINUTE)
//获取秒
calendar.get(Calendar.SECOND)

9.1获取当前时间返回值是Date

【重要的方法】获取当前的时间的，返回值是Date类型的数据

可以转为Date类型的数据

语法格式：

//Tue Aug 09 16:40:21 IRKT 2022
Date time = calendar.getTime();
//这上面的时间，对程序员非常不友好，通过一个类转换一下
SimpleDateFormat sdf = new SimpleDateFormat("yyyy—MM-dd HH:mm:ss");
//yyyy-MM-dd HH:mm:ss
//年-月-天 时:分:秒
//2022-08-09  16:43:32
//将这个格式Tue Aug 09 16:40:21 IRKT 2022
//转换为2022-08-09  16:43:32
String format = sdf.format(time);
System.out.println(format);
//yyyy-MM-dd HH:mm:ss
//以上能不能胡乱写？不能
//以后开发中要用的！！

输入两个日期，判断相差多少天

package com.qfedu.h_date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo3 {
    public static void main(String[] args) throws ParseException {

        //输入两个日期计算出两个日期相差多少天
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //将一个字符串类型的数据变成一个Date类型的数据
        Date strat = sdf.parse("2012-08-01");
        Date end = sdf.parse("2022-08-09");
        //一定要将字符串转为Date类型 才能按照日期来算
        //将Date类型的数据转为时间戳了，
        //为啥转为时间戳？因为时间戳是一个long类型数据可以想减！！！
        //算两个时间的间隔，相减。转为int或者long才能转
        long startTime = strat.getTime();
        long endTime = end.getTime();//毫秒数
        long num = endTime - startTime;
        System.out.println(num/1000/60/60/24);



    }
}