6 Java常用类

6.1 字符串

6.1.1 特点

  • 相关的类有：

    • java.lang.String
    • java.lang.StringBuilder
    • java.lang.StringBuffer

  • String:

    • 底层使用final修饰的char数组进行存储（private final char value[];）
    • 表示不可变的字符序列，字符串是常量，它们的值在创建后不能被更改
    • 双引号标识的一串字符串就是该类的一个对象
    • 字符串常量池（JDK7.0及之后在堆中，之前在方法区）用来保存字符串常量
    • String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象

  • StringBuilder，StringBuffer:（JDK1.5引入）

    • 相同点：

      • 底层使用char数组进行存储（char[] value;），默认是一个包含16个字符的数组new char[16];
      • 表示可变的字符序列，字符串缓冲区，一个类似于String的字符串缓冲区，可以被修改
      • 进行字符串拼接时，直接在数组中加入新内容，StringBuilder&StringBuffer会自动维护数组的扩容，不会创建新对象
      • 通过toString()方法，StringBuilder&StringBuffer对象将会转换为不可变的String对象

    • 不同点

      • StringBuilder：线程不安全，效率高
      • StringBuffer：线程安全，效率低

6.1.2 代码示例

  1. /**
  2.  * 字符串类
  3.  */
  4. public class StringTest {
  5.     public static void main(String[] args) {
  6.         String str = "abc";                     // 存在于字符串常量池中
  7.         String str1 = new String("abc"); // 存在于堆中的对象
  9.         String str2 = "abc";                    // 会从字符串常量池中寻找相同的字符串
  11.         System.out.println(str == str2);        // true  都是同一个常量池的引用
  12.         System.out.println(str == str1);        // false 一个在堆中，一个在常量池，属于不同的引用
  13.         System.out.println(str.equals(str1));   // true   String类重写了equals方法来进行字符串的比较
  15.         /*
  16.          * intern() 是一个本地方法
  17.          * 作用：如果常量池中有与当前字符串equals的字符串，返回常量池中的字符串的引用，
  18.          *      如果常量池中没有与当前equals的字符串，则将当前字符串添加到常量池并返回这个字符串的引用
  19.          * 注意：JDK6.0中比较都是false，因为字符串常量池不在堆中，在Perm区（持久代，即方法区），所以执行intern()方法后也不会相同
  20.          */
  21.         String cc = "33";   // 先定义cc，将"33"放入常量池
  22.         String str3 = new String("3")+new String("3"); // 堆中的对象
  23.         String aaa = str3.intern();  // 如果常量池中存在，返回常量池的字符串，如果没有，将字符串加入常量池，返回字符串引用
  24. //        str3.intern();
  25.         System.out.println(str3);
  27. //        String cc = "33";  // 后定义cc，此时常量池中已存在str3与”33“相同，这是就会拿到同一个引用
  29.         System.out.println(cc == str3);  // 先定义cc： false     后定义cc：true
  30.         System.out.println(cc == aaa);   // 先定义cc： true      后定义cc：true
  31.     }
  32. }
  1. /**
  2.  * 字符串常用操作
  3.  */
  4. public class StringOperation {
  5.     public static void main(String[] args) throws UnsupportedEncodingException {
  7.         char[] chr = {'a','b','c'};
  9.         // 将char数组转成字符串
  10.         String s = new String(chr);
  11.         System.out.println("1. 将char数组转成字符串: " + s);
  13.         byte[] bt = {97,98,99,100,101};
  15.         // 将byte数组转成字符串
  16.         String s1 = new String(bt);
  17.         System.out.println("2. 将byte数组转成字符串: " + s1);
  19.         // 截取数组中某一部分转成字符串
  20.         String s2 = new String(bt,2,2);
  21.         System.out.println("3. 截取数组中某一部分转成字符串: " + s2);
  23.         // 如果截取的长度或者下标超出范围，报异常：StringIndexOutOfBoundsException
  24. //        String sch2 = new String(chr,3,1);
  26.         String s3 = new String("abcdef");
  27.         // charAt(index): 获取字符串中某个字符，下标方式
  28.         char ch = s3.charAt(0);
  29.         System.out.println("4. charAt: " + ch);
  31.         // toCharArray(): 将字符串转换成char数组
  32.         char[] chs = s3.toCharArray();
  33.         System.out.println("5. toCharArray: "+ chs + " : " + Arrays.toString(chs));
  35.         String s4 = new String("abcd");
  36.         /*
  37.          * compareTo()方法
  38.          * 英文 且长度不等
  39.          *      字符一样，返回两个长度相减的值
  40.          *      长度不一样，前几个字符也不一样，从第一个开始找，找到不一样的字符，返回这两个字符比较的值
  41.          * 英文 且长度相等
  42.          *      一个字符：ascii 值相减
  43.          *      多个字符：第一个字符不同则直接比较第一个字符，第一个字符相同,则直接比较第二个字符，以此类推
  44.          */
  45.         int num = s3.compareTo(s4);
  46.         System.out.println("6. compareTo: "+num);
  48.         // 字符串拼接  concat
  49.         String s5 = s3.concat(s4);
  50.         System.out.println("7. concat: " + s5);
  53.         String s6 = "abc.doc";
  54.         String s7 = "ac";
  55.         // startsWith()/endsWith(): 判断是否以某个字符串开头和结尾
  56.         boolean bn = s6.startsWith(s7);
  57.         boolean bn1 = s6.endsWith(s7);
  58.         System.out.println("8. startsWith: " + bn);
  59.         System.out.println("9. endsWith: " + bn1);
  61.         String s8 = new String("abc");
  62.         String s9 = new String("ABC");
  64.         // equals()/equalsIgnoreCase(): 判断两个字符串是否相等（不忽略大小写，忽略大小写）
  65.         System.out.println("10. 大小写："+s8.equals(s9));
  66.         System.out.println("11. 忽略大小写："+s8.equalsIgnoreCase(s9));
  68.         // getBytes(): 将字符串转换成byte数组
  69.         byte[] bt1 = s8.getBytes();
  70.         System.out.println("12. getBytes: " + bt1 + " : " + Arrays.toString(bt1));  // [97, 98, 99]
  72.         /*
  73.          * getBytes(charsetName): 通常使用这个进行字符编码的转换
  74.          * idea设置默认编码为UTF8 将编码转成 GBK
  75.          */
  76.         String name = "李";
  77.         byte[] bname = name.getBytes("GBK");
  78.         System.out.println("13. getBytes()           转换前的编码: " + Arrays.toString(name.getBytes()));
  79.         System.out.println("14. getBytes(charsetName)转换后的编码: " + Arrays.toString(bname));
  81.         String s10 = new String("ABCABCABC");
  82.         // indexOf(str/int): 返回第一个匹配到的下标
  83.         System.out.println("15. indexOf(int): " + s10.indexOf(67));
  84.         int in = s10.indexOf("A");
  85.         System.out.println("16. indexOf(str): " + in);
  87.         // indexOf(str, fromindex):从某个位置开始匹配
  88.         int in2 = s10.indexOf("A",4);
  89.         System.out.println("17. indexOf(str, fromindex): " + in2);
  91.         // -1 :代表没有匹配到相应的数据
  92.         int in3 = s10.indexOf("d");
  93.         System.out.println("18. indexOf匹配不到: " + in3);
  95.         // lastIndexOf(str)：从后往前匹配
  96.         int in4 = s10.lastIndexOf("A");
  97.         System.out.println("19. lastIndexOf: " + in4);
  99.         // isEmpty(): 是否为空
  100.         boolean bn2 = s10.isEmpty();
  101.         System.out.println("20. isEmpty: " + bn2);
  103.         // length(): 字符串长度
  104.         int length = s10.length();
  105.         System.out.println("21. length: " + length);
  107.         // replace(oldChar, newChar): 用新的字符替换掉旧的字符，如替换手机号码等 177*****365
  108.         String s11 = s10.replace('A','a');
  109.         System.out.println("22. replace: " + s11);
  111.         // substring(beginIndex): 字符串截取，从beginIndex位置开始
  112.         String s12 = s10.substring(2);
  113.         System.out.println("23. substring(beginIndex): " + s12);
  115.         // substring(beginIndex, endIndex): 截取字符串，从beginIndex位置开始，到endIndex位置结束
  116.         String s13 = s10.substring(2,4);
  117.         System.out.println("24. substring(beginIndex, endIndex): " + s13);
  119.         // 大小写转换  toLowerCase：小写   toUpperCase：大写
  120.         String s14 = s10.toLowerCase(); // 小写
  121.         System.out.println("25. toLowerCase: " + s14);
  123.         // valueOf(): 其他类型转转成String类型方法
  124.         boolean bn3 = true;
  125.         String s15 = String.valueOf(bn3);
  126.         System.out.println("26. valueOf: " + s15);
  128.         // 字符串加法（连接字符串）
  129.         String s16 = s15+123;
  130.         System.out.println("27. 数字与字符串加法（连接字符串）: " + s16);
  132.         int aaa = 3333;
  133.         String s17 = aaa + "";
  134.         System.out.println("28. 数字与空字符串加法（连接字符串）: " + s17);
  136.         String s18 = 2222 + "";
  137. //        System.out.println(s17 - s18); // 只能做加法，不能做其他运算
  139.         // trim(): 返回一个去掉字符串开头和结尾空格的字符串
  140.         String s19 = "  abc def  ";
  141.         System.out.println("29. trim(): " + s19.trim());
  143.         /*
  144.          * split(regex): 按照指定的字符串或正则表达式将字符串进行分割，返回String[]
  145.          * split(regex, limit): 按照regex分割，且返回limit长度的字符串数组
  146.          */
  147.         String s20 = "1988-05-29";
  148.         s20 = "1988-05--29-";
  149.         s20 = "-1988-05--29-";
  150.         String[] sarr = s20.split("-");
  151.         String[] sarr1 = s20.split("-", 5);
  152.         System.out.println(Arrays.toString(sarr) + " length: " + sarr.length);
  153.         System.out.println(Arrays.toString(sarr1) + " length: " + sarr1.length);
  154.         System.out.println("**" + sarr1[4] + "##"); // 空字符串 ""
  155.     }
  156. }
  1. /**
  2.  * StringBuffer使用
  3.  * StringBuffer与StringBuilder方法类似，这里使用StringBuffer类来举例说明常用方法
  4.  */
  5. public class StringBufferTest {
  6.     public static void main(String[] args) {
  7.         // 拼接字符串，通常可以使用“+”号，但是每次在内存中都会产生新的对象，造成不必要的浪费
  8.         String a = "abc"; // 第1个字符串常量 "abc"
  9.         String b = "123"; // 第2个字符串常量 "123"
  10.         a = a + b;        // 第3个字符串常量 "abc123"，并不会改变 "abc" 或者 "123"
  12.         // 创建无参数实例
  13.         new StringBuffer();
  14.         new StringBuilder();
  15.         // 创建有参数实例
  16.         new StringBuffer("abc");
  17.         // 创建指定容量大小的实例，默认是16
  18.         new StringBuffer(32);
  19.         /*
  20.          * 通过制定的字符序列创建 StringBuffer(CharSequence seq),
  21.          * String, StringBuffer, StringBuilder 都是 CharSequence 接口的子类
  22.          */
  23.         new StringBuffer(new StringBuffer("abc"));
  25.         StringBuffer s = new StringBuffer("you ");
  26.         // append(任意类型...): 添加任意类型数据的字符串形式，并返回当前对象自身
  27.         StringBuffer s1 = s.append("are ");
  28. //        s.append(123);
  29. //        s.append(true);
  31.         System.out.println("1. append(...): " + s);       // Hello world
  32.         System.out.println("2. append(...): " + s1);      // Hello world
  33.         System.out.println(s == s1); // true
  35.         // 链式调用，可以一直.append
  36.         StringBuffer s2 = s.append("a ").append("good ").append("boy.");
  38.         // insert(下标，内容): 在某个位置添加内容
  39.         s.insert(1,"...");
  40.         System.out.println("3. insert(offset, str): " + s);
  42.         // delete(start, end): 删除从start开始到end结束，[start,end)区间的内容，不包括end位置的元素
  43.         s.delete(1, 4);
  44.         System.out.println("4. delete(start, end): " + s);
  46.         // deleteCharAt(index): 删除[index]位置的内容
  47.         s.deleteCharAt(1);
  48.         System.out.println("5. deleteCharAt(index): " + s);
  50.         // insert(offset, 内容): 在指定位置插入内容
  51.         s.insert(1, 'o');
  52.         System.out.println("6. insert(offset, 内容): " + s);
  54.         // replace(start, end, str): 把[start,end)位置替换为str
  55.         s.replace(10, 14, "bad");
  56.         System.out.println("7. replace(start, end, str): " + s);
  58.         //setCharAt(index, ch): 替换[index]位置的字符为ch
  59.         s.setCharAt(0, 'Y');
  60.         System.out.println("8. setCharAt(index, ch): " + s);
  62.         // setLength(newLength): 重新设置缓存的长度为newLength
  63.         s.setLength(15);
  64.         System.out.println("9. setLength(newLength): " + s);
  66.         /*
  67.          * substring(start): 返回一个从start开始的字符串常量
  68.          * substring(start, end): 返回一个从start开始到end结束，[start, end)，不包括end，的字符串常量
  69.          */
  70.         String subStr = s.substring(2);
  71.         String subStr2 = s.substring(2, 5);
  72.         System.out.println("10. substring(start): " + subStr);
  73.         System.out.println("11. substring(start, end): " + subStr2);
  75.         /*
  76.          * indexOf(str): 获取某个字符串第一次出现的顺序
  77.          * indexOf(str, fromIndex): 获取某个字符串从fromIndex开始往后数第一次出现的顺序
  78.          * lastIndexOf(str): 从后往前...
  79.          * lastIndexOf(str, fromIndex): 从后往前...
  80.          */
  81.         int index = s.indexOf("a");
  82.         int index2 = s.indexOf("a", 9);
  83.         int lindex = s.lastIndexOf("a");
  84.         int lindex2 = s.lastIndexOf("a", 10);
  86.         System.out.println("12. indexOf(str): " + index);
  87.         System.out.println("13. indexOf(str, fromIndex): " + index2);
  88.         System.out.println("14. lastIndexOf(str): " + lindex);
  89.         System.out.println("15. lastIndexOf(str, fromIndex): " + lindex2);
  91.         // reverse(): 字符串反转
  92.         s.reverse();
  93.         System.out.println("16. reverse(): " + s);
  95.         // 通过toString方法，StringBuilder对象将会转换为不可变的String对象
  96.         String toStr = s.toString();
  97.         System.out.println("17. toString(): " + toStr);
  98.     }
  99. }
  1. /**
  2.  * 执行效率测试 String, StringBuilder, StringBuffer
  3.  */
  4. public class StringExecutionEfficiencyTest {
  5.     public static final String HOPE = "希望是这个世界上最宝贵的东西。";
  6.     public static void main(String[] args) {
  7.         /*
  8.          * 测试字符串拼接
  9.          * String 效率最慢
  10.          * StringBuilder, StringBuffer 次数越多，区别越大
  11.          */
  12.         testString();        // 10000次：   820ms
  13.         testStringBuffer();  // 10000000次：341ms
  14.         testStringBuilder(); // 10000000次：202ms
  15.     }
  17.     public static void testString(){
  18.         long start = System.currentTimeMillis(); // 当前系统时间毫秒数
  19.         String str = "";
  20.         for (int i = 0; i < 10000; i++) {
  21.             str = str + HOPE;
  22.         }
  23.         long end = System.currentTimeMillis();
  24.         System.out.println("String+ :"+ (end - start));
  25.     }
  27.     public static void testStringBuffer(){
  28.         long start = System.currentTimeMillis();
  29.         StringBuffer str = new StringBuffer("");
  30.         for (int i = 0; i < 10000000; i++) {
  31.             str = str.append(HOPE);
  32.         }
  33.         long end = System.currentTimeMillis();
  34.         System.out.println("StringBuffer :"+ (end - start));
  35.     }
  37.     public static void testStringBuilder(){
  38.         long start = System.currentTimeMillis();
  39.         StringBuilder str = new StringBuilder("");
  40.         for (int i = 0; i < 10000000; i++) {
  41.             str = str.append(HOPE);
  42.         }
  43.         long end = System.currentTimeMillis();
  44.         System.out.println("StringBuilder :"+ (end - start));
  45.     }
  46. }

