[JAVA] Note de révision Enum

Aperçu

Ceci est une note de révision d'énumération introduite depuis Java 1.5.

environnement

référence

Fiche de JDK

Enum

échantillon

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()

renvoie le nom de la constante d'énumération. (Renvoie le nom de cette constante d'énumération)

ordinal()

Renvoie le numéro d'ordre (position déclarée) de la constante d'énumération. (Renvoie l'ordinal de cette constante d'énumération)

(La plupart d'entre eux sont écrits sous forme de constantes d'énumération, mais seule la partie d'origine est écrite sous forme de constantes d'énumération.)

valueOf(String)

Renvoie la constante d'énumération correspondante à partir du nom de la constante d'énumération. valueOf (String) est une méthode de déclaration implicite (statique publique) synthétisée par le compilateur.

values()

Renvoie toutes les constantes de type enum. values () est une méthode de déclaration implicite (statique publique) synthétisée par le compilateur.

equals()

Lorsque vous comparez les constantes d'énumération, vous utilisez généralement ==. La méthode equals de la classe Enum est remplacée comme suit.

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

EnumSet

Une implémentation Set spéciale à utiliser avec les types d'énumération. Tous les éléments d'un ensemble d'énumérations doivent être générés explicitement ou implicitement à partir du type d'énumération unique spécifié lors de la création de l'ensemble.

Puisqu'il n'y a pas de constructeur, créez une instance avec la méthode de fabrique suivante.

allOf(Class<E>)

Crée un EnumSet contenant tous les énumérateurs du type d'énumération spécifié.

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()

Crée un EnumSet vide du type d'énumération spécifié.

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

of(E)

Crée un EnumSet qui contient d'abord l'énumérateur spécifié.

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

range(E, E)

Crée un EnumSet contenant tous les énumérateurs dans la plage des deux énumérateurs spécifiés.

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

Une implémentation spéciale de la carte à utiliser avec les clés énumérées. Toutes les clés d'une mappe d'énumération doivent être générées explicitement ou implicitement à partir d'un type d'énumération unique spécifié lors de la création de la mappe.

Contrairement à EnumSet, il utilise un constructeur pour créer une instance.

EnumMap​(Class<k>)

Crée un EnumMap vide du type d'énumération spécifié.

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

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

Crée un EnumMap à partir de EnumMap spécifié. Je vais omettre le code.

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

Crée un EnumMap à partir de la carte spécifiée.

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

Enhanced Enums

L'extension enum (JEP 301: Enhanced Enums) envisagée par le projet Amber d'OpenJDK, mais l'état actuel (2019/01) est En attente ( Il n'a pas encore été publié car il est en attente).

Implémentation de méthode spécifique à la constante

La déclaration d'une méthode abstraite avec le type enum et la substitution de la méthode abstraite pour chaque constante enum dans le corps de la classe spécifique à la constante est appelée implémentation de méthode spécifique à la constante. (Extrait de «Effective Java 2nd Edition, Section 30 Utiliser enum au lieu des constantes int»)

Voici un exemple d'implémentation de méthode spécifique à une constante dans 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) {
      // ...réduction...
    }
    @Override
    public String print(Duration value, ChronoUnit unit) {
      // ...réduction...
    }
  },
  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 + '%';
    }
  },
  // ...réduction...

  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 {
    // ...réduction...
  },
  // ...réduction...
  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 {
    // ...réduction...
  }
  // ...réduction...

  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 {
    // ...réduction...
  },
  MEGA {
    // ...réduction...
  },
  // ...réduction...

  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) -> {
      // ...réduction...
    }),
    REPEAT((s,c) -> {
      // ...réduction...
    });

    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);
    }
  }

  // ...réduction...
}

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() {
    // ...réduction...
  });

  private final String name;
  private final OutputStream stream;

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

  // ...réduction...
}

Recommended Posts

Note de révision Enum
Une note de revue sur l'interface fonctionnelle
Notes de révision de Java NIO 2
Vérifier le type d'énumération Swift
Notes de révision de Java Collections Framework
Notes de révision des files d'attente / BlockingQueue / TransferQueue
Rails Examen 1
JUnit 4 notes
Revue Ruby 2
Revue Java
À propos d'énumération
note java
Revue d'encapsulation
[Java] enum (type d'énumération)
notes synchronisées
Ruby Review 1
Rails Revue 2
Consulter le mémo de la copie de fichier de Java 1.7 ou version ultérieure