Java中不相交的两个结果集

我有两个结果集来自两个不同的数据库，我需要比较它。我想要一个像这样的手术

A-B

要在他们身上执行

我无法执行逐行比较，因为结果集中的第一行可以出现在B结果集中的任何位置

下面是在.NET中执行此操作的代码，非常简单和完美

var nonIntersecting = dtSource.AsEnumerable().Except
                      (
                        dtTarget.AsEnumerable(), DataRowComparer.Default
                      );
try
{
   dtSrcToTgtResult = nonIntersecting.CopyToDataTable();
} catch (InvalidOperationException ex) {}

这里的dtSource、dtTarget是包含来自数据库的源数据和目标数据的数据表。 dtSrcToTgtResult包含源中存在的数据，但不包含目标中的数据，这正是我想要的

可以在JavaScript中使用结果集执行同样的操作。我还可以检查

CachedRowSet

或

webRowSet

中是否有类似的内容

编辑

对于投负票的人。这是我已经做过的，但并不能解决问题

private Boolean compare(ResultSet rsSrc,ResultSet rsTgt,String ExecCondition)
    {
        Boolean status = true;
        try  
        {
            ResultSetMetaData metaSrc = rsSrc.getMetaData(); 
            ResultSetMetaData metaTgt = rsTgt.getMetaData();
            final int columnCountSrc = metaSrc.getColumnCount();
            List<DBRow> dList = new  ArrayList<DBRow>();
            List<DBRow> DataInSourceNotInTarget = new ArrayList<DBRow>();
            List<DBRow> DataInTargetNotInSource = new ArrayList<DBRow>();

            DBRow d = new DBRow();
            DBRow d1 = new DBRow();

            for (int column = 1; column <= columnCountSrc; column++) 
            {
            d.Row.add(metaSrc.getColumnName(column));
            d1.Row.add(metaTgt.getColumnName(column));
            }
            DataInSourceNotInTarget.add(d);
            DataInTargetNotInSource.add(d1);

            if(ExecCondition.equals("Source To Target"))
            {

            while(rsSrc.next())
            {

                if(rsTgt.next())
                {
                for (int column = 1; column <= columnCountSrc; column++) 
                {

                    Object valueSrc = rsSrc.getObject(column);
                    Object valueTgt = rsTgt.getObject(column);

                        if(!valueSrc.toString().equals(valueTgt.toString()))
                        {
                            status=false;
                            System.out.println("ValueSRC: "+v    alueSrc.toString());
                            System.out.println("ValueTgt: "+valueTgt.toString());
                    }

            }
            }
            else
            {
                // if target rows ends
                DBRow dr = new DBRow();

                for (int column = 1; column <= columnCountSrc; column++) 
                {

                    Object valueSrc = rsSrc.getObject(column);
                    dr.Row.add(valueSrc);
                }
                DataInSourceNotInTarget.add(dr);

            }

        }
    }//exec condition if


        if(ExecCondition.equals("Target To Source"))
        {

        while(rsTgt.next())
        {

            if(rsSrc.next())
            {
            for (int column = 1; column <= columnCountSrc; column++) 
            {

                Object valueSrc = rsSrc.getObject(column);
                Object valueTgt = rsTgt.getObject(column);

                    if(!valueSrc.toString().equals(valueTgt.toString()))
                    {
                        status=false;
                        System.out.println("ValueSRC: "+valueSrc.toString());
                        System.out.println("ValueTgt: "+valueTgt.toString());
                    }

            }
            }
            else
            {
                // if Source rows ends
                DBRow dr = new DBRow();

                for (int column = 1; column <= columnCountSrc; column++) 
                {

                    Object valueTgt = rsTgt.getObject(column);
                    dr.Row.add(valueTgt);
                }
                DataInTargetNotInSource.add(dr);

            }

        }

        for(DBRow obj:DataInTargetNotInSource)
        {
            obj.print();
        }
    }//exec condition if


    }
    catch(Exception e)
    {
        e.printStackTrace();
    }

    return status;
}

