मैं "।" का उपयोग कैसे कर सकता हूं जावा

Question

में String.split() के साथ delimiter के रूप में मैं क्या करने की कोशिश कर रहा हूँ एक .java फ़ाइल पढ़ा है, और सभी पहचानकर्ताओं को बाहर निकालें और उन्हें एक सूची में स्टोर करें। मेरी समस्या .split() विधि के साथ है। यदि आप इस कोड को जिस तरह से चलाते हैं, तो आपको ArrayOutOfBounds मिलेंगे, लेकिन यदि आप "।" से डिलीमीटर बदलते हैं। किसी और चीज के लिए, कोड काम करता है। लेकिन मुझे "।" द्वारा पार्स लाइनों की आवश्यकता है। तो क्या यह एक और तरीका है जिसे मैं पूरा कर सकता हूं?

import java.io.BufferedReader; 
import java.io.FileNotFoundException; 
import java.io.FileReader; 
import java.io.IOException; 
import java.util.*; 


public class MyHash { 
    private static String[] reserved = new String[100]; 
    private static List list = new LinkedList(); 
    private static List list2 = new LinkedList(); 

    public static void main (String args[]){ 
     Hashtable hashtable = new Hashtable(997); 
     makeReserved(); 
     readFile(); 
     String line; 
     ListIterator itr = list.listIterator(); 
     int listIndex = 0; 
     while (listIndex < list.size()) { 

      if (itr.hasNext()){ 
       line = itr.next().toString(); 
       //PROBLEM IS HERE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
       String[] words = line.split("."); //CHANGE THIS AND IT WILL WORK 
       System.out.println(words[0]);  //TESTING TO SEE IF IT WORKED 
      } 
      listIndex++; 
     } 
    } 

    public static void readFile() { 
     String text; 
     String[] words; 
     BufferedReader in = null; 
     try { 
      in = new BufferedReader(new FileReader("MyHash.java")); //NAME OF INPUT FILE 


     } catch (FileNotFoundException ex) { 
      Logger.getLogger(MyHash.class.getName()).log(Level.SEVERE, null, ex); 
     } 
     try { 
      while ((text = in.readLine()) != null){ 
       text = text.trim(); 
       words = text.split("\\s+"); 
       for (int i = 0; i < words.length; i++){ 
        list.add(words[i]); 
       } 
       for (int j = 0; j < reserved.length; j++){ 
        if (list.contains(reserved[j])){ 
         list.remove(reserved[j]); 
        } 
       } 


      } 

     } catch (IOException ex) { 
      Logger.getLogger(MyHash.class.getName()).log(Level.SEVERE, null, ex); 
     } 
     try { 
      in.close(); 
     } catch (IOException ex) { 
      Logger.getLogger(MyHash.class.getName()).log(Level.SEVERE, null, ex); 
     } 
    } 

    public static int keyIt (int x) { 
     int key = x % 997; 
     return key; 
    } 

    public static int horner (String word){ 
     int length = word.length(); 
     char[] letters = new char[length]; 

     for (int i = 0; i < length; i++){ 
      letters[i]=word.charAt(i); 
     } 

     char[] alphabet = new char[26]; 
     String abc = "abcdefghijklmnopqrstuvwxyz"; 

     for (int i = 0; i < 26; i++){ 
      alphabet[i]=abc.charAt(i); 
     } 

     int[] numbers = new int[length]; 
     int place = 0; 
     for (int i = 0; i < length; i++){ 
      for (int j = 0; j < 26; j++){ 
       if (alphabet[j]==letters[i]){ 
        numbers[place]=j+1; 
        place++; 

       } 
      } 
     } 

     int hornered = numbers[0] * 32; 

     for (int i = 1; i < numbers.length; i++){ 

      hornered += numbers[i]; 
      if (i == numbers.length -1){ 
       return hornered; 
      } 
      hornered = hornered % 997; 
      hornered *= 32; 
     } 
     return hornered; 
    } 

