Formato de salida

Si te entiendo, es muy frecuente en toda aplicación el formateado de valores.
Yo tengo una clase especial java (Utilidades.class) donde voy añadiendo métodos estáticos de tipo static String toImporte(Object), toDate(java.sql.Date), etc.
Es muy útil por que añades todos los métodos formateadores que necesites y están parametrizados para un cambio de idioma por ejemplo (en inglés el punto decimal es, y la coma un .)
En el JSP solo pones <%=Utilidades.toImporte(variable)%> y te vale para N aplicaciones.

Muchas gracias por la ayuda que has brindado, pero casualidad me podrías enviar la clase utilidades para ilustrarme mejor, yo se que me va a servir mucho.
Muchas gracias por todo.

Haz un copy/paste de la clase. Es posible que algún método tenga errores por que usan otras clases externas. Quedate con lo que necesites:
package com.slb.sema.jgador.utils.gnral;
import com.slb.sema.jgador.transation.gnral.*;
import com.slb.sema.jgador.dbase.gnral.*;
import java.util.*;public class GadGenUtMetodos {
/**
* Comentario de constructor Formatea.
*/
public GadGenUtMetodos() {
super();
}
/**
* Desde un String que contenga algún tipo de separador devuelve un array de strings de las cadenas
* separadas por dicho separador, de manera análoga al Tokenizer aunque si hay 2 separadores contiguos
* no devuelve un elemento nulo en el array.
*
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String Cadena a defragmentar
* caracter char Caracter separador.
*/
public final static String[] fragmenta(String entrada, char caracter) {
java.util.Vector salida = new java.util.Vector();
int control = 0, i;
String fragmento = "";
char [] lista = entrada.toCharArray();
for (i = 0;i < lista.length;i++) {
if (lista == caracter) {
salida.addElement(String.valueOf(fragmento));
fragmento = "";
} else {
fragmento = fragmento + String.valueOf(lista);
}
}
if (fragmento.length() > 0) salida.addElement(String.valueOf(fragmento));
Object [] tmp = salida.toArray();
String [] sal = new String[tmp.length];
for (i = 0;i < tmp.length;i++) {
sal = (String) tmp;
}
return sal;
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
Entrada: 1234567.45677
Salida: 1.234.567,45
*/
public final static String fromImporte(String entrada) {
String salida = "", trozo = "";
for (int i = 0;i < entrada.length();i++) {
trozo = entrada.substring(i, i+1);
if (! trozo.equals(".")) {
if (trozo.equals(",")) {
salida = salida + ".";
} else {
salida = salida + trozo;
}
}
}
return salida;
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String padL(int entrada, int lon) {;
return padL(String.valueOf(entrada), lon);
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String padL(long entrada, int lon) {;
return padL(String.valueOf(entrada), lon);
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (28/9/01 10:18:26)
* @return java.lang.String
*/
private static String redondeaDecimales(String entrada) {
if (entrada.length() < 3) {
if (entrada == null ||
entrada.length() == 0 ||
Integer.parseInt(entrada) == 0) {
return "";
} else {
return entrada;
}
} else {
char [] listacarcteres = entrada.toCharArray();
int [] listanumeros = new int[listacarcteres.length];
int i = 0;
for (i=0;i < listacarcteres.length;i++)
listanumeros = Integer.parseInt(String.valueOf(listacarcteres));
for (i = listacarcteres.length-1;i > 1;i--) {
if (listanumeros > 4) {
listanumeros[i - 1] = listanumeros[i - 1] + 1;
}
listanumeros = 0;
}
if (listanumeros[1] > 9) {
listanumeros[0] = listanumeros[0] + 1;
listanumeros[1] = 0;
}
if (listanumeros[0] > 9) return "E";
return String.valueOf(listanumeros[0]) + String.valueOf(listanumeros[1]);
}
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String toDate(java.util.Date entrada) {;
if (entrada == null) return "";
java.util.Calendar cal = java.util.Calendar.getInstance();
cal.setTime(entrada);
String dd = String.valueOf(cal.get(cal.DAY_OF_MONTH)),
mm = String.valueOf(cal.get(cal.MONTH)+1),
aa = String.valueOf(cal.get(cal.YEAR));
return (dd.length() < 2?"0"+dd:dd) + "/" +
(mm.length() < 2?"0"+mm:mm) + "/" + aa;
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String toImporte(double entrada) {
return toImporte((new java.math.BigDecimal(entrada)));
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String toImporte(float entrada) {
return toImporte((new java.math.BigDecimal(entrada)));
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String toImporte(int entrada) {
return toImporte(new java.math.BigDecimal(entrada));
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String toImporte(Double entrada) {
return toImporte(entrada.doubleValue());
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String toImporte(Float entrada) {
return toImporte(entrada.floatValue());
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String toImporte(Integer entrada) {
return toImporte(new java.math.BigDecimal(entrada.intValue()));
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String toImporte(Long entrada) {
return toImporte((new java.math.BigDecimal(entrada.longValue())));
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
Entrada: 1234567.45677
Salida: 1.234.567,45
*/
public final static String toImporte(String entrada) {
String parteEntera = "";
String parteDecimal = "";
String salida= "";
int posicionPunto=entrada.indexOf(".");
int i = 0;
if (posicionPunto==-1){ //Si no tiene punto, es un numero entero.
parteEntera=entrada;
}else{ //Si tiene punto, partimos la cadena en dos: la parte entera y la decimal.
parteEntera=entrada.substring(0,posicionPunto);
parteDecimal=entrada.substring(posicionPunto+1,entrada.length());
}
//Si la parte decimal al redondear dá un exceso se suma 1 a la entera.
parteDecimal=redondeaDecimales(parteDecimal);
if (parteDecimal.equals("E")) {
parteDecimal = "";
parteEntera = String.valueOf(Integer.parseInt(parteEntera) + 1);
}
while ( i <= parteEntera.length()){
if ((parteEntera.length()-i)>3){
//Si nos quedan por mirar más de 3 posiciones, cogemos las tres
//últimas posiciones que quedan por mirar y metemos un punto delante.
salida="." + parteEntera.substring(((parteEntera.length()-i)-3),(parteEntera.length()-i)) + salida;
}else{
salida = parteEntera.substring(0,(parteEntera.length()-i)) + salida;
}
i+=3;
}
if(parteDecimal.length()!=0){
salida=salida + "," + parteDecimal;
} else {
salida=salida + ",00";
}
return salida;
}
public final static String padL(String entrada, int lon) {;
return padL(entrada, lon, '0');
}public final static int intValue(java.util.Date entrada) {
if (entrada == null) return 0;
java.util.Calendar cal = java.util.Calendar.getInstance();
cal.setTime(entrada);
int dd = cal.get(cal.DAY_OF_MONTH),
mm = cal.get(cal.MONTH)+1,
aa = cal.get(cal.YEAR);
return (aa * 10000) + (mm * 100) + dd;
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static java.util.Date goMonth(java.util.Date entrada, int meses) {
if (meses == 0) return entrada;
java.util.Calendar cal = java.util.Calendar.getInstance();
cal.setTime(entrada);
int dd = cal.get(cal.DAY_OF_MONTH),
mm = cal.get(cal.MONTH)+1,
aa = cal.get(cal.YEAR),
cn = meses;
// Avanzo los meses
if (meses > 0) {
while (cn > 0) {
mm++;
if (mm > 12) {
aa++;
mm = 1;
}
cn--;
}
} else {
while (cn < 0) {
mm--;
if (mm == 0) {
aa--;
mm = 12;
}
cn++;
}
}
// Reviso el día
if (dd > 28) {
if (mm==4 || mm==6 || mm==9 || mm==11) {
if (dd == 31) dd = 30;
}
if (mm==2) {
dd=28;
}
}
// Genero la nueva fecha
cal.set(cal.YEAR, aa);
cal.set(cal.MONTH, mm-1);
cal.set(cal.DAY_OF_MONTH, dd);
return cal.getTime();
}public final static String padL(String entrada, int lon, char ca) {;
String salida = entrada.trim();
for (int i=salida.length();i < lon;i++) salida = String.valueOf(ca) + salida;
return salida;
}public final static String padR(String entrada, int lon) {;
return padR(entrada, lon, ' ');
}public final static String padR(String entrada, int lon, char ca) {;
String salida = entrada.trim();
for (int i=salida.length();i < lon;i++) salida = salida + String.valueOf(ca);
return salida;
}/**
* Todos los tipos numéricos acaban aqui donde se revisa el signo
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String toImporte(java.math.BigDecimal entrada) {
if (entrada.doubleValue() < 0) return "-" + toImporte(entrada.abs());
return toImporte(entrada.toString());
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static int getDay(java.sql.Date entrada) {;
java.util.Date f = new java.util.Date(entrada.getTime());
return getDay(f);
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static int getDay(java.util.Date entrada) {;
if (entrada == null) return 0;
java.util.Calendar cal = java.util.Calendar.getInstance();
cal.setTime(entrada);
return cal.get(cal.DAY_OF_MONTH);
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static boolean getEsMenor(String entrada, int edad) {
return getEsMenor(toDate(entrada), edad);
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static boolean getEsMenor(java.util.Date entrada, int edad) {;
java.util.Date fecMayor = goMonth(entrada, edad * 12);
java.util.Date fecActua = new java.util.Date(System.currentTimeMillis());
int fecMay = intValue(fecMayor);
int fecAct = intValue(fecActua);
return fecAct < fecMay;
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static int getMonth(java.sql.Date entrada) {;
java.util.Date f = new java.util.Date(entrada.getTime());
return getMonth(f);
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static int getMonth(java.util.Date entrada) {;
if (entrada == null) return 0;
java.util.Calendar cal = java.util.Calendar.getInstance();
cal.setTime(entrada);
return cal.get(cal.MONTH)+1;
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static int getYear(java.sql.Date entrada) {;
java.util.Date f = new java.util.Date(entrada.getTime());
return getYear(f);
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static int getYear(java.util.Date entrada) {;
if (entrada == null) return 0;
java.util.Calendar cal = java.util.Calendar.getInstance();
cal.setTime(entrada);
return cal.get(cal.YEAR);
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
Entrada: 1234567.45677
Salida: 1.234.567,45
*/
public final static void printTraza(String entrada, String clase) {
System.out.println(
"jGador (" +
toDate(new java.util.Date(System.currentTimeMillis())) + " " +
toTime(new java.util.Date(System.currentTimeMillis())) + " clase: " +
clase + ") > " + entrada
);
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static java.sql.Date toDate(int entrada) {
if (entrada < 10000000) return null;
String cad = String.valueOf(entrada);
String aa = cad.substring(0,4);
String mm = cad.substring(4,6);
String dd = cad.substring(6,8);
return toDate(dd+ "/" + mm + "/" + aa);
}public final static java.sql.Date toDate(int ano, int mes, int dia) {
return toDate((ano * 10000) + (mes * 100) + dia);
}public final static java.sql.Date toDate(int ano, int mes, int dia, int hora, int minutos) {
java.util.Calendar cal = java.util.Calendar.getInstance();
cal.set(cal.DAY_OF_MONTH, dia);
cal.set(cal.MONTH, mes);
cal.set(cal.YEAR, ano);
cal.set(cal.HOUR_OF_DAY, hora);
cal.set(cal.MINUTE, minutos);
return new java.sql.Date(cal.getTime().getTime());
}public final static java.sql.Date toDate(Object ano, Object mes, Object dia) {
int aa = 0, mm = 0, dd = 0;
try {
aa = Integer.parseInt(ano.toString());
mm = Integer.parseInt(mes.toString());
dd = Integer.parseInt(dia.toString());
} catch (Exception e) {
return toDate(0,0,0);
}
return toDate(aa,mm,dd);
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static java.sql.Date toDate(String entrada) {;
String paEnt = entrada;
if (entrada.startsWith("1/") ||
entrada.startsWith("2/") ||
entrada.startsWith("3/") ||
entrada.startsWith("4/") ||
entrada.startsWith("5/") ||
entrada.startsWith("6/") ||
entrada.startsWith("7/") ||
entrada.startsWith("8/") ||
entrada.startsWith("9/")) {
paEnt = "0" + entrada;
}
if (paEnt.indexOf("/1/") != -1 ||
paEnt.indexOf("/2/") != -1 ||
paEnt.indexOf("/3/") != -1 ||
paEnt.indexOf("/4/") != -1 ||
paEnt.indexOf("/5/") != -1 ||
paEnt.indexOf("/6/") != -1 ||
paEnt.indexOf("/7/") != -1 ||
paEnt.indexOf("/8/") != -1 ||
paEnt.indexOf("/9/") != -1) {
paEnt = paEnt.substring(0,3) + "0" + paEnt.substring(3,9);
}
java.util.Calendar cal = java.util.Calendar.getInstance();
cal.set(cal.DAY_OF_MONTH, Integer.parseInt(paEnt.substring(0,2)));
cal.set(cal.MONTH, Integer.parseInt(paEnt.substring(3,5))-1);
cal.set(cal.YEAR, Integer.parseInt(paEnt.substring(6,10)));
return new java.sql.Date(cal.getTime().getTime());
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String toHora(Object hora, Object minutos) {;
if (hora == null || minutos == null) return "00:00";
return padL(hora.toString(),2) + ":" + padL(minutos.toString(),2);
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String toHora(Object hora, Object minutos, Object segundos) {;
String prefix = toHora(hora, minutos);
if (segundos == null) return prefix + ":00";
return prefix + ":" + padL(segundos.toString(),2);
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String toTime(java.util.Date entrada) {;
if (entrada == null) return "";
java.util.Calendar cal = java.util.Calendar.getInstance();
cal.setTime(entrada);
String hh = String.valueOf(cal.get(cal.HOUR_OF_DAY)),
mm = String.valueOf(cal.get(cal.MINUTE)),
ss = String.valueOf(cal.get(cal.SECOND));
return (hh.length() < 2?"0"+hh:hh) + ":" +
(mm.length() < 2?"0"+mm:mm) + ":" +
(ss.length() < 2?"0"+ss:ss);
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (28/9/01 10:18:26)
* @return java.lang.String
*/
public static GadGenTrException exceptionTraducida(String codigo,GadGenUtContexto o) throws Exception {
GadGenADErrores gr=new GadGenADErrores(o.POOL);
gr.execute(codigo,o.SESSION.getValue("SYSTEM.Lenguaje").toString());
o.ENTITY.set("ERROR",gr);
String head = gr.getHead();
String msg = gr.getMsg();
String error = head + "</P>" + "<P CLASS='parrafo'>" + msg;
return new GadGenTrException(error);
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static String getTime(java.util.Date entrada) {;
if (entrada == null) return "00:00";
java.util.Calendar cal = java.util.Calendar.getInstance();
cal.setTime(entrada);
return padL(cal.get(cal.HOUR_OF_DAY),2) + ":" + padL(cal.get(cal.MINUTE),2);
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (23/05/2002 15:22:37)
* @return java.lang.String
* @param is java.io.InputStream
*/
public final static String leerStream(java.io.InputStream is) throws Exception{
/*String resultado=null;
int len=0;
//java.io.BufferedInputStream buf=new java.io.BufferedInputStream(is);
byte[] datos=new byte[5550];
try{
while(is.read() != -1)
{
oracle.jdbc.driver.OracleBufferedStream ob=(oracle.jdbc.driver.OracleBufferedStream)is;
len=ob.available();
is.read(datos,0,datos.length);
}
}
catch(Exception e)
{
is.close();
e.getLocalizedMessage();
e.printStackTrace();
throw e;
}
resultado=new String(datos);
resultado=resultado.trim();
is.close();
return resultado;*/
String resultado=null;
int len=0;
java.io.BufferedInputStream b=new java.io.BufferedInputStream(is);
java.io.BufferedReader buf=new java.io.BufferedReader(new java.io.InputStreamReader(b));
char[] datos=new char[5550];
try{
int i;
do{
buf.read(datos);
}
while((i=buf.read()) != -1);
}
catch(Exception e)
{
is.close();
e.getLocalizedMessage();
e.printStackTrace();
throw e;
}
resultado=new String(datos);
resultado=resultado.trim();
is.close();
return resultado;
}
public final static String toImporte_abs(String entrada) {
String parteEntera = "";
String parteDecimal = "";
String salida= "";
int posicionPunto=entrada.indexOf(".");
int i = 0;
if (posicionPunto==-1){ //Si no tiene punto, es un numero entero.
parteEntera=entrada;
}else{ //Si tiene punto, partimos la cadena en dos: la parte entera y la decimal.
parteEntera=entrada.substring(0,posicionPunto);
parteDecimal=entrada.substring(posicionPunto+1,entrada.length());
}
//Si la parte decimal al redondear dá un exceso se suma 1 a la entera.
while ( i <= parteEntera.length()){
if ((parteEntera.length()-i)>3){
//Si nos quedan por mirar más de 3 posiciones, cogemos las tres
//últimas posiciones que quedan por mirar y metemos un punto delante.
salida="." + parteEntera.substring(((parteEntera.length()-i)-3),(parteEntera.length()-i)) + salida;
}else{
salida = parteEntera.substring(0,(parteEntera.length()-i)) + salida;
}
i+=3;
}
if(parteDecimal.length()!=0){
salida=salida + "," + parteDecimal;
}
return salida;
}
/**
* Inserte aquí la descripción del método.
* Fecha de creación: (15/07/2002 10:39:33)
* @return java.lang.String
* @param entrada java.lang.String
*/
public final static String fromImporteOracle(String entrada) {
String salida=null;
if(entrada != null || !entrada.equals(""))
{
salida=fromImporte(entrada).replace(',','.');
}
return salida;
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (28/9/01 10:18:26)
* @return java.lang.String
*/
private static String redondeaDecimalesA5(String entrada) {
if (entrada.length() < 6) {
if (entrada == null ||
entrada.length() == 0 ||
Integer.parseInt(entrada) == 0) {
return "";
} else {
return padR(entrada,5,'0');
}
} else {
String ca=entrada;
String de=null;
/* Voy redondeando decimales hasta dejarlo solo a 2 */
while (ca.length() > 5) {
de = ca.substring(0, ca.length() - 1) + "." + ca.substring(ca.length() - 1, ca.length());
double db=Double.valueOf(de).doubleValue();
String dR = String.valueOf(Math.round(db));
ca = "" + dR + "";
}
return ca;
}
}/**
* Inserte aquí la descripción del método.
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
Entrada: 1234567.45677
Salida: 1.234.567,45
*/
public final static String toImporteA5(String entrada) {
String parteEntera = "";
String parteDecimal = "";
String salida= "";
int posicionPunto=entrada.indexOf(".");
int i = 0;
if (posicionPunto==-1){ //Si no tiene punto, es un numero entero.
parteEntera=entrada;
}else{ //Si tiene punto, partimos la cadena en dos: la parte entera y la decimal.
parteEntera=entrada.substring(0,posicionPunto);
parteDecimal=entrada.substring(posicionPunto+1,entrada.length());
}
//Si la parte decimal al redondear dá un exceso se suma 1 a la entera.
parteDecimal=redondeaDecimalesA5(parteDecimal);
if (parteDecimal.equals("E")) {
parteDecimal = "";
parteEntera = String.valueOf(Integer.parseInt(parteEntera) + 1);
}
while ( i <= parteEntera.length()){
if ((parteEntera.length()-i)>3){
//Si nos quedan por mirar más de 3 posiciones, cogemos las tres
//últimas posiciones que quedan por mirar y metemos un punto delante.
salida="." + parteEntera.substring(((parteEntera.length()-i)-3),(parteEntera.length()-i)) + salida;
}else{
salida = parteEntera.substring(0,(parteEntera.length()-i)) + salida;
}
i+=3;
}
if(parteDecimal.length()!=0){
salida=salida + "," + parteDecimal;
} else {
salida=salida + ",00000";
}
return salida;
}/**
* Devuelve los valores ordenados por clave
* Fecha de creación: (21/9/01 11:27:58)
* @param entrada java.lang.String
*/
public final static Vector getSortedHashtable(Hashtable entrada) {
int cntN = entrada.size();
Enumeration lisKey = entrada.keys();
Vector cntL = new Vector(cntN);
Vector salida = new Vector(cntN);
//Cargo la Enumeración
while (lisKey.hasMoreElements()) cntL.addElement(lisKey.nextElement());
//Hago el recorrido comparativo
while (salida.size() < cntN) {
Object cntS = "";
int cntE = 0;
for (int i=0;i < cntL.size();i++) {
Object cadC = cntL.elementAt(i);
if (cadC.toString().compareTo(cntS.toString()) > 0) {
cntS = cadC;
cntE = i;
}
}
cntL.removeElementAt(cntE);
salida.addElement(entrada.get(cntS));
}
//Lo ordeno de menor a mayor
for (int i=cntN - 1;i > -1;i--) cntL.addElement(salida.elementAt(i));
return cntL;
}}