einen String in Array von int zersetzen ohne Schlaufe Java

Question

I eine Zeichenkette in Int-Array unter Verwendung von Java zersetzen wollen,

i jedes Element des Arrays keine Lösung wollen, die

als Typumwandlung iteriert auf ganzzahlige .

Gibt es eine Verknüpfung dafür?

Answer 1

Sie gonna haben, auf jedes Zeichen Ihrer String iterieren, das zu erreichen:

String str = "1234"; 
int[] array = new int[str.length()]; 

for (int i = 0; i < str.length(); i++) { 
    array[i] = Character.digit(str.charAt(i), 10); 
    // or 
    // array[i] = Integer.parseInt(str[i]); 
} 

EDIT

Wenn Sie wirklich keine Schleife wollen:

String str = "123,456,789"; 
String[] arr = str.split(","); 

ArrayList<Integer> list = new ArrayList<Integer>(); 

list.add(Integer.parseInt(arr[0])); 
list.add(Integer.parseInt(arr[1])); 
list.add(Integer.parseInt(arr[2])); 

Aber du wirst haben, kenne die Nummer von Integer, die du zuerst hast, wenn du keine Schleife brauchst.

Answer 2

Soweit ich weiß - nein. Es gibt keine einfache Möglichkeit, dies zu tun, da der String nur ein char [] ist, das nur über ascii auf ganze Zahlen abgebildet wird. Sie könnten ein Array von Strings erhalten, vorausgesetzt Sie haben ein Delimiter, dann verweisen Sie auf jeden Index des Arrays von String mit einer Funktion, die den String in einen Int konvertiert, aber ehrlich gesagt, Sie machen es viel schwieriger für sich selbst ...

z

String myEncodedInts = "7,14,12,9,3"; 
String[] myIntsAsStrings = myEncodedInts.split(","); 
//... 
int someReferenceAtSomeLaterPoint = Integer.parseInt(myIntsAsStrings[myReferenceIndex]); 

Aber es gibt keine Möglichkeit (die ich kenne) von nur das Umwandeln des String [] in eine int [], das nicht nur die Schleife in einer anderen Methode verstecken ...

Answer 3

Keine Schlaufen (sichtbar) ... aber war es das wirklich wert?

import static org.hamcrest.MatcherAssert.assertThat; 
import org.hamcrest.collection.IsArrayContainingInOrder; 
import com.google.common.base.Function; 
import com.google.common.base.Splitter; 
import com.google.common.collect.Iterables; 

@Test 
public void testDecompose() { 
    final String input = "1,2,3,4"; 
    Integer arr [] = Iterables.toArray(Iterables.transform(Splitter.on(",").split(input), new Function<String,Integer>(){ 
     @Override public Integer apply(String input) { 
      return Integer.parseInt(input); 
     }}), Integer.class); 
    assertThat(arr, IsArrayContainingInOrder.arrayContaining(1,2,3,4)); 
} 

Um Collection<Integer> oder List<Integer> ist es noch einfacher - wie Sie Iterable<Integer> vom transform bekommen werde:

@Test 
public void testDecompose() { 
    final String input = "1,2,3,4"; 
    List<Integer> l = Lists.newArrayList(Iterables.transform(Splitter.on(",").split(input), new Function<String,Integer>(){ 
     @Override public Integer apply(String input) { 
      return Integer.parseInt(input); 
     }})); 
    assertThat(l, IsCollectionContaining.hasItems(1,2,3,4)); 
} 

Answer 4

Mit Blick auf den Kommentar Yogesh zu @ Matt Fellows Antwort hinzugefügt:

'Ich möchte alle Elemente in der Liste. - yogesh prajapati '

Schreiben Sie eine benutzerdefinierte Implementierung von List, die vom Array unterstützt wird, und führt die Typkonvertierung durch, wenn auf die Elemente zugegriffen wird.

Answer 5

Nicht eine einzige Schleife in Sicht ... aber dann als @ Nick wies darauf hin ... Sie wahrscheinlich ein wenig über Rekursion lernen müssen:

private static void getNumbers(List<String> asList, List<Integer> myList) { 
    if (asList.isEmpty()) { 
     return; 
    } else { 
     String remove = asList.remove(0); 
     myList.add(Integer.parseInt(remove)); 
     getNumbers(asList, myList); 
    } 

} 

und Berufung Code:

String numbers = "1,2,3,4,5,6,7,8,9"; 
    List<String> inputList = new ArrayList<String>(); 
    inputList.addAll(Arrays.asList(numbers.split(","))); 
    List<Integer> outputList = new ArrayList<Integer>(); 

    getNumbers(inputList, outputList); 

    System.out.println(outputList); 

Answer 6

public toInts(String[] strings, int[] ints, int start) { 
    if (start > strings.length - 2) { 
     return; 
    } 
    ints[start] = Integer.parseInt(strings[start]); 
    toInts(string, ints, start+1); 
} 
... 
int[] ints = new int[3]; 
String[] strings = new String[]{"1", "2", "3"}; 
toInts(strings, ints, 0); 

Dort keine Iterationen.

Aber im Ernst, Leute, jede Lösung wird irgendwann eine Art von Iteration (oder Rekursion) haben.