streamalism.org

1. Inleiding

In deze zelfstudie laten we zien hoe u een stroom tekens in tokens kunt parseren met behulp van Java StreamTokenizer klasse.

2. StreamTokenizer

De StreamTokenizer class leest de stream karakter voor karakter. Elk van hen kan nul of meer hebben van de volgende attributen: witruimte, alfabetisch, numeriek, tekenreeks aanhalingstekens of commentaar.

Nu moeten we de standaardconfiguratie begrijpen. We hebben de volgende soorten karakters:

• Woordtekens: bereiken als 'a' tot 'z' en 'A' tot 'Z'
• Numerieke karakters: 0,1,…,9
• Witruimte-tekens: ASCII-waarden van 0 tot 32
• Commentaar karakter: /
• Tekenreeks aanhalingstekens: ‘En‘

Merk op dat de uiteinden van de regels worden behandeld als witruimten, niet als afzonderlijke tokens, en de opmerkingen in C / C ++ - stijl worden niet standaard herkend.

Deze klasse heeft een aantal belangrijke velden:

• TT_EOF - Een constante die het einde van de stream aangeeft
• TT_EOL - Een constante die het einde van de regel aangeeft
• TT_NUMBER - Een constante die een cijfertoken aangeeft
• TT_WORD - Een constante die een woordteken aangeeft

3. Standaardconfiguratie

Hier gaan we een voorbeeld maken om het StreamTokenizer mechanisme. We beginnen met het maken van een instantie van deze klasse en bellen vervolgens de volgendeToken () methode totdat het de TT_EOF waarde:

privé statische laatste int QUOTE_CHARACTER = '\' '; private static final int DOUBLE_QUOTE_CHARACTER = '"'; openbare statische lijst streamTokenizerWithDefaultConfiguration (Reader-lezer) gooit IOException {StreamTokenizer streamTokenizer = nieuwe StreamTokenizer (lezer); Lijsttokens = nieuwe ArrayList (); int currentToken = streamTokenizer.nextToken (); while (); ! = StreamTokenizer.TT_EOF) {if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER) {tokens.add (streamTokenizer.nval);} else if (streamTokenizer.ttype == StreamTokenizer.TT_WORD || streamTokenizer.ttype == QUOTE_CHARACTER || streamTokenizer.ttype == DOUBLE_QUOTE_CHARACTER) {tokens.add (streamTokenizer.sval);} else {tokens.add ((char) currentToken);} currentToken = streamTokenizer.nextToken ();} retourneer tokens;}

Het testbestand bevat simpelweg:

3 snelle bruine vossen springen over de "luie" hond! # test1 // test2

Als we nu de inhoud van de array zouden afdrukken, zouden we zien:

Nummer: 3.0 Woord: snel Woord: bruin Woord: vossen Woord: springen Woord: over Woord: het Woord: lui Woord: hond Gewone char:! Gewone char: # Word: test1

Om het voorbeeld beter te begrijpen, moeten we het StreamTokenizer.ttype, StreamTokenizer.nval en StreamTokenizer.sval velden.

De ttype veld bevat het type token dat zojuist is gelezen. Het zou kunnen TT_EOF, TT_EOL, TT_NUMBER, TT_WORD. Echter, voor een tekenreeks tussen aanhalingstekens is de waarde de ASCII-waarde van het aanhalingsteken. Bovendien, als het token een gewoon karakter is, zoals ‘!', zonder attributen, dan is de ttype wordt gevuld met de ASCII-waarde van dat teken.

De volgende, we gebruiken sval veld om het token te krijgen, alleen als het een TT_WORD, dat wil zeggen, een woordteken. Maar als we te maken hebben met een tekenreeks tussen aanhalingstekens - laten we zeggen "Lui" - dan bevat dit veld de body van de string.

Laatste, we hebben de nval veld om het token op te halen, alleen als het een nummertoken is, met TT_NUMBER.

4. Aangepaste configuratie

Hier zullen we de standaardconfiguratie wijzigen en een ander voorbeeld maken.

Eerste, we gaan wat extra woordtekens instellen met de wordChars (int laag, int hi) methode. Dan, we maken van het commentaarteken (‘/ ') een gewoon karakter en promoten ‘#' als het nieuwe commentaarteken.

Tenslotte, we beschouwen het einde van de regel als een teken met behulp van de eolIsSignificant (booleaanse vlag) methode.

We hoeven deze methoden alleen aan te roepen op de streamTokenizer voorwerp:

openbare statische lijst streamTokenizerWithCustomConfiguration (Reader-lezer) genereert IOException {StreamTokenizer streamTokenizer = nieuwe StreamTokenizer (lezer); Lijsttokens = nieuwe ArrayList (); streamTokenizer.wordChars ('!', '-'); streamTokenizer.ordinaryChar ('/'); streamTokenizer.commentChar ('#'); streamTokenizer.eolIsSignificant (waar); // hetzelfde als voorheen retourtokens; }

En hier hebben we een nieuwe output:

// dezelfde uitvoer als eerder Word: "lui" Word: hond! Gewoon teken: Gewoon teken: Gewoon teken: / Gewoon teken: / Woord: test2

Merk op dat de dubbele aanhalingstekens onderdeel zijn geworden van het token, het newline-teken is geen witruimteteken meer, maar een gewoon teken en daarom een ​​token met één teken.

Bovendien worden de tekens die volgen op het teken ‘# 'nu overgeslagen en is de‘ /' een gewoon teken.

We zouden ook kunnen verander het aanhalingsteken met de quoteChar (int ch) methode of zelfs de witruimtetekens door aan te roepen whitespaceChars (int laag, int hi) methode. Zo kunnen verdere aanpassingen worden gemaakt door te bellen StreamTokenizer‘S methoden in verschillende combinaties.

5. Conclusie

In deze tutorial we hebben gezien hoe je een stroom tekens in tokens kunt parseren met behulp van de StreamTokenizer klasse. We hebben geleerd over het standaardmechanisme en hebben een voorbeeld gemaakt met de standaardconfiguratie.

Ten slotte hebben we de standaardparameters gewijzigd en we hebben gemerkt hoe flexibel de StreamTokenizer klasse is.

Zoals gewoonlijk is de code te vinden op GitHub.