दो फाइलों में समान शब्द (तार) ढूंढने के लिए

Question

मुझे फ़ाइल 1 में शब्द 1 की समानता को फ़ाइल 2 में शब्द 2 के साथ मान्य करना होगा और इसी तरह। यदि शब्द 1 (फ़ाइल 1)। शब्द 2 (फ़ाइल 2) के लिए असमान, फ़ाइल 3 सही और गलत दिखाने के लिए आउटपुट होगा। नीचे कोडिंग है लेकिन जब कोई त्रुटि नहीं है लेकिन आउटपुट नहीं दे रहा है तो मैं अटक गया हूं। जावा में एक नौसिखिया हूँ।

import java.io.File; 
import java.io.FileNotFoundException; 
import java.io.FileWriter; 
import java.io.IOException; 
import java.util.ArrayList; 
import java.util.Scanner; 

public class test2 { 

    private static ArrayList<String> load(String f1) throws FileNotFoundException { 
     Scanner reader = new Scanner(new File(f1)); 
     ArrayList<String> out = new ArrayList<String>(); 
     while (reader.hasNext()) { 
      String temp = reader.nextLine(); 
      String[] sts = temp.split(" "); 
      for (int i = 0; i < sts.length; i++) { 
       if (sts[i].equals("") && sts[i].equals(" ") && sts[i].equals("\n")) { 
        out.add(sts[i]); 
       } 
      } 
     } 
     return out; 
    } 

    private static void write(ArrayList<String> out, String fname) throws IOException { 
     FileWriter writer = new FileWriter(new File("out_test2.txt")); 
     for (int i = 0; i < out.size(); i++) { 
      writer.write(out.get(i) + "\n"); 
     } 
     writer.close(); 
    } 

    public static void main(String[] args) throws IOException { 
     ArrayList<String> file1; 
     ArrayList<String> file2; 
     ArrayList<String> out = new ArrayList<String>(); 
     file1 = load("IbanDict.txt"); 
     file2 = load("AFF_outVal.txt"); 

     for (int i = 0; i < file1.size(); i++) { 
      String word1 = file1.get(i); 
      for (int z = 0; z < file2.size(); z++) { 
       if (word1.equalsIgnoreCase(file2.get(z))) { 
        boolean already = false; 
        for (int q = 0; q < out.size(); q++) { 
         if (out.get(q).equalsIgnoreCase(file1.get(i))) { 
          already = true; 
         } 
        } 
        if (already == false) { 
         out.add(file1.get(i)); 
        } 
       } 
      } 
     } 
     write(out, "out_test2.txt"); 
    } 

} 

Answer 1

सबसे पहले, Scanner आपके लिए आपके स्ट्रिंग को टोकन देगा। String.split विधि का उपयोग करके लाइन और टोकन में पढ़ने की कोई आवश्यकता नहीं है; here देखें।

दूसरे, यह है जैसा आप यहां एक तर्क त्रुटि है दिखता है:

for (int i = 0; i < sts.length; i++) { 
    if (sts[i].equals("") && sts[i].equals(" ") 
      && sts[i].equals("\n")) 
     out.add(sts[i]); 
} 

(यह मानते हुए कि मैं समझता हूँ कि तुम क्या करने की कोशिश कर रहे हैं) यह होना चाहिए:

for (int i = 0; i < sts.length; i++) { 
    if (!(sts[i].equals("") && sts[i].equals(" ") && sts[i] 
      .equals("\n"))) 
     out.add(sts[i]); 
} 

यह वह जगह है आप कोई आउटपुट क्यों नहीं देख रहे हैं।

नोट: मिलान का यह तरीका त्रुटि प्रवण है और इष्टतम (रैखिक) से बहुत दूर है; आपको एक विशेष टेक्स्ट पार्सिंग भाषा जैसे अजीब या पायथन (माना जाता है कि आप जावा से बाध्य नहीं हैं) के साथ अधिक सफलता प्राप्त कर सकते हैं। यदि आप जावा के साथ फंस गए हैं, तो कक्षाओं को दिखाए जाने के लिए वैकल्पिक कार्यान्वयन here दिखाया जा सकता है।

Answer 2

कुछ समस्याएं हैं जो मैं देखता हूं। रिक्त स्थान पर एक अनावश्यक विभाजन होने के नाते wulfgar.pro ने बताया।

एक और मुद्दा यह है कि Scanner में विराम चिह्न शामिल होगा, इसलिए फ़ाइल 1 "मैं खुश हूं और उदास" फ़ाइल 2 "आप खुश हैं" "खुश" नहीं पाएंगे।

