मैचों की गिनती को खोजने के लिए सबसे प्रभावी तरीका स्ट्रिंग शब्दों की सरणी के खिलाफ है?

Question

चलो कहते हैं कि मैं एक स्ट्रिंग

String test = "This is a test string and I have some stopwords in here"; 

है और मैं

psudocode

array = a,and,the,them,they,I 

तो जवाब होगा कितनी बार मेरी स्ट्रिंग के खिलाफ मैच के नीचे सरणी में शब्द देखना चाहते हैं, "3"

सिर्फ उत्सुक है कि जावा में ऐसा करने का सबसे प्रभावी तरीका क्या है?

Answer 1

मैं शायद इनपुट में शब्दों को हैशसेट में संग्रहीत करता हूं और फिर सरणी पर फिर से चलाता हूं और देखता हूं कि सरणी में प्रत्येक शब्द है। सेट में शामिल है।

यहां यह कोड में है ... इनपुट "Around the world in 80 days" है।

import java.io.File; 
import java.io.FileNotFoundException; 
import java.util.ArrayList; 
import java.util.Arrays; 
import java.util.HashSet; 
import java.util.List; 
import java.util.Scanner; 
import java.util.Set; 

public class Main 
{ 
    public static void main(final String[] argv) 
     throws FileNotFoundException 
    { 
     final File  file; 
     final String[] wordsToFind; 

     file  = new File(argv[0]); 
     wordsToFind = getWordsToFind(file); 
     a(file, wordsToFind); 
     b(file, wordsToFind); 
     c(file, wordsToFind); 
     d(file, wordsToFind); 
    } 

    // this just reads the file into the disk cache 
    private static String[] getWordsToFind(final File file) 
     throws FileNotFoundException 
    { 
     final Scanner  scanner; 
     final Set<String> words; 

     scanner = new Scanner(file); 
     words = new HashSet<String>(); 

     while(scanner.hasNext()) 
     { 
      final String word; 

      word = scanner.next(); 
      words.add(word); 
     } 

     return (words.toArray(new String[words.size()])); 
    } 

    // bad way, read intpo a list and then iterate over the list until you find a match 
    private static void a(final File  file, 
          final String[] wordsToFind) 
     throws FileNotFoundException 
    { 
     final long start; 
     final long end; 
     final long total; 
     final Scanner  scanner; 
     final List<String> words; 
     int    matches; 

     scanner = new Scanner(file); 
     words = new ArrayList<String>(); 

     while(scanner.hasNext()) 
     { 
      final String word; 

      word = scanner.next(); 
      words.add(word); 
     } 

     start = System.nanoTime(); 

     { 
      matches = 0; 

      for(final String wordToFind : wordsToFind) 
      { 
       for(final String word : words) 
       { 
        if(word.equals(wordToFind)) 
        { 
         matches++; 
         break; 
        } 
       } 
      } 

      System.out.println(matches); 
     } 

     end = System.nanoTime(); 
     total = end - start; 
     System.out.println("a: " + total); 
    } 

    // slightly better way, read intpo a list and then iterate over the set (which reduces the number of things you progbably 
    // have to read until you find a match), until you find a match 
    private static void b(final File  file, 
          final String[] wordsToFind) 
     throws FileNotFoundException 
    { 
     final long start; 
     final long end; 
     final long total; 
     final Scanner  scanner; 
     final Set<String> words; 
     int    matches; 

     scanner = new Scanner(file); 
     words = new HashSet<String>(); 

     while(scanner.hasNext()) 
     { 
      final String word; 

      word = scanner.next(); 
      words.add(word); 
     } 

     start = System.nanoTime(); 

     { 
      matches = 0; 

      for(final String wordToFind : wordsToFind) 
      { 
       for(final String word : words) 
       { 
        if(word.equals(wordToFind)) 
        { 
         matches++; 
         break; 
        } 
       } 
      } 

      System.out.println(matches); 
     } 

     end = System.nanoTime(); 
     total = end - start; 
     System.out.println("b: " + total); 
    } 

