Spark Java：当列的顺序不同时，如何比较模式？

下面，我现在运行以下代码：

List<StructField> fields = new ArrayList<>();
fields.add(DataTypes.createStructField("A",DataTypes.LongType,true));
fields.add(DataTypes.createStructField("B",DataTypes.DoubleType,true));
StructType schema1 = DataTypes.createStructType(fields);
Dataset<Row> df1 = spark.sql("select 1 as A, 2.2 as B");
Dataset<Row> finalDf1 = spark.createDataFrame(df1.javaRDD(), schema1);

fields = new ArrayList<>();
fields.add(DataTypes.createStructField("B",DataTypes.DoubleType,true));
fields.add(DataTypes.createStructField("A",DataTypes.LongType,true));
StructType schema2 = DataTypes.createStructType(fields);
Dataset<Row> df2 = spark.sql("select 2.2 as B, 1 as A");
Dataset<Row> finalDf2 = spark.createDataFrame(df2.javaRDD(), schema2);

finalDf1.printSchema();
finalDf2.printSchema();
System.out.println(finalDf1.schema());
System.out.println(finalDf2.schema());
System.out.println(finalDf1.schema().equals(finalDf2.schema()));

---

虽然列的排列顺序不同，但这两个数据集的列和列类型完全相同。这里需要进行什么比较才能得到

true

？

假设顺序cols不匹配，相同的名称具有相同的语义，并且需要相同的列数

在使用SCALA的示例中，您应该能够根据JAVA进行定制：

import spark.implicits._
val df = sc.parallelize(Seq(
        ("A", "X", 2, 100), ("A", "X", 7, 100), ("B", "X", 10, 100),
        ("C", "X", 1, 100), ("D", "X", 50, 100), ("E", "X", 30, 100)
        )).toDF("c1", "c2", "Val1", "Val2")
val names = df.columns

val df2 = sc.parallelize(Seq(
       ("A", "X", 2, 1))).toDF("c1", "c2", "Val1", "Val2")
val names2 = df2.columns

names.sortWith(_ < _) sameElements names2.sortWith(_ < _)

导入spark.implicits_
val df=sc.并行化（序号(
(A,X,2100),(A,X,7100),(B,X,10100),，
(C,X,1100),(D,X,50100),(E,X,30100)
)).toDF（“c1”、“c2”、“Val1”、“Val2”）
val name=df.columns
val df2=sc.parallelize（顺序(
（A）、（X）、（2、1））。toDF（“c1”、“c2”、“Val1”、“Val2”）
val names2=df2.0列
name.sortWith（

---

返回true或false，尝试输入。

如果它们的顺序不同，则它们不相同。甚至它们都有相同的列数和相同的名称。如果希望查看两个模式是否具有相同的列名，则从两个数据帧中获取列表中的模式，然后编写代码来比较它们。请参见下面的java示例

public static void main(String[] args)
{

    List<String> firstSchema =Arrays.asList(DataTypes.createStructType(ConfigConstants.firstSchemaFields).fieldNames());
    List<String> secondSchema = Arrays.asList(DataTypes.createStructType(ConfigConstants.secondSchemaFields).fieldNames());


    if(schemasHaveTheSameColumnNames(firstSchema,secondSchema))
    {
        System.out.println("Yes, schemas have the same column names");
    }else
    {
        System.out.println("No, schemas do not have the same column names");
    }
}

private static boolean schemasHaveTheSameColumnNames(List<String> firstSchema, List<String> secondSchema)
{
    if(firstSchema.size() != secondSchema.size())
    {
        return false;
    }else 
    {
        for (String column : secondSchema)
        {
            if(!firstSchema.contains(column))
                return false;
        }
    }
    return true;
}

publicstaticvoidmain（字符串[]args）
{
List firstSchema=Arrays.asList（DataTypes.createStructType（ConfigConstants.firstSchemaFields）.fieldNames（））；
List secondSchema=Arrays.asList（DataTypes.createStructType（ConfigConstants.secondSchemaFields）.fieldNames（））；
if（schema保存相同的列名（第一个schema，第二个schema））
{
System.out.println（“是的，架构具有相同的列名”）；
}否则
{
System.out.println（“不，架构没有相同的列名”）；
}
}
私有静态布尔模式保存相同的列名称（列出第一个模式，列出第二个模式）
{
if（firstSchema.size（）！=secondSchema.size（））
{
返回false；
}否则
{
for（字符串列：secondSchema）
{
如果（！firstSchema.contains（列））
返回false；
}
}
返回true；
}

根据前面的答案，似乎比较

结构字段（列和类型）而不仅仅是名称的最快方法是：

Set<StructField> set1 = new HashSet<>(Arrays.asList(schema1.fields()));
Set<StructField> set2 = new HashSet<>(Arrays.asList(schema2.fields()));
boolean result = set1.equals(set2);

setset1=newhashset（Arrays.asList（schema1.fields（））；
Set set2=newhashset（Arrays.asList（schema2.fields（））；
布尔结果=set1.equals（set2）；
获取架构信息，按名称对列进行排序，然后按数据类型对列进行排序并进行比较。返回ds1.schema（）.fields（）.equals（ds2.schema（）.fields（））；
Set<StructField> set1 = new HashSet<>(Arrays.asList(schema1.fields()));
Set<StructField> set2 = new HashSet<>(Arrays.asList(schema2.fields()));
boolean result = set1.equals(set2);