Java 从特定节点的实时数据库中读取

我的Firebase RealtimeDatabase包含一个名为Records的表。该表中有FirebaseUser Uid，每个Uid中都有日期，每个日期中都有产品列表。

在名为DailyTableActivity的活动中，有一个提示DatePickerDialog的按钮和一个ListView元素，该元素应为连接的用户显示对话框（或当前日期）中特定日期的产品

这是一流的产品

    import java.util.Comparator;

public class Product  {
    public Product() {

    }

    private String id;
    private String Name;
    private double Cal;
    private double Carb;
    private double Prot;
    private double Fat;
    private String Unit;
    private int Def;

    public Product(String name, int cal, int carb, int prot, int fat, String unit, int def,String id) {
        Name = name;
        Cal = cal;
        Carb = carb;
        Prot = prot;
        Fat = fat;
        Unit = unit;
        Def = def;
        this.id=id;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public double getCal() {
        return Cal;
    }

    public void setCal(double cal) {
        Cal = cal;
    }

    public double getCarb() {
        return Carb;
    }

    public void setCarb(double carb) {
        Carb = carb;
    }

    public double getProt() {
        return Prot;
    }

    public void setProt(double prot) {
        Prot = prot;
    }

    public double getFat() {
        return Fat;
    }

    public void setFat(double fat) {
        Fat = fat;
    }

    public String getUnit() {
        return Unit;
    }

    public void setUnit(String unit) {
        Unit = unit;
    }

    public int getDef() {
        return Def;
    }

    public void setDef(int def) {
        Def = def;
    }


    public static Comparator<Product> productComparator= new Comparator<Product>() {
        @Override
        public int compare(Product o1, Product o2) {
            return o1.getName().toLowerCase().compareTo(o2.getName().toLowerCase());
        }
    };
}

import java.util.Comparator；
公共类产品{
公共产品（）{
}
私有字符串id；
私有字符串名称；
私人双卡；
私人双碳；
私人双重保护；
私人双脂；
专用字符串单元；
私人int Def；
公共产品（字符串名称、int-cal、int-carb、int-prot、int-fat、字符串单位、int-def、字符串id）{
名称=名称；
Cal=Cal；
碳水化合物=碳水化合物；
Prot=Prot；
脂肪=脂肪；
单位=单位；
Def=Def；
这个.id=id；
}
公共字符串getId（）{
返回id；
}
公共无效集合id（字符串id）{
this.id=id；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
名称=名称；
}
公共双getCal（）{
返回Cal；
}
公共无效设定值（双设定值）{
Cal=Cal；
}
公共双getCarb（）{
返回碳水化合物；
}
公共无效设置carb（双carb）{
碳水化合物=碳水化合物；
}
公共双getProt（）{
返回保护；
}
公共无效设置保护（双重保护）{
Prot=Prot；
}
公共双getFat（）{
返回脂肪；
}
公共无效setFat（双fat）{
脂肪=脂肪；
}
公共字符串getUnit（）{
返回单元；
}
公共无效设置单位（字符串单位）{
单位=单位；
}
公共int getDef（）{
返回Def；
}
公共void setDef（int def）{
Def=Def；
}
公共静态比较器productComparator=新比较器（）{
@凌驾
公共整数比较（产品o1、产品o2）{
返回o1.getName（）.toLowerCase（）.compareTo（o2.getName（）.toLowerCase（））；
}
};
}

这是我读取数据的代码：

public void getRecordOfDate( String date , final DataStatus dataStatus)
{
    final String currId= FirebaseAuth.getInstance().getCurrentUser().getUid();
    date="D_"+date;
    DatabaseReference recordsOfUser=FirebaseDatabase.getInstance().getReference().child("records").child(currId);
    DatabaseReference dateRef=recordsOfUser.child(date);
    dateRef.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(@NonNull @NotNull DataSnapshot snapshot) {
            if (snapshot.exists()){
                List<String> keys = new ArrayList<>();
                for (DataSnapshot keyNode : snapshot.getChildren()) {
                    products.clear();
                    keys.add(keyNode.getKey());
                    Product product = keyNode.getValue(Product.class);
                    Log.d("DATA_SUCCESS", "Adding product " + product.getName());
                    products.add(product);
                    dataStatus.DataIsLoaded(products, keys);
            }
            }
        }

        @Override
        public void onCancelled(@NonNull @NotNull DatabaseError error) {

        }
    });


}

