成员变量与属性的关系

为Person类的中变量和方法

  1. public class Person {
  2.     private String name;
  3.     private int age;
  4.     private String gender;
  6.     public String getName() {
  7.         return name;
  8.     }
  9.     public void setName(String name) {
  10.         this.name = name;
  11.     }
  12.     public int getAge() {
  13.         return age;
  14.     }
  15.     public void setAge(int age) {
  16.         this.age = age;
  17.     }
  18.     public float getHeight() {
  19.         return 1.75f;
  20.     }
  21.     public void setHeight(float height) {
  22.     }
  23. }
  • 3个字段name，age，gender就是成员变量

  • set/get方法名，去掉set/get后，将剩余部分首字母小写得到的字符串就是这个类的属性，即name，age，height就是属性

    监听机制(观察者模式)

  • 事件源：触发事件的对象

  • 事件：要触发的行为，其中封装了事件源
  • 监听器：事件的行为触发了，将要执行的操作

理解案例：
如果我方[水晶]被[摧毁]了，我就[骂队友]
如果敌方[水晶]被[摧毁]了，我就[夸自己]
[水晶]是事件源，[摧毁]是事件，[骂队友][夸自己]是监听器

加密工具

  1. import org.apache.commons.codec.digest.DigestUtils;
  3. String s = DigestUtils.md5Hex("加密内容");

枚举

为什么要引入枚举？
自定义季节变量

  1. public class Season {
  2.     public static final int SEASON_SPRING = 1;
  3.     public static final int SEASON_SUMMER = 2;
  4.     public static final int SEASON_AUTUMN = 3;
  5.     public static final int SEASON_WINTER = 4;
  6. }

问题点
代码不够简洁
不同类型的数据是通过名字区分的
不安全，由于是数字类型，就有可能使用这几个值做一些运算操作;比比如:SEASON_SPRING + SEASON_SUMMER
概述
为了简洁的表示一些固定的值，Java就给我们提供了枚举
枚举是指将变量的值一一列出来，变量的值只限于列举出来的值的范围内
枚举类定义格式

  1. public enum s {
  2.     枚举项1,枚举项2,枚举项3;
  3. }

注意
定义枚举类要用关键字enum
示例代码

  1. // 定义一个枚举类，用来表示春，夏，秋，冬这四个固定值
  2. public enum Season {
  3.     SPRING,SUMMER,AUTUMN,WINTER;
  4. }

特点

  1. 所有枚举类都是Enum的子类
  2. 我们可以通过”枚举类名.枚举项名称”去访问指定的枚举项
  3. 每一个枚举项其实就是该枚举的一个对象
  4. 枚举也是一个类，也可以去定义成员变量
  5. 枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略
  6. 枚举类可以有构造器，但必须是private的，它默认的也是private的，枚举项的用法比较特殊：枚举(“”);
  7. 枚举类也可以有抽象方法，但是枚举项必须重写该方法

方法介绍

方法名 说明
String name() 获取枚举项的名称
int ordinal() 返回枚举项在枚举类中的索引值
int compareTo(E o) 比较两个枚举项，返回的是索引值的差值
String toString() 返回枚举常量的名称
static T valueOf(Class type,String name) 获取指定枚举类中的指定名称的枚举值
values() 获得所有的枚举项

序列化

类进行序列化时，要保证字段均已序列化

集合转数组

集合转String数组

  1. List<String> medias = record.getMedias();
  2. String[] strings = medias.toArray(new String[]{});

单个对象转换程集合

new的对象如何在栈不在堆

开启逃逸分析，如果new的对象，没有在方法外被使用，未发生逃逸，则会在栈上创建，不会触发垃圾回收机制

静态嵌套类与非静态嵌套类的区别

OuterClass.java

  1. public class OuterClass {
  3.     String outerField = "Outer field";
  4.     static String staticOuterField = "Static outer field";
  6.     class InnerClass {
  7.         void accessMembers() {
  8.             System.out.println(outerField);
  9.             System.out.println(staticOuterField);
  10.         }
  11.     }
  13.     static class StaticNestedClass {
  14.         void accessMembers(OuterClass outer) {
  15.             // Compiler error: Cannot make a static reference to the non-static
  16.             //     field outerField
  17.             // System.out.println(outerField);
  18.             System.out.println(outer.outerField);
  19.             System.out.println(staticOuterField);
  20.         }
  21.     }
  23.     public static void main(String[] args) {
  24.         System.out.println("Inner class:");
  25.         System.out.println("------------");
  26.         OuterClass outerObject = new OuterClass();
  27.         OuterClass.InnerClass innerObject = outerObject.new InnerClass();
  28.         innerObject.accessMembers();
  30.         System.out.println("\nStatic nested class:");
  31.         System.out.println("--------------------");
  32.         StaticNestedClass staticNestedObject = new StaticNestedClass();        
  33.         staticNestedObject.accessMembers(outerObject);
  35.         System.out.println("\nTop-level class:");
  36.         System.out.println("--------------------");
  37.         TopLevelClass topLevelObject = new TopLevelClass();        
  38.         topLevelObject.accessMembers(outerObject);                
  39.     }
  40. }

