[JAVA] Enum Review Memo

Überblick

Dies ist ein Review-Memo von Enum, das aus Java 1.5 eingeführt wurde.

Umgebung

Referenz

Bewertung von JDK

Enum

Stichprobe

public enum Fruits {
  Apple,
  Banana,
  Cherry,
  Durian,
  Elderberry,
  Feijoa,
  Guava {
    @Override
    public String toString() {
      return name().toLowerCase();
    }
  };

  @Override
  public String toString() {
    return this.name().toUpperCase();
  }

}

name()

Gibt den Namen der Enum-Konstante zurück. (Gibt den Namen dieser Enum-Konstante zurück.)

ordinal()

Gibt die Bestellnummer (deklarierte Position) der Aufzählungskonstante zurück. (Gibt die Ordnungszahl dieser Aufzählungskonstante zurück.)

(Die meisten von ihnen sind als Aufzählungskonstanten geschrieben, aber nur der ursprüngliche Teil ist als Aufzählungskonstanten geschrieben.)

valueOf(String)

Gibt die entsprechende Aufzählungskonstante aus dem Namen der Aufzählungskonstante zurück. valueOf (String) ist eine implizite Deklarationsmethode (public static), die vom Compiler synthetisiert wird.

values()

Gibt alle Konstanten vom Typ enum zurück. values () ist eine implizite Deklarationsmethode (public static), die vom Compiler synthetisiert wird.

equals()

Wenn Sie Enum-Konstanten vergleichen, verwenden Sie normalerweise ==. Die equals-Methode der Enum-Klasse wird wie folgt überschrieben.

public final boolean equals(Object other) {
    return this==other;
}

EnumSet

Eine spezielle Set-Implementierung zur Verwendung mit Aufzählungstypen. Alle Elemente in einem Aufzählungssatz müssen explizit oder implizit aus dem einzelnen Aufzählungstyp generiert werden, der beim Erstellen des Satzes angegeben wurde.

Da es keinen Konstruktor gibt, erstellen Sie eine Instanz mit der folgenden Factory-Methode.

allOf(Class<E>)

Erstellt ein EnumSet, das alle Enumeratoren des angegebenen Aufzählungstyps enthält.

EnumSet<Fruits> all = EnumSet.allOf(Fruits.class);
System.out.println(all.size());
// → 7
all.forEach(System.out::println);
// → APPLE
// → BANANA
// → CHERRY
// → DURIAN
// → ELDERBERRY
// → FEIJOA
// → guava

noneOf()

Erstellt ein leeres EnumSet des angegebenen Aufzählungstyps.

EnumSet<Fruits> none = EnumSet.noneOf(Fruits.class);
System.out.println(none.size());
// → 0
none.forEach(System.out::println);

of(E)

Erstellt zuerst ein EnumSet, das den angegebenen Enumerator enthält.

EnumSet<Fruits> one = EnumSet.of(Fruits.Durian);
System.out.println(one.size());
// → 1
one.forEach(System.out::println);
// → DURIAN

range(E, E)

Erstellt ein EnumSet, das alle Enumeratoren im Bereich der beiden angegebenen Enumeratoren enthält.

EnumSet<Fruits> range = EnumSet.range(Fruits.Cherry, Fruits.Feijoa);
System.out.println(range.size());
// → 4
range.forEach(System.out::println);
// → CHERRY
// → DURIAN
// → ELDERBERRY
// → FEIJOA

EnumMap

Eine spezielle Map-Implementierung zur Verwendung mit Aufzählungsschlüsseln. Alle Schlüssel in einer Aufzählungszuordnung müssen explizit oder implizit aus einem einzelnen Aufzählungstyp generiert werden, der beim Erstellen der Zuordnung angegeben wird.

Im Gegensatz zu EnumSet wird zum Erstellen einer Instanz ein Konstruktor verwendet.

EnumMap​(Class<k>)

Erstellt eine leere EnumMap des angegebenen Aufzählungstyps.

EnumMap<Fruits, String> enumMap = new EnumMap<>(Fruits.class);
enumMap.put(Fruits.Apple, "Apfel");
enumMap.put(Fruits.Banana, "Banane");
enumMap.put(Fruits.Cherry, "Kirsche");
enumMap.forEach((k, v) -> System.out.println(k + ":" + v));
// → APPLE:Apfel
// → BANANA:Banane
// → CHERRY:Kirsche

