java-2D数组查找随机空值

我有一个2D数组，其中有些索引为null，有些索引为value。 我想选择一个包含null的随机索引

范例

5,0,0,5,0
4,0,0,4,7
9,0,4,8,9
0,8,4,0,1

我想从这些零中选择随机索引

---

对于回复，您可以使用简单的技巧-只需将零值映射到数组。 或者更好的解决方案是只计算零值的数量，因此，您应该迭代二维数组并比较值-如果您想找到零值，那么它应该是：

int count = 0;
for(int i=0;i< array.length;i++)
  for(int j=0;j< array[i].length;j++)
    if(array[i][j] == 0)
      count++;

int count=0；
for（int i=0；i

之后，您可以从间隔1计数中获取随机数，然后迭代2D数组并选择具有随机位置的零

int randomPosition = (int )(Math.random() * (count-1));
int now=0;
if(randomPosition > -1)
  for(int i=0;i< array.length;i++)
    for(int j=0;j< array[i].length;j++)
      if(array[i][j]==0){
         now++;
         if(now == randomPosition){
         rowPosition = i;
         columnPosition = j;
        }
      }

intrandomposition=（int）（Math.random（）*（count-1））；
现在int=0；
如果（随机位置>-1）
for（int i=0；i

---

这并不是正确的方法，如果可以的话，您不应该在设计中使用空值或零作为空值，最好考虑另一种在2D数组中保存值的解决方案。您真的需要空值还是零值？为什么需要返回随机空位置？

或者您可以尝试以下方法：将“0”的索引作为键/值放在映射上，然后：

   Random   random = new Random();
   Map x= new HashMap();
    x.put(0,1); 

List keys=new ArrayList（x.keySet（））；
整数randomX=keys.get（random.nextInt（keys.size（））；
整数值=x.get（randomX）；

//初始化数组
int数组[][]={{5,0,0,5,0}，{4,0,0,4,7}，
{ 9, 0, 4, 8, 9 }, { 0, 8, 4, 0, 1 } };
//0值元素索引的初始向量
ArrayList索引=新的ArrayList（）；
//查找值为0的元素的索引
for（int i=0；i

---

该解决方案的基础是很容易在一维数组中选择随机值。因此，第一步是将所有属于值为0的元素的索引收集到ArrayList对象中，然后在此ArrayList对象中选择一个随机元素将得到搜索的索引。

从您的问题中，我了解到您希望在Java中的二维数组中选择一个随机元素（包含0）。首先，您应该了解，由于大多数数字都是基于值的，

0！=空

。这将有助于使你的问题更清楚

现在，您必须首先在数组中循环以确定哪些元素为0，并记录每个0元素的放置位置。然后，生成一个随机数以确定应拾取哪个0元素：

//determines amt of 0s in array
ArrayList<ArrayList<int>> keys = new ArrayList<>();
for (int i = 0; i < array.length; i++) {
    ArrayList<int> inner = new ArrayList<int>();
    for (int j = 0; j < array[i].length; j++) {
        if (i == 0) { inner.add(j); }
    }
    keys.add(inner);
}

Random r = new Random();
//TODO: generate random number, determine which element to pick

//确定数组中0的数量
ArrayList键=新的ArrayList（）；
for（int i=0；i

---

希望这有帮助。

此解决方案可能有点长，但很有效。我试图用java streams解决这个问题：

首先，您需要将2D数组转换为简单的IntStream。最简单的方法可能是：

Arrays.stream(arr).flatMapToInt(intArr -> Arrays.stream(intArr));

我们的流现在如下所示：

{5,0,0,0,5,0,4,0,0,4,7,9...}

{KeyValue[i=0 v=5], KeyValue[i=1 v=0], KeyValue[i=2 v=0], KeyValue[i=3 v=0]...}

int[][] arr = new int[][]
            {
                    {5, 0, 0, 5, 0},
                    {4, 0, 0, 4, 7},
                    {9, 0, 4, 8, 9},
                    {0, 8, 4, 0, 1}
            };
    Random random = new Random();
    KeyValue.restart();
    KeyValue[] zeros = Arrays
            .stream(arr)
            .flatMapToInt(intArr -> Arrays.stream(intArr))
            .mapToObj(KeyValue::new)
            .filter(k -> k.value == 0)
            .toArray(KeyValue[]::new);
    int ourResult = zeros[random.nextInt(zeros.length)].index;

接下来，您需要使用键值（本例中为索引值）等值获取流。这对于streams来说相当困难，可能有一个更简单的解决方案，但我创建了一个索引自动递增的KeyValue类：

class KeyValue {
    int index;
    int value;
    static int nextIndex;

    public KeyValue(int v) {
        this.index = nextIndex;
        nextIndex++;
        this.value = v;
    }
    public static void restart() {
        nextIndex = 0;
    }
}

