java - 从 Int[] 数组中删除重复项

Question

我已经为此苦苦挣扎了一个小时左右。我正在尝试从 int[] 数组中删除所有重复项。数组的每个元素都是一个 int[]，包含图 block 的 x 和 y 位置。所以，它是 [[3, 1], [3, 12], ...]。在生成我的世界时，我添加了已经看到的图 block ，因此我正在编写一个函数来“压缩”图 block 数组。

我尝试过使用 hashSet 和 set，但由于某种原因，两个 DS 都没有删除重复项。重写 int[] 的 Compare(object1, object2) 是否可能存在问题？

//获取 x,y 坐标数组(形式:int[]{x, y})并通过删除重复项来压缩它

private int[][] condenseTiles(int[][] tiles) {
    Set<int[]> setOfTiles = new LinkedHashSet<int[]>();

    for(int i = 0; i < tiles.length; i++){
        setOfTiles.add(tiles[i]);
    }

    System.out.println(setOfTiles.size());

    return tiles;
}

我知道有一些快捷方式可以将每个元素添加到 HashSet 中，但目前没有任何效果，而且我仍然看到重复项，所以我只是以缓慢且扩展的方式进行操作。作为引用，现在，无论我做什么，setOfTiles 和tiles 都具有相同的大小。如果您有任何建议，请告诉我。

Answer 1

一种可能的解决方案:

• 创建一个 Tile 类，其中包含 x 和 y int 字段
• 让类体面 public boolean equals(Object o)和public int hashCode()方法，一种将具有相同 x 和 y 值的两个 Tiles 视为相等并返回相同 hashCode 的方法
• 将图 block 放在 Set<Tile> 中从一开始——这可以防止重复输入。

例如，

public class Tile {
    private int x;
    private int y;

    public Tile(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + x;
        result = prime * result + y;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Tile other = (Tile) obj;
        if (x != other.x)
            return false;
        if (y != other.y)
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "Tile [" + x + ", " + y + "]";
    }

}

并进行了测试:

import java.util.LinkedHashSet;
import java.util.Set;

public class TestTile {
    public static void main(String[] args) {
        Set<Tile> tileSet = new LinkedHashSet<>();

        int[][] testData = {{1, 2}, {3, 4}, {5, 6}, {1, 2}, {5, 6}};
        for (int[] pair : testData) {
            Tile tile = new Tile(pair[0], pair[1]);
            tileSet.add(tile);
            System.out.println("Tile added: " + tile);
            System.out.println("All Tiles: ");
            for (Tile t : tileSet) {
                System.out.println("  " + t);
            }
            System.out.println();
        }

    }
}

返回结果:

Tile added: Tile [1, 2]
All Tiles: 
  Tile [1, 2]

Tile added: Tile [3, 4]
All Tiles: 
  Tile [1, 2]
  Tile [3, 4]

Tile added: Tile [5, 6]
All Tiles: 
  Tile [1, 2]
  Tile [3, 4]
  Tile [5, 6]

Tile added: Tile [1, 2]
All Tiles: 
  Tile [1, 2]
  Tile [3, 4]
  Tile [5, 6]

Tile added: Tile [5, 6]
All Tiles: 
  Tile [1, 2]
  Tile [3, 4]
  Tile [5, 6]

<小时/>

另一个可能的解决方案，如果你想使用Java 8流，请注意它有一个.filter()方法，但这仅适用于正在流式传输的对象的 hashCode 和 equals，如果您单独流式传输 int 数组，则这根本不起作用。解决方法是使用包装类，类似于 this Stack Overflow answer on "Remove duplicates from a list of objects based on property in Java 8" 。

可能有效的包装类:

import java.util.Arrays;

public class WrapperArray {
    int[] array;

    public WrapperArray(int[] array) {
        this.array = array;
    }

    @Override
    public int hashCode() {
        return Arrays.hashCode(array);
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        WrapperArray other = (WrapperArray) obj;
        if (!Arrays.equals(array, other.array))
            return false;
        return true;
    }

    public int[] unwrap() {
        return array;
    }
}

这可以像这样进行测试:

import java.util.Arrays;

public class TestTile {
    public static void main(String[] args) {

        int[][] testData = { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 1, 2 }, { 5, 6 } };
        System.out.println("before filtering:");
        for (int[] is : testData) {
            System.out.println(Arrays.toString(is));
        }

        int[][] filteredArray = Arrays.stream(testData) // stream int[][] array
                .map(WrapperArray::new)     // map to our wrapper objects
                .distinct()                 // find distinct using wrapper equals/hashCode
                .map(WrapperArray::unwrap)  // convert back to int[]
                .toArray(int[][]::new);     // create new int[][] with results


        System.out.println("after filtering:");
        for (int[] is : filteredArray) {
            System.out.println(Arrays.toString(is));
        }
    }
}

返回结果:

before filtering:
[1, 2]
[3, 4]
[5, 6]
[1, 2]
[5, 6]
after filtering:
[1, 2]
[3, 4]
[5, 6]