distinct多个字段去重

你可以使用 `DISTINCT` 关键字或 `GROUP BY` 子句来对多个字段进行去重。例如，假设你有一个名为 `table_name` 的表，其中包含 `field1`、`field2` 和 `field3` 三个字段，你可以使用以下 SQL 语句来去重：

1. 使用 DISTINCT 关键字

   SELECT DISTINCT field1, field2, field3
   FROM table_name;

这将根据 `field1`、`field2` 和 `field3` 这三个字段进行去重，并返回所有不同的组合。

2. 使用 GROUP BY 子句

   SELECT field1, field2, field3
   FROM table_name
   GROUP BY field1, field2, field3;

这将根据 `field1`、`field2` 和 `field3` 这三个字段进行分组，并返回每个不同的组合。注意，使用 GROUP BY 子句时，SELECT 语句中只能包含聚合函数或分组的字段。

相关问题

stream流 distinct 多个字段去重

可以使用 Java 8 的 Stream API 中的 `distinct` 方法结合自定义的 `equals` 和 `hashCode` 方法来实现多个字段的去重。具体代码如下：

List<MyObject> list = Arrays.asList(
        new MyObject("A", 1),
        new MyObject("B", 2),
        new MyObject("A", 1),
        new MyObject("C", 3),
        new MyObject("B", 2));

List<MyObject> distinctList = list.stream()
        .distinct()
        .collect(Collectors.toList());

System.out.println(distinctList);

其中，`MyObject` 为自定义的对象，包含两个字段 `field1` 和 `field2`。`equals` 和 `hashCode` 方法如下：

class MyObject {
    private String field1;
    private int field2;

    public MyObject(String field1, int field2) {
        this.field1 = field1;
        this.field2 = field2;
    }

    // 自定义equals方法，比较两个字段是否相等
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        MyObject myObject = (MyObject) o;

        if (field2 != myObject.field2) return false;
        return field1 != null ? field1.equals(myObject.field1) : myObject.field1 == null;
    }

    // 自定义hashCode方法，计算两个字段的hashCode值
    @Override
    public int hashCode() {
        int result = field1 != null ? field1.hashCode() : 0;
        result = 31 * result + field2;
        return result;
    }

    // getter和setter方法
    public String getField1() {
        return field1;
    }

    public void setField1(String field1) {
        this.field1 = field1;
    }

    public int getField2() {
        return field2;
    }

    public void setField2(int field2) {
        this.field2 = field2;
    }

    // toString方法，方便输出
    @Override
    public String toString() {
        return "MyObject{" +
                "field1='" + field1 + '\'' +
                ", field2=" + field2 +
                '}';
    }
}

运行结果为：

[MyObject{field1='A', field2=1}, MyObject{field1='B', field2=2}, MyObject{field1='C', field2=3}]

可以看到，相同的两个对象被去重了，只剩下了不同的对象。

distinct根据单个字段去重

在 SQL 中，可以使用 DISTINCT 关键字根据单个字段去重。例如，假设有一个表格叫做 orders，其中包含以下字段：order_id、customer_name 和 order_date。如果要根据 customer_name 去重，可以使用以下 SQL 语句：

SELECT DISTINCT customer_name FROM orders;

这将返回一个唯一的、去重后的 customer_name 列表。如果要同时根据多个字段去重，可以在 SELECT 语句中包含多个字段，用逗号分隔。例如，如果要根据 customer_name 和 order_date 去重，可以使用以下 SQL 语句：

SELECT DISTINCT customer_name, order_date FROM orders;

这将返回一个唯一的、去重后的 customer_name 和 order_date 组合的列表。