CLASS JAVA STREAMTOKENIZER - סט 1

ב-Java ה StreamTokenizer הכיתה נוכחת ב חבילת java.io . הוא משמש לניתוח זרם קלט על ידי פירוקו לנתחים קטנים הידועים בשם אסימונים אסימונים אלה מקלים על העיבוד. אסימון יכול להיות מילה מספר או כל סמל ספציפי. Stream Tokenizer יכול לזהות מחרוזות מצוטטות של מספרים וסגנונות הערות שונים.

תכונות של מחלקת StreamTokenizer:

תכונות המפתח של מחלקת StreamTokenizer מפורטות להלן:

זה מפרק את זרמי הקלט לאסימונים כמו סמלים מילים ומספרים.
הוא תומך במספרי קו מעקב.
זה יכול להתייחס לתווים מסוף השורה כאל אסימונים.
זה גם יכול להמיר אסימוני מילים לאותיות קטנות באופן אוטומטי.

הצהרת StreamTokenizer Class

ההצהרה של מחלקת StreamTokenizer היא:

מחלקה ציבורית StreamTokenizer מרחיבה את האובייקט מיישם Serializable

פֶּתֶק: זה מרחיב את Object ומיישם Serializable.

בונים של כיתת StreamTokenizer

מחלקה זו מורכבת משני בנאים שבעזרתם נוכל ליצור אובייקטים של מחלקה זו בדרכים שונות. להלן הבנאים הזמינים במחלקה זו:

1. StreamTokenizer (InputStream הוא): הקונסטרוקטור הזה הוא הוצא משימוש . זוהי דרך ישנה יותר ליצור אסימון ישירות מזרם בתים.

תַחבִּיר:

StreamTokenizer (InputStream הוא)

פֶּתֶק: זה לא מומלץ כי זה עובד על בתים ולא על תווים.

2. StreamTokenizer (Reader r): זו הדרך הטובה ביותר ליצור טוקנייזר זה משתמש בזרם תווים שמטפל בטקסט כראוי.

תַחבִּיר:

StreamTokenizer (Reader r)

דוּגמָה:

Java

    // Demonstrating the working    // of StreamTokenizer(Reader r)    import     java.io.*  ;   public     class   Geeks     {          public     static     void     main  (  String  []     args  )     throws     IOException     {          Reader     r     =     new     StringReader  (  'Hello 123'  );      StreamTokenizer     t     =     new     StreamTokenizer  (  r  );             int     token  ;      while     ((  token     =     t  .  nextToken  ())     !=     StreamTokenizer  .  TT_EOF  )     {      if     (  token     ==     StreamTokenizer  .  TT_WORD  )     {      System  .  out  .  println  (  'Word: '     +     t  .  sval  );      }     else     if     (  token     ==     StreamTokenizer  .  TT_NUMBER  )     {      System  .  out  .  println  (  'Number: '     +     t  .  nval  );      }      }      }   }

תְפוּקָה

Word: Hello Number: 123.0

שיטות Java StreamTokenizer

הטבלה שלהלן מדגימה את השיטות של מחלקה זו.

שִׁיטָה	תֵאוּר
commentChar()	מציין שהתו ch מתחיל הערה בשורה אחת. מתעלמים מכל התווים מתו ההערה ועד סוף השורה.
קַו()	מחזירה את מספר השורה הנוכחי של זרם הקלט.
toString()	מחזירה ייצוג מחרוזת של אסימון הזרם הנוכחי ומספר השורה שהוא מופיע.
eolIsSignificant(דגל בוליאני)	קובע אם תווי סוף השורה יטופלו כאסימונים משמעותיים. אם תווי סוף שורה אמיתיים מוחזרים כאסימונים.
ordinaryChar(int ch)	מציין שהתו ch יטופל כתו רגיל ולא כאל מספר מילה או תו הערה.
nextToken()	מנתח את האסימון הבא מזרם הקלט ומחזיר את הסוג שלו.
lowerCaseMode()	קובע אם אסימוני מילים יומרו אוטומטית לאותיות קטנות.
ordinaryChar()	מציין שהתו ch יטופל כתו רגיל.
ordinaryChars()	מציין שכל התווים בטווח הנמוך לגבוה יטופלו כתווים רגילים.

