如何比較兩個對象數組以檢查一個數組元素與其他數組的所有值？

Question

我需要比較兩個對象數組，以檢查一個數組元素與其他數組的所有值。 如果我以這種方式執行，它將在if語句中顯示NULL點異常。

package unlcomp;

import java.util.HashMap;
import java.util.List;

public class relation {
    int rcount=0;
    int r1count=0;
    public String[] rel=new String[100];
    relation rm[]=new relation[100];
    relation rm1[]=new relation[100];
    public String[] UW1=new String[1000];


    public relation[] hash(String[] s,String[] s1,int rcount) {
        for(int i=1;i<=rcount;i++) {
            rm[i]=new relation();
            rm[i].rel[i]=s[i];
            rm[i].UW1[i]=s1[i];
        }
        return rm;

        // System.out.println(rcount);
    }

    public relation[] hash1(String[] s,String[] s1,int r1count) {
        for(int i=1;i<=r1count;i++) {
            rm1[i]=new relation();
            rm1[i].rel[i]=s[i];
            rm1[i].UW1[i]=s1[i];
        }
        return rm1;
    }

    public void compare() {
        relation r[]= rm;
        relation r1[]=rm1;

        for(int i=1;i<r.length;i++) {
            for(int j=1;j<r1.length;j++) {
                if(r1[i].rel[i].equals(r[j].rel[j])) {
                    System.out.println("true");

                } else {
                    System.out.println("false");
                }
            }

        }
    }
}

我需要從另一個類名稱調用此compare方法。

這是調用上述函數的類。

package unlcomp;

import java.io.File;
import java.io.IOException;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Unlcomp {
    public   String[]rel;
    public   String[]  UW1;
    public   String[]  UW2=new String[100];
    public   String[] att1=new String[100];
    public   String[] att2=new String[100];
    int i=0;

    public String[] store=new String[500];
    String pattern2="[-a-z0-9R:._-`&=*'`~\"\\+[\\s]]+[\\(]";

    //String pattern = "[(]+[-a-z0-9R:._-`&=*'`~\"\\+[\\s]]+[\\(.,]";
    String pattern = "[(]+[-a-z0-9R:_]+[(]+[-a-z0-9R:_-`&=*'`~&+,:;=?@#'<>.^*%!-\"\\+[\\s]]+[)]+[\\.\\,\\:]";
    String patterna = "[(]+[-a-z0-9R:_]+[(]+[-a-z0-9R:_-`&=*'`~&+,:;=?@#'<>.^*%!-\"\\+[\\s]]+[)]+[\\,]";
    //String pattern1="[,]+[-a-z0-9R:._-`&=*'`~\"\\+[\\s]]+[\\(.]";
    String pattern1="[,]+[-a-z0-9R:_]+[(]+[-a-z0-9R_,>-`&=*'`~&+,:;=?@#'<>.^*%!-\"\\+[\\s]]+[)]+[\\)\\.]";
    //String pattern1a="[,]+[-a-z0-9R:_]+[(]+[-a-z0-9R_,>-`&=*'`~&+,:;=?@#'<>.^*%!-\"\\+[\\s]]+[)]+[\\.]";
    String pattern3="[\\)]+[\\.@]+[-a-z0-9R:._-`&=*'`~&+,:;=?@#'<>.^*%!-\"\\+[\\s]]+[\\ ,]";
    String pattern4="[\\)]+[\\.@]+[-a-z0-9R:._-`&=*'`~&+,:;=?@#'<>.^*%!-\"\\+[\\s]]+[\\ )]";

    Pattern r = Pattern.compile(pattern);
    //Pattern ra = Pattern.compile(patterna);
    Pattern r1 = Pattern.compile(pattern1);
    //Pattern r1a = Pattern.compile(pattern1a);
    Pattern r2 = Pattern.compile(pattern2);
    Pattern r3 = Pattern.compile(pattern3);
    Pattern r4 = Pattern.compile(pattern4);

    String line;
    relation obj=new relation();
    private int rcount=0;

    public  void preprocess(String pathf1,String pathf2) throws Exception {
        try {
            Scanner scanner = new Scanner(new File(pathf1));
            scanner.useDelimiter("###"); 
            Scanner scanner1 = new Scanner(new File(pathf2));
            scanner1.useDelimiter("###"); 
            //BufferedReader br1 = new BufferedReader(new FileReader(pathf2));
            if( scanner.hasNext()) {
                if(scanner1.hasNext())
                    extract(scanner.next());
                obj.hash(rel,UW1,rcount);
                extract(scanner1.next());
                obj.hash1(rel,UW1,rcount);
                obj.compare();
            }
            scanner.close();
            scanner1.close();
        } catch (IOException e) {}
    }

    public void extract(String line) {
        String [] lines=line.split("\n"); 
        System.out.println(line);
        rel=new String[100];
        UW1=new String[100];
        for(String line1: lines ) {
            // rel=null;
            // UW1=null;
            //UW2=null;
            //att1=null;
            //att2=null;

            Matcher m2 = r2.matcher(line1);
            Matcher m1 = r1.matcher(line1);
            Matcher m3 = r3.matcher(line1);
            Matcher m4 = r4.matcher(line1);
            Matcher m = r.matcher(line1);

            if( m2.find()) {
                rel[i]=m2.group();
                rel[i]=rel[i].substring(0, rel[i].length()-1).trim();
                rcount++;
                //System.out.println(rel[i]);
            }
            if(m.find()) {
                UW1[i]=m.group();
                UW1[i]=UW1[i].substring(1, UW1[i].length()-1).trim();
            }
            i++;
        }
    }

    public  static void main(String[] args) throws Exception {
        Unlcomp u=new Unlcomp();
        String pathsr="E:/M.E/project/test.txt";
        String pathdes="E:/M.E/project/test1.txt";
        relation r=new relation();      

        u.preprocess(pathsr,pathdes);

    }
}

