Java基础学习（10）——常用实用类的定义和注意事项

Java基础学习（10）——实用类的定义和注意事项

1、枚举类型

枚举
    枚举类更加直观，类型安全。使用常量会有以下几个缺陷：
    　　1. 类型不安全，可以随便赋值，而枚举类型的话，就只能传入枚举类中包含的对象。

    　　2. 没有命名空间。开发者要在常量命名的时候以固定格式开头，这样另外一个开发者再看这段代码的时候，才知常量的含义。

使用场景：
    1）作为常量使用
    枚举，可以把相关的常量分组到一个枚举类型里。 
    public enum CarEnum {
        AUDI, BMW, BENZ
    }
    备注：
        enum和class、interface的地位一样
        使用enum定义的枚举类默认继承了java.lang.Enum，而不是继承Object类。
        枚举类的所有实例都必须放在第一行展示，不需使用new 关键字。自动添加public static final修饰。

    2）使用Switch选择结构
        	// 当匹配枚举类型时，会自动强校验，case的值，必须是枚举类中声明的枚举类型变量
            CarEnum car = CarEnum.BMW;
            switch (car) {
            case AUDI:
                System.out.println("买了一辆奥迪");
                break;
            case BMW:
                System.out.println("买了一辆宝马");
                break;
            case BENZ:
                System.out.println("买了一辆奔驰");
                break;

            default:
                break;
            }

    3）枚举类内也可以定义属性和方法。注意必须加对应的属性和构造方法（还有普通方法来获取属性）才可以，否则报错

        public enum StateCodeEnum {
            // 定义的默认都是常量（public static final）
            // 枚举类的所有的实例必须放带第一行，不需要使用new
            // 枚举类内还可以定义属性和方法，对应的实例必须改为对应的带参构造
            
            SUCCESS("0000", "成功"), FAIL("6666","失败"), ERROR("9999", "错误");
	
            // 内部私有属性
            private String code;
            private String desc;

            // 提供一个跟实例一致的构造方法
            private StateCodeEnum(String code, String desc){
                this.code = code;
                this.desc = desc;
            }

            public String getCode() {
                return code;
            }

            public String getDesc() {
                return desc;
            }

            // 提供一个枚举类的普通方法，方便使用（当只知道状态码，获取其说明的时候）
            public static String getDescByCode(String code){
                // 枚举的遍历
                for(StateCodeEnum codeEnum : StateCodeEnum.values()){
                    if(codeEnum.code.equals(code)){
                        return codeEnum.desc;
                    }
                }
                return null;
            }

        }

2、包装类

java中的基本数据类型int，double等不是对象，无法通过向上转型获取到Object提供的方法，而像String却可以，只因为String是一个类而不是一个类型。基本数据类型由于这样的特性，导致无法参与转型，泛型等过程。为了弥补这个缺陷，java提供了包装类，包装类都在java.lang包下面。

包装类作用：
    1）提供了一系列实用的方法，作为基本数据类型对应的类类型，提供了一系列实用的对象操作，如类型转换。
    2）集合不允许存放基本数据类型数据，存放数字时，要用包装类型。
    3）包含了每种基本数据类型的相关属性，如最大值、最小值、所占位数等
        //获取基本数据类型的相关属性
        System.out.println(Byte.SIZE);// 8
        System.out.println(Byte.MIN_VALUE);// -128
        System.out.println(Byte.MAX_VALUE);// 127
    4）所有包装类都是final类型，不能创建它们的子类
    5）JDK1.5后，允许基本数据类型和包装类型进行混合数学运算，包装类并不是用来取代基本数据类型的，在基本数据类型需要用对象表示时使用

基本类型和包装类的对应关系：
    byte-Byte int-Integer short-Short long-Long float-Float 
    double-Double boolean-Boolean char-Character

基本数据类型的长度（位-bit）-- 一个字节占8位，char两个字节，可以存放汉字。
   System.out.println(Byte.SIZE);     // 8
   System.out.println(Short.SIZE);    // 16
   System.out.println(Integer.SIZE);  // 32
   System.out.println(Long.SIZE);     // 64
   System.out.println(Float.SIZE);    // 32
   System.out.println(Double.SIZE);   // 64
   System.out.println(Character.SIZE);// 16

所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例：
    Integer integer1 = new Integer(100);
	Double double1 = new Double(100.12);
	Boolean boolean1 = new Boolean(true);
	Character character1 = new Character('a');
除Character类外，其他包装类可将一个字符串作为参数构造它们的实例:
    Integer integer2 = new Integer("200");
	Double double2 = new Double("200.12");

