Can this java code be reduced?

[debbie_82]

final class TraverseGrid{
private final static int UP = 1;
private final static int DOWN = 2;
private final static int LEFT = 3;
private final static int RIGHT = 4;

private static Vector getAllFocusableComponents(Container cycleRoot){
Vector components = new Vector();
int iCtr;

for (iCtr = 0; iCtr < cycleRoot.getComponentCount(); iCtr++) {
if ((cycleRoot.getComponent(iCtr).isFocusable()) == true){
components.addElement((Object)cycleRoot.getComponent(iCtr));
}
}
return components;
}

private static Component mapComponent(Vector components, Component origin, int position){
Component comp;
Vector subset = new Vector();
Vector row = new Vector();
Point reference = origin.getLocation();
int minimum = origin.getLocation().y;
Component temp;
int iCtr;
for (iCtr = 0; iCtr < components.size(); iCtr++ ) {
temp = (Component)components.elementAt(iCtr);
if ((position == UP && origin.getLocation().y > temp.getLocation().y) ||
(position == DOWN && origin.getLocation().y < temp.getLocation().y)) {
if (minimum == origin.getLocation().y)
minimum = temp.getLocation().y;
else if ((position == UP && minimum < temp.getLocation().y)||
(position == DOWN && minimum > temp.getLocation().y))
minimum = temp.getLocation().y;
subset.addElement(temp);
}
}

comp = origin;
for (iCtr = 0; iCtr < subset.size(); iCtr++) {
temp = (Component)subset.elementAt(iCtr);
comp = temp;
if (temp.getLocation().y == minimum && temp.getLocation().x >= origin.getLocation().x)
break;
}
return comp;
}

private static Component getComponent(Vector components, Component theComponent, int iDirection){
Component comp = theComponent;
int iCtr;

for (iCtr = 0; iCtr < components.size(); iCtr++) {
if (theComponent.equals((Component)components.elementAt(iCtr)) == true){
if (iDirection == RIGHT)
iCtr++;
else
iCtr--;
break;
}
}
if (iCtr > -1 && iCtr < components.size())
comp = (Component)components.elementAt(iCtr);
return comp;
}
synchronized public static Component getAboveComponent(Container cycleRoot, Component origin){
Vector comp = getAllFocusableComponents(cycleRoot);
return mapComponent(comp, origin, UP);
}
synchronized static Component getBelowComponent(Container cycleRoot, Component origin){
Vector comp = getAllFocusableComponents(cycleRoot);
return mapComponent(comp, origin, DOWN);
}
synchronized static Component getNextComponent(Container container, Component origin){
return getComponent(getAllFocusableComponents(container), origin, LEFT);
}
synchronized static Component getPreviousComponent(Container container, Component origin){
return getComponent(getAllFocusableComponents(container), origin, RIGHT);
}
}

[CornedBee]

I doubt that the code itself can be made much faster.