Java - Trier un tableau basé sur les valeurs d'un autre tableau?

J'ai un tableau de Chaînes de caractères qui sont des instances d'une classe à partir d'un code externe, que je préfère ne pas changer.

J'ai également un tableau d'entiers qui ont été générées par l'appel d'une fonction sur chaque objet. J'ai donc

Un: [string1, string2, string3]

B: [40, 32, 34]

Comment puis-je trier facilement Une telle qu'elle est triée par les valeurs de B. j'ai boost disponible. Je veux Un tel qu'il est dans l'ordre:

[string2, string3, string1]

En javascript vous pouvez faire cela comme:

B.sort(function(a,b){return A[B.indexOf(a)] < A[B.indexOf(b)];});

Créer un Comparateur de cette première associés entre la valeur en A de valeur dans B (dans le constructeur) et de l'utiliser pour trier
Ne pouvez-vous pas simplement de mettre en œuvre la même chose que l'option JavaScript de votre exemple comme un Comparator?
Vous devez écrire votre propre Comparateur.
Vous pouvez également utiliser TreeMap (Valeurs en B comme la clé et la valeur correspondante dans Une valeur), étant donné que les valeurs de B sont uniques.

InformationsquelleAutor Reza | 2015-02-17

Dans java 8, vous pouvez le faire

avec un lambda:

    String[] strings = new String[]{"string1", "string2", "string3"};
    final int[] ints = new int[]{40, 32, 34};

    final List<String> stringListCopy = Arrays.asList(strings);
    ArrayList<String> sortedList = new ArrayList(stringListCopy);
    Collections.sort(sortedList, (left, right) -> ints[stringListCopy.indexOf(left)] - ints[stringListCopy.indexOf(right)]);

Ou mieux, avec Comparateur de:

    String[] strings = new String[]{"string1", "string2", "string3"};
    final int[] ints = new int[]{40, 32, 34};

    final List<String> stringListCopy = Arrays.asList(strings);
    ArrayList<String> sortedList = new ArrayList(stringListCopy);
    Collections.sort(sortedList, Comparator.comparing(s -> ints[stringListCopy.indexOf(s)]));