    public static String[] makeReserved(){ 
     reserved[0] = "abstract"; 
     reserved[1] = "assert"; 
     reserved[2] = "boolean"; 
     reserved[3] = "break"; 
     reserved[4] = "byte"; 
     reserved[5] = "case"; 
     reserved[6] = "catch"; 
     reserved[7] = "char"; 
     reserved[8] = "class"; 
     reserved[9] = "const"; 
     reserved[10] = "continue"; 
     reserved[11] = "default"; 
     reserved[12] = "do"; 
     reserved[13] = "double"; 
     reserved[14] = "else"; 
     reserved[15] = "enum"; 
     reserved[16] = "extends"; 
     reserved[17] = "false"; 
     reserved[18] = "final"; 
     reserved[19] = "finally"; 
     reserved[20] = "float"; 
     reserved[21] = "for"; 
     reserved[22] = "goto"; 
     reserved[23] = "if"; 
     reserved[24] = "implements"; 
     reserved[25] = "import"; 
     reserved[26] = "instanceof"; 
     reserved[27] = "int"; 
     reserved[28] = "interface"; 
     reserved[29] = "long"; 
     reserved[30] = "native"; 
     reserved[31] = "new"; 
     reserved[32] = "null"; 
     reserved[33] = "package"; 
     reserved[34] = "private"; 
     reserved[35] = "protected"; 
     reserved[36] = "public"; 
     reserved[37] = "return"; 
     reserved[38] = "short"; 
     reserved[39] = "static"; 
     reserved[40] = "strictfp"; 
     reserved[41] = "super"; 
     reserved[42] = "switch"; 
     reserved[43] = "synchronize"; 
     reserved[44] = "this"; 
     reserved[45] = "throw"; 
     reserved[46] = "throws"; 
     reserved[47] = "trasient"; 
     reserved[48] = "true"; 
     reserved[49] = "try"; 
     reserved[50] = "void"; 
     reserved[51] = "volatile"; 
     reserved[52] = "while"; 
     reserved[53] = "="; 
     reserved[54] = "=="; 
     reserved[55] = "!="; 
     reserved[56] = "+"; 
     reserved[57] = "-"; 
     reserved[58] = "*"; 
     reserved[59] = "/"; 
     reserved[60] = "{"; 
     reserved[61] = "}"; 

     return reserved; 
    } 
} 

Answer 1

String.split एक रेगेक्स लेता है, और '।' regexes के लिए एक विशेष अर्थ है।

String[] words = line.split("\\."); 

कुछ लोगों मुसीबत काम करने के लिए इस हो रही हो रहे हैं, तो यहाँ कुछ runnable कोड आप सही व्यवहार सत्यापित करने के लिए उपयोग कर सकते हैं:

आप (शायद) की तरह कुछ करना चाहते हैं।

import java.util.Arrays; 

public class TestSplit { 
    public static void main(String[] args) { 
    String line = "aa.bb.cc.dd"; 
    String[] words = line.split("\\."); 
    System.out.println(Arrays.toString(words)); 
    // Output is "[aa, bb, cc, dd]" 
    } 
} 

Answer 2

विभाजित करने का तर्क नियमित अभिव्यक्ति है। "।" कुछ भी मेल खाता है ताकि आपके डिलीमीटर को विभाजित किया जा सके।

Answer 3

क्या आपने डॉट से बचने की कोशिश की है? इस तरह:

String[] words = line.split("\\.");

Answer 4

तर्क विभाजित करने के लिए एक नियमित अभिव्यक्ति है। यह अवधि एक नियमित अभिव्यक्ति मेटाएक्टेक्टर है जो किसी भी चीज़ से मेल खाती है, इस प्रकार line में प्रत्येक चरित्र को एक अलग चरित्र माना जाता है, और इसे फेंक दिया जाता है, और उनके बीच के सभी खाली तारों को फेंक दिया जाता है (क्योंकि वे खाली तार होते हैं)। नतीजा यह है कि आपके पास कुछ भी नहीं बचा है।

यदि आप अवधि से बचते हैं (इससे पहले एक बच निकला बैकस्लैश जोड़कर), तो आप शाब्दिक काल से मेल खा सकते हैं। (line.split("\\."))

Answer 5

आपको StringTokenizer कक्षा में रुचि हो सकती है। हालांकि, जावा दस्तावेज़ सलाह देते हैं कि आप .split विधि का उपयोग करें क्योंकि स्ट्रिंगटोकनाइज़र एक विरासत वर्ग है।

Answer 6

यदि प्रदर्शन एक मुद्दा है, तो आपको split के बजाय StringTokenizer का उपयोग करने पर विचार करना चाहिए। StringTokenizersplit से बहुत तेज है, भले ही यह "विरासत" वर्ग है (लेकिन बहिष्कृत नहीं है)।

Answer 7

जब एक स्ट्रिंग शाब्दिक सीमांकक के साथ बंटवारे, सबसे सुरक्षित तरीका Pattern.quote() विधि का उपयोग करने के लिए है: अन्य उत्तर ने वर्णन किया है

String[] words = line.split(Pattern.quote(".")); 

, "\\." साथ बंटवारे सही है, लेकिन quote() यह आपके लिए भागने करेंगे।

Answer 8

यह निश्चित रूप से ऐसा करने का सबसे अच्छा तरीका नहीं है, लेकिन मुझे ऐसा कुछ करने के द्वारा किया गया है।

String imageName = "my_image.png"; 
String replace = imageName.replace('.','~'); 
String[] split = replace.split("~"); 

System.out.println("Image name : " + split[0]); 
System.out.println("Image extension : " + split[1]); 

आउटपुट,

Image name : my_image 
Image extension : png 

इस