用List<List<Integer>>写一个只含1的数组

可以使用以下代码来创建一个只含1的二维数组，其实就是一个2x2的矩阵：

List<List<Integer>> matrix = new ArrayList<>();
matrix.add(Arrays.asList(1, 1));
matrix.add(Arrays.asList(1, 1));

这里使用了 ArrayList 和 Arrays 类来创建 List<List<Integer>>。首先创建一个空的 ArrayList，然后使用 add() 方法向其中添加两个元素，每个元素都是一个包含两个整数的 List，这两个整数都是1。这样就创建了一个只含1的二维数组。

相关问题

List<Map<String, List<Integer>>>字符串转数组 java实现jdk8

要将字符串转换为List<Map<String, List<Integer>>>类型的数组，你可以按照以下步骤进行实现：

1. 首先，将字符串解析为JSON格式对象。你可以使用JSON库（如Jackson或Gson）来完成这一步骤。假设你已经将字符串解析为一个名为"jsonObject"的JSON对象。

2. 接下来，创建一个List<Map<String, List<Integer>>>类型的数组。我们可以称之为"result"。

3. 遍历"jsonObject"中的每个元素。对于每个元素，执行以下步骤：

- 创建一个新的Map<String, List<Integer>>类型的对象，我们可以称之为"map"。
- 遍历当前元素中的每个键值对。对于每个键值对，执行以下步骤：
- 将键转换为String类型，我们可以称之为"key"。
- 将值转换为List<Integer>类型，我们可以称之为"value"。
- 将"key"和"value"添加到"map"中。
- 将"map"添加到"result"数组中。

4. 当遍历完所有元素后，"result"数组将包含所有转换后的数据。

以下是一个示例代码：

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        String jsonString = "your_json_string";
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            // Step 1: Parse the jsonString to a JSON object
            Object jsonObject = objectMapper.readValue(jsonString, Object.class);

            // Step 2: Create a List<Map<String, List<Integer>>> array
            List<Map<String, List<Integer>>> result = new ArrayList<>();

            // Step 3: Iterate over each element in the jsonObject
            for (Map.Entry<String, Object> entry : ((Map<String, Object>) jsonObject).entrySet()) {
                Map<String, List<Integer>> map = new HashMap<>();

                // Step 3.1: Iterate over each key-value pair in the current element
                for (Map.Entry<String, Object> innerEntry : ((Map<String, Object>) entry.getValue()).entrySet()) {
                    String key = innerEntry.getKey();
                    List<Integer> value = (List<Integer>) innerEntry.getValue();

                    // Step 3.2: Add the key-value pair to the map
                    map.put(key, value);
                }

                // Step 3.3: Add the map to the result array
                result.add(map);
            }

            // Step 4: The result array now contains the converted data
            for (Map<String, List<Integer>> map : result) {
                System.out.println(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

java for循环，循环外定义了两个数组对象 CompletableFuture<Integer>[] futuresDa = new CompletableFuture[floorIds.size()]; CompletableFuture<List<Map<String,Object>>>[] futuresXiao = new CompletableFuture[floorIds.size()]; 在for循环内 循环调用两个异步方法， 第一个异步方法返回：CompletableFuture<List<Map<String,Object>>> addDaXiang 执行完第一个异步方法 调用CompletableFuture.allOf(futuresDa).join(); CompletableFuture 空指针

根据你提供的信息，我猜测你的代码大致如下：

CompletableFuture<Integer>[] futuresDa = new CompletableFuture[floorIds.size()];
CompletableFuture<List<Map<String,Object>>>[] futuresXiao = new CompletableFuture[floorIds.size()];
for (int i = 0; i < floorIds.size(); i++) {
    CompletableFuture<List<Map<String,Object>>> addDaXiang = addDaXiang(floorIds.get(i));
    CompletableFuture<List<Map<String,Object>>> addXiaoXiang = addXiaoXiang(floorIds.get(i));
    futuresDa[i] = addDaXiang.thenApplyAsync(daXiang -> {
        // some code here
        return someValue;
    });
    futuresXiao[i] = addXiaoXiang.thenApplyAsync(xiaoXiang -> {
        // some code here
        return someValue;
    });
}
CompletableFuture.allOf(futuresDa).join();

根据代码分析，我认为你出现空指针异常的原因是因为`addDaXiang`方法返回的`CompletableFuture`对象为空。这可能是因为在异步方法内部出现了异常，导致返回的`CompletableFuture`对象没有正确地被赋值。

你可以在`addDaXiang`方法内部添加异常处理逻辑，将异常信息打印出来，以便你更好地定位问题所在。例如：

public CompletableFuture<List<Map<String,Object>>> addDaXiang(int floorId) {
    CompletableFuture<List<Map<String,Object>>> future = new CompletableFuture<>();
    // some code here
    try {
        // some code here
        future.complete(someValue);
    } catch (Exception e) {
        future.completeExceptionally(e);
    }
    return future;
}

这样，如果`addDaXiang`方法内部出现异常，将会把异常信息放入`CompletableFuture`对象中，并返回给调用者。在调用者处，你可以通过`CompletableFuture.exceptionally()`方法来处理异常信息。