TopLevelClass.java

  1. public class TopLevelClass {
  3.     void accessMembers(OuterClass outer) {     
  4.         // Compiler error: Cannot make a static reference to the non-static
  5.         //     field OuterClass.outerField
  6.         // System.out.println(OuterClass.outerField);
  7.         System.out.println(outer.outerField);
  8.         System.out.println(OuterClass.staticOuterField);
  9.     }  
  10. }

输出结果

  1. Inner class:
  2. ------------
  3. Outer field
  4. Static outer field
  6. Static nested class:
  7. --------------------
  8. Outer field
  9. Static outer field
  11. Top-level class:
  12. --------------------
  13. Outer field
  14. Static outer field

时间转换

  1.     @Test
  2.     public void testJava8DateFormat() {
  3.         DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
  4.         DateTimeFormatter dateTimeFormatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd");
  6.         LocalDateTime localDateTime = LocalDateTime.parse("2019-07-31 00:00:00", dateTimeFormatter1);
  7.         LocalDate localDate = LocalDate.parse("2019-07-31", dateTimeFormatter2);
  8.         Date date = Date.from(LocalDateTime.parse("2019-07-31 00:00:00", dateTimeFormatter1).atZone(ZoneId.systemDefault()).toInstant());
  11.         String strDateTime = "2019-07-31 00:00:00";
  12.         String strDate = "2019-07-31";
  13.         Long timestamp = 1564502400000L;
  15.         /* LocalDateTime 转 LocalDate */
  16.         System.out.println("LocalDateTime 转 LocalDate: " + localDateTime.toLocalDate());
  17.         /* LocalDateTime 转 Long */
  18.         System.out.println("LocalDateTime 转 Long: " + localDateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli());
  19.         /* LocalDateTime 转 Date */
  20.         System.out.println("LocalDateTime 转 Date: " + Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant()));
  21.         /* LocalDateTime 转 String */
  22.         System.out.println("LocalDateTime 转 String: " + localDateTime.format(dateTimeFormatter1));
  24.         System.out.println("-------------------------------");
  26.         /* LocalDate 转 LocalDateTime */
  27.         System.out.println("LocalDate 转 LocalDateTime: " + LocalDateTime.of(localDate, LocalTime.parse("00:00:00")));
  28.         /* LocalDate 转 Long */
  29.         System.out.println("LocalDate 转 Long: " + localDate.atStartOfDay(ZoneId.systemDefault()).toInstant().toEpochMilli());
  30.         /* LocalDate 转 Date */
  31.         System.out.println("LocalDate 转 Date: " + Date.from(localDate.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant()));
  32.         /* LocalDate 转 String */
  33.         System.out.println("LocalDateTime 转 String: " + localDateTime.format(dateTimeFormatter2));
  35.         System.out.println("-------------------------------");
  37.         /* Date 转 LocalDateTime */
  38.         System.out.println("Date 转 LocalDateTime: " + LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()));
  39.         /* Date 转 Long */
  40.         System.out.println("Date 转 Long: " + date.getTime());
  41.         /* Date 转 LocalDate */
  42.         System.out.println("Date 转 LocalDateTime: " + LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()).toLocalDate());
  43.         /* Date 转 String */
  44.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
  45.         System.out.println("Date 转 String: " + sdf.format(date));
  47.         System.out.println("-------------------------------");
  49.         /* String 转 LocalDateTime */
  50.         System.out.println("String 转 LocalDateTime: " + LocalDateTime.parse(strDateTime, dateTimeFormatter1));
  51.         /* String 转 LocalDate */
  52.         System.out.println("String 转 LocalDate: " + LocalDateTime.parse(strDateTime, dateTimeFormatter1).toLocalDate());
  53.         System.out.println("String 转 LocalDate: " + LocalDate.parse(strDate, dateTimeFormatter2));
  54.         /* String 转 Date */
  55.         System.out.println("String 转 Date: " + Date.from(LocalDateTime.parse(strDateTime, dateTimeFormatter1).atZone(ZoneId.systemDefault()).toInstant()));
  57.         System.out.println("-------------------------------");
  59.         /* Long 转 LocalDateTime */
  60.         System.out.println("Long 转 LocalDateTime:" + LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault()));
  61.         /* Long 转 LocalDate */
  62.         System.out.println("Long 转 LocalDate:" + LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault()).toLocalDate());
  63.     }

当日最早和最晚时间

  1. // 最早
  2. LocalDateTime.now().with(LocalTime.MIN).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli()
  3. // 最晚
  4. LocalDateTime.now().with(LocalTime.MAX).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli()

大写字符串转驼峰

  1.     private String getCamelCaseName(String name) {
  2.         String lowerCaseName = name.toLowerCase();
  3.         char[] chars = lowerCaseName.toCharArray();
  4.         StringBuilder builder = new StringBuilder();
  5.         int temp = 0;
  6.         for (int i = 0; i < chars.length; i++) {
  7.             if (temp != 0 && temp == i) continue; // 跳过'_'字符的添加
  8.             if ('_' == (chars[i]) && i < chars.length - 1) {
  9.                 // 将下一个字符转换成大写
  10.                 char aChar = chars[i + 1];
  11.                 aChar -= 32;
  12.                 builder.append(aChar);
  13.                 temp = i + 1;
  14.             } else {
  15.                 builder.append(chars[i]);
  16.             }
  17.         }
  18.         return builder.toString();
  19.     }