private Boolean compare（ResultSet rsSrc、ResultSet rsTgt、String ExecCondition）
{
布尔状态=真；
尝试
{
ResultSetMetaData metaSrc=rsSrc.getMetaData（）；
ResultSetMetaData metaTgt=rsTgt.getMetaData（）；
final int columnCountSrc=metaSrc.getColumnCount（）；
List dList=new ArrayList（）；
List DataInSourceNotTarget=new ArrayList（）；
List DataInTargetNotInSource=new ArrayList（）；
DBRow d=新的DBRow（）；
DBRow d1=新的DBRow（）；
对于（int column=1；column我有一个功能性但非最佳的解决方案：

它需要将所有行加载到内存中的数据结构中（每个结果集都加载到列表中，每个项都是列名值的映射）
在源行列表上循环，并针对该列表中的每个项目-搜索目标列表中不存在的项目（表示o（n^2）处理）
我过去很容易将结果集转换为列表

import java.sql.*;
import java.util.*;
import java.util.stream.*;
import org.apache.commons.dbutils.handlers.MapListHandler;

try (Connection conn = DriverManager.getConnection(url, user, password)) {

    // load source table
    Statement st = conn.createStatement();
    ResultSet sourceRs = st.executeQuery("SELECT * FROM source");
    List<Map<String, Object>> sourceRows = new MapListHandler().handle(sourceRs);
    sourceRs.close();
    st.close();

    // load target table
    st = conn.createStatement();
    ResultSet targetRs = st.executeQuery("SELECT * FROM target");
    List<Map<String, Object>> targetRows = new MapListHandler().handle(targetRs);
    targetRs.close();
    st.close();

    // for every row in source, look for no match in target
    List<Map<String, Object>> diffRows = 
    sourceRows.stream()
        .filter(sourceRow -> rowExistsInTable(sourceRow, targetRows) == false)
        .collect(Collectors.toList());

    diffRows.stream().forEach(System.out::println); 

} catch (Exception e) {
    e.printStackTrace();
}

比较是如何进行的？源和目标是否具有相同的列？@sharonbn源和目标将具有相同的列，但数据中可能会出现不匹配，这就是验证。要确定源中有哪些内容而目标中没有。你想让其他人做你的功课吗？@skible我已经编写了代码，但这是逐行比较的。然后t并没有解决问题。我已经说过了。为什么要投负数票。我不能在我的应用程序中导入java.util.stream.*和sourceRows.stream（）不可用。这是Java 8功能。您使用的是什么版本？diffRows只返回源中的所有内容。这意味着您需要修改行的比较。在我的示例中，我使用
targetRow.equals（sourceRow）
确定目标结果集中是否存在源行。它基于equals（）HashMap的，它应该检查键和值是否相等。您可能需要根据您拥有的数据修改它（可能只检查主键列？）。打印和/或调试是下一步…我一生中从未使用过lambda exp。您能否建议我进行修改，以便在源与目标之间进行比较时获得行的差异。
/**
 * checks if {@code searchRow} exists in {@code table}
 * existence is determined according to {@code areRowsEqual} method 
 * @param searchRow {@code Map<String, Object>} where keys are column names and values are column vales 
 * @param table {@code List} of {@code Map<String, Object>} rows 
 * @return {@code true} if {@code searchRow} was found in {@code table} 
 */
public static boolean rowExistsInTable(Map<String, Object> searchRow, List<Map<String, Object>> table)
{
    for (Map<String, Object> tableRow : table) {
        if (areRowsEqual(tableRow, searchRow)) return true;
    }
    return false;
}

/**
 * checks if all of row1 columns are found with same values in row2
 * note: does not check if there is column in row2 that does not exist in row1  
 * @param row1 
 * @param row2
 * @return {@code true} if {@code row1} is equal to {@code row2}
 */
public static boolean areRowsEqual(Map<String, Object> row1, Map<String, Object> row2)
{
    // loop on row1 columns
    for (Map.Entry<String, Object> row1Column : row1.entrySet()) {
        String row1ColumnName = row1Column.getKey(); 
        Object row1ColumnValue = row1Column.getValue();
        // search row1 column in row2
        if (row2.containsKey(row1ColumnName) &&
            row2.get(row1ColumnName) != null &&
            row2.get(row1ColumnName).equals(row1ColumnValue)) {
            // row1 column was found in row2, nothing to do 
        } else {
            // row1 column was not found in row2
            return false;
        }
    }
    return true;  // all row 1 columns found in row 2
}