1. 工具类的封装

工具类的封装主要是将一些我们常用的方法或者功能封装在一个类中,这就实现了当我们在开发工程中根据常用的方法来自定义封装类,加快开发进度.

package chapter04;

import java.text.SimpleDateFormat; // 自定义日期格式包
import java.util.Calendar;
import java.util.Date; // 日期包
import java.util.Random; // 随机数生成包(java自带)
import java.util.UUID; // 随机生成字符串包(java自带)

public class Util {
    public static void main(String[] args) throws Exception {

        System.out.println(StringUtil.isEmpty(null));// true(空字符串)
        System.out.println(StringUtil.isEmpty(""));// true(空字符串)
        System.out.println(StringUtil.isEmpty("   "));// true(空字符串)
        System.out.println(StringUtil.isEmpty("abc"));// false(非空字符串)

        System.out.println(StringUtil.makeString());// 无限制随机生成的字符串 - 57fe6405-0270-46ff-968e-4a4161e52d7d
        System.out.println(StringUtil.makeString("abcdedf123456", 6));// 有限制长度和范围生成的随机字符串 - b5db3e

        System.out.println(StringUtil.formatDate(new Date(), "yyyy-MM-dd"));// 时间类型转字符串 - 2023-07-05
        System.out.println(StringUtil.parseDate("2020-06-14", "yyyy-MM-dd"));// 字符串类型转回时间 - Sun Jun 14 00:00:00 CST 2020
    }
}

// 字符串工具类
// 1. 工具类不应该创建对象才能使用，也就意味着，可以直接使用类中的属性和方法，一般都声明为静态的。
// 2. 工具类对外提供的属性或方法都应该是公共的。
// 3. 为了使用者开发方便，应该尽量提供丰富的方法和属性
class StringUtil {
    // 非空判断
    public static boolean isEmpty(String str) {
//        // 如果字符串为null，为空
//        if ( str == null ) {
//            return true;
//        }
//        // 如果字符串为空字符串，为空
//        if ( "".equals(str) ) {
//            return true;
//        }
//        // 如果字符串全都是空格，也为空(去掉首位空格均为空则也为空判断)
//        if ( "".equals(str.trim()) ) {
//            return true;
//        }

        // 简写版本
        if ( str == null || "".equals(str.trim()) ) {
            return true;
        }
        return false;

    }
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    // 生成随机字符串
    // 1. 返回一段随机字符串无条件限制
    public static String makeString() {
        return UUID.randomUUID().toString();
    }

    // 返回一段随机字符串,有条件限制(限制长度,限制取值范围)
    public static String makeString(String from, int len) {// from:取值范围, len,取值长度
        if ( len < 1 ) {
            return "";
        } else {
            // 将取值范围转化未 char数组
            char[] chars = from.toCharArray();
            StringBuilder str = new StringBuilder();
            for ( int i = 0; i < len; i++ ) {
                Random random = new Random();
                // 根据长度范围内随机生成数字
                int j = random.nextInt(chars.length);
                char c = chars[j];// 随机生成的数字设置为数组下标
                str.append(c);// 循环压入生成的新字符串中
            }
            return str.toString();
        }
    }

    // 转换字符串 : ISO8859-1 => str => UTF-8
    public static String transform( String source, String encodeFrom, String encodeTo  ) throws Exception {
        byte[] bytes = source.getBytes(encodeFrom);
        return new String(bytes, encodeTo);
    }

    // 时间数据转字符串输出
    public static Date parseDate( String dateString, String format ) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.parse(dateString);
    }

    // 字符串格式转换回时间格式输出
    public static String formatDate( Date date, String format ) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(date);
    }
}

2. 比较

package chapter04;

public class Compare_oop {
    public static void main(String[] args) throws Exception {

        // TODO 常见类和对象
        // 等于
        // 基本数据类型，双等号比较数值
        int i = 10;
        int j = 10;
        System.out.println(i == j); // true
        double d = 10.0;
        System.out.println(i == d); // true

        // 引用数据类型，双等号比较变量的内存地址
        String s = "abc"; // 字符串常量池
        String s1 = "abc";
        String s2 = new String("abc");
        System.out.println(s == s1); // true
        System.out.println(s == s2); // false (两个不同的地址,new会开辟一个新的内存地址)
        System.out.println(s.equals(s2)); // true (.equals比较的是内容)

        User9 user1 = new User9();
        User9 user2 = new User9();

        System.out.println(user1 == user2); // false (new 两个不同的对象)
        // 使用的是复写后的 .equals
        System.out.println(user1.equals(user2)); // true (对象之间的比较内部也是使用 "==",因此我们需要复写该方法)

        // 包装类型
        // int => Integer => JVM为了操作方便，简化了很多操作
        // Integer缓存：-128 ~ 127
        Integer i1 = Integer.valueOf(-129);
        Integer i2 = Integer.valueOf(-129);

        System.out.println(i1 == i2); // 缓存外,false
        System.out.println(i1.equals(i2)); // 比较内容 true

    }
}

class User9 {
    @Override
    public int hashCode() {
        return 1;
    }

    @Override
    public boolean equals(Object obj) {
        return true;
    }
}
/*
*  我们有上面的例子可以看出,引用数据类型比较的是内存地址,但是在包装类的情况中,jvm虚拟机的优化下
*  是会存在 -128~127 个字节范围内的缓存的,也就是说,当你设定一个字节在这个范围内的两个包装类的时候
*  这两个变量是相等的,但是在这个外围外设置的两个变量就不想等,因此我们推荐在使用 基本数据类型作比较的
*  时候是推荐使用 "==" ,引用数据类型作比较时推荐使用 ".equals()" 是比较准确的.
* */