[Java知识库]Java基础之常用类

前言

本文主要浅谈了常用类的用法。

提示：以下是本篇文章正文内容，下面案例可供参考

一、StringBuffer类

StringBuffer： 和String类功能类似，都是专门处理字符串的，是字符串容器，长度可变，是线程安全的

面试题：简单介绍下String、StringBuffer、StringBuilder这三个类？

String是一个不可改变的字符序列
StringBuffer是可改变的字符序列，线程安全的，效率低
StringBuilder也是可改变的字符序列，线程不安全，效率高。

代码如下（示例）：

public class Demo7 {
    public static void main(String[] args) {
        //StringBuffer这个类以后在开发中非常常用
        //后期学习MySql数据库知识，会经常进行字符串的拼接，可以使用
        StringBuffer sb = new StringBuffer();
        sb.append(1);
        sb.append(true);
        System.out.println(sb);//1true
        //上面的sb就是同一个对象。在内存地址里面，可以在这种字符序列对象中随时加入其它数据
        
        sb.append("你好");
        sb.append('a');
        sb.insert(1, 'p');
        System.out.println(sb);//1ptrue你好a

    }
}

二、枚举

enum:枚举
public static final int DEFAULT_CAPACITY = 10;//静态常量
上面这种写法也可以使用枚举的写法。静态常量，不可改变量，而且在这个类都可以使用
枚举可以使用switch-case这个语句中
但是现在开发中一般都是写枚举，而不是写静态常量，因为枚举看着高大上！！！
Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西北等。
Java 枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割。

代码如下（示例）：

//之前写类的时候  public class 类名
//现在写枚举   public enum 枚举名字
public enum Week {
	//定义的枚举是一个常量

	//类名.常量   打印的就是常量
	//Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西北等。

	//Java 枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割。
	MON,TUE,WEN,THUR, FRI,SAT,SUN
}

三、包装类

八大基本数据类型
整型：byte、short、int、long对应的包装类分别为：Byte、Short、Integer、Long
其中Integer最常用，其它三个基本不用
浮点类型：float、double对应的包装类为：Float、Double
字符型：char 对应的包装类为 Character
布尔型：boolean 对应的包装类为 Boolean

总结： 除了int和char包装类特殊以外，其它的包装类都是对应的首字母大写，每一个基本数据类型都有与之对应的包装类

包装类的目的：对基本数据类型进行包装，让其拥有更多的方法和常量，说白了就是让其功能变得更加强大

代码如下（示例）：

public class Test1 {
    public static void main(String[] args) {
        test1();
        test2();
        //测试哪个方法，调用哪个方法
        //......
    }
    public static void test1(){
        //int  short byte long
        int i = 10;
        System.out.println(i);
        //int类型所对应的包装类叫Integer
        Integer i1 = 10;
        System.out.println(i1);
        //只不过在内存中存储的空间不一样而已
        //为什么要包装？
        //是因为int类型的数据java给咱们提供的常量和方法比较少
        //所以干脆对int类型的数据进行包装，让他变成一个类，
        //那么这个包装类就可以封装很多方法和常量
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);