मैंने इसे सेट्स का उपयोग करने के लिए भी बदल दिया, क्योंकि आप इस बात से चिंतित नहीं हैं कि शब्द कितनी बार मेल खाता है। फिर प्रत्येक लूप को फिर से चलाने के लिए उपयोग करें (आप जेनेरिक का उपयोग कर रहे हैं, इसलिए आप प्रत्येक लूप के लिए भी करने में सक्षम होना चाहिए)।

private static final Pattern PUNCTUATION_PATTERN = Pattern.compile("[\\w']+"); 

private static Set<String> load(String f1) throws FileNotFoundException { 
    Scanner reader = new Scanner(new File(f1)); 
    Set<String> out = new HashSet<String>(); 
    while (reader.hasNext()) { 
     String tempLine = reader.nextLine(); 
     if (tempLine != null 
       && tempLine.trim().length() > 0) { 
      Matcher matcher = PUNCTUATION_PATTERN.matcher(tempLine); 
      while (matcher.find()) { 
       out.add(tempLine.substring(matcher.start(), matcher.end())); 
      } 
     } 
    } 
    return out; 
} 

के लिए लूप main विधि में तो करने के लिए सरल किया जा सकता:

तो मैं load विधि में, जबकि लूप दुबारा लिखा

public static void main(String[] args) throws IOException { 
    Set<String> out = new HashSet<String>(); 
    Set<String> file1 = load("IbanDict.txt"); 
    Set<String> file2 = load("AFF_outVal.txt"); 

    for (String word1 : file1) { 
     for (String word2 : file2) { 
      if (word1.equalsIgnoreCase(word2)) { 
       boolean already = false; 
       for (String outStr : out) { 
        if (outStr.equalsIgnoreCase(word1)) { 
         already = true; 
        } 
       } 
       if (!already) { 
        out.add(word1); 
       } 
      } 
     } 
    } 
    write(out, "out_test2.txt"); 
} 

और करने के लिए write पद्धति को बदलने iterate, और File.separator का उपयोग ओएस-स्वतंत्र होने के लिए करें:

private static void write(Iterable<String> out, String fname) throws IOException { 
    OutputStreamWriter writer = new FileWriter(new File(fname)); 
    for (String s : out) { 
     writer.write(s + File.separator); 
    } 
    writer.close(); 
} 

Answer 3

तो मूल रूप से आप यह जांचना चाहते हैं कि फ़ाइल 2 से कोई शब्द फ़ाइल 1 में भी मौजूद है या नहीं। यदि ऐसा गलत है, तो गलत प्रिंट न करें।

संभवतः फ़ाइल में सभी शब्दों का एक खोज करने योग्य डेटासेट बनाने का सबसे आसान तरीका है। फ़ाइल 2 में प्रत्येक शब्द के लिए आप डेटासेट व्हील के खिलाफ जांच सकते हैं या इसमें कोई शब्द नहीं है।

नीचे दिया गया कोड कुछ भी नहीं करता है। यह एसटीएस में फ़ाइल में सभी शब्दों की एक सरणी बनाता है और फिर आप wheter की जांच करते हैं एक शब्द कुछ भी नहीं है और एक जगह और एक नई लाइन है। यदि ऐसा है तो आप इसे एक ArrayList में जोड़ें। एक शब्द कभी भी उन सभी चीजें नहीं होगा और इसलिए कभी भी एक शब्द नहीं जोड़ा जाएगा।

Scanner reader = new Scanner(new File(f1)); 
ArrayList<String> out = new ArrayList<String>(); 
while (reader.hasNext()) { 
    String temp = reader.nextLine();  
    String[] sts = temp.split(" "); 
    for (int i = 0; i < sts.length; i++) { 
    if (sts[i].equals("") && sts[i].equals(" ") && sts[i].equals("\n")) { 
     out.add(sts[i]); 
    } 
    } 
} 

आप अपने शब्दकोश में सभी शब्दों का एक ArrayList है कि अपने स्कैनर में सभी टोकन पुनरावृत्ति और उन्हें ArrayList को जोड़ने

while (reader.hasNext()) { 
out.add(reader.next()); 
} 

अब से सभी शब्दों का एक संग्रह प्राप्त करने के लिए यहाँ पाश संशोधित आप जांचना शुरू कर सकते हैं।