注意：
    1.Boolean类构造方法参数为String类型时，若该字符串内容为true(不考虑大小写)，则该Boolean对象表示true，否则表示false
        Boolean b2 = new Boolean("True");
        Boolean b3 = new Boolean("TRUE");
        Boolean b4 = new Boolean("OK");
    2.当包装类构造方法参数为String 类型时，字符串不能为null，且该字符串必须可解析为相应的基本数据类型的数据，否则编译通过，运行时NumberFormatException异常
        Integer a2 = new Integer("");// NumberFormatException: For input string: ""
        Integer a3 = new Integer(null);// NumberFormatException: null
        Integer a4 = new Integer("abc");// NumberFormatException: For input string: "abc"

3、包装类的常用方法

1）valueOf
    Integer intValue = Integer.valueOf(345);
    除Character类外，其他包装类都可以如下操作：
    Integer intValue = Integer.valueOf("456");
2) xxxValue()--包装类转换为基本数据类型
    Integer in1 = new Integer(123);
    int in2 = in1.intValue();
3）toString()--以字符串形式返回包装对象表示的基本类型数据
    String str = Integer.toString(50);//自动装箱并调用toString()方法，这也是将基本类型转换为包装类的好处。
    String sex = Character.toString('男');
    // String str = String.valueOf(21); -- String类提供的方法
4）parseXXX()：把字符串转换为相应的基本数据类型数据（Character除外）
    int num1 = Integer.parseInt("100");
    System.out.println(num1); //100
    boolean bool = Boolean.parseBoolean("false");

4、包装类的自动装箱和拆箱

装箱：基本类型转换为包装类的对象  
拆箱：包装类对象转换为基本类型的值

//自动装箱
Integer in = 10;
System.out.println(in);// 10
  
//自动拆箱
Integer inn = new Integer(10);
int n = inn + 10;
System.out.println(n);// 20

5、String类

定义字符串两种方式：
	String s = "Hello World"; // 常用
	String s = new String("Hello World");

	注意：字符串一经定义，不可以修改，
	1、String类是final修饰的 
	2、字符串的地址的引用变了，字符串多次赋值不是改变变量的值，只是改变了字符串的引用地址
	3、底层实现是一个final类型的字符数组

常用方法：

1）length()方法，确定字符串的长度，返回字符串中的字符数
    注意：是length()方法，数组是length属性

2）equals()方法，比较存储在两个字符串对象的内容是否一致，区别于==(判断两个字符串在内存中的地址， 即判断是否是同一个字符串对象，object类中equals方法和==是一致的)。

3）equalsIgnoreCase()方法：不区分大小写的判断值是否一致

    toLowerCase()方法：转换为小写

    toUpperCase()方法：转换为大写

4) 字符串连接
    方式1：使用 + 
        String str = "aaa"+"bbb"+"ccc";

    方式2：使用 concat 方法
        String str = str.concat("ddd").concat("ccc").concat("eee");

5）字符串提取方法
    字符串中单个字符查找
        indexOf(int ch/String str) 
            查找当前字符串中字符或子串，返回字符或子串在当前字符串中从左边起首次出现的位置，若没有返回-1。
        indexOf(int ch/String str, int fromIndex)
            与第一种类似，区别在于该方法从fromIndex位置向后查找。
        lastIndexOf(int ch/String str)
            该方法与第一种类似，区别在于该方法从字符串的末尾位置向前查找，返回的位置仍然是左起位置。
        lastIndexOf(int ch/String str, int fromIndex)
            该方法与第二种方法类似，区别于该方法从fromIndex位置向前查找。

    字符串截取：substring方法可以提取字符串中的子串，该方法有两种常用参数:
            1)substring(int begin)
                //该方法从begin位置(下标)起，从当前字符串中取出剩余的字符作为一个新的字符串返回。
            2)substring(int beg, int end)
                //该方法从begin位置(下标)起，从当前字符串中取出到end-1位置的字符作为一个新的字符串返回。
        
    字符串去除首尾空格: trim()方法
        截去字符串两端的空格，但对于中间的空格不处理。

    字符串判断开始、结束
        statWith(String prefix)
        endWith(String suffix)
        用来比较当前字符串的起始字符或子字符串prefix和终止字符或子字符串suffix是否和当前字符串相同

    字符串判断是否包含子串
        contains(String str)
        判断子字符串是否被包含在字符串中，并返回一个布尔类型的值。

    字符串分割
        split()方法，将一个字符串分割为子字符串，结果作为字符串数组返回

    按照指定位置获取单个字符 
        charAt(下标)
    
    直接将字符串转换为字符数组
        toCharArray()
    
    字符串转字节数组
        getBytes()
    
    字符串替换
        replace("旧串","新串")