6.2 包装类

6.2.1 基本数据类型相关的包装类

字节型 短整型 整型 长整型 单精度浮点 双精度浮点 字符型 布尔型 默认值
基本数
据类型		 byte short int long float double char boolean 0、空格、false
包装类 Byte Short Integer Long Float Double Character Boolean null

6.2.2 特点

  • 自动装箱：基本数据类型 —> 包装类，例如：Integer a = 1; // int -> Integer
  • 自动拆箱：包装类 —> 基本数据类型，例如：int c = a; // Integet -> int

  • 包装类型是为了方便对基本数据类型进行操作，包装类型可以解决一些基本类型解决不了的问题：

    • 基本类型可以和包装类型直接相互转换，自动装箱拆箱
    • 传递参数时，如果函数的参数是引用数据类型而不是基本数据类型，则可以使用包装类
    • 集合不允许存放基本数据类型，只能存放应用数据类型
    • 包装类中提供了常用的对基本数据类型的操作方法，可以很方便使用，如通过包装类型的parse()方法可以实现基本数据类型和String类型之间的相互转换等等

6.2.3 代码示例

  1. /**
  2.  * 包装类
  3.  */
  4. public class Wrapper {
  5.     public static void main(String[] args) {
  6.         test();
  7.         test1();
  8.         test2();
  9.     }
  10.     public static void test(){
  11.         int mima = 123456;
  12.         String str = String.valueOf(mima);
  13.         System.out.println(str);
  15.         String str1 = Integer.toString(mima);
  16.         System.out.println(str1);
  17.     }
  19.     public static void test1(){
  20.         int a = 123;
  21.         Integer a1 = new Integer(a);
  22.         Integer a2 = Integer.valueOf(a);
  24.         Integer a3 = a;  // 自动包装   new Integer(a);
  25.         int b = a3.intValue(); // 返回int类型数据
  27.         int b1 = a3;  // 自动拆箱   intValue();
  28.         System.out.println(b1);
  29.     }
  31.     // 异常： NumberFormatException
  32.     public static void test2(){
  33.         String abc = "a123456";
  34.         Integer integer = Integer.valueOf(abc);
  35.         System.out.println(integer);
  37.         int in = Integer.parseInt(abc);
  38.         System.out.println(in);
  39.     }
  40. }