        //构造方法
        //Integer(int value)
        //构造一个新分配的 Integer对象，该对象表示指定的 int值。
        Integer i2 = new Integer(10);
        System.out.println(i2);
        //short 的包装类 Short
        //byte 的包装类  Byte
        //long  的包装类  Long
    }
    public static void test2(){
        float f1 = 3.23234f;
        Float float1 = new Float(7.9);
        System.out.println(float1);
        double d1 = 9.378376;
        Double double1 = new Double(279.278465);

        //char类型的包装类
        char c1 = 'a';//存在栈区
        Character character = new Character('a');//真实的值存在于堆区
        System.out.println(c1);
        System.out.println(character);
        //boolean类型的包装类
        boolean b1 = true;
        Boolean boolean1 = new Boolean(false);
        System.out.println(b1);
        System.out.println(boolean1);
    }
    //除了Character这个包装类以外，其它的包装类都是支持与之对应的基本数据类型作为字符串的参数构造方法。
    public static void test3(){
        Integer i1 = new Integer("2");
        System.out.println(i1);//2  是int类型的数据

        Boolean boolean1 = new Boolean("true");
        System.out.println(boolean1);

        Double double1 = new Double("4.36");
        System.out.println(double1);

        //字符  单引号中只能有一个元素
        Character character = new Character('q');
    }
    //通过xxxValue()方法将包装类转为对应的基本数据类型
    public static void test4(){
        byte a = 10;
        Byte aByte = new Byte(a);
        //aByte是包装类实例化的数据
        //将aByte这个引用数据转为基本数据类型
        //将包装类转为基本数据类型   ***Value()
        byte b = aByte.byteValue();
        System.out.println(b);

        Short short1 = new Short("20");
        short sh = short1.shortValue();
        System.out.println(sh);

        Long aLong = new Long(47484848);
        long l = aLong.longValue();
        System.out.println(l);
    }
    //通过XXXValueOf()方法将基本数据类型转换为对应的包装类对象
    public static void test5(){
        byte b1 = 20;
        //将基本数据类型转为对应的包装类对象
        Byte aByte = Byte.valueOf(b1);
        System.out.println(aByte);
        Integer integer = Integer.valueOf(1);
        System.out.println(integer);
        Character character = Character.valueOf('c');
        System.out.println(character);
    }
    //通过静态的toString方法，将基本数据类型转为字符串
    //不是重写Object类下面的toString方法
    public static void test6(){
        byte b1 = 10;
        String string = Byte.toString(b1);
        System.out.println(string);
        int i1 = 39;
        String string1 = Integer.toString(i1);
        System.out.println(string1);
    }
    //parse***(); 将字符串转为基本数据类型
    //都是静态方法   类名.方法名字()
    //这个方法比较重要！！！
    //parseInt();
    //parseByte()
    //parseShort()
    //parseLong()
    //parseBoolean()
    //parseFloat()
    //parseDouble()
    public static void test7(){
        byte b1 = Byte.parseByte("29");
        System.out.println(b1);

        boolean aTrue = Boolean.parseBoolean("true");
        System.out.println(aTrue);

        //后期学习物理分页的时候，需要使用parseInt这个方法
        int i = Integer.parseInt("12");
        System.out.println(i);
    }
    //拆箱：将包装类转为与之对应的基本数据类型
    //装箱：将基本数据类型转为对应的包装类对象
    public static void test8(){
        Integer i = 20;//自动装箱
        //上面一行代码相当于下面两行代码
//        int i = 20;
//        Integer integer = Integer.valueOf(i);

        Integer i2 = new Integer("30");
//        int i3 = i2.intValue();//将Integer类型转为int类型
        int a  = i2;//自动拆箱
        System.out.println(a);
    }

}

总结

包装类下面的方法
包装类给我们提供了一些构造方法和常用的方法
1.除了Character这个包装类以外，其它的包装类都是支持与之对应的基本数据类型作为字符串的参数构造方法。
2.将引用数据（包装类）类型转为基本数据类型，比如Intege转为int类型，使用xxxValue()；比如intValue() byteValue…
3.valueOf方法；将基本数据类型转为与之对应的包装类
4.parseXxx();将字符串转为基本数据类型，Character除外
5.toString方法，将基本数据类型转为字符串类型的数据
6.自动装箱和拆箱
装箱：将基本数据类型转为包装类对象
拆箱：将包装类对象转为基本数据类型
java为了简单省事，咱们有两个方法叫***Value()和 valueOf这两个方法，目的是装箱和拆箱，但是调用方法太麻烦，所以就进行封装，自动拆箱和装箱。不用调用上面两个函数，自己就可以完成了。JDK 1.5+

四、Math类

Java是面向对象的，专门的类做专门的事。
Math这个类是专门处理数学方法的一个类
Math类下面的方法全是静态方法

abs();求绝对值
max();//求最大值
min();//求最小值
ceil();//向上取整
floor();//向下取整
round();//四舍五入
random();//随机数

代码如下（示例）：

public class Test2 {
    public static void main(String[] args) {
        System.out.println(Math.abs(-3.4));//3.4
        System.out.println(Math.max(2,4));//4 只能比较两个数的最大值
        System.out.println(Math.max(2,Math.max(3,Math.max(5,9))));//9

        System.out.println(Math.min(3,4));//3
        System.out.println(Math.ceil(3.4));//4.0
        System.out.println(Math.floor(3.7));//3.0

        System.out.println(Math.round(3.6));//4

        System.out.println(Math.random());//Math.Random()函数能够返回带正号的double值，该值大于等于0.0且小于1.0，
        // 即取值范围是[0.0,1.0)的左闭右开区间，返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。

        System.out.println((int)(Math.random() * 100));//[0,100)
    }
}

五、Random类

提供了更为丰富的随机数的方法的类

代码如下（示例）：

import java.util.Random;

//Random随机生成数的一个类
public class Test3 {
    public static void main(String[] args) {
        //Random类有空参构造方法，所以可以实例化
        Random random = new Random();
        System.out.println(random.nextBoolean());//随机生成的是布尔类型的数据，没有规律
        System.out.println(random.nextInt());//随机生成int类型的数据(-2*31 ~ 2*31 - 1)
        System.out.println(random.nextDouble());//0-1之间的数 16位的小数
        System.out.println(random.nextFloat());//0-1之间的数  8位的小数
        System.out.println(random.nextLong());
    }
}

