Java 各种常用类

最新推荐文章于 2024-07-29 14:22:26 发布

喵497

最新推荐文章于 2024-07-29 14:22:26 发布

阅读量95

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/weixin_68567699/article/details/126256516

版权

1.常用类

1.1StringBuffer类

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

package zzy;

public class Dome2 {
    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer();
        StringBuffer stringBuffer1 = new StringBuffer();
        stringBuffer.append("123");
        stringBuffer.append(1);
        stringBuffer.append('1');//将指定类型数据追加到此字符序列
        System.out.println(stringBuffer.reverse());//将字符串反转
        stringBuffer.delete(1, 2);//删除指定两个下标中间的值 左删右留
        System.out.println(stringBuffer);
        stringBuffer.insert(1,"狗蛋");//将指定类型的数据插入指定位置
        System.out.println(stringBuffer);
        stringBuffer.replace(1,3,"1");//替换指定两个下标中间的值
        stringBuffer1.append("123456789");
        stringBuffer.append(stringBuffer1);//拼接
        System.out.println(stringBuffer);

    }
}

1.2枚举类（enum）

Java 中的枚举是一个特殊的类，一般是表示一组常量  final  static int a = 30;
比如一年有四季  一天24小时  pi  e

Java中定义枚举类的时候的语法格式:
public enum 枚举类名 {
	//下面写常量，常量之间使用逗号隔开
	
}

package com.qfedu.b_enum;

public enum Color {
    //常量,一般都是大写的  没有任何数据类型的！！！
    RED, GREEN, BLUE
}

枚举类的实例用法

package com.qfedu.b_enum;

//声明一个枚举类  是一个特殊的类
 enum Color2 {
    RED, GREEN, BLUE
}
public class Demo2 {
    public static void main(String[] args) {
        //RED这个数据  属于Color2这个类的实例的
        //Color2.RED  为啥可以用类名.常量  常量是static修饰的！！！
        Color2 red = Color2.RED;
        System.out.println(red);//RED
        Color2 green = Color2.GREEN;
        System.out.println(green);

    }
}

swicth （表达式）｛｝

表达式数据类型有哪些：
	byte  short  int char  String 枚举

枚举在swicth-case中如何使用【这个重要】

package com.qfedu.b_enum;

enum Color3 {
    RED, GREEN, BLUE
}
//可以通过switch-case将咱们的常量变成咱们所数据类型
//RED===》红色
//只是一个用判断的一个东西
public class Demo3 {
    public static void main(String[] args) {
        Color3 red = Color3.RED;
        switch (red) {
            case RED:
                System.out.println("红色");
                break;
            case GREEN:
                System.out.println("绿色");
                break;
            case BLUE:
                System.out.println("蓝色");
                break;
        }
    }
}

枚举类中的几个方法

values();枚举类中所有的值
ordinal();可以找到每个枚举类中常量的索引
valueOf();返回值的是指定字符串的枚举常量

package com.qfedu.b_enum;

enum Color4 {

    RED, GREEN, BLUE
}
public class Demo4 {
    public static void main(String[] args) {
        //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());//"下架"
    }
}

1.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 就是包装类
        //有没有必要写这个方法？没有  因为会自动装箱


    }
}

面试题：

Integer i1 = 10;
Integer i2 = 10;
sout(i1 == i2);
Integer i3 = 1000;
Integer i4 = 1000;
sout(i3 == i4);

1.4Math

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


    }
}

1.5Random类

专门处理随机数的类

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



    }
}

1.6System类

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



    }
}

1.7Runtime【不重要】

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

1.8Date类

专门处理日期的一个类，不过好多方法已经过期了

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

y年代表整数y - 1900 。
一个月由0到11的整数表示; 0是1月，1是2月，等等; 11月12日。
日期（月的一天）以通常的方式从1到31的整数表示。
一小时由0到23之间的整数表示。因此，从午夜到凌晨1点的时间是小时0，从中午到下午1点的小时是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


    }
}

1.9Calendar

现在国际通用的是Calendar类

package com.qfedu.h_date;

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

public class Demo2 {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        //获取当前的年份
        int i = calendar.get(Calendar.YEAR);
        System.out.println(i);//2022
        //获取月份  需要加1的
        System.out.println(calendar.get(Calendar.MONTH) + 1);//8
        //获取当月的第几天
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//9
        //获取这周的第几天  漂亮国的周日是第1天
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));//3
        //获取这一年的第几天
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));//221
        //获取时
        System.out.println(calendar.get(Calendar.HOUR));//4
        System.out.println(calendar.get(Calendar.MINUTE));//39
        System.out.println(calendar.get(Calendar.SECOND));//3

        //重要的方法  获取当前的时间的 返回值是Date类型的数据
        //可以转为Date类型的数据
        Date time = calendar.getTime();
        System.out.println(time);
        //Tue Aug 09 16:40:21 IRKT 2022
        //这上面时间 对程序员相当不友好！！！
        //通过一个类将日期格式转换一下
        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
        //以上能不能胡乱写？不能
        //以后开发中要用的！！

    }
}