Formato de salida

Hola como estas
Quisiera que me ayudaras con un problemita que tengo y no se como solucionarlo, resulta que tengo un HTML la cual invoca una JSP y esta a su vez llama un procedimiento en PL/SQL, el problema es el siguiente en el procedimiento debo mandar unos parámetros de salida, los cuales son en tipo pesos y quiero que cuando la JSP invoque el procedimiento el resultado de este me lo muestre en el HTML estos parámetros con la distinción de "$", "%" y con la separación de miles y décimas, el problema es que esto no lo quiero hacer desde el procedimiento sino desde la JSP ya que tengo que graficar en la JSP con los valores enviados por el procedimiento, y si los envío dentro del procedimiento me forma conflicto al graficar en la JSP, por eso quisiera saber si existe un método para poder agregarle estos caracteres en la JSP y me los mostrara en el HTML sin que me afecte la gráfica.
Espero que me hayas entendido y ojala me puedas ayudar
Mil Gracias

3 Respuestas

Respuesta
1
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;
}}
Muchas gracias por tu ayuda voy a analizar bien el código, y por lo que puedo ver esto me va a servir mucho para mi problemita.
Mil gracias, te estoy muy agradecido, creo que me has sacado de un apuro.
Respuesta
1
Con lo de la separación de miles no se como hacerlos, los decimales te lo hace el sólito a no ser que uses in Integer (no tiene decimales), si usas un integer cambia la variable a Float.
Si lo he entendido bien, con lo de añadir $ o % solo es hacer lo siguiente:
<%= variable%>%
Muestras la variable que tu quieres i fuera del código JSP le añades el % i el $.
Respuesta
En Java cual es la función para definir o convertir formatos de datos. Ese te sirve para darle el formato que tu quieras.

Añade tu respuesta

Haz clic para o

Más respuestas relacionadas