Classé Liste en Java

Question

je dois trier la liste en java comme ci-dessous:

Liste contient collection d'objets comme celui-ci,

List list1 = {obj1, obj2,obj3,.....}; 

J'ai besoin la liste finale qui a « valeur la plus faible » et " la répétition du nom devrait éviter ".

Ex:

List list1 = {[Nellai,10],[Gujarath,10],[Delhi,30],[Nellai,5],[Gujarath,15],[Delhi,20]} 

Après tri, je dois la liste comme ceci:

List list1 = {[Nellai,5],[Gujarath,10],[Delhi,20]}; 

J'ai 2 Delhi (30,20) dans ma liste. Mais j'ai besoin seulement d'un Delhi qui a le prix le plus bas (20).

Comment faire ça en java?

Gnaniyar Zubair

Answer 1

Presque la même chose que @Visage réponse, mais l'ordre est différent:

public class NameFare { 
    private String name; 
    private int fare; 
    public String getName() { 
     return name; 
    } 
    public int getFare() { 
     return fare; 
    } 
    @Override public void equals(Object o) { 
     if (o == this) { 
      return true; 
     } else if (o != null) { 
      if (getName() != null) { 
       return getName().equals(o.getName()); 
      } else { 
       return o.getName() == null; 
      } 
     } 
     return false; 
    } 
} 
.... 
public Collection<NameFare> sortAndMerge(Collection<NameFare> toSort) { 
    ArrayList<NameFare> sorted = new ArrayList<NameFare>(toSort.size()); 
    for (NameFare nf : toSort) { 
     int idx = sorted.getIndexOf(nf); 
     if (idx != -1) { 
      NameFare old = sorted.get(idx); 
      if (nf.getFare() < old.getFare()) { 
       sorted.remove(idx); 
       sorted.add(nf); 
      } 
     } 
    } 
    Collections.sort(sorted, new Comparator<NameFare>() { 
     public int compare(NameFare o1, NameFare o2) { 
      if (o1 == o2) { 
       return 0; 
      } else { 
       if (o1.getName() != null) { 
        return o1.getName().compareTo(o2.getName()); 
       } else if (o2.getName() != null) { 
        return o2.getName().compareTo(o1.getName()); 
       } else { 
        return 0; 
       } 
      } 
     } 
    }); 
} 

Answer 2

je le faire en deux étapes.

Première tri de la liste à l'aide d'un comparateur personnalisé.

Deuxièmement, parcourez la liste et, pour les entrées en double (qui seront maintenant adjacentes les unes aux autres, à condition de parcourir correctement votre comparateur), supprimez les entrées avec les valeurs les plus élevées.

Answer 3

Si l'ordre n'a pas d'importance, une solution est d'utiliser un Map[String, Integer], ajoutez une entrée à chaque fois que vous trouvez une nouvelle ville , mettez à jour la valeur chaque fois que la valeur stockée est inférieure à celle stockée, puis compressez toutes les paires dans une liste.

Answer 4

J'utiliser un ArrayList comme ceci:

ArrayList<Name> listOne = new ArrayList<Name>(); 
listOne.add(new Name("Nellai", 10); 
listOne.add(new Name("Gujarath", 10); 
listOne.add(new Name("Delhi", 30); 
listOne.add(new Name("Nellai", 5); 
listOne.add(new Name("Delhi", 20); 

Collection.sort(listOne); 

Ensuite, créez la classe Nom

class name implements Comparable 
{ 
private String name; 
private int number; 

public Name(String name, int number) 
{ 
this.name= name; 
this.number= number; 
} 

public String getName() 
{ 
     return this.name; 
} 
public int getNumber() 
{ 
     return this.number; 
} 
public int compareTo(Object otherName) // must be defined if we are implementing //Comparable interface 
{ 
if(otherName instanceif Name) 
{ 
throw new ClassCastException("Not valid Name object"): 
} 
Name tempName = (Name)otherName; 
// eliminate the duplicates when you sort 
if(this.getNumber() >tempName.getNumber()) 
    { 
    return 1; 
    }else if (this.getNumber() < tempName.getNumber()){ 
    return -1; 
    }else{ 
    return 0; 
    } 
} 

} 

Je n'ai pas compilé le code, il est édité ici, donc vous devez corriger le code. Et aussi pour comprendre comment éliminer les doublons et n'imprimer que le plus bas.

Vous devez transpirer aussi.

Answer 5

Si vous voulez éviter les doublons, une classe comme TreeSet pourrait être un meilleur choix que List.