EnumMap​(EnumMap<K,​? extends V> m)

Erstellt eine EnumMap aus der angegebenen EnumMap. Ich werde den Code weglassen.

EnumMap​(Map<K,​? extends V> m)

Erstellt eine EnumMap aus der angegebenen Map.

Map<Fruits, String> map = new HashMap<>();
map.put(Fruits.Apple, "Apfel");
map.put(Fruits.Banana, "Banane");
map.put(Fruits.Cherry, "Kirsche");
EnumMap<Fruits, String> enumMap = new EnumMap<>(map);
enumMap.forEach((k, v) -> System.out.println(k + ":" + v));
// → APPLE:Apfel
// → BANANA:Banane
// → CHERRY:Kirsche

Enhanced Enums

Die Enum-Erweiterung (JEP 301: Enhanced Enums), die von Project Amber von OpenJDK geprüft wird, ist jedoch der aktuelle Status (2019/01) On Hold ( Es wurde noch nicht veröffentlicht, da es sich in der Warteschleife befindet.

Konstante spezifische Methodenimplementierung

Das Deklarieren einer abstrakten Methode mit dem Aufzählungstyp und das Überschreiben der abstrakten Methode für jede Aufzählungskonstante im konstantenspezifischen Klassenkörper wird als konstantenspezifische Methodenimplementierung bezeichnet. (Aus "Effective Java 2nd Edition, Abschnitt 30 Verwenden von Enum anstelle von Int-Konstanten")

Das Folgende ist ein Beispiel für eine konstantenspezifische Methodenimplementierung in OSS.

Spring Boot

org.springframework.boot.convert.DurationStyle

https://github.com/spring-projects/spring-boot/blob/2.1.x/spring-boot-project/spring-boot/src/main/java/org/springframework/boot/convert/DurationStyle.java

public enum DurationStyle {

  SIMPLE("^([\\+\\-]?\\d+)([a-zA-Z]{0,2})$") {
    @Override
    public Duration parse(String value, ChronoUnit unit) {
      // ...Kürzung...
    }
    @Override
    public String print(Duration value, ChronoUnit unit) {
      // ...Kürzung...
    }
  },
  ISO8601("^[\\+\\-]?P.*$") {
    @Override
    public Duration parse(String value, ChronoUnit unit) {
      //
    }
    @Override
    public String print(Duration value, ChronoUnit unit) {
      //
    }
  }

  private final Pattern pattern;

  DurationStyle(String pattern) {
    this.pattern = Pattern.compile(pattern);
  }

  public abstract Duration parse(String value, ChronoUnit unit);
  public abstract String print(Duration value, ChronoUnit unit);
}

Hibernate-ORM

org.hibernate.envers.query.criteria.MatchMode

https://github.com/hibernate/hibernate-orm/blob/5.3/hibernate-envers/src/main/java/org/hibernate/envers/query/criteria/MatchMode.java

public enum MatchMode {

  EXACT {
    @Override
    public String toMatchString(String pattern) {
      return pattern;
    }
  },
  START {
    @Override
    public String toMatchString(String pattern) {
      return pattern + '%';
    }
  },
  // ...Kürzung...

  public abstract String toMatchString(String pattern);
}

org.hibernate.dialect.Database

https://github.com/hibernate/hibernate-orm/blob/5.3/hibernate-core/src/main/java/org/hibernate/dialect/Database.java

public enum Database {

  CACHE {
    // ...Kürzung...
  },
  // ...Kürzung...
  MYSQL {
    @Override
    public Class<? extends Dialect> latestDialect() {
      return MySQL57Dialect.class;
    }

    @Override
    public Dialect resolveDialect(DialectResolutionInfo info) {
      final String databaseName = info.getDatabaseName();

      if ( "MySQL".equals( databaseName ) ) {
        final int majorVersion = info.getDatabaseMajorVersion();
        final int minorVersion = info.getDatabaseMinorVersion();

        if ( majorVersion < 5 ) {
          return new MySQLDialect();
        }
        else if ( majorVersion == 5 ) {
          if ( minorVersion < 5 ) {
            return new MySQL5Dialect();
          }
          else if ( minorVersion < 7 ) {
            return new MySQL55Dialect();
          }
          else {
            return new MySQL57Dialect();
          }
        }

        return latestDialectInstance( this );
      }

      return null;
    }
  },
  ORACLE {
    // ...Kürzung...
  }
  // ...Kürzung...

  public abstract Class<? extends Dialect> latestDialect();
  public abstract Dialect resolveDialect(DialectResolutionInfo info);
}

elasticsearch

org.elasticsearch.common.unit.SizeUnit

https://github.com/elastic/elasticsearch/blob/6.6/server/src/main/java/org/elasticsearch/common/unit/SizeUnit.java

public enum SizeUnit {

  SINGLE {
    @Override
    public long toSingles(long size) {
      return size;
    }
    @Override
    public long toKilo(long size) {
      return size / (C1 / C0);
    }
    @Override
    public long toMega(long size) {
      return size / (C2 / C0);
    }
    @Override
    public long toGiga(long size) {
      return size / (C3 / C0);
    }
    @Override
    public long toTera(long size) {
      return size / (C4 / C0);
    }
    @Override
    public long toPeta(long size) {
      return size / (C5 / C0);
    }
  },
  KILO {
    // ...Kürzung...
  },
  MEGA {
    // ...Kürzung...
  },
  // ...Kürzung...

  public abstract long toSingles(long size);
  public abstract long toKilo(long size);
  public abstract long toMega(long size);
  public abstract long toGiga(long size);
  public abstract long toTera(long size);
  public abstract long toPeta(long size);
}

org.elasticsearch.xpack.sql.expression.function.scalar.string.BinaryStringNumericProcessor

https://github.com/elastic/elasticsearch/blob/6.6/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/function/scalar/string/BinaryStringNumericProcessor.java

public class BinaryStringNumericProcessor extends FunctionalBinaryProcessor<String, Number, String, BinaryStringNumericOperation> {

  public enum BinaryStringNumericOperation implements BiFunction<String, Number, String> {

    LEFT((s,c) -> {
      int i = c.intValue();
      if (i < 0) {
        return "";
      }
      return i > s.length() ? s : s.substring(0, i);
    }),
    RIGHT((s,c) -> {
      // ...Kürzung...
    }),
    REPEAT((s,c) -> {
      // ...Kürzung...
    });

    BinaryStringNumericOperation(BiFunction<String, Number, String> op) {
      this.op = op;
    }

    private final BiFunction<String, Number, String> op;

    @Override
    public String apply(String stringExp, Number count) {
      if (stringExp == null || count == null) {
        return null;
      }
      return op.apply(stringExp, count);
    }
  }

  // ...Kürzung...
}

logback

ch.qos.logback.core.joran.spi.ConsoleTarget

https://github.com/qos-ch/logback/blob/1.1.11/logback-core/src/main/java/ch/qos/logback/core/joran/spi/ConsoleTarget.java

public enum ConsoleTarget {

  SystemOut("System.out", new OutputStream() {
    @Override
    public void write(int b) throws IOException {
      System.out.write(b);
    }
    @Override
    public void write(byte b[]) throws IOException {
      System.out.write(b);
    }
    @Override
    public void write(byte b[], int off, int len) throws IOException {
      System.out.write(b, off, len);
    }
    @Override
    public void flush() throws IOException {
      System.out.flush();
    }
  }),
  SystemErr("System.err", new OutputStream() {
    // ...Kürzung...
  });

  private final String name;
  private final OutputStream stream;

  private ConsoleTarget(String name, OutputStream stream) {
    this.name = name;
    this.stream = stream;
  }

  // ...Kürzung...
}

Recommended Posts

Enum Review Memo
Ein Überprüfungshinweis zur Funktionsoberfläche
Überprüfungshinweise zu Java NIO 2
Überprüfen Sie den Swift-Aufzählungstyp
Überprüfungshinweise zum Java Collections Framework
Überprüfungsnotizen zu Queue / BlockingQueue / TransferQueue
Rails Review 1
JUnit 4 Notizen
Ruby Review 2
Java-Überprüfung
Über Aufzählung
Java Note
Verkapselungsüberprüfung
[Java] enum (Aufzählungstyp)
synchronisierte Notizen
Ruby Review 1
Rails Review 2
Lesen Sie den Hinweis zur Dateikopie von Java 1.7 oder höher