כעת נדון בפירוט על כל שיטה בזה אחר זה:

1. commentChar(): שיטה זו משמשת לציון התו ch שמתחיל בהערה של שורה בודדת וכל התווים מהתו הזה ועד סוף השורה אינם מזוהים על ידי StreamTokenizer.

תַחבִּיר:

public void commentChar(int ch)

פָּרָמֶטֶר: שיטה זו לוקחת ערך שלם בודד ch אחרי זה מתעלמים מכל הדמויות
סוג החזרה: השיטה הזו לא מחזירה כלום.

דוּגמָה:

Java

    // Demonstrating the working of commentChar() method   import     java.io.*  ;   public     class   Geeks     {      public     static     void     main  (  String  []     args  )     throws     IOException     {      FileReader     reader     =     new     FileReader  (  'ABC.txt'  );      BufferedReader     bufferread     =     new     BufferedReader  (  reader  );      StreamTokenizer     token     =     new     StreamTokenizer  (  bufferread  );      // Use of commentChar() method      token  .  commentChar  (  'a'  );         int     t  ;      while     ((  t     =     token  .  nextToken  ())     !=     StreamTokenizer  .  TT_EOF  )     {      switch     (  t  )     {      case     StreamTokenizer  .  TT_NUMBER  :      System  .  out  .  println  (  'Number : '     +     token  .  nval  );      break  ;      case     StreamTokenizer  .  TT_WORD  :      System  .  out  .  println  (  'Word : '     +     token  .  sval  );      break  ;      }      }      }   }

