Java学习总结07

常用类

java提供给开发者的一些经常使用的类。

掌握一种通用的学习方法。

需要学习的类有：String、日期、枚举、包装类、JDK8之后新增的一些类和方法。

枚举类

单例设计模式：需要让一个类只能创建一个对象，截至目前我们学习的创建方式中已经包含了 饿汉式 . 懒 汉式 . 静态内部类 。枚举类也是官方推荐的一种设计单例模式的方式。

设计类的一种方式，将类中可以存在的对象挨个举例。

如何设计枚举类

要求对外提供的对象，都是成员常量而且构造器都必须私有。

public enum Gender{
    BOY,GIRL;
}

对于枚举当中的属性而言通过 ， 分割

所有的属性都是 public static final

构造器都是私有的

某认属性

调用的是私有的空构造器

常见方法

//获取当前枚举类中所有的实例对象 作为一个枚举数组
Season[] ss = Season.values();
for (Season s:ss){
System.out.println(s);
}
// 通过变量名获取当前Season对象
System.out.println(Season.valueOf("SUMMER"));
// 枚举类中定义的对象的索引 从0开始
System.out.println(Season.SPRING.ordinal());

枚举类无法继承其他类，但是默认情况下都是java.lang.Enum的子类 枚举类可以实现接口，如果枚举类中的各个对象对于实现的功能有所区分需要按照如下写法：

public enum Season implements Info{
    SPRING(){
    public void info(){
        System.out.println("春天在哪里呀！春天在哪里？");
    }
},
    SUMMER(){
        public void info(){
            System.out.println("夏天夏天悄悄过去留下甜蜜蜜");
        }
    };
}

String类

类的声明

public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence, Constable,
ConstantDesc

Serializable 序列化接口 IO 将对象可以写入到某个指定的地方去

Comparable 比较的接口

CharSequence 字符序列都必须要实现这个接口

Constable, ConstantDesc jdk9之后增加的两个接口

String描述的是一个字符串对象，所有的"abc"这样的字符串都是一个String类的实例对象

package com.baidu.common.str;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
/**
* 测试String构造器
*/
public class Test01 {
    public static void main(String[] args)throws
UnsupportedEncodingException {
        // 通过空构造器创建一个String对象 就是一个空串 ""
        String str = new String();
        System.out.println("==="+str+"===");
        // 创建一个byte数组
        byte[] buf = new byte[]{65,66,67}; // 转为对应的字符
        // 通过byte数组创建一个对应的字符串对象
        str = new String(buf);
        System.out.println(str);
        //通过字节数组的偏移量创建对象
        str = new String(buf,1,2);
        System.out.println(str);
        // 不需要测试 这个方法已经过时了 不推荐使用
        new String(buf,1);
        //指定字符集合创建当前字符串对象
        //utf-8 utf8 之所以都能够成功后面一定时做了处理
        str = new String(buf,0,3,"UTF8");
        System.out.println(str);
        //通过获取默认的字符集和 创建string字字符串对象
        Charset ch = Charset.defaultCharset();
        str = new String(buf,0,3,ch);
        System.out.println(str);
        // 使用char数组创建对象
        char[] chs = new char[]{'张',(char)21111,'丰'};
        str = new String(chs);
        System.out.println(str);
        // 代码点创建对象
        int[] ars = new int[]{97,98,99};
        str = new String(ars,0,3);
        System.out.println(str);
        str = nvalueOf
        System.out.println(str);
        // 最重要的赋值方式
        str = "abc";
        System.out.println(str);
    }
}

最常用的方法

valueOf(数据类型);

indexOf(String);

getBytes();

compareTo();

equals();

toString();

StringBuilder和StringBuffer

StringBuffer线程安全，SringBuilder快。

/**
* 测试StringBuilder
*/
public class Test05 {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        System.out.println();
        StringBuilder sb2 = new StringBuilder("abc");
        System.out.println(sb2);
        // append 追加 insert 插入 delete 删除 查看indexOf reverse
        sb1.append("abc").append("efg").append("234");
        System.out.println(sb1);
        // 在指定的位置上插入
        sb1.insert(2,true);
        System.out.println(sb1);
        //删除 [start,end)
        sb1.delete(2,6);
        System.out.println(sb1);
        // 查看
        System.out.println(sb1.indexOf("abc"));
        // 将一个数字倒叙输出 123456789
        int num = 123456789;
        //1: 将num转换为对应的string对象
        String string = String.valueOf(num);
        //2: 将String转为对应的StringBuilder对象
        StringBuilder sb3 = new StringBuilder(string);
        //3： 调用reverse方法
        sb3 = sb3.reverse();
        System.out.println(new
        StringBuilder(String.valueOf(num)).reverse());
    }
}

包装类

java时一门面向对象的语言，但是java中存在基本数据类型，面向对象的好处就是创建好对象之后可 以 . 。但是基本数据类型时不可以 . 的。对于每一种基本数据类型都做了一个包装类。

