web-dev-qa-db-de.com

Konvertieren eines int-Arrays in ein String-Array

Ich habe also diese "Liste" von Ints. Es könnte eine Vector, int[], List<Integer> oder was auch immer sein. 

Mein Ziel ist es jedoch, die Ints zu sortieren und mit einem String[] zu enden. Wie das int-Array so beginnt, wie es in der Luft liegt.

beispiel: Beginnen Sie mit: {5,1,2,11,3} Ende mit: String[] = {"1","2","3","5","11"}

Gibt es das überhaupt ohne for-Schleife? Ich habe jetzt eine for-Schleife zum Sammeln der Ints. Ich würde lieber eine weitere for-Schleife machen.

17
dev4life
int[] nums = {5,1,2,11,3}; //List or Vector
Arrays.sort(nums); //Collections.sort() for List,Vector
String a=Arrays.toString(nums); //toString the List or Vector
String ar[]=a.substring(1,a.length()-1).split(", ");
System.out.println(Arrays.toString(ar));

UPDATE:

Eine kürzere Version:

int[] nums = {-5,1,2,11,3};
Arrays.sort(nums);
String[] a=Arrays.toString(nums).split("[\\[\\]]")[1].split(", "); 
System.out.println(Arrays.toString(a));  
21
Emil

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);
12
Skywave

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.

8
Noel M

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());
5
ColinD

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 :-)

4

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);
3
missingfaktor

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.

3
Carl Manaster

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);
1
Adam

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

1
Donald Raab

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);
0
Maxim Pavlov

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

0
gpeche

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!

0
elfinkind

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("");
0
Intelligent