skip to main content

kiesler.at

Variablen mit Hashtable verwalten
updated by rck, 2004-10-03

Beispiel 1186 der EPROG-Beispielsammlung lässt sich sehr schön mit einer Hashtable lösen. Es handelt sich hierbei um eine schlichte Variablenverwaltung für ganzzahlige Werte.
1 | 2 | 3 | 4 | 5 | 6 | 7 | 8

variable.java

Hier das gesamte Programm:

1 /*      variable.java
2  *
3  *      umsetzung von http://eprog.sourceforge.net/eprog/1186/variable.html
4  *      zu Übungszwecken
5  *
6  *      (c) 2004-09-12 http://www.kiesler.at/
7  *
8  */
9 
10 
11 
12 /* eprog.jar: siehe http://www.kiesler.at/article53.html */
13 import eprog.*;
14 import java.io.*;
15 
16 import java.util.Hashtable;
17 
18 
19 /* StringTokenizer: siehe http://www.kiesler.at/article60.html */
20 import java.util.StringTokenizer;
21 
22 
23 
24 public class variable {
25 
26 
27         /* in dieser hashtable
28          * landen alle unsere variablen
29          */
30         static Hashtable syms;
31         static int vars=0;
32 
33 
34         /* isLetter() liefert true, wenn übergebenes
35          * Zeichen ein Buchstabe ist (a-z bzw. A-Z).
36          * false, wenn nicht.
37          */
38 
39         public static boolean isLetter(char c) {
40                 return( ( (c >= 'a') && (c <= 'z') ) ||
41                         ( (c >= 'A') && (c <= 'Z') ));
42         }
43 
44 
45         /* checkName() prüft, ob ein Name tatsächlich,
46          * wie in der Angabe gefordert, nur aus Buchstaben
47          * besteht.
48          *
49          * Wenn ja, passiert nichts. Wenn nein, wird eine
50          * Exception geworfen.
51          *
52          * Hier würden sich die Regular Expressions von
53          * JAVA auszahlen. Da wir als Vorgabe JDK 1.3.1_1
54          * haben, die Regular Expressions aber erst ab
55          * JDK 1.4 existieren, dürfen wir sie nicht
56          * verwenden.
57          */
58 
59         public static void checkName(String s)
60                 throws Exception
61         {
62                 for(int i=0; i<s.length(); i++)
63                         if(!isLetter(s.charAt(i)))
64                                 throw new Exception(
65                                         "Variable '"+s+"' besteht nicht "+
66                                         "ausschließlich aus Buchstaben!");
67         }
68 
69 
70         /* getWert liefert entweder die übergebene Konstante
71          * (Fall name=nummer) oder den Wert der übergebenen
72          * Variable zurück (Fall name=variable)
73          *
74          * Die Angabe sieht Werte des Typs Short vor.
75          */
76 
77         public static Short getWert(String s)
78                 throws Exception
79         {
80                 // etwaiges führendes Fragezeichen entfernen
81                 // (Stichwort: Ausgabe). Fängt an dieser Stelle
82                 // auch den gemeinen Fall ab, dass zB  ?14
83                 // abgefragt wird.
84 
85                 if(s.startsWith("?"))
86                         s=s.substring(1);
87 
88                 if(s.startsWith("-"))
89                         throw new Exception("Negative Werte sind "+
90                                 "laut Spezifikation nicht vorgesehen!");
91 
92                 try {
93 
94                         return(Short.valueOf(s));
95 
96                 } catch(NumberFormatException nfe) {
97 
98 
99                         // nichtexistente Werte haben den
100                         // Wert null (wie in einer Datenbank).
101                         // Wir müssen uns somit um das Werfen
102                         // der Exception kümmern!
103 
104                         Short wert=(Short)syms.get(s);
105 
106                         if(wert == null)
107                                 throw new Exception("Wert '"+
108                                         s+"' ist unbekannt!");
109                         else
110                                 return(wert);
111 
112                 }
113         }
114 
115 
116         /* assign bekommt einen String im Format
117          * name=wert und schreibt ihn in die hashtable
118          */
119 
120         public static void assign(String s)
121                 throws Exception
122         {
123 
124                 int eq=s.indexOf('=');
125 
126                 if(eq<1)
127                         throw new Exception("'"+s+"' ist keine "+
128                                 "gültige Zuweisung!");
129 
130                 if(eq+1>s.length())
131                         throw new Exception("Zuweisung '"+s+"' ist "+
132                                 "leer!");
133 
134                 String name=s.substring(0, eq);
135                 Short wert=getWert(s.substring(eq+1));
136 
137                 checkName(name);
138 
139                 // Spezifikation sieht vor, dass nur max. 10 Variablen
140                 // verwendet werden können.
141 
142                 if(syms.put(name, wert) == null) {
143                         vars++;
144 
145                         if(vars>10)
146                                 throw new Exception("Es werden nur "+
147                                         "maximal 10 Variablen unterstützt, "+
148                                         name+" wäre Nummer 11.");
149                 }
150         }
151 
152 
153         /* process nimmt eine lt. Spezifikation formatierte
154          * Eingabe, teilt sie in mundgerechte Happen auf und
155          * liefert dann gegebenenfalls die gewünschte Variable
156          * zurück
157          */
158 
159         public static Short process(String s)
160                 throws Exception
161         {
162                 syms=new Hashtable();
163                 StringTokenizer st=new StringTokenizer(s);
164                 String wort=st.nextToken();
165 
166                 while(!wort.startsWith("?")) {
167                         assign(wort);
168                         wort=st.nextToken();
169                 }
170 
171                 if(st.hasMoreTokens())
172                         throw new Exception("Da sind noch Worte übrig!");
173                 else
174                         return(getWert(wort));
175         }
176 
177 
178         public static void main(String args[]) {
179                 // Nachdem die eprog-Bibliothek buggy ist
180                 // (siehe http://www.kiesler.at/article53.html)
181                 // hier die ausprogrammierte Variante.
182                 //
183                 // ist erlaubt, benutzt nur das JDK.
184 
185                 InputStreamReader ins=new InputStreamReader(System.in);
186                 BufferedReader reader=new BufferedReader(ins);
187 
188                 try {
189 
190                         EprogIO.println(process(reader.readLine()));
191 
192                 } catch(Exception e) {
193 
194                         EprogIO.println("FALSCHE EINGABE");
195                 }
196         }
197 
198 }
1 | 2 | 3 | 4 | 5 | 6 | 7 | 8



RSSComments - Make a comment
The comments are owned by the poster. We are not responsible for its content.
RSSAll Articles
2008, 2007, 2006, 2005, 2004