现在很容易将流转换为索引值项。电话：

.mapToObj(KeyValue::new)

现在，我们的流如下所示：

{5,0,0,0,5,0,4,0,0,4,7,9...}

{KeyValue[i=0 v=5], KeyValue[i=1 v=0], KeyValue[i=2 v=0], KeyValue[i=3 v=0]...}

int[][] arr = new int[][]
            {
                    {5, 0, 0, 5, 0},
                    {4, 0, 0, 4, 7},
                    {9, 0, 4, 8, 9},
                    {0, 8, 4, 0, 1}
            };
    Random random = new Random();
    KeyValue.restart();
    KeyValue[] zeros = Arrays
            .stream(arr)
            .flatMapToInt(intArr -> Arrays.stream(intArr))
            .mapToObj(KeyValue::new)
            .filter(k -> k.value == 0)
            .toArray(KeyValue[]::new);
    int ourResult = zeros[random.nextInt(zeros.length)].index;

现在过滤零并将流收集到数组：

.filter(kv -> kv.value == 0).toArray(KeyValue[]::new);

创建数组的全部代码如下：

KeyValue[] zeros = Arrays
                .stream(arr)
                .flatMapToInt(intArr -> Arrays.stream(intArr))
                .mapToObj(KeyValue::new)
                .filter(k -> k.value == 0)
                .toArray(KeyValue[]::new);

现在很容易从数组中获取随机值：

int ourResult = zeros[random.nextInt(zeros.length)].index;

整个代码如下所示：

{5,0,0,0,5,0,4,0,0,4,7,9...}

{KeyValue[i=0 v=5], KeyValue[i=1 v=0], KeyValue[i=2 v=0], KeyValue[i=3 v=0]...}

int[][] arr = new int[][]
            {
                    {5, 0, 0, 5, 0},
                    {4, 0, 0, 4, 7},
                    {9, 0, 4, 8, 9},
                    {0, 8, 4, 0, 1}
            };
    Random random = new Random();
    KeyValue.restart();
    KeyValue[] zeros = Arrays
            .stream(arr)
            .flatMapToInt(intArr -> Arrays.stream(intArr))
            .mapToObj(KeyValue::new)
            .filter(k -> k.value == 0)
            .toArray(KeyValue[]::new);
    int ourResult = zeros[random.nextInt(zeros.length)].index;

---

快乐编码：）

我一直在寻找这个答案，并在处理过程中得出以下结论：

// object to hold some info
class Point {
    // public fields fine for Point object
    public int i, j, count;
    // constructor
    public Point (int i, int j) {
        this.i = i;
        this.j = j;
        this.count = 0;
    }

    public String toString() {
        return i + " , " + j;
    }
}
int[][] grid;

// processing needs to init grid in setup
void setup() {
    // init grid
    grid = new int[][] {
    {5,1,2},
    {3,4,4},
    {4,0,1}
    };
println(getRandomZero(new Point(0,0)));
}

// recursion try for 300 random samples
Point getRandomZero(Point e) {
    // base case
    Point p = e;
    if (grid[p.i][p.j] != 0 && p.i < grid.length && p.j < grid[p.i].length) {
        p.i = randomInt(0,grid.length);
        p.j = randomInt(0,grid[p.i].length);
        p.count++;
// if can't find it in 300 tries return null (probably not any empties)
        if (p.count > 300) return null;
        p = getRandomZero(p);
    }
    return p;
}
// use Random obj = new Random() for Java
int randomInt(int low, int high) {
    float random = random(1);
    return (int) ((high-low)*random)+low;
}

//用于保存某些信息的对象
类点{
//点对象的公共字段
公共int i，j，计数；
//建造师
公共点（int i、int j）{
这个。i=i；
这个。j=j；
此值为0.count；
}
公共字符串toString（）{
返回i+“，”+j；
}
}
int[][]网格；
//处理需要在安装程序中初始化网格
无效设置（）{
//初始网格
网格=新整数[][]{
{5,1,2},
{3,4,4},
{4,0,1}
};
println（getRandomZero（新点（0,0））；
}
//300个随机样本的递归尝试
零点（e点）{
//基本情况
点p=e；
if（grid[p.i][p.j]！=0&&p.i300）返回null；
p=零（p）；
}
返回p；
}
//对Java使用Random obj=new Random（）
int randomInt（int低，int高）{
浮动随机=随机（1）；
返回（int）（（高-低）*随机）+低；
}

---

明天我将专门为Java进行编辑。

我正在为gomoku制作随机算法，所以我需要从清空thx中选择随机位置replies@MarekForst好的，我不知道这个游戏，但是如果你真的需要它，你可以使用我写的，没有效果的，