public void getRecordOfDate（字符串日期，最终数据状态数据状态）
{
最后一个字符串currId=FirebaseAuth.getInstance（）.getCurrentUser（）.getUid（）；
date=“D”+日期；
DatabaseReference recordsOfUser=FirebaseDatabase.getInstance（）.getReference（）.child（“记录”）.child（currId）；
DatabaseReference dateRef=recordsOfUser.child（日期）；
dateRef.addListenerForSingleValueEvent（新的ValueEventListener（））{
@凌驾
公共无效onDataChange（@NonNull@NotNull数据快照快照）{
if（snapshot.exists（））{
列表键=新的ArrayList（）；
对于（DataSnapshot键节点：snapshot.getChildren（））{
产品；
添加（keyNode.getKey（））；
Product Product=keyNode.getValue（Product.class）；
Log.d（“数据_成功”，“添加产品”+product.getName（））；
产品。添加（产品）；
dataStatus.DataIsLoaded（产品、密钥）；
}
}
}
@凌驾
已取消公共无效（@NonNull@NotNull数据库错误）{
}
});
}

dataStatus是一个工作良好的接口，这就是为什么我没有在这里包括它。 我认为我的主要问题来自不存在的日期，然而，即使我选择了存在的日期，它也不起作用

我认为重要的一点是，如果我选择硬代码中存在的日期，数据将被读取，如下所示：

DatabaseReference dateRef=recordsOfUser.child（“D_21_05_2021”）

我非常感谢您的帮助和支持，我希望您能帮助我找到解决此问题的方法，因为我对NoSQL数据库不太熟悉，我想探索实时性的可能性。
String public void getRecordOfDate（String date，final DataStatus DataStatus）{
String public void getRecordOfDate( String date , final DataStatus dataStatus){
final String currId= FirebaseAuth.getInstance().getCurrentUser().getUid();
date="D_"+date;
DatabaseReference recordsOfUser=FirebaseDatabase.getInstance().getReference().child("records").child(currId);
DatabaseReference dateRef=recordsOfUser.child(date);
dateRef.addListenerForSingleValueEvent(new ValueEventListener() {
    @Override
    public void onDataChange(@NonNull @NotNull DataSnapshot snapshot) {
        if (snapshot.exists()){
            List<String> keys = new ArrayList<>();
            if(snapshot.hasChild(date)){
            for (DataSnapshot keyNode : snapshot.getChildren()) {
                //products.clear();
                keys.add(keyNode.getKey());
                //Product product = keyNode.getValue(Product.class);
                String Name = keyNode.child("name").getValue().toString();
                double Cal = Double.parseDouble(keyNode.child("cal").getValue().toString());
                double Carb = Double.parseDouble(keyNode.child("carb").getValue().toString());
                double Prot = Double.parseDouble(keyNode.child("prot").getValue().toString());
                double Fat = Double.parseDouble(keyNode.child("fat").getValue().toString());
                String Unit = keyNode.child("unit").getValue().toString();
                int Def = Integer.parseInt(keyNode.child("def").getValue().toString());
                String Id = keyNode.getKey();
                Product product = new Product(Name, Cal, Carb, Prot, Fat, Unit, Def, Id);
                Log.d("DATA_SUCCESS", "Adding product " + product.getName());
                products.add(product);
                dataStatus.DataIsLoaded(products, keys);
        }
        }else{System.out.print("Date does not exist")}
        }
    }

    @Override
    public void onCancelled(@NonNull @NotNull DatabaseError error) {

    }
});}

最后一个字符串currId=FirebaseAuth.getInstance（）.getCurrentUser（）.getUid（）；
date=“D”+日期；
DatabaseReference recordsOfUser=FirebaseDatabase.getInstance（）.getReference（）.child（“记录”）.child（currId）；
DatabaseReference dateRef=recordsOfUser.child（日期）；
dateRef.addListenerForSingleValueEvent（新的ValueEventListener（））{
@凌驾
公共无效onDataChange（@NonNull@NotNull数据快照快照）{
if（snapshot.exists（））{
列表键=新的ArrayList（）；
if（快照.hasChild（日期））{
对于（DataSnapshot键节点：snapshot.getChildren（））{
//产品；
添加（keyNode.getKey（））；
//Product Product=keyNode.getValue（Product.class）；
字符串名称=keyNode.child（“名称”）.getValue（）.toString（）；
double-Cal=double.parseDouble（keyNode.child（“Cal”）.getValue（）.toString（））；
double-Carb=double.parseDouble（keyNode.child（“Carb”）.getValue（）.toString（））；
double Prot=double.parseDouble（keyNode.child（“Prot”）.getValue（）.toString（））；
double-Fat=double.parseDouble（keyNode.child（“Fat”）.getValue（）.toString（））；
字符串单位=keyNode.child（“单位”）.getValue（）.toString（）；
int Def=Integer.parseInt（keyNode.child（“Def”）.getValue（）.toString（））；
String Id=keyNode.getKey（）；
产品=新产品（名称、标定、碳水化合物、蛋白质、脂肪、单位、Def、Id）；
Log.d（“数据_成功”，“添加产品”+product.getName（））；
产品。添加（产品）；
dataStatus.DataIsLoaded（产品、密钥）；
}
}else{System.out.print（“日期不存在”）}
}
}
@凌驾
已取消公共无效（@NonNull@NotNull数据库错误）{
}
});}