J'ai une gamme de chaînes et je veux remplir un autre tableau avec les plus grandes chaînes de la matrice susmentionnée. Je peux obtenir la taille du tableau correctement et le remplir avec la quantité correcte de variables, mais deux des variables sont nuls pendant que le troisième est la valeur correcte. mes résultats sont les suivants: Comment puis-je obtenir les deux valeurs null pour devenir ABA et VCD?
5 Réponses :
Vous devez compter le nombre d'éléments de cette longueur. Actuellement, votre code attribue une matrice de résultat avec len code> nombre d'éléments. La longueur de la chaîne la plus longue ( len code> dans votre code) n'a rien à voir avec le nombre de chaînes de cette longueur. public static String[] allLongestStrings(String[] inputArray) {
TreeMap<Integer, List<String>> lengthToStrings = Arrays.stream(inputArray)
.collect(Collectors.groupingBy(String::length, TreeMap::new, Collectors.toList()));
return lengthToStrings.lastEntry()
.getValue()
.toArray(new String[0]);
}
Pourquoi ne pas mettre un autre-si dans la première boucle? si (temp> len) {len = temp.length (); num = 1; } else si (temp == len) {num ++;}
@ErTriThean vous avez raison. Nous pouvons éviter la deuxième itération. Mise à jour de la réponse :)
Il y a quelques problèmes avec votre code:
res code> n'est pas liée à la longueur maximale réelle len code>. li>
- Vous ne faites que ajouter des éléments au dernier index de
RET code> tableau: li>
ol> xxx pré> Donc, pour le premier problème, vous pouvez conserver un compter code> de chaînes de longueur maximale dans le tableau d'origine et adresser la seconde par Utilisation des pointeurs d'index appropriés: P> public static String[] allLongestStrings(String[] inputArray) {
int len = 0, count = 0;
for(String temp: inputArray) {
if (temp.length() > len) {
len = temp.length();
count = 1; // new max length, so reset count to 1
} else if (temp.length() == len) {
count++;
}
}
String[] ret = new String[count];
for(int i = 0, j = 0; i < inputArray.length; i++) {
if (inputArray[i].length() == len) {
ret[j++] = inputArray[i];
}
}
return ret;
}
Courte Java 8 Version:
String[] inputArray = {"aba", "aa", "ad", "vcd", "123"};
// find out the biggest element size
Optional<String> biggest = asList(inputArray).stream().max(Comparator.comparing(String::length));
// filter only element that contains the same size as the biggest one
List<String> bigOnes = asList(inputArray).stream()
.filter(element -> element.length() == biggest.map(String::length).orElse(0))
.collect(Collectors.toList());
// print them
bigOnes.forEach(System.out::println);
Ignorer le fait que le nombre d'éléments correspondant au max len n'est pas correctement calculé (mais par hasard, dans votre cas d'utilisation, la longueur maximale correspond au nombre d'éléments de cette longueur I.E. 3). Vous pouvez utiliser une liste pour supprimer la contrainte de taille et renvoie ReList.Tearray () si vous avez vraiment besoin d'une matrice.
retour au problème réel, vous ne remplissez pas correctement le réseau RET. Vous devez garder une trace de l'index au lieu d'utiliser toujours la longueur -1: acclamations!
Voici la solution de boucle unique.
public static String[] allLongestStrings(String[] inputArray) {
int len = 0;
ArrayList<String> ret = new ArrayList<>(inputArray.length);
for(String temp: inputArray) {
if(temp.length() > len) {//reset list as bigger length is found.
len = temp.length();
ret.clear();
ret.add(temp);
}else if(temp.length()==len){//accumulate all longest Strings in the list
ret.add(temp);
}
}
return ret.toArray(new String[0]);
}