अगर फाइल 2 से एक शब्द शब्दकोश में शामिल है तो आप बस फोन कर सकते हैं

dictionary.contains(file2.get(i)) 

शामिल करता है, तो मिलान हो जाता है की जाँच करने के ArrayList में सभी स्ट्रिंग्स की बराबरी विधि का उपयोग करता देखने के लिए।

अब यदि आप लाइन से लाइन करना चाहते हैं तो आपको 2 डेटासेट नहीं बनाना चाहिए। आपका शब्दकोश एक डेटासेट होना चाहिए, लेकिन फ़ाइल 2 के लिए केवल स्कैनर ऑब्जेक्ट का उपयोग करना आसान है।

स्कैनर से प्रत्येक पंक्ति पढ़ें। सुनिश्चित करें कि आपने hasNextLine() के बजाय hasNextLine() का उपयोग किया है, क्योंकि यहां नेक्स्टलाइन() है जो आपको पुनरावृत्ति के लिए आवश्यक चेक करता है। लाइन में प्रत्येक टोकन के लिए

line = reader.nextLine(); 

जांच अगर यह सूची में एक मैच है और सही या गलत + एक अंतरिक्ष बारे में प्रत्येक पंक्ति की जाँच के दौरान अगर यह

String[] splitLine = line.split(" "); 
for(String token: splitLine){  
    writer.write(dictionary.contains(file2.get(i))+" "); 
} 

करता है आप के लिए एक लाइन लिख सकते हैं आपकी आउटपुट फ़ाइल ताकि रेखा संख्या मेल हो।

public class Test{ 

    private static List<String> loadDictionary(String fileName) throws FileNotFoundException { 
    Scanner reader = new Scanner(new File(fileName)); 
    List<String> out = new ArrayList<String>(); 
    while (reader.hasNext()) { 
     out.add(reader.next()); 
    } 
    reader.close(); 
    return out; 
    } 

    public static void main(String[] args) throws IOException { 
    List<String> dictionary; 
    dictionary = loadDictionary("IbanDict.txt"); 

    Scanner reader = new Scanner(new File("AFF_outVal.txt")); 
    OutputStreamWriter writer = new FileWriter(new File("out_test2.txt")); 

    while(reader.hasNextLine()){ 
     String line = reader.nextLine(); 
     String[] tokens = line.split(" "); 
     for(String token: tokens){ 
     writer.write(dictionary.contains(token)+" "); 
     } 
     writer.write(System.getProperty("line.separator")); 
    } 
    writer.close(); 
    reader.close(); 
    } 
} 

Answer 4

यहाँ है अपने porblem

import java.io.File; 
import java.io.FileNotFoundException; 
import java.io.FileWriter; 
import java.io.IOException; 
import java.util.HashMap; 
import java.util.Map; 
import java.util.Scanner; 
import java.util.regex.Matcher; 
import java.util.regex.Pattern; 

public class Test { 

    private static final Pattern WORD_PATTERN = Pattern.compile("[\\w']+"); 

    private static Map<String, Integer> load(final String f1) throws FileNotFoundException { 
    Scanner reader = new Scanner(new File(f1)); 
    Map<String, Integer> out = new HashMap<String, Integer>(); 
    while (reader.hasNext()) { 
     String tempLine = reader.nextLine(); 
     if (tempLine != null && tempLine.trim().length() > 0) { 
     Matcher matcher = WORD_PATTERN.matcher(tempLine); 
     while (matcher.find()) { 
      out.put(matcher.group().toLowerCase(), 0); 
     } 
     } 
    } 

    return out; 
    } 

    private static void write(final Map<String, Integer> out, final String fname) throws IOException { 
    FileWriter writer = new FileWriter(new File(fname)); 
    for (Map.Entry<String, Integer> word : out.entrySet()) { 
     if (word.getValue() == 1) { 
     writer.write(word.getKey() + "\n"); 
     } 
    } 
    writer.close(); 
    } 

    public static void main(final String[] args) throws IOException { 
    Map<String, Integer> file1 = load("file1.txt"); 
    Map<String, Integer> file2 = load("file2.txt"); 

    // below for loop will run just one time, so it is much faster 
    for (Map.Entry<String, Integer> file1Word : file1.entrySet()) { 
     if (file2.containsKey(file1Word.getKey())) { 
     file1.put(file1Word.getKey(), 1); 
     file2.put(file1Word.getKey(), 1); 
     } 
    } 

    write(file1, "test1.txt"); 
    write(file2, "test2.txt"); 
    } 

}