Algorithm practice

Question

so i am playing around with some different search algorithms, one such one is:
public static int bubbleUp (String list[], String partNumber)
    // declares comparison to be used as a counter
    int comparisons = 1; 
    // declares moves as a counter to be used later on
    int moves = 0;
    // declares sum of both comprisons and moves variables
    int sumNumbers = 0;
    // gets the variable partNumber and searches for it in list
    for (int i = 0; i < list.length; i++)
      if (!partNumber.equals (list ))
// add one to comparisons
comparisons++;
else
//if statement used to add the appropriate number of moves to the counter
if (!partNumber.equals (list [0]))
list [i] = list [i - 1];
list [i - 1] = partNumber;
moves+=2;
break;
// calculates sum of moves and comparisons
sumNumbers = comparisons + moves;
// return the number of comparisons
return sumNumbers;
now i am trying to use a two dimensional array rather than a single to search for different objects.
My question is, how would you change my code i wrote above to function for 2d arrays?

Answer 1

There's a saying: "code to the interface, not the implementation" and
that saying can be applied here; all you want to know in your algorithm is this:public interface BubbleUpable {
   public Object get(int index);
   public void set(int index, Object obj);
   public int length();
}One dimensional arrays can be wrapped in a simple wrapper class like this:public class ArrayWrapper implements BubbleUpable {
   private String[] a;
   public ArrayWrapper(String[] a) { this.a= a; }
   // interface implementation
   public Object get(int index) { return a[index]; }
   public void set(int index, Object obj) { a[index[= (String)obj; }
   public int length() { return a.length; }
}I'm sure a bit of Java 1.5 can take away a bit of explicit casting by applying
some generics here.
If you rewrite your algorithm such that it uses a BubbleUpable instead
of a String[] array, you can implement another wrapper (see above) that
wraps around a two dimensional array. Your algorithm wouldn't care at
all about the implementation though.
kind regards,
Jos