Java String Fragmination

Question

Ich habe eine Zeichenfolge, zum Beispiel "90 60 90" - Körperproportionen. Ich möchte 3 Zahlen aus der Zeichenfolge herausziehen und sie in das int-Array setzen. So:

sizes[0] = 90; 
sizes[1] = 60; 
sizes[2] = 90; 

Vielleicht gibt es elegantere Weg, um dieses Problem zu lösen, aber ich konnte mit nur diese Weise kommen. Ich würde mich freuen, wenn Sie mir einen eleganteren Weg zeigen oder helfen könnten, dies zu beheben. Die Schleife stoppt auf diese Weise, wenn j = 2 und a = ''.

public class Main { 

    public static void main(String[] args) { 

     String[] sizes = {"90 60 90", "90 70 60"}; 
    // int[][] firstNumber = new int[sizes.length][3]; 
     String firstNumber = ""; 
     String secondNumber = ""; 
     String thirdNumber = ""; 
     int spaces = 0; 

     for (int i = 0; i < sizes.length; i++) { 
      int length = sizes[i].length(); 
      for (int j = 0; j < length; j++) { 
       char a = sizes[j].charAt(j); 
       if (a != ' ' && spaces == 0) { 
        firstNumber += String.valueOf(a); 
       } else if (a != ' ' && spaces == 1) { 
        secondNumber += String.valueOf(a); 
       } else if (a != ' ' && spaces == 2) { 
        thirdNumber += String.valueOf(a); 
       } else if (a == ' ') { 
        spaces++; 
       } 
      } 
     } 
     System.out.println(firstNumber + secondNumber + thirdNumber); 
    } 
} 

Vielen Dank.

Answer 1

Eine einfachere Art und Weise als Ströme ist ein StringTokenizer zu verwenden. Das Argument des Konstruktors ist der String, den Sie trennen möchten. Die Methode nextToken wird aufgerufen, um zum nächsten Token (in diesem Beispiel von 90 zu 60) zu springen. Wenn kein Argument vorhanden ist, werden Token durch Leerzeichen getrennt. Hier ist sie:

import java.util.Arrays; 
import java.util.StringTokenizer; 

public class test { 

    public static void main(String[] args) { 

     String[] sizes = {"90 60 90", "90 70 60"}; 
     StringTokenizer st = new StringTokenizer(sizes[0]); 
     int[] sizesInt = new int[6]; 
     sizesInt[0] = Integer.parseInt(st.nextToken()); 
     sizesInt[1] = Integer.parseInt(st.nextToken()); 
     sizesInt[2] = Integer.parseInt(st.nextToken()); 
     st = new StringTokenizer(sizes[1]); 
     sizesInt[3] = Integer.parseInt(st.nextToken()); 
     sizesInt[4] = Integer.parseInt(st.nextToken()); 
     sizesInt[5] = Integer.parseInt(st.nextToken()); 

     System.out.println("sizesInt: " + Arrays.toString(sizesInt)); 

    } 

} 

Output:

sizesInt: [90, 60, 90, 90, 70, 60] 

Answer 2

Eine elegante Möglichkeit wäre Streams zu verwenden. dh:

eine String Array abzurufen:

String[] result = Arrays.stream(sizes) 
         .flatMap((String s) -> Arrays.stream(s.split(" "))) 
         .toArray(String[]::new); 

eine int Array abzurufen:

int[] result = Arrays.stream(sizes) 
        .flatMap((String s) -> Arrays.stream(s.split(" "))) 
        .mapToInt(Integer::parseInt) 
        .toArray(); 

Answer 3

Sie verwenden können:

String[] sizes = {"90 60 90", "90 70 60"}; 
List<Integer[]> list = Stream.of(sizes).map(
     string -> Arrays.asList(string.split("\\s+")).stream() 
       .map(s -> Integer.parseInt(s)) 
       .toArray(Integer[]::new) 
).collect(toList()); 

Um das Ergebnis zu zeigen:

list.forEach(array -> System.out.println(Arrays.asList(array))); 

Ausgänge

[90, 60, 90] 
[90, 70, 60] 

Answer 4

Eine andere Möglichkeit ist:

public class StringToArray { 

    // we use this as index counter in our lambda (effectively final) 
    private static int index = 0; 

    public static void main(String[] args) { 

    // our String 
    String s = "90 60 90"; 

    // we declare and initialize our int array to store 
    // converted Strings to 
    int[] array = new int[s.split(" ").length]; 

     // split by space, get an array, get stream out of 
     // that array, map each String value to int and save 
     // to appropriate index in our int array 
     Arrays.stream(s.split(" ")) 
       .map(Integer::parseInt) 
       .forEach(x -> array[index++] = x); 

     // print out int array content 
     System.out.println(Arrays.toString(array)); 

    } 
} 

Answer 5

Ein weiterer Ansatz ein mehrdimensionales Array Bestücken einer einzigen Schleife und für Eilers. Sollte effizient sein. Multidimensionales Array ist eine intuitive Möglichkeit, Körperproportinformationen zu speichern, wobei jede Zeile zusammenhängende Daten enthält, die sich auf einen bestimmten Körper beziehen. Skalierbar ohne Änderung für so viele Datenzeilen wie erforderlich. Getestet um jdoodle

public class Main { 

    public static void main(String[] args) { 

     String[] sizes = {"90 60 90", "90 70 60"}; 
     String element; 
     String[] sizeArray; 
     int[][] sizeIntArray= new int[sizes.length][3]; 

     for (int i = 0; i < sizes.length; i++) { 
      element = sizes[i]; 
      sizeArray=element.split("\\s"); 
      sizeIntArray[i][0]=Integer.parseInt(sizeArray[0]); 
      sizeIntArray[i][1]=Integer.parseInt(sizeArray[1]); 
      sizeIntArray[i][2]=Integer.parseInt(sizeArray[2]); 
      } 
    } 
}