6.3 枚举

6.3.1 特点

  • 相关的类有：java.lang.Enum

  • 枚举是JDK1.5引入的新特性，通过关键字enum来定义枚举类

  • 枚举类是一种特殊类，它和普通类一样可以使用构造器、定义成员变量和方法，也能实现一个或多个接口

  • 枚举类不能继承其他类，他已默认继承Enum类（Java只支持单继承）

  • 枚举类不能被继承（默认被final修饰）

  • 枚举类是线程安全的

  • 枚举类型是类型安全的(typesafe)

6.3.2 代码示例

  1. /**
  2.  * 普通类方式定义常量
  3.  */
  4. public class Genders {
  5.     public static final int MAN = 0;
  6.     public static final int WOMAN = 1;
  7.     public static final int UNKNOWN = 2;
  8. }
  1. /**
  2.  * 定义枚举类，使用 enum 代替 class，定义更简洁
  3.  */
  4. public enum GenderEnum {
  5.     MAN, WOMAN, UNKNOWN
  6. }
  1. /**
  2.  * 枚举类常量可以是对象
  3.  */
  4. public enum Gender1Enum {
  5.     MAN{},
  6.     WOMAN{},
  7.     UNKNOWN{}
  8. }
  1. /**
  2.  * 在枚举类中使用抽象方法
  3.  */
  4. public enum Gender2Enum {
  5.     MAN{
  6.         @Override
  7.         public String getInfo() {
  8.             return "男性";
  9.         }
  10.     }, WOMAN{
  11.         @Override
  12.         public String getInfo() {
  13.             return "女性";
  14.         }
  15.     }, UNKNOWN{
  16.         @Override
  17.         public String getInfo() {
  18.             return "未知";
  19.         }
  20.     };
  22.     /**
  23.      * 定义抽象方法
  24.      * @return String
  25.      */
  26.     public abstract String getInfo();
  27. }
  1. /**
  2.  * 定义枚举类其他内容
  3.  */
  4. public enum Gender3Enum implements Runnable { // 可以实现接口
  5.     // 带参数的枚举常量，括号中的参数对应的是我们自定义的变量，本例中参数是私有变量(info, i)
  6.     MAN("男",1),
  7.     WOMAN("女",2),
  8.     UNKNOWN("未知",3); // 枚举类型定义必须写在最上面，如果后面有其他非枚举成员，则最后使用分号结尾
  10.     // 添加私有变量
  11.     private String info;
  12.     private int i;
  14.     // 可以自定义构造函数，默认是private
  15.     Gender3Enum(String info,int i) {
  16.         this.info = info;
  17.         this.i = i;
  18.     }
  20.     // 可以重写父类方法
  21.     @Override
  22.     public String toString() {
  23.         return "info=" + info + ", i=" + i;
  24.     }
  26.     // 可以实现接口方法
  27.     @Override
  28.     public void run() {
  29.     }
  30. }
  1. /**
  2.  * 枚举类
  3.  */
  4. public class EnumTest {
  5.     public static void main(String[] args) throws Exception {
  6.         testEnumConst();
  7.         testEnumMethods();
  8.         testEnumSwitch(GenderEnum.MAN);
  9.         testEnumGetClass();
  10.         testEnumAbstractMethod();
  11.         testEnumToString();
  12.         testEnumReflect();
  13.     }
  15.     /**
  16.      * 获取枚举类常量
  17.      */
  18.     public static void testEnumConst() {
  19.         // 调用普通类静态常量
  20.         System.out.println(Genders.MAN);    // 0
  21.         // 使用枚举类，直接通过类名调用
  22.         System.out.println(GenderEnum.MAN); // MAN
  23.     }
  25.     /**
  26.      * 枚举类常用方法
  27.      */
  28.     public static void testEnumMethods() {
  29.         // 返回枚举类型 name
  30.         System.out.println(GenderEnum.MAN.name());          // MAN
  31.         System.out.println(GenderEnum.MAN.toString());      // MAN
  32.         // 返回枚举类型序数，通常不使用
  33.         System.out.println(GenderEnum.WOMAN.ordinal());     // 1
  35.         // 比较大小（底层比较的是序数的大小）
  36.         int i = GenderEnum.MAN.compareTo(GenderEnum.WOMAN);
  37.         System.out.println(i);                              // -1
  39.         // 判断是否相等，底层使用 == 判断
  40.         boolean eq = GenderEnum.MAN.equals(GenderEnum.MAN);
  41.         System.out.println(eq);                             // true
  43.         // 根据 name 获取枚举对象
  44.         GenderEnum gender = GenderEnum.valueOf("MAN");
  45.         System.out.println(gender);                         // MAN
  46.     }
  48.     /**
  49.      * 在switch case中使用枚举
  50.      * @param gender
  51.      */
  52.     public static void testEnumSwitch(GenderEnum gender) {
  53.         switch (gender) {
  54.             case MAN: // 不需要 gender 的引用，直接 case 枚举类型
  55.                 System.out.println("man"); break;    // man
  56.             case WOMAN:
  57.                 System.out.println("woman"); break;
  58.             case UNKNOWN:
  59.                 System.out.println("unknown"); break;
  60.         }
  61.     }
  63.     /**
  64.      * 获取枚举类的类型
  65.      */
  66.     public static void testEnumGetClass() {
  67.         /*
  68.          * 当枚举类参数是一个类时，如：enum Gender { MAN{}, WOMAN{}, UNKNOWN{} }，
  69.          * 此时：Gender.WOMEN.getDeclaringClass(); 返回数据为：*.Gender
  70.          *      Gender.WOMEN.getClass();          返回数据为：*.Gender1$2
  71.          * 所以如果是获取枚举类类型信息，建议使用 getDeclaringClass() 方法
  72.          */
  73.         Class cls = GenderEnum.WOMAN.getDeclaringClass();
  74.         Class cls1 = Gender1Enum.WOMAN.getClass();
  75.         System.out.println(cls);  // class cn.com.liyanlong......GenderEnum
  76.         System.out.println(cls1); // class cn.com.liyanlong......Gender1Enum$2
  77.     }
  79.     /**
  80.      * 测试枚举类中的抽象方法
  81.      */
  82.     public static void testEnumAbstractMethod() {
  83.         System.out.println(Gender2Enum.MAN.getInfo());     // 男性
  84.         System.out.println(Gender2Enum.WOMAN.getInfo());   // 女性
  85.         System.out.println(Gender2Enum.UNKNOWN.getInfo()); // 未知
  86.     }
  88.     /**
  89.      * 测试获取枚举自定义变量
  90.      */
  91.     public static void testEnumToString() {
  92.         for (Gender3Enum value : Gender3Enum.values()) {
  93.             System.out.println("value: " + value
  94.                     + "\t\tname: " + value.name()
  95.                     + "\t\ttoString: " + value.toString());
  96.         }
  97.         /*
  98.          * value: 男        name: MAN        toString: info=男, i=1
  99.          * value: 女        name: WOMAN        toString: info=女, i=2
  100.          * value: 未知        name: UNKNOWN    toString: info=未知, i=3
  101.          */
  102.     }
  104.     /**
  105.      * 测试，不可以通过反射方式获取枚举类实例
  106.      * @throws Exception
  107.      */
  108.     public static void testEnumReflect() throws Exception{
  109.         // 获取类对象
  110.         Class<?> cls = Class.forName("cn.com.liyanlong.java.javase._09_frequently_used_classes.enum_class.GenderEnum");
  111.         // 获取 color 的构造函数
  112.         Constructor<?> constructor = cls.getDeclaredConstructor(String.class, int.class);
  113.         // 获取私有变量访问权限
  114.         constructor.setAccessible(true);
  115.         // 实例化
  116.         Object reflectGender = constructor.newInstance("MAN", 0);
  118.         /*
  119.          * 报错信息：
  120.          * Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
  121.          *  at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
  122.          *  ......
  123.          */
  124.     }
  125. }
  1. # 可以使用javap（反编译class得到汇编）或者jad（反编译class）查看反编译后的内容，可以看到我们的枚举类自动继承了Enum类
  3. # 用jad反编译并生成反编译后的java文件（推荐）
  4. >jad -sjava GenderEnum.class
  6. # 用javap命令可以查看一个java类反汇编、常量池、变量表、指令代码行号表等信息
  7. >javap -c -l GenderEnum.class
  9. # jad工具下载地址：https://varaneckas.com/jad/jad158g.win.zip，下载后将jad.exe文件放入环境变量中就可以使用了
  10. # Java虚拟机指令集：https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html
  11. # javap命令详解：https://docs.oracle.com/javase/8/docs/technotes/tools/windows/javap.html
  1. // 使用jad命令反编译后的代码
  2. // 这里默认使用final修饰，所以枚举类不能被继承
  3. public final class GenderEnum extends Enum
  4. {
  5.     // 这个方法返回原数组的副本，为了避免返回的数组内容被修改而引起内部值的改变，Enum类中没有此方法
  6.     public static GenderEnum[] values()
  7.     {
  8.         return (GenderEnum[])$VALUES.clone();
  9.     }
  11.     // 通过name来获取枚举实例
  12.     public static GenderEnum valueOf(String name)
  13.     {
  14.         return (GenderEnum)Enum.valueOf(cn/com/liyanlong/java/javase/_09_frequently_used_classes/enum_class/GenderEnum, name);
  16.     // 私有构造函数，不能new对象，自动生成
  17.     private GenderEnum(String s, int i)
  18.     {
  19.         super(s, i);
  20.     }
  22.     // 我们自己声明的枚举常量，都对应一个枚举类实例，且是static final修饰的常量
  23.     public static final GenderEnum MAN;
  24.     public static final GenderEnum WOMEN;
  25.     public static final GenderEnum UNKNOW;
  27.     // 成员变量$VALUES[]包含所有定义的枚举常量，可以通过values()方法获取
  28.     private static final GenderEnum $VALUES[];
  30.     // 静态初始化代码块，说明在类加载阶段就被实例化了，jvm能够保证类加载线程安全，且自动按照我们写的顺序添加序数，从0开始
  31.     sstatic 
  32.     {
  33.         MAN = new GenderEnum("MAN", 0);
  34.         WOMAN = new GenderEnum("WOMAN", 1);
  35.         UNKNOWN = new GenderEnum("UNKNOWN", 2);
  36.         $VALUES = (new GenderEnum[] {
  37.             MAN, WOMAN, UNKNOWN
  38.         });
  39.     }
  40. }
  1. // 普通定义常量类反编译后，所以枚举类编译后，占用的内存稍微多一些
  2. public class Genders
  3. {
  5.     public Genders()
  6.     {
  7.     }
  9.     public static final int MAN = 0;
  10.     public static final int WOMAN = 1;
  11.     public static final int UNKNOWN = 2;
  12. }
  1. // 1. 枚举类不能被克隆，这是Enum类的clone()方法说明
  2.     /**
  3.      * Throws CloneNotSupportedException.  This guarantees that enums
  4.      * are never cloned, which is necessary to preserve their "singleton"
  5.      * status.
  6.      *
  7.      * @return (never returns)
  8.      */
  9.     protected final Object clone() throws CloneNotSupportedException {
  10.         throw new CloneNotSupportedException();
  11.     }
  13. // 2. 枚举类比较大小的方法最终比较的是初始化枚举类实例的时候自动添加的序数
  14.     /**
  15.      * Compares this enum with the specified object for order.  Returns a
  16.      * negative integer, zero, or a positive integer as this object is less
  17.      * than, equal to, or greater than the specified object.
  18.      *
  19.      * Enum constants are only comparable to other enum constants of the
  20.      * same enum type.  The natural order implemented by this
  21.      * method is the order in which the constants are declared.
  22.      */
  23.     public final int compareTo(E o) {
  24.         Enum<?> other = (Enum<?>)o;
  25.         Enum<E> self = this;
  26.         if (self.getClass() != other.getClass() && // optimization
  27.             self.getDeclaringClass() != other.getDeclaringClass())
  28.             throw new ClassCastException();
  29.         return self.ordinal - other.ordinal;
  30.     }

6.4 数学计算

6.4.1 特点

  • 相关的类有：java.lang.Math

  • Math类封装了与数学运算相关的一些属性和方法

6.4.2 代码示例

  1. /**
  2.  * 数学计算相关类 Math
  3.  */
  4. public class MathTest {
  5.     public static void main(String[] args) {
  7.         // 自然对数的底数(或称为基数)
  8.         double e = Math.E;
  9.         System.out.println(e);               // 2.718281828459045
  11.         // 圆周率
  12.         System.out.println(Math.PI);         // 3.141592653589793
  14.         // 求绝对值
  15.         double abs = Math.abs(-10.1);
  16.         System.out.println(abs);              // 10.1
  18.         // 求最大值
  19.         double max = Math.max(100,99.9);
  20.         System.out.println(max);               // 100.00
  22.         // 求最小值
  23.         System.out.println(Math.min(1, 2));    // 1
  25.         // Math.pow(x, y): 返回 x的y次幂
  26.         System.out.println(Math.pow(2, 3));    // 2³ = 8.0
  28.         // Math.scalb(x, y): x*(2的y次幂）
  29.         System.out.println(Math.scalb(3, 3));  // 3*2³ = 24.0
  31.         // Math.ceil(x): 向上取整
  32.         System.out.println(Math.ceil(10.1));   // 11.0
  33.         System.out.println(Math.ceil(-10.1));  // -10.0
  35.         // Math.floor(x): 向下取整
  36.         System.out.println(Math.floor(10.1));  // 10.0
  37.         System.out.println(Math.floor(-10.1)); // -11.0
  39.         // Math.hypot(x, y): x和y平方和的二次方根，√（x²+y²）
  40.         System.out.println(Math.hypot(2, 2));  // 2.8284271247461903
  42.         // Math.sqrt(x): 求二次方根，
  43.         System.out.println(Math.sqrt(9));      //3.0
  44.         System.out.println(Math.sqrt(16));     //4.0
  46.         // Math.cbrt(x): 求立方根
  47.         System.out.println(Math.cbrt(27.0));   //3.0
  48.         System.out.println(Math.cbrt(-64.0));  //-4.0
  50.         // Math.log(): 对数函数
  51.         System.out.println(Math.log(e));       // 1 以e为底的对数
  52.         System.out.println(Math.log10(100));   // 10 以10为底的对数
  53. //        Math.log1p(x);                       // Ln（x+ 1）
  55.         // Math.random(): 随机数，范围：[0,1)
  56.         double random = Math.random();
  57.         System.out.println(random);            // 0.6724380240187329
  58.         // 例：100以内随机数
  59.         int r = (int) (random * 100);
  60.         System.out.println(r);                 // 67
  62.         // Math.rint(x): 返回最接近这个数的整数,如果刚好居中，则取偶数
  63.         System.out.println(Math.rint(10.1));   // 10.0
  64.         System.out.println(Math.rint(-10.1));  // -10.0
  65.         System.out.println(Math.rint(10.9));   // 11.0
  66.         System.out.println(Math.rint(-10.9));  // -11.0
  67.         System.out.println(Math.rint(10.5));   // 10.0
  68.         System.out.println(Math.rint(11.5));   // 12.0
  70.         // Math.round(): 四舍五入
  71.         System.out.println(Math.round(10.5)); // 11 与rint相似，返回值为 long
  72.         System.out.println(Math.round(10.4)); // 10 与rint相似，返回值为 long
  74.         // 三角函数
  75. //        Math.sin(α);                    //sin（α）的值
  76. //        Math.cos(α);                    //cos（α）的值
  77. //        Math.tan(α);                    //tan（α）的值
  79.         // 求角
  80. //        Math.asin(x/z);                 //返回角度值[-π/2，π/2]  arc sin（x/z）
  81. //        Math.acos(y/z);                 //返回角度值[0~π]   arc cos（y/z）
  82. //        Math.atan(y/x);                 //返回角度值[-π/2，π/2]
  83. //        Math.atan2(y-y0, x-x0);         //同上，返回经过点（x，y）与原点的的直线和经过点（x0，y0）与原点的直线之间所成的夹角
  85. //        Math.sinh(x);                   //双曲正弦函数sinh(x)=(exp(x) - exp(-x)) / 2.0;
  86. //        Math.cosh(x);                   //双曲余弦函数cosh(x)=(exp(x) + exp(-x)) / 2.0;
  87. //        Math.tanh(x);                   //tanh(x) = sinh(x) / cosh(x);
  89.         // 角度弧度互换
  90. //        Math.toDegrees(angrad);         //角度转换成弧度，返回：angrad * 180d / PI
  91. //        Math.toRadians(angdeg);         //弧度转换成角度，返回：angdeg / 180d * PI
  92.     }
  93. }

6.5 日期时间

6.5.1 基本概念

  • 时间

  • 日期

  • 时区

  • 本地时间

  • 本地化

  • 夏令时

  • 相关的类有：

    • java.util.Date：日期类（包含日期和时间）
    • java.util.Calendar：日历类
    • java.text.SimpleDateFormat：日期时间格式化类

  • 以上相关类不是final修饰的，可以被改变，线程不安全

  • JDK8-日期时间相关类新曾API

6.5.2 代码示例

  1. /**
  2.  * 日期操作相关类（JDK8之前【了解】）
  3.  * JDK8重新设计了新的时间API，建议使用新的API
  4.  * @see cn.com.liyanlong.java.javase.new_snytax.jdk8.LocalDateTest
  5.  */
  6. public class DateTest {
  7.     public static void main(String[] args) {
  8.         testDate();
  9.         testSimpleDateFormat();
  10.         testCalender();
  11.     }
  13.     /**
  14.      * Date使用
  15.      */
  16.     public static void testDate() {
  17.         Date date = new Date();
  18.         String s = date.toString();
  19.         System.out.println(s);                       // Tue Jun 23 03:16:30 CST 2020
  21.         // 1970年1月1日0时到现在的毫秒数
  22.         long time = date.getTime();
  23.         System.out.println("时间戳：" + time);        // 时间戳：1592885386872
  25.         /*
  26.         Date date1 = new Date(1592854524200L);
  27.         Date date2 = new Date("2020/6/23");          // 过时方法
  29.         System.out.println(date.equals(date1));      // false
  30.         System.out.println(date1.compareTo(date2));  // 1 大于返回1，小于返回-1，等于返回0
  31.         System.out.println(date.before(date1));      // false 在...之前
  32.         System.out.println(date.after(date1));       // true   在...之后
  33.          */
  35.         // 以下方法为已过时方法，不建议使用
  36.         // API问题：年份从1900年开始，月份从0开始（新版API中已修正）
  37.         /*
  38.         System.out.println(date.getYear());           // 120 年份，返回1900年到现在的年数
  39.         System.out.println(date.getMonth());          // 5 月份，实际月份-1
  40.         System.out.println(date.getDate());           // 23
  41.         System.out.println(date.getDay());            // 2
  42.         System.out.println(date.getHours());          // 3
  43.         System.out.println(date.getMinutes());        // 16
  44.         System.out.println(date.getSeconds());        // 30
  45.         System.out.println(date.getTimezoneOffset()); // -480
  46.         System.out.println(date.toLocaleString());    // 1592853935794
  47.          */
  48.     }
  50.     /**
  51.      * SimpleDateFormat：转换日期时间格式，线程不安全
  52.      */
  53.     public static void testSimpleDateFormat() {
  54.         Date date = new Date();
  55.         // 可以自定义格式：如 yyyy-MM-dd， yyyy年MM月dd日 HH:mm:ss
  56.         SimpleDateFormat sdf =
  57.                 new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
  59.         System.out.println(date); // Tue Jun 23 03:42:00 CST 2020
  60.         String str = sdf.format(date);
  61.         System.out.println(str);  // 2020年06月23日 03:42:00
  62.     }
  64.     /**
  65.      * 日历类
  66.      */
  67.     public static void testCalender() {
  68.         // 获取默认时区时间
  69.         Calendar calendar = Calendar.getInstance();
  70.         // 获取固定时区时间 （获取东八区时间）
  71.         Calendar c = Calendar.getInstance(TimeZone.getTimeZone("GMT+08:00"));
  72.         //获取年
  73.         int year = c.get(Calendar.YEAR);
  74.         //获取月份，0表示1月份
  75.         int month = c.get(Calendar.MONTH) + 1;
  76.         //获取当前天数
  77.         int day = c.get(Calendar.DAY_OF_MONTH);
  78.         //获取本月最小天数
  79.         int first = c.getActualMinimum(Calendar.DAY_OF_MONTH);
  80.         //获取本月最大天数
  81.         int last = c.getActualMaximum(Calendar.DAY_OF_MONTH);
  82.         //获取当前小时
  83.         int time = c.get(Calendar.HOUR_OF_DAY);
  84.         //获取当前分钟
  85.         int min = c.get(Calendar.MINUTE);
  86.         //获取当前秒
  87.         int sec = c.get(Calendar.SECOND);
  89.         SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  91.         String curDate = s.format(c.getTime()); //当前日期
  92.         System.out.println(curDate);            // 2020-06-23 11:15:18
  93.         System.out.println("当前时间：" + year + "-" + month + "-" + day + " " + time + ":" + min + ":" + sec);
  94.         System.out.println("本月第一天和最后一天：" + first +"," + last);
  96.         System.out.println("时间戳：" + calendar.getTimeInMillis());
  97.         System.out.println(calendar.getTime());     // Tue Jun 23 11:16:32 CST 2020
  98.         System.out.println(calendar.getTimeZone()); // 获取时区信息
  100.         int ryear = 2024;
  101.         if(ryear%4 == 0 && ryear%100 != 0 || ryear%400 == 0){
  102.             System.out.println("是闰年");
  103.         } else {
  104.             System.out.println("是平年");
  105.         }
  107.         // isLeapYear(year): 判断是否是闰年
  108.         boolean bn = new GregorianCalendar().isLeapYear(ryear);
  109.         System.out.println(bn); // true
  110.     }
  111. }

6.6 文件

6.6.1 特点

6.6.2 代码示例