這將采用rm的值，而將其作為數組中的對象中的值。 我使用system.out.println()語句檢查了它。 我也不怎么退貨。 這是此概念的完整編碼，它從文件中讀取輸入。

Answer 1

如果數組中的位置為Null，則if語句只能強制轉換為null指針，否則該方法看起來很好，除了您只查看子數組r1[i].rel[i]一個位置。

             if(r1[i].rel[i].equals(r[j].rel[j]))
             {
                 System.out.println("true");
             }
             else
             {
                System.out.println("false");

也會丟失非靜態或最終變量的初始化

public class relation {
int rcount;
int r1count;
public String[] rel;
relation rm[];
relation rm1[];
public String[] UW1;

Answer 2

問題肯定是空值。

r1或r1 [i]或r1 [i] .rel [i]或r [j]可能為空。

比較前請檢查是否為空。

Answer 3

嘗試這個

 relation rm[];
 relation rm1[];

public relation[] hash(String[] s,String[] s1,int rcount)
{
   rm = new relation[rcount];
   rm1 = new relation[rcount];

    ...
}

// Do the same for hash1

在您的代碼，除非rcount是100 ，會出現null指標，如果rcount低於100，你會得到一個IndexOutOfBounds如果rcount大於100，因為你宣布你的陣列具有100個指數會出現這兩件事情。

還有，這里供參考

(r1[i].rel[i].equals(r[j].rel[j]))

您實際上是在比較Objects是否引用相同的Object reference ，而不是實際上是== 。 我不知道這是否影響您想要的輸出。

Answer 4

由於未更新，因此調用方法如何填充rm和rm1 relation[] ，在compare方法中，兩個循環條件的終點是長度，因為您已將長度定義為100

public String[] rel = new String[100];
relation rm[] = new relation[100];

因此，循環將被迭代100次， if (r1[i].rel[i].equals(r[j].rel[j])) {

r1[i].rel[i] , here r1[i] 

如果尚未在數組的該位置插入對象，則索引為null，

並且您嘗試對null任何操作均為null.rel [i]將變成NPE ，

您需要注意

public String[] rel = new String[100];
    relation rm[] = new relation[100];

確保在所有位置上都有元素。

extract(scanner.next());
obj.hash(rel,UW1,rcount); 

在preprocess方法中，您確定始終將rCount傳遞為100，否則，在hash方法中，關系對象數組中沒有所有元素。 一種進行比較之前檢查null的方法，例如

if ( r1[i] != null && r[j] != null && r1[i].rel[i].equals(r[j].rel[j]))