6、StringBuffer对象

    特点：
        1)可变字符串类，创建StringBuffer类的对象后可以随意修改字符串的内容。
        每个StringBuffer 类的对象都能够存储指定容量的字符串，如果字符串的长度超过了 StringBuffer 类对象的容量，则该对象的容量会自动扩大。
        2)对字符串频繁修改（如字符串连接）时，使用StringBuffer类可以大大提高程序执行效率

    语法：
        StringBuffer() 构造一个空的字符串缓冲区，并且初始化为 16 个字符的容量。底层实现是16个字符长度的数组。
        StringBuffer(int length) 创建一个空的字符串缓冲区，并且初始化为指定长度 length 的容量。
        StringBuffer(String str) 创建一个字符串缓冲区，并将其内容初始化为指定的字符串内容 str，字符串缓冲区的初始容量为 16 加上字符串 str 的长度。

        输出字符串的容量大小
            capacity()方法返回字符串的容量大小
            
    使用
        1）toString -- 转换为String类型
        2）append() -- 用于向原有 StringBuffer 对象中追加字符串，常用方法 *
            append追加内容到当前 StringBuffer 对象的末尾，类似于字符串的连接。调用该方法以后，StringBuffer 对象的内容也发生了改变。
            使用 append() 方法时，如果长度超过了字符串存储空间大小就需要进行扩容，它会重新分配内存，创建一个更大的数组，这个数组的容量是原来的 2 倍 + 2 的大小，并将原先的数组复制过来，再丢弃旧的数组。

        3）插入字符串 -- 了解
            insert(1, "**");
            
        4）字符串倒序输出：
            reverse()方法，可以将字符串内容倒序

    String,StringBuffer,StringBuilder比较

        1）String是不可变对象，经常改变内容的字符串最好不要使用String，任何对String的改变都 会引发新的String对象的生成
        2）StringBuffer是可变的字符串，字符串经常改变的情况可使用StringBuffer，更高效，任何对它所指代的字符串的改变都不会产生新的对象。
        3）JDK1.5后提供了StringBuilder，等价StringBuffer。作为一个简易替代，他们的原理和操作基本相同，区别在于StringBuffer支持并发操作，线性安全的，适合多线程中使用。StringBuilder不支持并发操作，线性不安全的，不适合多线程中使用，而且大量字符操作时候，相对来说执行会快.
    因此：
        String：适用于少量的字符串操作的情况
        StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
        StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

7、Math类

java.lang.Math类提供了常用的数学运算方法和两个静态常量E（自然对数的底数） 和PI（圆周率）
	// 绝对值
    System.out.println(Math.abs(-3.5)); // 3.5  
    // 最大值
    System.out.println(Math.max(2.5, 90.5));// 90.5
    // 随机数
    int random = (int) (Math.random() * 10); // 生成一个0-10之间的随机数
    // 四舍五入
	System.out.println(Math.round(3.45)); // 3
	System.out.println(Math.round(3.55)); // 4
	// 向上取整(取大于当前数的最小整数)
	System.out.println(Math.ceil(3.25)); // 4.0
	// 向下取整(取小于当前数的最大整数)
	System.out.println(Math.floor(3.25)); // 3.0

    注：Math类方法很多，需要使用直接看API文档即可，不需要全部掌握

8、Random类 – java.util.Random类

简单介绍使用示例，不需要全部掌握，用到时候查下文档即可
    // 创建一个Random对象
    Random rand=new Random();
    for(int i=0; i<20; i++){
        // 随机生成20个随机整数，并显示
        int num=rand.nextInt(10);// 返回下一个伪随机数，整型的
        System.out.println("第"+(i+1)+"个随机数是："+num);
    } 

9、日期操作类

