Java高级特性中的实用类

---

前言

本文讲解一下Java高级特性中一些常用的实用类

---

一、枚举

特点

Java中的枚举是一种特殊的类，用于存放一组常量。使用枚举的好处在于他对应的实例是有限的，限制了实例的范围。举个例子：一年四季只有春夏秋冬，性别只有男女。当我们实例化时，只能引用实例范围内的，保证了数据的安全性。

使用

创建枚举类：

//枚举类
public enum U {
    U1,U2,U3
}

使用枚举：

import java.util.*;
public class UTest {
    public static void main(String[] args) {
        UTest uTest=new UTest();
        uTest.week(U.U1);
    }

    public void week(U u){
        switch (u){
            case U1:
                System.out.println("数学");
                break;
            case U2:
                System.out.println("语文");
                break;
            case U3:
                System.out.println("英语");
                break;
        }
    }
}

二、包装类

1.基本数据类型和封装类

2.特点

1.基本数据类型数据存储相对简单，运算效率比较高
2.封装类满足了java一切皆是对象的思想，在使用集合时必须使用包装类。
3.包装类的默认值为 null，包装类可以区分出未赋值和值为 0 的区别，而数据类型无法表达出未赋值的情况。
4.基本数据类型在传递参数时都是按值传递，封装类都是按引用传递。

3.装箱和拆箱

JDK1.5之后， 新增了 2 个功能：自动装箱、自动拆箱。

自动装箱 ----- 基本类型的值 → 包装类的实例
自动拆箱 ----- 基本类型的值 ← 包装类的实例

代码实现：

public class Main {
    public static void main(String[] args) {         
        Integer i = 10;  //自动装箱
        int n = i;  //自动拆箱
    }
}

4.赋值比较

案例一：

public class Main {
    public static void main(String[] args) {
         
        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;
         
        System.out.println(i1==i2);  //true
        System.out.println(i3==i4);  //false
    }
}

相信大家看到上面的结果肯定很疑惑，为什么i3和i4比较的结果为false，其实这是由于封装类底层的valueOf方法和IntegerCache类的原因，下面我们来看一下底层代码。
valueOf方法：

public static Integer valueOf(int i) {
        if(i >= -128 && i <= IntegerCache.high)
            return IntegerCache.cache[i + 128];
        else
            return new Integer(i);
}

IntegerCache类：

private static class IntegerCache {
        static final int high;
        static final Integer cache[];
 
        static {
            final int low = -128;
 
            // high value may be configured by property
            int h = 127;
            if (integerCacheHighPropValue != null) {
                // Use Long.decode here to avoid invoking methods that
                // require Integer's autoboxing cache to be initialized
                int i = Long.decode(integerCacheHighPropValue).intValue();
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - -low);
            }
            high = h;
 
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }
 
        private IntegerCache() {}
    }

通过上面两段代码我们可以发现，通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用，否则创建一个新的Integer对象。所以i3和i4比较的结果为false也就可以理解了。

案列二：

public class Main {
    public static void main(String[] args) {
         
        Double i1 = 100.0;
        Double i2 = 100.0;
        Double i3 = 200.0;
        Double i4 = 200.0;
         
        System.out.println(i1==i2);  //false
        System.out.println(i3==i4);  //false
    }
}

看到这里小伙伴又有疑问了，怎么这次结果全都为false了。这是因为在某个范围内的整型数值的个数是有限的，而浮点数却不是。我们可以理解为Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。Double、Float的valueOf方法的实现是类似的。

案例三：

public class Main {
    public static void main(String[] args) {
         
        Boolean i1 = false;
        Boolean i2 = false;
        Boolean i3 = true;
        Boolean i4 = true;
         
        System.out.println(i1==i2);  //true
        System.out.println(i3==i4);  //true
    }
}

和以上的原理一样，大家感兴趣的话可以去看一下Boolean底层的valueOf方法。

三、随机数的生成

1.random

// 生成 Random 对象
Random random = new Random();
for (int i = 0; i < 10; i++) {
    // 生成 0-9 随机整数
    int number = random.nextInt(10);
    System.out.println("生成随机数：" + number);
}

2.Math

for (int i = 0; i < 10; i++) {
    // 产生随机数
    double number = Math.random();
    System.out.println("生成随机数：" + number);
}

这里有一个生成指定范围的方法：

//生成[min，max]之间的随机数
int x=(int)(Math.random*(max-min+1)+min);
System.out.println(x);

四、日期操作类

DATE类

对象用来表示日期和时间，该类提供了一系列操作日期和时间各组成部分的方法。

Calendar类

是用来操作日期和时间的类，它是抽象类，可以通过静态方法getInstance()获得Calender类的对象。它的方法如下：

DateFormat类

是一个抽象类，提供了多种格式化和解析时间的方法。使用比较多的是它的子类SimpleDateFormat。

使用

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Date date = new Date();
        SimpleDateFormat formater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("当前时间为"+formater.format(date));
    }
}    

五、String、StringBuffer和StringBuilder

String

不可被改变，真正意义上的安全，在频繁字符串拼接的情况下，速度非常慢。
方法：

str.length();   //求长度
str1.equals(str2);  //字符串的比较，“==”比较的是两个字符串对象在内存中的地址，而equals()比较的是两个字符串对象的值
str1.equalsIgnoreCase(str2);  //忽略大小写比较
str.toLowerCase();  //转小写
str.toUpperCase();  //转大写
str1.concat(str2);  //拼接
.indexOf(int x);  //找出x的下标
.subString(int start,int end);  //从下标为start开始截取，截取到下标为end，包含下标为start的值，不包含下标为end的值

StringBuffer

长度是可变的，线程安全，速度慢。
方法：

.toString()方法
.append()方法
.inset()方法 字符串.insert(位置，参数)
.replace()方法字符串名.replace(int start,int end,String str)

StringBuilder

长度也是可变的，线程不安全，速度快。
方法：

.toString()方法
.append()方法
.inset()方法 字符串.insert(位置，参数)
.replace()方法字符串名.replace(int start,int end,String str)

总结

以上讲解了Java高级特性中一些常用的实用类，可以当作小技巧来使用，其中仍然还有许多需要改进和完善的地方，后续会持续更新。