六、System类

System类是系统类，提供了一些静态的方法和静态常量
代码如下（示例）：

//System是系统类
public class Test4 {
    public static void main(String[] args) {
        //out是标准输出，err是错误输出
        System.out.print("不换行输出");
        System.out.println("换行输出");//标准正常输出
        System.out.println("错误输出");//错误输出，是红色的字体

        //获取当前的时间
        //从1970年1月1日00:00:00到现在的时间的差值，以毫秒为单位
        System.out.println(System.currentTimeMillis());//获取当前的时间，该时间是一个时间戳

        System.gc();//垃圾回收机制，会自动进行垃圾回收
        //如果写了这个代码就代表让JVM强制回收一些东西

        //可以获取当前系统的属性
        Properties properties = System.getProperties();
        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"));//当前程序执行支持的JDK的版本号
    }
}

七、Runtime类

Runtime这个类不能被实例化，因为Runtime这个类的设计采用了（饿汉式）单例模式，其构造方法私有化了，不能直接new
通常Runtime类的对象通过静态的getRunTime这个方法类获取的
这个类是专门提供java在运行程序的运行时候的信息
代码如下（示例）：

import java.io.IOException;

//Runtime这个类提供了java的运行时候的信息
public class Test5 {
    public static void main(String[] args) throws IOException {
        //不能直接实例化，通过公开的静态的getRuntime()方法获取Runtime的对象
        Runtime runtime = Runtime.getRuntime();
        System.out.println(runtime.maxMemory()/1024/1024);//java运行程序时的最大内存，以字节为单位
        System.out.println(runtime.freeMemory()/1024/1024);//空间总量
        System.out.println(runtime.totalMemory()/1024/1024);//内存总量

        //可以使用runtime执行电脑安装好的软件
        //通过java代码可以打开我们电脑上的应用程序
        Runtime.getRuntime().exec("D:\\app\\Notepad++\\notepad++.exe");
    }
}

八、Date类

Date专门处理日期的类，这个类很少用，一般用日历类Calendar

代码如下（示例）：

import java.util.Date;

public class Demo1 {
    public static void main(String[] args) {
        //1.实例化Date对象
        Date date = new Date();
        System.out.println(date);//Tue Aug 17 23:31:03 CST 2021 这个时间是不友好的

        Date date1 = new Date(2000, 10, 5);//已经被弃用
        System.out.println(date1);

        Date date2 = new Date(System.currentTimeMillis());
        System.out.println(date2);//Tue Aug 17 23:32:45 CST 2021

        System.out.println(date2.getYear() + 1900);
        System.out.println(date2.getMonth() + 1);//0 代表1月
    }
}

九、Calendar类

专门处理日历的类,Calendar是一个抽象类，不能直接实例化，通过Calendar类名调用公开的静态的getIntance()方法获得Calendar对象。

Calendar的getInstance方法返回一个Calendar对象，其日历字段已使用当前日期和时间进行初始化：

代码如下（示例）：

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

public class Demo2 {
    public static void main(String[] args) {
        //1.得到Calendar类的对象
        Calendar calendar = Calendar.getInstance();

        //源码中YEAR的值为1
        //public final static int YEAR = 1;
        System.out.println(Calendar.YEAR);//1
        System.out.println(calendar.get(Calendar.YEAR));//获取当前的年份  2021
        System.out.println(calendar.get(Calendar.MONTH) + 1);//获取当前的月份(0代表一月)  8
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//本月的第几天  17

        //一周中的第几天，从周日开始，周日为第一天，周一为第二天
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));//3
        //以上是日期

        System.out.println(calendar.get(Calendar.HOUR));
        System.out.println(calendar.get(Calendar.MINUTE));
        System.out.println(calendar.get(Calendar.SECOND));
        //以上是获取时、分、秒

        //Date已经被弃用了一些方法
        Date date = calendar.getTime();

        System.out.println(date);//Tue Aug 17 23:51:02 CST 2021
        //这个日期对我们查看时间很不友好
        //转换为能看懂的
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd  hh:mm:ss");
        System.out.println(sdf.format(date));
    }
}

总结

常用类不常用，但是学习这些东西的时候，要学习思想，给你一个你没有见过的类，

你要从几点考虑：
	1.这个类是干嘛？比如String处理字符串  Date处理日期时间     System是和系统有关的。专门的类做这一类相关的事儿
	2.看这个类的构造方法，能不能new？
	3.这个类下面java估计猜测应该封装了好多方法。要学习常用的方法