Super utile, merci.
Cette logique ne fonctionne pas pour moi avec différents exemples, testé en premier cas d'utilisation : il est conseillé de tester sur : String[] chaînes = new String[]{"mot1", "chaîne2", "string3", "string4"}; final int[] ints = new int[]{100,88, 98, 92}; obtenu de résultats: Tableau d'après nature[chaîne2, mot1, string4, string3] (mais string1 devrait être en fin de compte, pouvez-vous l'expliquer ou de le réparer?
vous avez besoin de copier à un autre tableau et de la base de tri de tableau qui ne change pas, sinon il ne fonctionnera pas dans d'autres exemples.
C'est corrigé, merci

InformationsquelleAutor Thermech

5

Réponse courte: je suggère qu'une catégorie distincte est créée qui contient les informations à propos de la String et le développement (le int). Si vous assumez le suivant:
```
public class BoostString {
    int boost;
    String str;

    public BoostString(int boost, String str) {
        this.boost = boost;
        this.str = str;
    }
}
```
Ensuite, vous pouvez trier votre tableau en utilisant une Comparator et il fonctionne particulièrement bien avec le Java 8 Streaming API.
```
String[] strings = {"string1", "string2", "string3"};
int[] boosts = {40, 32, 34};

final String[] sorted = IntStream.range(0, boosts.length)
        .mapToObj(i -> new BoostString(boosts[i], strings[i])) //Create the instance
        .sorted(Comparator.comparingInt(b -> b.boost))         //Sort using a Comparator
        .map(b -> b.str)                                       //Map it back to a string
        .toArray(String[]::new);                               //And return an array
```
La Comparator dans l'exemple ci-dessus est créé à l'aide de la Comparator.comparingInt méthode qui est un moyen pratique de créer un Comparator pour ints à l'aide de Java 8.

Explication: Généralement lorsque l'on compare les objets en Java que vous utilisez une des fonctions de tri comme Collections.sort où vous fournissez votre propre Comparator. Le Comparator interface est simple et ressemble à ceci:
```
public interface Comparator<T> {
    int compare(T o1, T o2);

    //Other default methods for Java 8
}
```
La valeur de retour est de type int et est décrit comme cela dans la JavaDoc:

retourner un entier négatif, zéro ou un entier positif comme le premier argument est inférieur, égal ou plus grand que le second.

Cela fonctionne out-of-the-box quand vous le tri Strings ou int (ou en fait Integers) car ils sont Comparable – en quelque sorte ils ont un tri naturel et pour Strings c'est dans l'ordre alphabétique et pour Integers c'est triée dans l'ordre croissant de numéro de commande (voir la JavaDoc pour Comparable).

Sur une note de côté, il y a d'autres "paire" ou "tuple" implémentations disponibles si vous utilisez 3ème partie les bibliothèques. Vous n'avez pas à créer votre propre "paire" d'un String et int. Un exemple est la Paire classe de Apache Commons.

InformationsquelleAutor wassgren

Vous pouvez faire quelque chose de similaire à votre JS exemple dans le vieux style Java (mais je vous recommande de rejoindre vos données dans un objet comme @wassgren l'indique):

import java.util.*;

public class WeightSort {
  public static void main(String[] args) {
    String[] strings = new String[]{"string1", "string2", "string3"};
    final int[] weights = new int[]{40, 32, 34};
    final List<String> stringList = Arrays.asList(strings);
    List<String> sortedCopy = new ArrayList<String>(stringList);
    Collections.sort(sortedCopy, new Comparator<String>(){
        public int compare(String left, String right) {
          return weights[stringList.indexOf(left)] - weights[stringList.indexOf(right)];  
        }
      });
      System.out.println(sortedCopy);
  }
}

InformationsquelleAutor Alexander Torstling

J'ai résolu ce problème en utilisant le Comparateur interface.

 import java.util.Comparator;
 import java.util.Collections;
 import java.util.List;
 import java.util.Arrays;


 public class ComparatorDemo {

 public static void main(String[] args) {
    List<Area> metaData = Arrays.asList(
            new Area("Joe", 24),
            new Area("Pete", 18),
            new Area("Chris", 21),
            new Area("Rose",21)
    );

    Collections.sort(metaData, new ResultComparator());
    for(int i =0 ;metaData.size()>i;i++)
             System.out.println(metaData.get(i).output);


  }
 }


 class ResultComparator implements Comparator<Area> {
     @Override
     public int compare(Area a, Area b) {
         return a.result < b.result ? -1 : a.result == b.result ? 0 : 1;
     }
 }

 class Area{
   String output;
   int result;

Area(String n, int a) {
    output = n;
    result = a;
     }
 }

erreur: MainActivity.ResultCompare n'est pas abstrait et ne remplace pas la méthode abstraite comparer(Long,Long) en Comparateur. classe ResultCompare implémente Comparateur de<Long>{

InformationsquelleAutor Reza

0

Si vous êtes à la construction de la matrice B doit être utilisé uniquement pour ce tri, vous pouvez différer le calcul de ses valeurs au sein d'Un de compareTo(). En d'autres termes, calculer le poids des chaînes uniquement dans les comparaisons au cours de tri.

InformationsquelleAutor simurg

package com.appkart.array;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
public class SortExample {
Map<String, Integer> map = new HashMap<String, Integer>();
Map<String, Integer> treemap = new TreeMap<String, Integer>(
new MyComparator(map));
public void addValueInMapAndSort() {
map.put("string1", 40);
map.put("string2", 32);
map.put("string3", 34);
System.out.println(map);
treemap.putAll(map);
System.out.println(treemap);
}
class MyComparator implements Comparator<String> {
Map<String, Integer> map;
public MyComparator(Map<String, Integer> map) {
this.map = map;
}
@Override
public int compare(String o1, String o2) {
if (map.get(o1) >= map.get(o2)) {
return 1;
} else {
return -1;
}
}
}
public static void main(String[] args) {
SortExample example = new SortExample();
example.addValueInMapAndSort();
}
}

Utilisez le Comparateur pour le tri en fonction de leur valeur.

InformationsquelleAutor Arun Kumar

J'ai eu un problème similaire, et résolu par le codage d'un algorithme de tri qui triées un tableau de mesures, et de fait identiques swaps dans le tableau d'objets. Voici le code, avec des tests, meilleurs voeux et pas de promesses:

package other;
import java.util.Arrays;
import java.util.Random;
/**
* Sorts an array of objects (<code>bags</code>) by a separate array of doubles (<code>measures</code>). 
* It sorts into ascending order. 
* <p>
* The <code>results</code> array is always a new array. 
* <p>
* The algorithm used:<ul>
* <li> Is (I believe) a merge-sort, which would mean it is stable. (I haven't tested this.)
* <li> Efficiently exploits already ordered subsequences. 
* <li> Requires the allocation of eight arrays: four of the baggage type, four of doubles, each the length of the original data. 
* </ul>
* <p>
* A <code>NaN</code> in the <code>measures</code> - I haven't thought about that, and don't want to. 
* <p>
* There is test code at the end of the class. 
*/
public class SortBaggageByDouble { 
public final Object [] results ; 
protected final int length ; 
public SortBaggageByDouble(Object[] bags, double[] measures) { 
this.length = bags.length; 
if (bags.length!=measures.length) throw new IllegalArgumentException("Mismatched lengths: payload array "+bags.length+", measures array "+measures.length); 
this.results = new Object[length]; 
Object [] bagsA = new Object[length] ; 
Object [] bagsB = new Object[length] ; 
Object [] bagsC = new Object[length] ; 
Object [] bagsD = new Object[length] ; 
double [] measuresA = new double[length] ; 
double [] measuresB = new double[length] ; 
double [] measuresC = new double[length] ; 
double [] measuresD = new double[length] ; 
System.arraycopy(bags, 0, bagsA, 0, length); 
System.arraycopy(measures, 0, measuresA, 0, length); 
munge(length, 0, bagsA, bagsB, bagsC, bagsD, measuresA, measuresB, measuresC, measuresD); 
}
private void munge(int inLengthA, int inLengthB, Object[] inBagsA, Object[] inBagsB, Object[] outBagsC, Object[] outBagsD, double[] inMeasuresA, double[] inMeasuresB, double[] outMeasuresC, double[] outMeasuresD) { 
int outLengthC = 0 ; 
int outLengthD = 0 ; 
int cursorA = 0 ; 
int cursorB = 0 ; 
boolean toC = true ; 
while(outLengthC+outLengthD<length) { 
boolean fromA ; 
if (cursorA>=inLengthA) { 
fromA = false ; 
} else if (cursorB>=inLengthB) { 
fromA = true ; 
} else { 
fromA = inMeasuresA[cursorA] <= inMeasuresB[cursorB] ;  
} 
double tmpMeasure = fromA ? inMeasuresA[cursorA] : inMeasuresB[cursorB] ; 
Object tmpBag = fromA ? inBagsA[cursorA] : inBagsB[cursorB] ; 
if (fromA) cursorA ++ ; else cursorB ++ ; 
if (toC) { 
if (outLengthC==0 || (outMeasuresC[outLengthC-1]<=tmpMeasure)) { 
outMeasuresC[outLengthC] = tmpMeasure ; 
outBagsC[outLengthC] = tmpBag ; 
outLengthC ++ ; 
} else { 
toC = false ; 
outMeasuresD[outLengthD] = tmpMeasure ; 
outBagsD[outLengthD] = tmpBag ; 
outLengthD ++ ; 
}
} else { 
if (outLengthD==0 || (outMeasuresD[outLengthD-1]<=tmpMeasure)) { 
outMeasuresD[outLengthD] = tmpMeasure ; 
outBagsD[outLengthD] = tmpBag ; 
outLengthD ++ ; 
} else { 
toC = true ; 
outMeasuresC[outLengthC] = tmpMeasure ; 
outBagsC[outLengthC] = tmpBag ; 
outLengthC ++ ; 
}
}
}
if (outLengthC==length) { 
System.arraycopy(outBagsC, 0, results, 0, length); 
} else { 
munge(outLengthC, outLengthD, outBagsC, outBagsD, inBagsA, inBagsB, outMeasuresC, outMeasuresD, inMeasuresA, inMeasuresB); 
}
}
/**
* Subclass to sort strings, with a result object <code>sortedStrings</code> which is of a useful type. 
*/
public static class Strings extends SortBaggageByDouble { 
public final String [] sortedStrings ; 
public Strings(String[] in, double[] measures) {
super(in, measures);
this.sortedStrings = new String[results.length]; 
for (int i=0 ; i<results.length ; i++) sortedStrings[i] = (String) results[i] ; 
} 
}
/**
* Tests sorting - assumes there are no duplicates among the measures. 
*/
private static class NoDuplicatesTest { 
private NoDuplicatesTest(String[] shuffledStrings, double[] shuffledMeasures, String[] expectedStrings) { 
SortBaggageByDouble.Strings sorter = new SortBaggageByDouble.Strings(shuffledStrings, shuffledMeasures); 
if (!Arrays.equals(expectedStrings, sorter.sortedStrings)) throw new RuntimeException("Test failed"); 
}
}
private static class MultiseedNoDuplicatesTest { 
private MultiseedNoDuplicatesTest(String[] orderedStrings, double[] orderedMeasures, int[] seeds) { 
int length = orderedStrings.length;
for (int seed : seeds) { 
Random random = new Random(seed); 
int [] shuffleIndices = new int[length] ; 
for (int i=0 ; i<length ; i++) shuffleIndices[i] = i ; 
for (int i=1 ; i<length ; i++) { 
int j = random.nextInt(i+1); //'j' is in the range 0..i, bounds inclusive. 
int tmp = shuffleIndices[i]; 
shuffleIndices[i] = shuffleIndices[j] ; 
shuffleIndices[j] = tmp ; 
}
String[] shuffledStrings = new String[length]; 
double[] shuffledMeasures = new double[length]; 
for (int i=0 ; i<length ; i++) { 
shuffledStrings[shuffleIndices[i]] = orderedStrings[i] ; 
shuffledMeasures[shuffleIndices[i]] = orderedMeasures[i] ; 
}
if (false && 0<length && length<8) { 
System.out.println("shuffleIndices is "+ stringfor(shuffleIndices)); 
System.out.println("shuffledStrings is "+ stringfor(shuffledStrings)); 
System.out.println("shuffledMeasures is "+ stringfor(shuffledMeasures)); 
}
new NoDuplicatesTest(shuffledStrings, shuffledMeasures, orderedStrings); 
}
}
}
private static class MultilengthMultiseedNoDuplicatesTest { 
MultilengthMultiseedNoDuplicatesTest(int[] lengths, int[] seeds) { 
for (int i=0 ; i<lengths.length ; i++) { 
int length = lengths[i] ; 
String[] orderedStrings = new String[length] ; 
double[] orderedMeasures = new double[length] ; 
for (int j=0 ; j<length ; j++) { 
orderedStrings[j] = "_"+j+"_" ; 
orderedMeasures[j] = j ; 
}
if (false && 0<length && length<8) { 
System.out.println("orderedStrings is "+ stringfor(orderedStrings)); 
System.out.println("orderedMeasures is "+ stringfor(orderedMeasures)); 
}
new MultiseedNoDuplicatesTest(orderedStrings, orderedMeasures, seeds); 
}
}
}
public static class ClassTest { 
ClassTest() { 
new MultilengthMultiseedNoDuplicatesTest(new int[]{0}, new int[]{8543, 45125}); 
new MultilengthMultiseedNoDuplicatesTest(new int[]{1}, new int[]{8543, 45125}); 
new MultilengthMultiseedNoDuplicatesTest(new int[]{2}, new int[]{8543, 45125, 4545, 785413}); 
new MultilengthMultiseedNoDuplicatesTest(new int[]{3, 4, 5, 6, 7, 8, 9, 10}, new int[]{8543, 45125, 4545, 785413}); 
new MultilengthMultiseedNoDuplicatesTest(new int[]{50, 100, 1000}, new int[]{474854, 43233}); 
////// Passed! Bye bye.  
System.out.println("Passed test suite "+this.getClass().getCanonicalName()); 
}
}
public static String stringfor(int[] array) {
StringBuilder sb = new StringBuilder(); 
build(sb, array);
return sb.toString();
}
public static void build(StringBuilder sb, int[] array) { 
for (int i=0 ; i<array.length ; i++) { 
if (sb.length()>0) sb.append(' '); 
sb.append(array[i]); 
} 
}
public static String stringfor(double[] array) {
StringBuilder sb = new StringBuilder(); 
build(sb, array);
return sb.toString();
}
public static void build(StringBuilder sb, double[] array) { 
for (int i=0 ; i<array.length ; i++) { 
if (sb.length()>0) sb.append(' '); 
sb.append(array[i]); 
} 
}
public static String stringfor(String[] labels) {
StringBuffer sb = new StringBuffer();
String sep = "" ; 
for (int i=0 ; i<labels.length ; i++) { 
sb.append(sep); 
String label = labels[i] ; 
sb.append(label!=null ? label : "null"); 
sep = ", " ; 
}
return sb.toString();
}
}

InformationsquelleAutor Guy Smith

Peut-être pas exactement pour ce cas, mais pour ceux qui la recherche pour répondre à comment trier un tableau de Chaîne de caractères en fonction d'une autre:

//Array of values, in a order of sorting
static final Map<String, Integer> ROUNDS_SORT = new HashMap<String, Integer>();
static {
ROUNDS_SORT.put("f", 0);
ROUNDS_SORT.put("s", 1);
ROUNDS_SORT.put("q", 2);
ROUNDS_SORT.put("r16", 3);
ROUNDS_SORT.put("r32", 4);
ROUNDS_SORT.put("r64", 5);
}
//Your array to be sorted
static ArrayList<String> rounds = new ArrayList<String>() {{
add("f");
add("q");
add("q");
add("r16");
add("f");
}};
//implement
public List<String> getRoundsSorted() {
Collections.sort(rounds, new Comparator<String>() {
@Override
public int compare(String p1, String p2) {
return Integer.valueOf(ROUNDS_SORT.get(p1)).compareTo(Integer.valueOf(ROUNDS_SORT.get(p2)));
}
});
return rounds;
}

InformationsquelleAutor user1908375

En java, vous devez avoir deux tableaux, l'un copier de les trier off et le tableau que vous souhaitez trier.

avec un lambda:

String[] strings = new String[]{"string1", "string2", "string3", "string4"};
final int[] ints = new int[]{100, 88, 92, 98};
final List<String> stringListCopy = Arrays.asList(strings);
ArrayList<String> sortedList = new ArrayList(stringListCopy);
Collections.sort(sortedList, (left, right) -> ints[stringListCopy.indexOf(left)] - ints[stringListCopy.indexOf(right)]);

Ou avec Comparateur:

String[] strings = new String[]{"string1", "string2", "string3", "string4"};
final int[] ints = new int[]{100, 92, 88, 98};
final List<String> stringListCopy = Arrays.asList(strings);
ArrayList<String> sortedList = new ArrayList(stringListCopy);
Collections.sort(sortedList, Comparator.comparing(s -> ints[stringListCopy.indexOf(s)]));

InformationsquelleAutor beee

-1

Faire un TreeMap<Integer, List<ObjectTypeFromA>> où la carte est la clé de valeurs dans B, et la carte des valeurs sont les valeurs de A (à l'aide d'une liste pour permettre de dupliquer des clés). Il sera classé dans l'ordre de B par définition.
```
public static void main(String[] args) {
String[] strings = { "string1", "string2", "string3", "string4" };
int[] ints = { 40, 32, 32, 34 };
System.out.println(Arrays.toString(getSortedStringArray(strings, ints)));
}
public static String[] getSortedStringArray(String[] strings, int[] order) {
Map<Integer, List<String>> map = new TreeMap<>();
for (int i = 0; i < strings.length; i++) {
if (!map.containsKey(order[i])) {
map.put(order[i], new LinkedList<String>());
}
map.get(order[i]).add(strings[i]);
}
String[] ret = new String[strings.length];
int i = 0;
for (Map.Entry<Integer, List<String>> mapEntry : map.entrySet()) {
for (String s : mapEntry.getValue()) {
ret[i++] = s;
}
}
return ret;
}
```
- Que faire si B a des doublons?
- J'ai duplication question. Treemap n'est pas de travail ici.
- Ensuite, la valeur d'une Collection d'objets, et de créer un wrapper qui lors d'une itération de l'arbre dans l'ordre, permettra également de parcourir le contenu de chaque collection. Je mettrai à jour réponse sous peu. Vous devriez probablement mise à jour de question pour spécifier que les doublons sont autorisés; votre exemple n'apporte pas cette possibilité à l'esprit.
- mise à jour de répondre à montrer comment ce concept fonctionne toujours très bien avec des doubles de clés et une légère modification.
- mise à jour de répondre à poignées doubles, voir int[] ints = { 40, 32, 32, 34 };
InformationsquelleAutor The111

Vous devez vous connecter pour publier un commentaire.