byte->Byte short->Short int->Integer long->Long char->Character double->Double float->Float boolean->Boolean。

Integer

Integer in1 = new Integer(20);
Integer in2 = new Integer(30);
System.out.println(in1==in2); //false 因为两个对象都是new出来的地址指向不同
Integer in3 = 40; // valueOf
Integer in4 = 40;
System.out.println(in3==in4); // true Integer对象创建后存放再常量池中，
//第二次创建时在常量池中存在所以两个对象指向都是同一个地址
Integer in5 = 340;
Integer in6 = 340;
System.out.println(in5==in6); //false 因为超出了Integer的大小范围

缓存

static类和静态代码块

Integer中缓存了 -128~127之间的 数字，如果通过自动装箱创建的对象时，在这个区间内，那么此 时创建的对象时相等的。反之则会重新new一了。

Boolean

Boolean b = new Boolean("12345");
System.out.println(b);

通过字符串创建Boolean对象时 不需要区分大小写，如果不是 true 则全部结果都为false

Double

NaN

无穷大

无穷小

Java中存储小数的包装类时Double但是小数不够精准，结局额办法： 扩大倍数(int) -> 缩小单位 银行中的利率算法： 对于业务会强制规定-> 精确到第多少位 精确方式

BigDecimal

// boolean 包装类创建
Boolean b = new Boolean("12345");
System.out.println(b);


// Double的对象创建 小数的十进制转二进制
// *2 = 整数 小数*2 =
System.out.println(10/3.0);


// 使用BigDecima对象的创建统一不适用待double值 使用字符串方式创建 可以减少精确度的损失
BigDecimal b1 = new BigDecimal(10.0);
BigDecimal b2 = new BigDecimal(3.0);

BigDecimal b3 = b1.divide(b2,3, RoundingMode.HALF_DOWN);
System.out.println(b3);


BigDecimal b4 = new BigDecimal("10.0");
BigDecimal b5 = new BigDecimal("3.0");
//System.out.println(b4.divide(b5));


System.out.println(new BigDecimal(0.5).add(new BigDecimal(0.1)).equals(new
BigDecimal(0.6)));
System.out.println(new BigDecimal("0.5").add(new
BigDecimal("0.1")).equals(new BigDecimal("0.6")));

使用BigDecima对象的创建统一不适用通过double值 使用字符串方式创建 可以减少精确度的损失

时间日期类

Date

Date date = new Date(); //当前系统时间
    System.out.println(date);
    //获取一下当前系统时间到1970年之间的毫秒数
    long time = System.currentTimeMillis();
    System.out.println(time);
    Date befor = new Date(1628130515461L); // 毫秒数 1970年
    System.out.println(date);
    System.out.println(date.after(befor));
    System.out.println(date.before(befor));
    Date d = Date.from(Instant.now());
    System.out.println(d);
    Calendar c1 = Calendar.getInstance();
    System.out.println(c1);
    // 获取一下月份 实际存储从0开始
    System.out.println(c1.get(Calendar.MONTH));
    System.out.println(c1.get(Calendar.DATE));
    System.out.println(c1.get(Calendar.DAY_OF_MONTH));
    System.out.println(c1.get(Calendar.DAY_OF_WEEK)); // 周四 周日开始
    //set修改值
    c1.set(Calendar.DATE,8); // 2021 8 8
    System.out.println(c1);

public static void print(int year,int month,int days){
    System.out.println("=====================");
    System.out.println("=====\t万年历\t=====");
    System.out.println("=====================");
    System.out.println("日\t一\t二\t三\t四\t五\t六");
    //1：创建一个日历对象
    Calendar c = Calendar.getInstance();
    //2：修改日历对象
    c.set(Calendar.MONTH,month-1);
    c.set(Calendar.DAY_OF_MONTH,1);
    //3:获取空格个数 获取日历对象的星期几
    int count = c.get(Calendar.DAY_OF_WEEK);
    for (int i = 1 ; i < count;i++){
        System.out.print("\t");
    }
    //4：打印日期
    for (int i=0;i<c.getActualMaximum(Calendar.DATE);i++){
        //判定当前日历是否时传入的日期
        if (days == c.get(Calendar.DAY_OF_MONTH)){
            System.out.print("*");
        }
        //打印当前日历对象的日期 1
        System.out.print(c.get(Calendar.DAY_OF_MONTH)+"\t");
        //准备换行
        if (c.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY){
            System.out.println();
        }
        c.set(Calendar.DAY_OF_MONTH,c.get(Calendar.DAY_OF_MONTH)+1);
    }
Date d = new Date();
// 父类变量指向子类对象
SimpleDateFormat dateFormat = new SimpleDateFormat();
dateFormat.applyPattern("yy-MM-dd hh:mm:ss");
String str = dateFormat.format(d);
System.out.println(str);
DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
str = df.format(d);
System.out.println(str);
System.out.println(str);