Commande les valeurs de l'enum

Je me demandais si il existe un moyen de commande enum pour les différentes classes. Si par exemple, j'ai un groupe fixe, de produits chimiques qui réagissent différemment à d'autres produits chimiques, dont certains fortement, certains faiblement. En gros, je veux être en mesure de changer l'ordre dans lequel elles sont disposées selon le produit chimique, le groupe est censé réagir(j'.e en fonction de la classe.). Je sais que je suis censé utiliser Comparables, mais je ne suis pas sûr de savoir comment faire. Si je ne suis pas assez clair, laisser un commentaire et je vais l'expliquer plus loin.

Grâce.

public static enum Chem {
    H2SO4, 2KNO3, H20, NaCl, NO2
};

Donc, j'ai quelque chose qui ressemble à ça et je sais déjà comment chaque produit chimique de réagir à certains autres produits chimiques. J'ai simplement envie de prendre le Chems basée sur les produits chimiques, il serait réagissant avec. C'est à peu près tout ce que j'ai.

Vous voulez dire que vous avez une liste de composants chimiques que vous voulez trier selon différents critères?
Je ne dirais pas la liste. Ils sont de type enum.
Certainement pas assez clair. Pourriez-vous montrer un peu de code?
enum membres doivent être valables Java identifiants. 2KNO3 n'est pas valide Java identificateur puisqu'il commence par un chiffre.

OriginalL'auteur Ester | 2012-05-05

De mettre en œuvre différentes Comparator's ( voir http://docs.oracle.com/javase/6/docs/api/java/util/Comparator.html )

Comparator comparator1 = new Comparator<MyEnum>() {

  public int compare(MyEnum e1, MyEnum e2) {
     //your magic happens here
     if (...)
       return -1;
     else if (...)
       return 1;

     return 0;
  }
};

//and others for different ways of comparing them

//Then use one of them:
MyEnum[] allChemicals = MyEnum.values();
Arrays.sort(allChemicals, comparator1); //this is how you sort them according to the sort critiera in comparator1.

OriginalL'auteur Mattias Isegran Bergander

Voici un exemple vous montrant les mêmes valeurs de l'enum triés selon différents critères:

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class SortEnum {
public enum TestEnum {
A(1, 2), B(5, 1), C(3, 0);
private int value1;
private int value2;
private TestEnum(int value1, int value2) {
this.value1 = value1;
this.value2 = value2;
}
public int getValue1() {
return value1;
}
public int getValue2() {
return value2;
}
}
public static void main(String[] args) {
List<TestEnum> list = Arrays.asList(TestEnum.values());
System.err.println(list);
Collections.sort(list, new Comparator<TestEnum>() {
@Override
public int compare(TestEnum o1, TestEnum o2) {
return o1.getValue1() - o2.getValue1();
}
});
System.err.println(list);
Collections.sort(list, new Comparator<TestEnum>() {
@Override
public int compare(TestEnum o1, TestEnum o2) {
return o1.getValue2() - o2.getValue2();
}
});
System.err.println(list);
}
}

De SORTIE est

[A, B, C]
[A, C, B]
[C, B, A]

OriginalL'auteur Guillaume Polet

Vous pouvez mettre autant de comparateurs dans l'énumération que vous aimez, voir exemple ci-dessous:

import java.util.Comparator;
public enum Day {
MONDAY(1, 3),
TUESDAY(2, 6),
WEDNESDAY(3, 5),
THURSDAY(4, 4),
FRIDAY(5, 2),
SATURDAY(6, 1),
SUNDAY(0, 0);
private final int calendarPosition;
private final int workLevel;
Day(int position, int level) {
calendarPosition = position;
workLevel = level;
}
int getCalendarPosition(){ return calendarPosition; }  
int getWorkLevel() { return workLevel;  }
public static Comparator<Day> calendarPositionComparator = new Comparator<Day>() {
public int compare(Day d1, Day d2) {
return d1.getCalendarPosition() - d2.getCalendarPosition();
}
};
public static Comparator<Day> workLevelComparator = new Comparator<Day>() {
public int compare(Day d1, Day d2) {
//descending order, harder first
return d2.getWorkLevel() - d1.getWorkLevel();
}
};
}

Pour voir les comparateurs en action:

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class EnumDayTest
{
public static void main (String[] args) {
List<Day> allDays = Arrays.asList(Day.values());
System.out.println("===\nListing days in order of calendar position:");
Collections.sort(allDays, Day.calendarPositionComparator);
showItems(allDays);
System.out.println("===\nListing days in order of work level:");
Collections.sort(allDays, Day.workLevelComparator);
showItems(allDays);
}
public static void showItems(List<Day> days) {
for (Day day : days) {
System.out.println(day.name());
}
}
}

OriginalL'auteur MaxZoom

1

Supposons que vous avez une énumération d'éléments:
```
enum Elements {Oxygen, Hydrogen, Gold}
```
et que vous souhaitez trier dans un ordre donné, je peux le faire:
```
Elements[] myElements = Elements.values();
Arrays.sort(myElements, new ElementComparator());
```
où ElementComparator peut être quelque chose comme:
```
public class ElementComparator implements java.util.Comparator<Elements> {
public int compare(Elements left, Elements right){
return right.compareTo(left); //use your criteria here
}
}
```
La nature de la commande de critères n'est pas clair dans votre question. Il semble que c'est à propos de quelque chose lié à des réactions chimiques. Je suppose que ces critères devraient aller dans le Comparator de décider qui enum élément est plus grand que les autres compte tenu d'une réaction chimique.

OriginalL'auteur Edwin Dalorzo
0

Vous dire les objets de la représentation de vos produits chimiques sont les énumérations? Que sooooounds étrange mise en œuvre si l'on peut dire: les énumérations sont vraiment plus adapté à des "propriétés" de quelque chose.

Mais de toute façon... si vous voulez vraiment les représenter comme des enums et ensuite de les trier, je dirais implemeting un Comparateur qui permet de trier les énumérations de votre type particulier, puis dans sa méthode compare (), faire la comparaison appropriée, par exemple:
```
Comparator<Chemical> comp = new Comparator<Chemical>() {
public int compare(Chemical o1, Chemical o2) {
if (o1.reactivity() > o2.reactivity()) {
return 1;
} else if (o1.reactivity() < o2.reactivity()) {
return -1;
} else {
return integer depending on whatever else you want to order by...
}
}
};
```
Ensuite, vous pouvez passer cette comparaison à la méthode de tri, collection ordonnée de constructeur etc impliqué.

Vous pouvez étendre votre enum sous-classe pour comprendre ce que des méthodes supplémentaires, par exemple, de la réactivité(), que vous avez besoin.

OriginalL'auteur Neil Coffey

Vous devez vous connecter pour publier un commentaire.