分解字符串转换成int的阵列而不循环的java

Question

我想用JAVA分解一个串入int数组，

我不想迭代访问数组的每个元素

比类型转换为整数的溶液。

有没有这方面的任何捷径？

Answer 1

你得去迭代你的字符串的每个字符来实现这一目标：

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]); 
} 

编辑

如果你真的想没有循环：

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])); 

但是你得去首先知道Integer的数量，如果你不需要循环。

Answer 2

据我所知 - 没有。没有简单的方法，因为String只是一个char []，它只能通过ascii映射到整数。你可以得到一个字符串数组，假设你有一个分隔符，然后用一个将字符串转换为int的函数来引用String数组的每个索引，但是坦率地说，你正在使它对自己来说更难......

例如

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

但没有办法（我知道的），只是转换的String []为int []不只是躲在里面其他一些方法中的循环...

Answer 3

没有循环（可见）...但它真的值得吗？

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)); 
} 

要获得Collection<Integer>或List<Integer>这是更简单 - 因为你会从transform越来越Iterable<Integer>：

@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

望着评论约杰什已经加入到@马特研究员答案：

'我想要列表中的所有元素。 - yogesh prajapati'

编写由数组支持的List的自定义实现，并在访问项时进行类型转换。

Answer 5

不在视线单环......但随后的@Nick指出...你可能需要学习一些关于递归：

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); 
    } 

} 

而且调用代码：

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

在那里，没有迭代。

但是，严重的人，任何解决方案将有某种形式的迭代（或递归）在某一点。