help with some code.

[ben riches]

hello everyone i hope someone can help me.
i want to be able to test 10 strings(some of the strings might have the same value) i want to be able test each string in turn with a loop though the hashtable. so for example if the hashtable equals string 1 extract the strings that do equal string 1 and put them inside a array list along with there key values, and then delete the ones that have been found to equal string 1, so that when i test again it will not find them again. then i want a loop to test the next string (string2) and do the same to that string and so on with the rest of the strings.
could someone please help me as my code does work but it is hard coded and i need some help please.
thanks for yr time.
ben

[Norm Miller]

Maybe you could show us what you have done so far. Use UBB code tags to bracket the code.

[ben riches]

this is what i have done so far it works how i want it to but it is just so ugly
thanks
ben

import java.io.*;
import java.util.*;
import java.lang.*;
public class has2 {
public static void main(String[] args) {
ArrayList arr = new ArrayList();
Hashtable hash = new Hashtable();
String a =  "firstname";            //column names
String b = "lastname";
String c = "id";
String d = "adress1";
String k = "phone";
String f = "county";
String g = "post code";
String h = "country";
String i = "goods in";
String j = "goods out";
String st1 = "ben";
String st2 = "ben";  //table names
String st3 = "alex";
String st4 = "alex";
String st5 = "matt";
String st6 = "matt";
String st7 = "mum";
String st8 = "mum";
String st9 = "dad";
String st10 = "ben";
hash.put(a, st1);
hash.put(b, st2);
hash.put(c, st3);
hash.put(d, st4);
hash.put(k, st5);
hash.put(f, st6);
hash.put(g, st7);
hash.put(h, st8);
hash.put(i, st9);
hash.put(j, st10);
while(hash.containsValue(st1)) {
     Enumeration e = hash.keys();
      while (e.hasMoreElements()) { 
           String tempkey = (String) e.nextElement(); 
           String tempvalue = (String) hash.get(tempkey);
 
            if(tempvalue.equals(st1)) {
arr.add(tempkey);
arr.add(tempvalue);
System.out.println(arr);//tempkey+"\n"+tempvalue);
  hash.remove(tempkey);
            }

       }
break; 
}
while(hash.containsValue(st2)) {
Enumeration e1 = hash.keys();
      while (e1.hasMoreElements()) { 
           String tempkey1 = (String) e1.nextElement(); 
           String tempvalue1 = (String) hash.get(tempkey1);
 
            if(tempvalue1.equals(st2)) {
System.out.println(tempkey1+"\n"+tempvalue1);
hash.remove(tempkey1);
 }

}
break;

}
while(hash.containsValue(st3)) {
Enumeration e2 = hash.keys();
      while (e2.hasMoreElements()) { 
           String tempkey2 = (String) e2.nextElement(); 
           String tempvalue2 = (String) hash.get(tempkey2);
 
            if(tempvalue2.equals(st3)) {
System.out.println(tempkey2+"\n"+tempvalue2);
hash.remove(tempkey2);
 }

}
break;
}
while(hash.containsValue(st4)) {
Enumeration e3 = hash.keys();
      while (e3.hasMoreElements()) { 
           String tempkey3 = (String) e3.nextElement(); 
           String tempvalue3 = (String) hash.get(tempkey3);
 
            if(tempvalue3.equals(st4)) {
System.out.println(tempkey3+"\n"+tempvalue3);
hash.remove(tempkey3);
 }

}
break;
}
while(hash.containsValue(st5)) {
Enumeration e4 = hash.keys();
      while (e4.hasMoreElements()) { 
           String tempkey4 = (String) e4.nextElement(); 
           String tempvalue4 = (String) hash.get(tempkey4);
 
            if(tempvalue4.equals(st5)) {
System.out.println(tempkey4+"\n"+tempvalue4);
hash.remove(tempkey4);
 }

}
break;
}
while(hash.containsValue(st6)) {
Enumeration e5 = hash.keys();
      while (e5.hasMoreElements()) { 
           String tempkey5 = (String) e5.nextElement(); 
           String tempvalue5 = (String) hash.get(tempkey5);
 
            if(tempvalue5.equals(st6)) {
System.out.println(tempkey5+"\n"+tempvalue5);
hash.remove(tempkey5);
 }

}
break;
}
while(hash.containsValue(st7)) {
Enumeration e6 = hash.keys();
      while (e6.hasMoreElements()) { 
           String tempkey6 = (String) e6.nextElement(); 
           String tempvalue6 = (String) hash.get(tempkey6);
 
            if(tempvalue6.equals(st7)) {
System.out.println(tempkey6+"\n"+tempvalue6);
hash.remove(tempkey6);
 }

}
break;
}
while(hash.containsValue(st8)) {
Enumeration e7 = hash.keys();
      while (e7.hasMoreElements()) { 
           String tempkey7 = (String) e7.nextElement(); 
           String tempvalue7 = (String) hash.get(tempkey7);
 
            if(tempvalue7.equals(st8)) {
System.out.println(tempkey7+"\n"+tempvalue7);
hash.remove(tempkey7);
 }

}
break;
}
while(hash.containsValue(st9)) {
Enumeration e8 = hash.keys();
      while (e8.hasMoreElements()) { 
           String tempkey8 = (String) e8.nextElement(); 
           String tempvalue8 = (String) hash.get(tempkey8);
 
            if(tempvalue8.equals(st9)) {
System.out.println(tempkey8+"\n"+tempvalue8);
hash.remove(tempkey8);
 }

}
break;
}
while(hash.containsValue(st10)) {
Enumeration e9 = hash.keys();
      while (e9.hasMoreElements()) { 
           String tempkey9 = (String) e9.nextElement(); 
           String tempvalue9 = (String) hash.get(tempkey9);
 
            if(tempvalue9.equals(st10)) {
System.out.println(tempkey9+"\n"+tempvalue9);
hash.remove(tempkey9);
 }

}
break;
}
}
}

