输入 3 2 2 2转化成int []arr = {2,2,2}

您可以使用以下代码将字符串 "3 2 2 2" 转换为 int 数组 `{2, 2, 2}`：

import java.util.Arrays;

public class ConvertArray {
    public static void main(String[] args) {
        String input = "3 2 2 2";
        
        String[] elements = input.split(" ");
        
        int[] arr = new int[elements.length];
        
        for (int i = 0; i < elements.length; i++) {
            arr[i] = Integer.parseInt(elements[i]);
        }
        
        System.out.println(Arrays.toString(arr));
    }
}

上述代码将字符串按空格拆分成字符串数组 `elements`，然后创建一个与元素数量相同的 int 数组 `arr`。接下来，使用循环将字符串元素逐个转换为整数，并存储到 int 数组中。最后，使用 `Arrays.toString()` 方法打印转换后的整数数组。

输出结果为：[3, 2, 2, 2]

相关问题

下面java代码转化为c import java.util.*; public class Main{ public static void main(String args[]) { Scanner scan = new Scanner(System.in); String line; while (scan.hasNextLine()) { line = scan.nextLine().trim(); // please write your code here String[] strs=line.split("\\s+"); int[]ints=new int[strs.length]; for(int i=0;i<strs.length;i++) { ints[i]=Integer.valueOf(strs[i]); } try { int[]ints1=sort(ints); for(int i=0;i<ints1.length;i++) { System.out.print(ints1[i]+" "); } } catch (Exception e) { e.printStackTrace(); } System.out.println(); } } static int[] sort(int[] sourceArray) throws Exception { int[] arr = Arrays.copyOf(sourceArray, sourceArray.length); int maxDigit = getMaxDigit(arr); return radixSort(arr, maxDigit); } static int getMaxDigit(int[] arr) { int maxValue = getMaxValue(arr); return getNumLenght(maxValue); } static int getNumLenght(long num) { if (num == 0) { return 1; } int lenght = 0; for (long temp = num; temp != 0; temp /= 10) { lenght++; } return lenght; } static int getMaxValue(int[] arr) { int maxValue = arr[0]; for (int value : arr) { if (maxValue < value) { maxValue = value; } } return maxValue; } static int[] radixSort(int[] arr, int maxDigit) { int mod = 10; int dev = 1; for (int i = 0; i < maxDigit; i++, dev *= 10,mod *= 10) { int[][] counter = new int[20][0]; for (int j = 0; j < arr.length; j++) { int bucket = ((arr[j] % mod) / dev)+10; counter[bucket] = arrayAppend(counter[bucket], arr[j]); } int pos = 0; for (int[] bucket : counter) { for (int value : bucket) { arr[pos++] = value; } } } return arr; } static int[] arrayAppend(int[] arr, int value) { arr = Arrays.copyOf(arr, arr.length + 1); arr[arr.length - 1] = value; return arr; } }

下面是将Java代码转换为C的等效代码：

c
#include <stdio.h>
#include <stdlib.h>

int* arrayAppend(int* arr, int value, int length) {
arr = (int*)realloc(arr, (length + 1) * sizeof(int));
arr[length] = value;
return arr;
}

int getMaxValue(int* arr, int length) {
int maxValue = arr[0];
for (int i = 1; i < length; i++) {
if (maxValue < arr[i]) {
maxValue = arr[i];
}
}
return maxValue;
}

int getNumLength(long num) {
if (num == 0) {
return 1;
}
int length = 0;
for (long temp = num; temp != 0; temp /= 10) {
length++;
}
return length;
}

int getMaxDigit(int* arr, int length) {
int maxValue = getMaxValue(arr, length);
return getNumLength(maxValue);
}

int* radixSort(int* arr, int length, int maxDigit) {
int mod = 10;
int dev = 1;
for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
int** counter = (int**)malloc(20 * sizeof(int*));
for (int j = 0; j < 20; j++) {
counter[j] = (int*)malloc(0 * sizeof(int));
}
for (int j = 0; j < length; j++) {
int bucket = ((arr[j] % mod) / dev) + 10;
counter[bucket] = arrayAppend(counter[bucket], arr[j], sizeof(counter[bucket]) / sizeof(counter[bucket][0]));
}
int pos = 0;
for (int j = 0; j < 20; j++) {
for (int k = 0; k < sizeof(counter[j]) / sizeof(counter[j][0]); k++) {
arr[pos++] = counter[j][k];
}
free(counter[j]);
}
free(counter);
}
return arr;
}

int* sort(int* sourceArray, int length) {
int* arr = (int*)malloc(length * sizeof(int));
for (int i = 0; i < length; i++) {
arr[i] = sourceArray[i];
}
int maxDigit = getMaxDigit(arr, length);
return radixSort(arr, length, maxDigit);
}

int main() {
char line[100];
while (fgets(line, sizeof(line), stdin)) {
int ints[100];
int intsLength = 0;
char* token = strtok(line, " ");
while (token != NULL) {
ints[intsLength++] = atoi(token);
token = strtok(NULL, " ");
}
int* sortedInts = sort(ints, intsLength);
for (int i = 0; i < intsLength; i++) {
printf("%d ", sortedInts[i]);
}
printf("\n");
free(sortedInts);
}
return 0;
}

需要注意的是，C语言中没有内置的动态数组，因此我们需要使用`realloc`和`malloc`来动态分配和重新分配内存。另外，在C语言中，我们需要手动释放动态分配的内存，以避免内存泄漏。在这个C代码中，我们使用了`malloc`和`realloc`来分配和重新分配内存，并使用`free`来释放内存。

此外，为了与Java代码中的`Scanner`相对应，我们使用了`fgets`来从标准输入读取整行输入，并使用`strtok`来将输入字符串分割成整数数组。最后，我们通过循环打印排序后的整数数组，并在每行结束后释放内存。

请注意，上述代码是根据Java代码逐行转换得来的，可能不是最优的C实现。为了提高性能和效率，你可以进一步优化该代码。

解释这段def data_init(): row_x = int(input('输入第一个矩阵总行数：')) col_x = int(input('输入第一个矩阵总列数：')) arr_row_1 = input('输入第一个矩阵的行号数组（使用空格隔开 应小于总行数）：') row_1 = [int(n) for n in arr_row_1.split()] # 将输入每个数以空格键隔开做成数组 arr_col_1 = input('输入第一个矩阵的列号数组（使用空格隔开 应小于总列数）：') col_1 = [int(n) for n in arr_col_1.split()] arr_data_1 = input('输入第一个矩阵的数据数组（使用空格隔开）：') data_1 = [int(n) for n in arr_data_1.split()] row_y = int(input('输入第二个矩阵总行数：')) col_y = int(input('输入第二个矩阵总列数：')) arr_row_2 = input('输入第二个矩阵的行号数组（使用空格隔开 应小于总行数）：') row_2 = [int(n) for n in arr_row_2.split()] arr_col_2 = input('输入第二个矩阵的列号数组（使用空格隔开 应小于总列数）：') col_2 = [int(n) for n in arr_col_2.split()] arr_data_2 = input('输入第二个矩阵的数据数组（使用空格隔开）：') data_2 = [int(n) for n in arr_data_2.split()] coo_1 = coo_matrix((data_1, (row_1, col_1)),shape=[row_x,col_x])#创建稀疏矩阵 coo_2 = coo_matrix((data_2, (row_2, col_2)),shape=[row_y,col_y]) matrix_1 = coo_1.toarray() # 三元组转化为二维数组来表示稀疏矩阵 matrix_2 = coo_2.toarray() print('\n===== 生成矩阵如下 =====') print('------ 矩阵一 -----') print(matrix_1) print('------ 矩阵二 -----') print(matrix_2) print() return matrix_1, matrix_2

这段代码是一个函数，名为data_init，该函数的目的是从用户输入中生成两个矩阵。函数开始时会要求用户输入第一个矩阵的总行数和总列数，然后要求用户输入第一个矩阵的行号数组、列号数组和数据数组。接下来，函数会要求用户输入第二个矩阵的总行数和总列数，以及第二个矩阵的行号数组、列号数组和数据数组。最后，函数会将这两个稀疏矩阵转换为二维数组，并打印出来。函数返回这两个二维数组。