java 把整数拆分成数组不能用string

是的，Java中可以使用整型数组来拆分整数，不需要使用字符串。以下是一个示例代码，可以将一个整数拆分为数组：

int num = 12345;
int length = (int) Math.log10(num) + 1; //获取数字的位数
int[] arr = new int[length]; //创建整型数组，长度为数字的位数

for (int i = 0; i < length; i++) {
    arr[i] = num % 10; //将数字的每一位存入数组中
    num /= 10;
}

//输出数组中的元素
for (int i = length - 1; i >= 0; i--) {
    System.out.print(arr[i] + " ");
}

输出结果为：5 4 3 2 1

相关问题

一个有10000个元素的整型数组，数组中的每个元素是0-10000间的随机整数，计算数组中所有元素之和，要求用两个线程实现。Java

在Java中，我们可以使用`ConcurrentHashMap`和`ForkJoinPool`或者`ExecutorService`以及自定义的`ThreadLocal`来实现这个任务的并行计算，确保两个线程同时对数组的一半进行求和。以下是使用`ExecutorService`的一个示例：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ParallelSum {
    private int[] array;
    private int totalSum = 0;
    
    public ParallelSum(int[] array) {
        this.array = array.clone();
    }

    public void parallelSum(ExecutorService executor) {
        int half = array.length / 2;
        
        List<Future<Integer>> futures = new ArrayList<>();
        for (int i = 0; i < half; i++) {
            final int start = i;
            Future<Integer> future = executor.submit(() -> sumSubArray(start, start + half));
            futures.add(future);
        }
        
        // Wait for all threads to finish and get their results
        for (Future<Integer> future : futures) {
            totalSum += future.get();  // Block until result is available
        }
        
        executor.shutdown();
    }

    private int sumSubArray(int low, int high) {
        int sum = 0;
        for (int i = low; i < high; i++) {
            sum += array[i];
        }
        return sum;
    }

    public int getTotalSum() {
        return totalSum;
    }

    public static void main(String[] args) {
        int[] randomArray = new int[10000];  // 随机填充0-10000的整数
        // ... (填充随机数)

        ExecutorService executor = Executors.newFixedThreadPool(2);  // 创建一个固定大小的线程池
        ParallelSum sumCalculator = new ParallelSum(randomArray);
        sumCalculator.parallelSum(executor);

        System.out.println("Total sum: " + sumCalculator.getTotalSum());
    }
}

在这个例子中，我们首先将数组分成两半，然后创建一个线程池来处理每个部分的求和。当所有任务完成之后，我们将结果合并得到最终总和。

java随机分配_java正整数分成n份且每一份数值随机分配

可以使用Java中的Random类和数组来实现这个功能。具体步骤如下：

1. 首先输入要分成的份数n和总数值sum。

2. 定义一个长度为n的整数数组，用于存放每一份的数值。

3. 生成n-1个随机数，每个随机数表示分割点的位置，从小到大排序。

4. 根据分割点和sum值，计算每一份的数值。

5. 将每一份的数值存入数组中并输出。

下面是Java代码实现：

import java.util.*;

public class RandomSplit {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入要分成的份数n：");
        int n = scanner.nextInt();
        System.out.print("请输入总数值sum：");
        int sum = scanner.nextInt();

        Random random = new Random();
        int[] splitPoints = new int[n-1];
        for (int i = 0; i < n-1; i++) {
            splitPoints[i] = random.nextInt(sum);
        }
        Arrays.sort(splitPoints);

        int[] values = new int[n];
        int start = 0;
        for (int i = 0; i < n-1; i++) {
            values[i] = splitPoints[i] - start;
            start = splitPoints[i];
        }
        values[n-1] = sum - start;

        for (int i = 0; i < n; i++) {
            int value = random.nextInt(values[i])+1;
            System.out.println("第"+(i+1)+"份的数值是："+value);
        }
    }
}

其中，random.nextInt(n)表示生成一个0到n-1的随机整数。注意，这里需要加1，因为题目要求每一份的数值是正整数。