Konvertieren eines int-Arrays in ein String-Array

Verwenden Sie ein Stream, das von Java 8 verfügbar ist. So erhalten Sie eine Stream -Instanz mit einer "Liste" von Ints:

• Für int[]
  • IntStream intStream = Arrays.Stream(nums); oder
  • Stream<Integer> intStream = Arrays.Stream(nums).boxed();, wenn Sie dieselbe Klasse wie die unterste benötigen.
• Für alle Klassen mit der Schnittstelle Collection<Integer> (Z. B. Vector<Integer>, List<Integer>)
  • Stream<Integer> intStream = nums.stream();

Zum Schluss erhalten Sie einen String[]:

String[] answer = intStream.sorted().mapToObj(String::valueOf).toArray(String[]::new);

Kann ich stattdessen eine while-Schleife verwenden?

@Test
public void test() {
    int[] nums = {5,1,2,11,3};

    Arrays.sort(nums);

    String[] stringNums = new String[nums.length];
    int i = 0;
    while (i < nums.length) {
        stringNums[i] = String.valueOf(nums[i++]);
    }

    Assert.assertArrayEquals(new String[]{"1","2","3","5","11"}, stringNums);
}

JUnit-Assertionen verwenden.

Entschuldigung, ich bin leichtfertig. Aber zu sagen, dass Sie keine for-Schleife verwenden können, ist dumm - Sie müssen iterieren irgendwie über die Liste gehen. Wenn Sie eine Bibliotheksmethode aufrufen, um sie für Sie zu sortieren (cf Collections.sort () ) -, wird irgendwie über die Elemente geschleift.

Einfache Lösung mit Guave :

public List<String> toSortedStrings(List<Integer> ints) {
  Collections.sort(ints);
  return Lists.newArrayList(Iterables.transform(ints, 
      Functions.toStringFunction()));
}

Offensichtlich wird diese Lösung (wie jede andere) Schleifen intern verwenden, aber sie holt sie aus dem Code heraus, den Sie lesen müssen. Sie können auch die Reihenfolge in ints nicht ändern, indem Sie das Ergebnis von Ordering.natural().sortedCopy(ints) an transform übergeben, anstatt zuerst Collections.sort zu verwenden. Der Lists.newArrayList-Teil ist auch nicht erforderlich, wenn Sie der resultierenden Liste keine neuen Elemente hinzufügen müssen.

Die verkürzte Version dieses Methodenkörpers mit statischen Importen:

return transform(Ordering.natural().sortedCopy(ints), toStringFunction());

Wenn Sie ein TreeSet verwenden, habe ich einen (länglichen) Einzeiler für Sie (vorausgesetzt, items ist das TreeSet):

final String[] arr =
    items.toString() // string representation
        .replaceAll("\\D+", " ") // replace all non digits with spaces
        .trim() // trim ends
        .split(" "); // split by spaces

Testcode:

Set<Integer> items = new TreeSet<Integer>(Arrays.asList(5, 1, 2, 11, 3));

// insert above code here

System.out.println(Arrays.toString(arr));

Ausgabe:

[1, 2, 3, 5, 11]

BEARBEITEN:

OK, hier ist eine andere Version, die direkt mit dem int-Array funktioniert. Aber leider ist es kein One-Liner. Es behält jedoch Duplikate und ist wahrscheinlich schneller

nochmal BEARBEITEN:

Fehlerbehebungen und negative Zahlen werden nach Wunsch unterstützt:

EDIT noch einmal : Nur ein Regex-Pass und kein Zuschnitt

    final int[] in = { 5, 1, 2, 11, 3, 2, -5 }; // with duplicate
    Arrays.sort(in);
    final String[] out =
        Arrays.toString(in)
            .replaceAll("(?:\\[?)([-\\d]+)(?:\\]?)", "$1") // just remove [ and ]
            .split("\\s*,\\s*"); // split by comma

    System.out.println(Arrays.toString(out));

Ausgabe:

[-5, 1, 2, 2, 3, 5, 11]

Oder ganz ohne Regex (abgesehen von split ()), jedoch mit einem weiteren Schritt:

final int[] in = { 5, 1, 2, 11, 3, 2, -5 }; // with duplicate
Arrays.sort(in);
final String stringRep = Arrays.toString(in);
final String[] out =
    stringRep.substring(1, stringRep.length() - 1).split("\\s*,\\s*");

System.out.println(Arrays.toString(out));

Ausgabe:

[-5, 1, 2, 2, 3, 5, 11]

Update: Leerzeichen von meinen letzten beiden Lösungen entfernt, ich hoffe, Sie sind jetzt glücklich :-)