1）java.util.Date类：表示日期和时间，提供操作日期和时间各组成部分的方法
    Date对象本身所存储的毫秒数可以通过date.getTime()方法得到（long型的值）；该函数返回自1970年1月1日 00:00:00 GMT（格林威治平时（Greenwich Mean Time））以来此对象表示的毫秒数(实际中国获取的，是需要加上时区的概念，中国8时区，即我们获取的是1970年1月1日 08:00:00)。

    日期转换：
        java.text.SimpleDateFormat类

            // Date指定格式：yyyy-MM-dd HH:mm:ss
            // yyyy -- 年
            // MM -- 月
            // dd -- 天
            // HH -- 24小时制 hh -- 12进制
            // mm -- 分钟
            // ss -- 秒
            // SSS -- 毫秒

            // 日期转字符串
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            // 创建一个date对象保存当前时间
            Date date = new Date();
            String dateStr = simpleDateFormat.format(date);
            
            // 字符串转日期：
            // 已知日期字符串，如何获取当前日期对象
            String date1 = "2020-11-28 13:52:00";
            try {
                Date date2 = sdf.parse(date1);
                System.out.println(date2);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            // 调用parse()方法时 注意 传入的格式必须符合simpleDateFormat对象的格式，即"yyyy-MM-dd HH:mm:ss" 否则会报错！！
            且抛出转换异常，需要捕获异常处理。

    备注：
        模式字母含义：只需要知道常用的几种（一定注意大小写，容易导致数据问题，比如数据库条件用24小时制，而代码处理用12小时制，会出问题）

            y   年   Year    
            M   年中的月份   Month
            D   年中的天数   Number
            d   月份中的天数  Number
            a   Am/pm 标记    Text 
            H   一天中的小时数（0-23）
            h   am/pm 中的小时数（1-12）
            m   小时中的分钟数 Number 
            s   分钟中的秒数  Number 
            S   毫秒数 Number 

        扩展：日期的比较，不能直接使用 > 或者 <
            // 方式一：getTime方法，比较两个日期的毫秒数大小
            long time1 = date1.getTime();
            long time2 = date2.getTime();
            if (time1 > time2) {
                System.out.println("date2 在 date1 之前");
            } else {
                System.out.println("date2 在 date1 之后");
            }
            
            // 方式二：使用before方法，或者after方法
            if(date2.before(date1)){
                System.out.println("date2 在 date1 之前");
            } else {
                System.out.println("date2 在 date1 之后");
            }

        	// 当前时间加1个小时
            Date date3 = new Date();
            System.out.println(sdf.format(date3));
            long time3 = date3.getTime();
            time3 += 60*60*1000;
            Date date4 = new Date(time3);
            System.out.println(sdf.format(date4));

2）日历Calendar类，java.util.Calendar    
        用于设置和获取日期/时间数据的特定部分

    示例：
        // 创建一个代表系统当前日期的Calendar对象
        Calendar calendar = Calendar.getInstance();//默认是当前日期

    方法或属性：
        int get(int field) -- 返回给定日历字段的值
        // 获取年
        int year = calendar.get(Calendar.YEAR);
 
        // 获取月，这里需要需要月份的范围为0~11，因此获取月份的时候需要+1才是当前月份值
        int month = calendar.get(Calendar.MONTH) + 1;
 
        // 获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
 
        // 获取时
        int hour = calendar.get(Calendar.HOUR);
        // int hour = calendar.get(Calendar.HOUR_OF_DAY); // 24小时表示
 
        // 获取分
        int minute = calendar.get(Calendar.MINUTE);
 
        // 获取秒
        int second = calendar.get(Calendar.SECOND);
 
        // 星期，英语国家星期从星期日开始计算
        int weekday = calendar.get(Calendar.DAY_OF_WEEK);

    设置指定日期：
        // 首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。
        // 创建一个Calendar对象
        Calendar c1 = Calendar.getInstance();
        // 单独设置：
        c1.set(Calendar.YEAR, 2017);
        // 通过日历类获取当前日期对象
        Date date = calendar.getTime();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(sdf.format(date));
 
    Calendar和Date之间的转换：
        1）Calendar转Date
            // Calendar-->Date
            Calendar calendar = Calendar.getInstance();  
            Date time = calendar.getTime();

        2）Date转Calendar
            // 日历类和日期类型的转换
            String str1 = "2010-10-01 11:11:11";
            Date date2 = null;
            try {
                date2 = sdf.parse(str1);
                System.out.println(date2);
            } catch (ParseException e) {
                e.printStackTrace();
            }

            // 通过setTime方法，将日期类转换为日历类
            Calendar calendar2 = Calendar.getInstance();
            calendar2.setTime(date2);
            // 获取当前多少周
            int weeks = calendar.get(Calendar.WEEK_OF_YEAR);
            System.out.println("当前周数：" + weeks);

        // 通过日历类，当前时间加一个小时
            Calendar calendar3 = Calendar.getInstance();
            calendar3.add(Calendar.HOUR, 1);
            System.out.println(sdf.format(calendar3.getTime()));