תְפוּקָה:

 Word : Programmers   
 Number : 1.0   
 Number : 2.0   
 Number : 3.0   
 Word : Geeks   
 Word : Hello   
 Word : a   
 Word : Program   
 Word : is   
 Word : explained   
 Word : here   
 Word : my   
 Word : friends.      פֶּתֶק:    תוכנית זו לא תפעל בהצלחה מכיוון שהקובץ 'ABC.txt' אינו קיים. אם אנחנו רוצים לבדוק את הקוד במערכת אנחנו פשוט צריכים ליצור את שם הקובץ ABC.txt.  
  צור קובץ ABC.txt עם התוכן הבא שרשום להלן:  
   מתכנתים 1 2 3 חנונים שלום תוכנית מוסברת כאן חברים שלי.  
 
   
 
     2. שורה():    שיטה זו מחזירה את מספר השורה הנוכחי אשר מעובד על ידי StreamTokenizer. שיטה זו שימושית מאוד כאשר אנו רוצים לבדוק כיצד עובד העיבוד, נפה באגים בתוכנית ונוכל גם לעקוב אחר מספרי השורות בזמן הטוקניזציה.  
     תַחבִּיר:    
   public int linen()  
 
      פָּרָמֶטֶר:    שיטה זו אינה לוקחת שום פרמטר.  
     סוג החזרה:    שיטה זו מחזירה ערך int מספר השורה של זרם הקלט הנוכחי.  
 
     דוּגמָה:    
 Java      // Demonstrating the use of lineno() method   import     java.io.*  ;   public     class   Geeks   {      public     static     void     main  (  String  []     args  )     throws     InterruptedException           FileNotFoundException       IOException      {      FileReader     reader     =     new     FileReader  (  'ABC.txt'  );      BufferedReader     bufferread     =     new     BufferedReader  (  reader  );      StreamTokenizer     token     =     new     StreamTokenizer  (  bufferread  );          token  .  eolIsSignificant  (  true  );      // Use of lineno() method       // to get current line no.      System  .  out  .  println  (  'Line Number:'     +     token  .  lineno  ());      token  .  commentChar  (  'a'  );      int     t  ;      while     ((  t     =     token  .  nextToken  ())     !=     StreamTokenizer  .  TT_EOF  )      {      switch     (  t  )      {      case     StreamTokenizer  .  TT_EOL  :      System  .  out  .  println  (  ''  );      System  .  out  .  println  (  'Line No. : '     +     token  .  lineno  ());      break  ;      case     StreamTokenizer  .  TT_NUMBER  :      System  .  out  .  println  (  'Number : '     +     token  .  nval  );      break  ;      case     StreamTokenizer  .  TT_WORD  :      System  .  out  .  println  (  'Word : '     +     token  .  sval  );      break  ;      }      }      }   }   
       תְפוּקָה:    
  Line Number:1   
 Word : Progr   
  
 Line No. : 2   
 Number : 1.0   
  
 Line No. : 3   
 Number : 2.0   
  
 Line No. : 4   
 Number : 3.0   
  
 Line No. : 5   
 Word : Geeks   
  
 Line No. : 6   
 Word : Hello   
  
 Line No. : 7   
 Word : This   
 Word : is    
 
     3. toString():    שיטה זו מחזירה מחרוזת המייצגת את אסימון הזרם הנוכחי עם ערך האסימון ומספר השורה שבו הוא משתמש כעת.  
     תַחבִּיר:    
   public String toString()  
 
      פָּרָמֶטֶר:    שיטה זו אינה לוקחת שום פרמטר.  
     סוג החזרה:    שיטה זו מחזירה ערך מחרוזת המייצגת את אסימון הזרם הנוכחי עם מספר השורה.  
 
     דוּגמָה:    
 Java      // Demonstrating the use of toString() method   import     java.io.*  ;   public     class   Geeks     {      public     static     void     main  (  String  []     args  )     throws     IOException     {      FileReader     reader     =     new     FileReader  (  'ABC.txt'  );      BufferedReader     bufferread     =     new     BufferedReader  (  reader  );      StreamTokenizer     token     =     new     StreamTokenizer  (  bufferread  );      int     t  ;      while     ((  t     =     token  .  nextToken  ())     !=     StreamTokenizer  .  TT_EOF  )     {      switch     (  t  )     {      case     StreamTokenizer  .  TT_NUMBER  :      System  .  out  .  println  (  'Number : '     +     token  .  nval  );      break  ;      case     StreamTokenizer  .  TT_WORD  :      System  .  out  .  println  (  'Word : '     +     token  .  toString  ());         break  ;      }      }      }   }   
       תְפוּקָה:    
  Word : Token[Programmers] line 1   
 Number : 1.0   
 Number : 2.0   
 Number : 3.0   
 Word : Token[Geeks] line 5   
 Word : Token[Hello] line 6   
 Word : Token[a] line 7   
 Word : Token[Program] line 7   
 Word : Token[is] line 7   
 Word : Token[explained] line 7   
 Word : Token[here] line 7   
 Word : Token[my] line 7   
 Word : Token[friends.] line 7    
 
     4. eolIsSignificant():    שיטה זו אינה מחזירה דבר, אך היא משמשת כדי לבדוק אם התו EOL (End of Line) צריך להיות אסימון. אם הדגל נכון אז כל תו של סוף שורה מטופל כאל אסימון ומוקצה לסוג האסימון TT_EOL שמתעלמים מהתו eol יטופלו כרווח לבן.  
     תַחבִּיר:    
   ריק ציבורי eolIsSignificant(דגל בוליאני)  
 
      פָּרָמֶטֶר:    שיטה זו לוקחת בוליאן     דֶגֶל    אם זה נכון, תו סוף השורה יטופל כאל אסימון או יתעלם ממנו כרווח לבן.  
     סוג החזרה:    השיטה הזו לא מחזירה כלום.  
 
     דוּגמָה:    
 Java      // Demonstrating the use of eolIsSignificant() method   import     java.io.*  ;   public     class   Geeks   {      public     static     void     main  (  String  []     args  )     throws     InterruptedException        FileNotFoundException       IOException      {      FileReader     reader     =     new     FileReader  (  'ABC.txt'  );      BufferedReader     bufferread     =     new     BufferedReader  (  reader  );      StreamTokenizer     token     =     new     StreamTokenizer  (  bufferread  );      boolean     arg     =     true  ;      // Use of eolIsSignificant() method      token  .  eolIsSignificant  (  arg  );      // Here the 'arg' is set true so EOL is treated as a token      int     t  ;      while     ((  t     =     token  .  nextToken  ())     !=     StreamTokenizer  .  TT_EOF  )      {      switch     (  t  )      {      case     StreamTokenizer  .  TT_EOL  :      System  .  out  .  println  (  'End of Line encountered.'  );      break  ;      case     StreamTokenizer  .  TT_NUMBER  :      System  .  out  .  println  (  'Number : '     +     token  .  nval  );      break  ;      case     StreamTokenizer  .  TT_WORD  :      System  .  out  .  println  (  'Word : '     +     token  .  sval  );      break  ;      }      }      }   }   
       תְפוּקָה:    
  Number : 1.0   
 End of Line encountered.   
 Word : Geeks   
 End of Line encountered.   
 Number : 2.0   
 End of Line encountered.   
 Word : For   
 End of Line encountered.   
 Number : 3.0   
 End of Line encountered.   
 Word : Geeks      פֶּתֶק:    תוכנית זו לא תפעל בהצלחה מכיוון שהקובץ 'ABC.txt' אינו קיים. אם אנחנו רוצים לבדוק את הקוד במערכת אנחנו פשוט צריכים ליצור את שם הקובץ ABC.txt.  
  צור קובץ ABC.txxt עם התוכן הבא שרשום להלן:  
   1 חנונים 2 עבור 3 חנונים   
 
 
   
 
     5. nextToken():    שיטה זו קוראת את האסימון הבא מזרם הקלט ומחזירה את הסוג. סוג האסימון מאוחסן ב-     ttype    שָׂדֶה. זה מחזיר את הסוג כערך שלם שיכול להיות TT_WORD TT_NUMBER ו-TT_EOL וכו'.  
     תַחבִּיר:    
   public int nextToken()  
 
      פָּרָמֶטֶר:    שיטה זו אינה לוקחת שום פרמטר.  
     סוג החזרה:    שיטה זו מחזירה את     int    הערך של סוג האסימון.  
 
     דוּגמָה:    
 Java      // Demonstrating the use of nextToken() method   import     java.io.*  ;   public     class   Geeks   {      public     static     void     main  (  String  []     args  )     throws     InterruptedException        FileNotFoundException       IOException      {      FileReader     reader     =     new     FileReader  (  'ABC.txt'  );      BufferedReader     bufferread     =     new     BufferedReader  (  reader  );      StreamTokenizer     token     =     new     StreamTokenizer  (  bufferread  );      // Use of nextToken() method to parse Next Token from the Input Stream      int     t     =     token  .  nextToken  ();      while     ((  t     =     token  .  nextToken  ())     !=     StreamTokenizer  .  TT_EOF  )      {      switch     (  t  )      {      case     StreamTokenizer  .  TT_NUMBER  :      System  .  out  .  println  (  'Number : '     +     token  .  nval  );      break  ;      case     StreamTokenizer  .  TT_WORD  :      System  .  out  .  println  (  'Word : '     +     token  .  sval  );      break  ;      }      }      }   }   
       תְפוּקָה:    
  Word : This   
 Word : program   
 Word : tells   
 Number : 2.0   
 Word : about   
 Word : use   
 Word : of   
 Number : 3.0   
 Word : next   
 Word : token   
 Word : method      פֶּתֶק:    תוכנית זו לא תפעל בהצלחה מכיוון שהקובץ 'ABC.txt' אינו קיים. אם אנחנו רוצים לבדוק את הקוד במערכת אנחנו פשוט צריכים ליצור את שם הקובץ ABC.txt.  
  צור קובץ ABC.txt עם התוכן הבא שרשום להלן:  
   1 תוכנית זו מספרת ל-2 על השימוש בשיטת 3 next token()  
 
   
 
     6. lowerCaseMod():    שיטה זו לוקחת בוליאן     דֶגֶל    ערך ובודק האם יש להמיר את האסימון אוטומטית לאותיות קטנות. אם הדגל נכון אז כל המילים של האסימון מומרות לאותיות קטנות או אחרת האסימונים מוגדרים כפי שהם ולא רוצים להמיר אותם.  
     תַחבִּיר:    
   public void lowerCaseMode(דגל בוליאני)  
 
      פָּרָמֶטֶר:    זה לוקח בוליאן     דֶגֶל    עֵרֶך. אם זה נכון אז כל האסימונים מומרים לאותיות קטנות ואם לא נכון אז הם לא יומרו.  
     סוג החזרה:    השיטה הזו לא מחזירה כלום.  
 
     דוּגמָה:    
 Java      // Demonstrating the use of lowerCaseMode() method   import     java.io.*  ;   public     class   NewClass   {      public     static     void     main  (  String  []     args  )     throws     InterruptedException        FileNotFoundException       IOException      {      FileReader     reader     =     new     FileReader  (  'ABC.txt'  );      BufferedReader     bufferread     =     new     BufferedReader  (  reader  );      StreamTokenizer     token     =     new     StreamTokenizer  (  bufferread  );      // Use of lowerCaseMode() method to      //Here the we have set the Lower Case Mode ON          boolean     arg     =     true  ;      token  .  lowerCaseMode  (  arg  );      int     t  ;      while     ((  t     =     token  .  nextToken  ())     !=     StreamTokenizer  .  TT_EOF  )      {      switch     (  t  )      {      case     StreamTokenizer  .  TT_NUMBER  :      System  .  out  .  println  (  'Number : '     +     token  .  nval  );      break  ;      case     StreamTokenizer  .  TT_WORD  :      System  .  out  .  println  (  'Word : '     +     token  .  sval  );      break  ;      }      }      }   }   
       תְפוּקָה:    
  Word : hello   
 Word : geeks   
 Word : this   
 Word : is   
 Word : about   
 Word : lowercasemode      פֶּתֶק:    תוכנית זו לא תפעל בהצלחה מכיוון שהקובץ 'ABC.txt' אינו קיים. אם אנחנו רוצים לבדוק את הקוד במערכת אנחנו פשוט צריכים ליצור את שם הקובץ ABC.txt.  
  צור קובץ ABC.txt עם התוכן הבא שרשום להלן:  
   שלום חנונים זה לגבי LowerCaseMode()   
 
 
   
 
     7. ordinaryChar():    שיטה זו לוקחת ערך int     ch    צריך להתייחס כאל דמות. באמצעות שיטה זו נוכל לטפל בא     אוֹפִי    א          כתו מיוחד כמו מילת מספר או רווח לבן.  
     תַחבִּיר:    
   public void ordinaryChar(int ch)  
 
      פָּרָמֶטֶר:    שיטה זו לוקחת אינט בודד     ch    ערך שיתייחס אליו כאל דמות.  
     סוג החזרה:    השיטה הזו לא מחזירה כלום.  
 
     דוּגמָה:    
 Java      // Demonstrating the use of ordinaryChar() method   import     java.io.*  ;   public     class   Geeks   {      public     static     void     main  (  String  []     args  )     throws     InterruptedException        FileNotFoundException       IOException      {      FileReader     reader     =     new     FileReader  (  'ABC.txt'  );      BufferedReader     bufferread     =     new     BufferedReader  (  reader  );      StreamTokenizer     token     =     new     StreamTokenizer  (  bufferread  );      // Use of ordinaryChar() method       // Here we have taken 's' as an ordinary character      token  .  ordinaryChar  (  's'  );      int     t  ;      while     ((  t     =     token  .  nextToken  ())     !=     StreamTokenizer  .  TT_EOF  )      {      switch     (  t  )      {      case     StreamTokenizer  .  TT_NUMBER  :      System  .  out  .  println  (  'Number : '     +     token  .  nval  );      break  ;      case     StreamTokenizer  .  TT_WORD  :      System  .  out  .  println  (  'Word : '     +     token  .  sval  );      break  ;      }      }      }   }   
       תְפוּקָה:    
  Word : Hello   
 Word : Geek   
 Word : Thi   
 Word : I   
 Word : zz   
 Word : About   
 Word : ordinaryChar      פֶּתֶק:    תוכנית זו לא תפעל בהצלחה מכיוון שהקובץ 'ABC.txt' אינו קיים. אם אנחנו רוצים לבדוק את הקוד במערכת אנחנו פשוט צריכים ליצור את שם הקובץ ABC.txt.  
  צור קובץ ABC.txt עם התוכן הבא שרשום להלן:  
   Hello Geeks Thissss Issszz אודות ordinaryChar() בשיטה זו הסירו 's' מכל הזרם  
 
   
 
     8. ordinaryChars():    שיטה זו מציינת שכל התווים בטווח מהנמוך לגבוה (כולל) יטופלו כתווים רגילים ולאחר קריאה לשיטה זו, התווים לא יטופלו עוד כאל תווים מיוחדים.  
     תַחבִּיר:    
   public void ordinaryChars (int low int high)  
 
      פָּרָמֶטֶר:    שיטה זו לוקחת שני ערכים שלמים     נָמוּך    ו     גבוה (    כולל) הטווח של התו המומר לתו מיוחד.  
     סוג החזרה:    השיטה הזו לא מחזירה כלום.  
 
     דוּגמָה:    
 Java      // Demonstrating the use of ordinaryChars() method   import     java.io.*  ;   public     class   Geeks   {      public     static     void     main  (  String  []     args  )     throws     InterruptedException        FileNotFoundException       IOException      {      FileReader     reader     =     new     FileReader  (  'ABC.txt'  );      BufferedReader     bufferread     =     new     BufferedReader  (  reader  );      StreamTokenizer     token     =     new     StreamTokenizer  (  bufferread  );      // Use of ordinaryChars() method       // Here we have taken low = 'a' and high = 'c'       token  .  ordinaryChars  (  'a'    'c'  );      int     t  ;      while     ((  t     =     token  .  nextToken  ())     !=     StreamTokenizer  .  TT_EOF  )      {      switch     (  t  )      {      case     StreamTokenizer  .  TT_NUMBER  :      System  .  out  .  println  (  'Number : '     +     token  .  nval  );      break  ;      case     StreamTokenizer  .  TT_WORD  :      System  .  out  .  println  (  'Word : '     +     token  .  sval  );      break  ;      }      }      }   }   
       תְפוּקָה:    
  Word : Hello   
 Word : Geeks   
 Word : This   
 Word : is   
 Word : out   
 Word : ordin   
 Word : ryCh   
 Word : rs      פֶּתֶק:    תוכנית זו לא תפעל בהצלחה מכיוון שהקובץ 'ABC.txt' אינו קיים. אם אנחנו רוצים לבדוק את הקוד במערכת אנחנו פשוט צריכים ליצור את שם הקובץ ABC.txt.  
  צור קובץ ABC.txt עם התוכן הבא שרשום להלן:  
   שלום חנונים זה על רגילים Chars()   
 
 
   
 
  שימוש ב-StreamTokenizer כדי לסמל קובץ טקסט  
  המחלקה של StreamTokenizer משמשת גם ל-Tokenization של קובץ הטקסט וכאן אנו משתמשים בשיטות של שיטות מחלקות Tokenizer.  
     שלב 1:    ראשית צור קובץ טקסט עם     .txt    הרחבה באותה ספריית שורש. כאן יצרנו אותו עם השם     Geeks.txt    .  
      
 
   
 
     שלב 2:    כעת צור קובץ ג'אווה וכתוב את הקוד כדי לסמל את נתוני הטקסט הקיימים בקובץ הטקסט.  
     קובץ Geeks.java:    
 Java      // Java program to Tokenized the text    // file data using StreamTokenizer methods   import     java.io.*  ;      public     class   Geeks   {         public     static     void     main  (  String  []     args  )     throws     InterruptedException           FileNotFoundException       IOException         {         FileReader     reader     =     new     FileReader  (  'Geeks.txt'  );         BufferedReader     bufferread     =     new     BufferedReader  (  reader  );         StreamTokenizer     token     =     new     StreamTokenizer  (  bufferread  );             // Use of ordinaryChar() method       // Here we have taken 's' as an ordinary character       token  .  ordinaryChar  (  's'  );             int     t  ;         while     ((  t     =     token  .  nextToken  ())     !=     StreamTokenizer  .  TT_EOF  )         {         switch     (  t  )         {         case     StreamTokenizer  .  TT_NUMBER  :         System  .  out  .  println  (  'Number : '     +     token  .  nval  );         break  ;         case     StreamTokenizer  .  TT_WORD  :         System  .  out  .  println  (  'Word : '     +     token  .  sval  );         break  ;             }         }         }      }      
       תְפוּקָה:    
      
 
     מבנה תיקיות:    
      
    המאמר הבא     –     Class Java.io.StreamTokenizer ב-Java | סט 2    
         צור חידון