Funktionales Java verwenden ,

import fj.data.List;
import static fj.data.List.*;
import static fj.pre.Show.*;
.
.
.
final List<Integer> xs = list(5,1,2,11,3);
final List<String> ys = xs.sort(Ord.intOrd).map(
  new F<Integer, String>() {
    @Override public String f(final Integer i) {
       return String.valueOf(i);
    }
  }
);
listShow(stringShow).println(ys);

Ich würde es lieber überspringen, einen anderen für Schleife.

Das ist dumm. Es ist ein dummer Wunsch und eine dumme Basis für eine Code-Übung. Wenn Sie die Qualitäten, die Ihr Code haben soll, besser ausdrücken können, dann haben wir etwas zu besprechen - dass es einfach zu lesen, zu sagen oder performant oder testbar oder robust sein sollte. Aber "Ich würde es lieber überspringen" gibt uns nichts Nützliches, um damit zu arbeiten.

Wie wäre es mit so etwas:

List<String> stringList = new ArrayList<String>();
List<Integer> list = new ArrayList<Integer>(Arrays.asList(5,1,2,11,3));
Collections.sort(list);
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()) {
  stringList.add(iterator.next().toString());
}
System.out.println(stringList);

Eclipse-Sammlungen verwendenMutableIntList :

String[] result = IntLists.mutable.with(5, 1, 2, 11, 3)
        .sortThis()
        .collect(Integer::toString)
        .toArray(new String[]{});

Assert.assertArrayEquals(
        new String[]{"1", "2", "3", "5", "11"}, result);

Oder etwas Lesbarkeit gegen mögliche Effizienz eintauschen:

MutableIntList intList = IntLists.mutable.with(5, 1, 2, 11, 3).sortThis();
String[] result = intList.injectIntoWithIndex(
        new String[intList.size()], 
        (r, each, index) -> {
            r[index] = Integer.toString(each);
            return r;
        });

Assert.assertArrayEquals(
        new String[]{"1", "2", "3", "5", "11"}, result);

Hinweis: Ich bin ein Committer für Eclipse-Sammlungen

Java 8 Weg, überhaupt keine Schleifen:

 // Given
int[] array         = {-5, 8, 3, 10, 25};
// When
String[] actual = Arrays.stream(array)
        .sorted()
        .mapToObj(String::valueOf)
        .toArray(String[]::new);
// Then
String[] expected = {"-5", "3", "8", "10", "25"};

assertArrayEquals(expected, actual);

Sie können Collections.sort() verwenden und dann jedes Element durch die Liste und collectString.valueOf() durchlaufen.

http://download.Oracle.com/javase/6/docs/api/Java/util/Collections.html#sort%28Java.util.List%29

Für einen Vektor erhalten Sie zuerst eine Liste mit Collections.list(Enumeration e).

Für ein Array würden Sie Arrays.sort() anstelle von Collections.sort() verwenden.

http://download.Oracle.com/javase/6/docs/api/Java/util/Arrays.html#sort%28int%5b%5d%29

Warum wandeln Sie diese Werte nicht einfach in String innerhalb der ursprünglichen for-Schleife um und erstellen ein String-Array anstelle eines int-Arrays? Wenn Sie davon ausgehen, dass Sie Ihre anfängliche Ganzzahl von einem Startpunkt aus sammeln und für jede Wiederholungsschleife hinzufügen, wird im Folgenden eine einfache Methode zum Erstellen eines String-Arrays anstelle eines int-Arrays beschrieben. Wenn Sie sowohl int- als auch String-Arrays mit denselben Werten benötigen, erstellen Sie sie in derselben for-Schleife und erledigen Sie sie.

yourInt = someNumber;

for (int a = 0; a < aLimit; a ++) {

String stringName = String.valueOf(yourInt);
StringArrayName[a] = stringName;
yourInt ++;

}

Oder, wenn Sie beide brauchen:

yourInt = someNumber;

for (int a = 0; a < aLimit; a ++) {

String stringName = String.valueOf(yourInt);
StringArrayName[a] = stringName;
intArrayName[a] = yourInt;
yourInt ++;

}

Ich stimme mit allen anderen überein. Loops sind einfach zu erstellen, erfordern zum Ausführen fast keinen Overhead und sind beim Lesen von Code leicht zu verfolgen. Eleganz in der Einfachheit!

Wir können dieses Problem mit regulären Ausdrücken wie folgt lösen:

int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8};
String str = new String(Arrays.toString(intArray));
String stripNoneDigits= str.replaceAll("[^\\d]", "");
String[] stringArray = stripNoneDigits.split("");