    // my way 
    private static void c(final File  file, 
          final String[] wordsToFind) 
     throws FileNotFoundException 
    { 
     final long start; 
     final long end; 
     final long total; 
     final Scanner  scanner; 
     final Set<String> words; 
     int    matches; 

     scanner = new Scanner(file); 
     words = new HashSet<String>(); 

     while(scanner.hasNext()) 
     { 
      final String word; 

      word = scanner.next(); 
      words.add(word); 
     } 

     start = System.nanoTime(); 

     { 
      matches = 0; 

      for(final String wordToFind : wordsToFind) 
      { 
       if(words.contains(wordToFind)) 
       { 
        matches++; 
       } 
      } 

      System.out.println(matches); 
     } 

     end = System.nanoTime(); 
     total = end - start; 
     System.out.println("c: " + total); 
    } 

    // Nikita Rybak way 
    private static void d(final File  file, 
          final String[] wordsToFind) 
     throws FileNotFoundException 
    { 
     final long start; 
     final long end; 
     final long total; 
     final Scanner  scanner; 
     final Set<String> words; 
     int    matches; 

     scanner = new Scanner(file); 
     words = new HashSet<String>(); 

     while(scanner.hasNext()) 
     { 
      final String word; 

      word = scanner.next(); 
      words.add(word); 
     } 

     start = System.nanoTime(); 

     { 
      words.retainAll(new HashSet<String>(Arrays.asList(wordsToFind))); 
      matches = words.size(); 
      System.out.println(matches); 
     } 

     end = System.nanoTime(); 
     total = end - start; 
     System.out.println("d: " + total); 
    } 
} 

परिणाम (कुछ रन के बाद, प्रत्येक रन काफी समान हालांकि है):

12596 
a: 2440699000 
12596 
b: 2531635000 
12596 
c: 4507000 
12596 
d: 5597000 

आप (getWordsToFind में शब्दों में से प्रत्येक के लिए "XXX" जोड़ें, ताकि द्वारा इसे संशोधित यदि कोई शब्द पाए जाते हैं) आपको मिलेगा:

0 
a: 7415291000 
0 
b: 4688973000 
0 
c: 2849000 
0 
d: 7981000 

और, संपूर्णता के लिए, मैं इसे करने की कोशिश की तो बस शब्द "मैं" के लिए खोज, और परिणाम हैं:

1 
a: 235000 
1 
b: 351000 
1 
c: 75000 
1 
d: 10725000 

Answer 2

ऐसा कुछ? 'सबसे कुशल' के बारे में निश्चित नहीं है, लेकिन काफी सरल है।

Set<String> s1 = new HashSet<String>(Arrays.asList("This is a test string and I have some stopwords in here".split("\\s"))); 
Set<String> s2 = new HashSet<String>(Arrays.asList("a", "and", "the", "them", "they", "I")); 
s1.retainAll(s2); 
System.out.println(s1.size()); 

शब्दों के दो सेटों का बस छेड़छाड़।

Answer 3

करने के लिए सबसे कारगर बात प्रकार दोनों 'परीक्षण' और 'सरणी' और फिर दोनों से अधिक पुनरावृति है: n.log (एन) + n

परीक्षण -> [ 'एक', 'और', 'है', 'यहां', में, है, ..., 'यह'] सरणी -> ['ए', 'और', 'द', 'उन्हें', 'वे', 'मैं']

सरणी परीक्षण से मेल खाता है 'एक' 'एक' 1 'एक' 'और' 1 'और' 'और' 2 'और' है 'और' 2 '' 'यहाँ' 2 '' 'इन' 2 'द' 'है' 2 ...

Answer 4

निकिता के उत्तर पर एक मामूली बदलाव (निकिता के लिए ऊपर 1)। यदि आप एस 1 के लिए एक सूची का उपयोग करते हैं, तो आपको घटनाओं की संख्या मिलती है (यदि वाक्य में एक शब्द कई बार प्रकट होता है)।

List<String> s1 = new ArrayList<String>(Arrays.asList("This is a test string and I have some stopwords in here".split("\\s"))); 
Set<String> s2 = new HashSet<String>(Arrays.asList("a", "and", "the", "them", "they", "I")); 
s1.retainAll(s2); 
System.out.println(s1.size()); 

Answer 5

दुकान hashtable में अपने तार, तो पाठ के ऊपर इटरेटर ((स्ट्रिंग और पूर्णांक) की HashMap) और hashtable में मिलान शब्द के लिए पूर्णांक मान बढ़ा सकते हैं। फिर हैशटेबल पर iterator और सभी पूर्णांक मान योग।