(edited by Cindy to close the code block - although now it is SOOOO wide . . . )
[ December 13, 2002: Message edited by: Cindy Glass ]

[Greg Charles]

Wow, you're right. That is ugly!
OK, I'll make a few suggestions. First of all, why a while(hash.containsValue()) ? I'd use, "if" instead. In fact, the unconditional break at the end of the loop makes it act like an "if" structure anyway. If you ever see an unconditional break or continue ... that is one not in an "if" structure ... you know you've made a mistake.
Here's another idea. How about putting the strings into an array, rather than individually named variables? Then you could use a loop and not have to cut and paste the same block of code ten times. If that approach doesn't work, how about breaking that duplicated block into a method that you call ten times. An identical or nearly identical block of code duplicated ten times is also a sure sign of a programming mistake.

[Jamie Robertson]

here is a different way of ( hopefully ) accomplishing some of what you tried to do with the Hashtable

import java.util.*;
import java.lang.*;
public class has2 {
ArrayList keys = new ArrayList();
ArrayList values = new ArrayList();
public void add ( String key, String value )
{
   keys.add( key );
   values.add( value );
}
public void remove ( int index )
{
   keys.remove( index );
   values.remove( index );
}
public void removeAll ( String value )
{
   int index = -1;
   while (  (  index = values.indexOf( value ) ) != -1 )
   {
      remove( index );
   }
}
public static void main ( String args[] )
{
   has2 h = new has2();
   has2.add( "firstname", "ben" );
   has2.add( "lastname", "ben" );
   ....
   has2.removeAll( "ben" );
   ....
}  

Not sure what you need to do in your program, but something like a dual arraylist seems more practical to me. Usually it is obvious when you've chosen the wrong data structure ( or are misusing it ) and all hands are pointing to 'misuse'! There is little functionality in my code snippet and I just typed it off the top of my head, so don't assume it will compile! But it may give you some other ideas to make your life easier!
Jamie