paquete com.ruoyi.common.core.text;
importar java.math.BigDecimal;
importar java.math.BigInteger;
importar java.nio.ByteBuffer;
importar java.nio.charset.Charset;
importar java.text.NumberFormat;
importar java .util.Set;
import com.ruoyi.common.utils.StringUtils;
/**
* Convertidor de tipo
*
* @author ruoyi
*/
public class Convertir
{
/**
* Convertir a cadena<br>
* Si el valor dado es null, o la conversión falla y se devuelve el valor predeterminado<br>
* No se informará ningún error si la conversión falla
*
* @param value El valor convertido
* @param defaultValue El valor predeterminado cuando ocurre el error de conversión
* @return result
* /
Cadena estática pública toStr (valor del objeto, valor predeterminado de la cadena)
{
if (null == valor)
{
devolver valor predeterminado;
}
if (valor instancia de cadena)
{
devolver valor (cadena);
}
devolver valor.toString();
}
/**
* convertir a cadena<br>
* si se proporciona el valor es <code>null</code>, o si la conversión falla, devolverá el valor predeterminado <code>null</code><br>
* Si la conversión falla, no se informará ningún error
*
* El valor @param es el valor convertido
* @return resultado
* /
public static String toStr(Valor del objeto)
{
return toStr(valor, nulo);
}
/**
* Convertir a carácter<br>
* Si el valor dado es nulo o la conversión falla, devuelve el valor predeterminado<br>
* No se informará ningún error si la conversión falla
*
* @param value El valor convertido
* @param defaultValue El valor predeterminado cuando ocurre el error de conversión
* @return result
*/
public static Character toChar(Valor del objeto, Character defaultValue)
{
if (null == valor)
{
return defaultValue;
}
if (valor instancia de Character)
{
return (Carácter) value;
}
final String valueStr = toStr( valor, nulo);
devolver StringUtils.isEmpty(valueStr)? defaultValue: valueStr.charAt(0);
}
/**
* Convertir a carácter<br>
* Si el valor dado es <code>null</code>, o la conversión falla, devuelve el valor predeterminado <code>null</code><br>
* No se informará ningún error si la conversión falla
*
* @ valor del parámetro valor convertido
* @return resultado
*/
public static Character toChar(Valor del objeto)
{
return toChar(value, null);
}
/**
* convertido a byte<br>
* si el valor dado es <code> null</code>, o si la conversión falla, regrese al valor predeterminado<br>
* No se informará ningún error si la conversión falla
*
* @param value El valor convertido
* @param defaultValue El valor predeterminado cuando la conversión falla
* @return result
*/
public static Byte toByte(Valor del objeto,Byte valor predeterminado)
{
if (valor == nulo)
{
return valor predeterminado;
}
if (valor instancia de Byte)
{
valor de retorno (Byte);
}
if (valor instancia de Número)
{
return ((Número) valor).byteValue();
}
valor de cadena finalStr = toStr(valor, nulo);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
prueba
{
return Byte.parseByte(valueStr);
}
catch (Excepción e)
{
return defaultValue;
}
}
/**
* Convertir a byte<br>
* Si el valor dado es <code>null</code>, o la conversión falla, devuelve el valor predeterminado <code>null</code><br>
* No se informará ningún error si el la conversión falla
*
* @ valor del parámetro El valor convertido
* @return resultado
*/
public static Byte toByte(Valor del objeto)
{
return toByte(valor, nulo);
}
/**
* Convertir a Short<br>
* Si el valor dado es <code> null</code>, o la conversión falla, devuelve el valor predeterminado<br>
* No se informará ningún error si la conversión falla
*
* @param value El valor convertido
* @param defaultValue El valor predeterminado cuando se produce el error de conversión ocurre
* @return result
*/
public static Short toShort(Valor del objeto, Short defaultValue)
{
si (valor == nulo)
{
devolver valor predeterminado;
}
if (valor instancia de Corto)
{
valor de retorno (Corto);
}
if (valor instancia de Número)
{
return ((Número) valor).shortValue();
}
valor de cadena finalStr = toStr(valor, nulo);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
prueba
{
return Short.parseShort(valueStr.trim());
}
catch (Excepción e)
{
return defaultValue;
}
}
/**
* Convertir a Corto<br>
* Si el valor dado es <code>null</code>, o la conversión falla, devuelve el valor predeterminado <code>null</code><br>
* Si la conversión falla, no informará un error
*
* @param value El valor convertido
* @return result
*/
public static Short toShort(Valor del objeto)
{
return toShort(value, null);
}
/**
* Convertir a Número<br>
* Si el valor dado está vacío o la conversión falla, devuelve el valor predeterminado<br>
* No se informará ningún error si la conversión falla
*
* @param value El valor convertido
* @param defaultValue El valor predeterminado cuando ocurre el error de conversión
* @return result
*/
public static Número toNumber(Valor del objeto,Número valor predeterminado)
{
if (valor == nulo)
{
return defaultValue;
}
if (valor instancia de Número)
{
valor de retorno (Número);
}
valor de cadena finalStr = toStr(valor, nulo);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
prueba
{
return NumberFormat.getInstance().parse(valueStr);
}
catch (Excepción e)
{
return defaultValue;
}
}
/**
* 转换为Número<br>
* Si el valor dado está vacío o la conversión falla, se devuelve el valor predeterminado <code>null</code><br>
* No se informará ningún error si la conversión falla
*
* @param value El valor convertido
* @return resultado
*/
public static Number toNumber(Valor del objeto)
{
return toNumber(value, null);
}
/**
* Convertir a int<br>
* Si el valor dado está vacío o la conversión falla, devuelve el valor predeterminado<br>
* Si la conversión falla, no informará un error
*
* @param value El valor convertido
* @param defaultValue El valor predeterminado cuando ocurre el error de conversión
* @return result
*/
public static Integer toInt(Object value, Integer defaultValue)
{
if (valor == nulo)
{
return defaultValue;
}
if (valor instancia de Integer)
{
valor de retorno (entero);
}
if (valor instancia de Número)
{
return ((Número) valor).intValue();
}
valor de cadena finalStr = toStr(valor, nulo);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
prueba
{
return Integer.parseInt(valueStr.trim());
}
catch (Excepción e)
{
return defaultValue;
}
}
/**
* 转换为int<br>
* Si el valor proporcionado es <code>null</code>, o la conversión falla, se devolverá el valor predeterminado <code>null</code><br>
*/
* No se informará ningún error si la conversión falla
*
* @param valor valor convertido
* @return resultado
*/
public static Integer toInt(Valor del objeto)
{
return toInt(valor, nulo);
}
/**
* convertido a una matriz de enteros <br>
*
* @param str valor convertido
* @return resultado
*/
public static Integer[] toIntArray(String str)
{
return toIntArray(",", str);
}
/**
* convertido a matriz larga<br>
*
* @param str El valor convertido
* @return result
public static Long[] toLongArray(String str)
{
return toLongArray(",", str);
}
/**
* Convertir a matriz de enteros<br>
*
* @param delimitador de división
* @param dividir valor convertido
* @return resultado
*/
public static Integer[] toIntArray( String split, String str)
{
if (StringUtils.isEmpty(str))
{
return new Integer[] {};
}
String[] arr = str.split(split);
final Integer[] ints = new Integer[arr.length ];
para (int i = 0; i < arr.length; i++)
{
entero final v = toInt(arr[i], 0);
}
ints[i] = v;
}
return ints;
}
/**
* Convertir a matriz larga<br>
*
* @param delimitador de división
* @param str valor convertido
* @return resultado
*/
public static Long[] toLongArray(String split, String str)
{
if (StringUtils .isEmpty(str))
{
return new Long[] {};
}
String[] arr = str.split(split);
final Long[] longs = new Long[arr.length];
for (int i = 0; i < arr.length; i++)
{
final Long v = toLong(arr[i], null);
longs[i] = v;
devolver longs;
}
/**
* Convertir a matriz de cadenas<br>
*
* @param str El valor convertido
* @return resultado
*/
public static String[] toStrArray(String str)
{
return toStrArray(",", str);
}
/* *
* Convertir a matriz de cadenas<br>
*
* @param delimitador de división
* @param dividir valor convertido
* @return resultado
*/
public static String[] toStrArray(String split, String str)
{
return str.split(split ); }
/
**
* Convertir a largo<br>
* Si el valor dado está vacío o la conversión falla, devuelve el valor predeterminado<br>
* @param valor el valor convertido
* No se informará ningún error si la conversión falla.
*
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Long toLong(Valor del objeto, Long defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (valor instancia de Long)
{
valor de retorno (Long);
}
if (valor instancia de Número)
{
return ((Número) valor).longValue();
}
valor de cadena finalStr = toStr(valor, nulo);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
prueba
{
// admite notación científica
return new BigDecimal(valueStr.trim()).longValue();
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* convertir a long<br>
* si el valor dado es <code >null</code>, o si la conversión falla, devuelve el valor predeterminado <code>null</code><br>
* No se informará ningún error si la conversión falla
*
* @param valor valor convertido
* @return resultado
* /
public static Long toLong(Valor del objeto)
{
return toLong(valor, nulo);
}
/**
* Convertir a doble<br>
* Si el valor dado está vacío o la conversión falla, devuelve el valor predeterminado<br>
* No se informará ningún error si la conversión falla.
*
* @param value El valor convertido
* @param defaultValue El valor predeterminado cuando se produce un error de conversión
* @return result
*/
public static Double toDouble(Valor del objeto, Double defaultValue)
{
if (value == null)
{
return defaultValue;
}
if ( valor instancia de Doble)
{
devolver valor (Doble);
}
if (valor instancia de Número)
{
devolver ((Número) valor).doubleValue();
}
valor de cadena finalStr = toStr(valor, nulo);
if (StringUtils.isEmpty(valueStr ))
{
return defaultValue;
}
try
{
// Admite notación científica
return new BigDecimal(valueStr.trim()).doubleValue();
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* Convertir a doble<br>
* If el valor dado está vacío o la conversión falla, se devuelve el valor predeterminado <code>null</code><br>
* No se informará ningún error si la conversión falla
*
* @param valor El valor convertido
* @return resultado
* /
public static Double toDouble(Valor del objeto)
{
return toDouble(valor, nulo);
}
/**
* Convertir a flotante<br>
}
* Si el valor proporcionado está vacío o la conversión falla, devuelve el valor predeterminado<br>
* No se informará ningún error si la conversión falla
*
* @param value El valor convertido
* @param defaultValue El valor predeterminado cuando ocurre el error de conversión
* @return resultado
*/
public static Float toFloat(Valor del objeto, Float valor predeterminado)
{
if (valor == null)
{
devolver valor predeterminado;
}
if (valor instancia de Float)
{
devolver valor (Float);
}
if (valor instancia de Número)
{
return ((Número) valor). floatValue();
valor de cadena finalStr = toStr(valor, nulo);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Float.parseFloat(valueStr.trim());
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* Convertir a flotante<br>
* Si el valor dado está vacío o la conversión falla, devuelve el valor predeterminado <code>null</code><br>
* No se informará ningún error si la conversión falla
*
* El valor de @param es el valor convertido
* @return resultado
*/
public static Float toFloat(Valor del objeto)
{
volver aFloat(valor, nulo);
}
cadena valorStr = toStr(valor, nulo);
/**
* Convertir a booleano<br>
* Los valores admitidos de String son: verdadero, falso, sí, ok, no, 1, 0. Si el valor dado está vacío o la conversión falla, se devuelve el valor predeterminado < br> * Si la conversión falla,
no informará un error
*
* @param value El valor convertido
* @param defaultValue El valor predeterminado cuando ocurre el error de conversión
* @return result
*/
public static Boolean toBool(Valor del objeto, Boolean defaultValue )
{
if (valor == null)
{
devolver valor predeterminado;
}
if (valor instancia de booleano)
{
devolver valor (booleano);
}
devolver valor predeterminado;
}
if (StringUtils.isEmpty(valueStr))
{
valueStr = valueStr.trim().toLowerCase();
switch (valueStr)
{
case "true":
devuelve verdadero;
caso "falso":
devuelve falso;
caso "sí":
devuelve verdadero;
caso "ok":
devuelve verdadero;
caso "no":
devuelve falso;
caso "1":
devuelve verdadero;
caso "0":
devuelve falso;
predeterminado:
}
}
/**
* 转换为booleano<br>
* Si el valor dado está vacío o la conversión falla, devuelve el valor predeterminado <code>null</code><br>
* No se informará ningún error si la conversión falla
*
* @param valor el valor convertido
* @return resultado
*/
public static Boolean toBool(Valor del objeto)
{
return toBool(valor, nulo);
}
/**
* Convertir a objeto Enum<br>
* Si el valor dado está vacío o la conversión falla, devuelve el valor predeterminado< br>
*
* @ param clazz Clase de Enum
* @param value value
* @param defaultValue valor predeterminado
* @return Enum
*/
public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue )
{
si (valor == nulo)
{
return valor predeterminado;
}
if (clazz.isAssignableFrom(value.getClass()))
{
@SuppressWarnings("sin marcar")
E myE = (E) valor;
devolver miE;
}
valor de cadena finalStr = toStr(valor, nulo);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
prueba
{
return Enum.valueOf(clazz, valueStr);
}
catch (Excepción e)
{
return defaultValue;
}
}
/**
* Convertir a objeto Enum<br>
* Si el valor dado está vacío o la conversión falla, devuelve el valor predeterminado <code>null</code><br>
*
* @param clazz Clase de Enum
* @param value value
* @ return Enum
*/
public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value)
{
return toEnum(clazz, value,null);
}
/**
* Convertir a BigInteger<br>
* Si el valor dado está vacío o la conversión falla, devuelve el valor predeterminado<br>
* No se informará ningún error si la conversión falla
*
* @param valor El convertido value
* @ param defaultValue El valor predeterminado cuando se produce un error de conversión
* @return result
*/
if (value == null)
{
return defaultValue;
public static BigInteger toBigInteger(Valor del objeto,Valor predeterminado de BigInteger)
{
}
if (valor instancia de BigInteger)
{
valor de retorno (BigInteger);
}
if (valor instancia de Long)
{
return BigInteger.valueOf((Long) valor);
}
valor de cadena finalStr = toStr(valor, nulo);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
prueba
{
return new BigInteger(valueStr);
}
catch (Excepción e)
{
return defaultValue;
}
}
/**
* Convertir a BigInteger<br>
* Si el valor dado está vacío o la conversión falla, devuelve el valor predeterminado <code>null</code><br>
* No se informará ningún error si la conversión falla
*
* El valor @param es el valor convertido
* @return resultado
*/
public static BigInteger toBigInteger(Valor del objeto)
{
return toBigInteger(valor, nulo);
}
/**
* Convertir a BigDecimal<br>
* Si el valor dado está vacío o la conversión falla, devuelve el valor predeterminado<br>
* No se informará ningún error si la conversión falla
*
* @param valor El valor convertido
* @param defaultValue El valor predeterminado cuando ocurre el error de conversión
* @return resultado
*/
public static BigDecimal toBigDecimal(Valor del objeto , valor predeterminado de BigDecimal)
{
si (valor == nulo)
si (StringUtils.isEmpty(valueStr))
{
devolver valor predeterminado;
}
if (valor instancia de BigDecimal)
{
valor de retorno (BigDecimal);
}
if (valor instancia de Long)
{
return new BigDecimal((Long) valor);
}
if (valor instancia de Doble)
{
return new BigDecimal((Double) valor);
}
if (valor instancia de entero)
{
return new BigDecimal((Entero) valor);
}
valor de cadena finalStr = toStr(valor, nulo);
{
return valor predeterminado;
}
try
{
return new BigDecimal(valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* Convertir a BigDecimal<br>
* Si el valor dado está vacío o la conversión falla, devuelve el valor predeterminado<br>
* No se informará ningún error si la conversión falla
*
* @param valor El valor convertido
* @return resultado
*/
public static BigDecimal toBigDecimal(Valor del objeto)
{
return toBigDecimal(valor, nulo);
}
/**
* Convertir el objeto en cadena< br>
* 1. Las matrices de bytes y ByteBuffer se convertirán en matrices correspondientes a cadenas 2. Las matrices de objetos llamarán al método Arrays.toString
*
* @param obj objeto
* @return cadena
*/
public static String utf8Str(Object obj)
{
return str(obj, CharsetKit.CHARSET_UTF_8);
}
/**
* Convertir el objeto en una cadena<br>
* 1. Las matrices de bytes y ByteBuffer se convertirán en matrices de cadenas correspondientes 2, la matriz de objetos llamará al método Arrays.toString
*
* @param obj object
* @param charsetName juego de caracteres
* @return string
*/
public static String str(Object obj, String charsetName)
{
return str(obj, Charset.forName(charsetName) )); } /
**
*
Convertir objetos en cadenas<br>
* 1. Las matrices de bytes y ByteBuffer se convertirán en matrices correspondientes a cadenas 2. Las matrices de objetos llamarán al método Arrays.toString
* @ param charset conjunto de caracteres
*
* @param obj 对象
* @return 字符串
*/
public static String str(Object obj, Charset charset)
{
if (null == obj)
{
return null;
}
if (obj instancia de Cadena)
{
return (Cadena) obj;
}
else if (obj instancia de byte[] || obj instancia de Byte[])
{
return str((Byte[]) obj, juego de caracteres);
}
else if (obj instancia de ByteBuffer)
{
return str((ByteBuffer) obj, charset);
}
devolver obj.toString();
}
/**
* Convertir matriz de bytes en cadena
*
* @param bytes matriz de bytes
* @param juego de caracteres del juego de caracteres
* @return string
*/
public static String str(byte[] bytes, String charset)
{
return str(bytes, StringUtils.isEmpty (charset) ? Charset.defaultCharset() : Charset.forName(charset));
}
/**
* Decodificar código de bytes
*
* @param cadena de datos
* @param conjunto de caracteres del juego de caracteres, si este campo está vacío, el resultado decodificado depende de la plataforma
* @return cadena decodificada
*/
cadena estática pública str(byte[] datos, juego de caracteres Charset)
{
if (data == null)
{
return null;
}
if (null == juego de caracteres)
{
return new String(data);
}
return new String(data, charset);
}
/**
* Convierte los datos codificados de byteBuffer en una cadena
*
* @param data data
* @param charset conjunto de caracteres, utilízalo si está vacío Sistema actual conjunto de caracteres
* @return string
*/
public static String str(ByteBuffer data, String charset)
{
if (data == null)
{
return null;
}
return str(data, Charset.forName(charset));
}
/ **
* Convertir datos codificados de byteBuffer a cadena
*
* @param datos de datos
* Conjunto de caracteres del conjunto de caracteres @param; si está vacío, utilice el conjunto de caracteres del sistema actual
* @return String
*/
public static String str(ByteBuffer data, Charset charset)
{
if (null == charset)
{
charset = Charset.defaultCharset();
}
return charset.decode(data).toString();
}
/ / -------------------------------------------------- ---------------------- Conversión de ancho completo a medio ancho
/**
* Conversión de medio ancho a ancho completo
*
* @param cadena de entrada.
* @return Cadena de ancho completo.
*/
public static String toSBC(String input)
{
return toSBC(input, null);
}
/**
* De medio ancho a ancho completo
*
* @param cadena de entrada
* @param notConvertSet El conjunto de caracteres no debe reemplazarse
* @return cadena de ancho completo.
*/
public static String toSBC(String input, Set<Character> notConvertSet)
{
char c[] = input.toCharArray() ;
for (int i = 0; i < c. length; i++)
{
if (null != notConvertSet && notConvertSet.contiene(c[i]))
{
// Omitir caracteres que no se reemplazan
continuar;
}
if (c[i] == ' ')
{
c[i] = '\u3000';
}
else if (c[i] < '\177')
{
c[i] = (char) (c[i] + 65248);
}
}
devuelve nueva cadena(c);
}
/**
* De ancho completo a medio ancho
*
* @param cadena de entrada.
* @return Half- cadena de ancho
*/
cadena estática pública toDBC(entrada de cadena)
{
return toDBC(entrada, nulo);
}
/**
* Reemplazar ancho completo con ancho medio
*
* @param text Texto
* @param notConvertSet El juego de caracteres no se reemplazará
* @return Caracteres reemplazados
*/
public static String toDBC(String text, Set<Character> notConvertSet)
{
char c[] = text.toCharArray();
for (int i = 0; i < c.length; i++)
{
if (null! = notConvertSet && notConvertSet.contiene(c[i]))
{
// Omitir caracteres que no se reemplazan
continuar;
}
if (c[i] == '\u3000')
{
c[i] = ' ';
}
else if (c[i] > '\uFF00' && c[i] < '\uFF5F')
{
c[i] = (char) (c[i] - 65248);
}
}
String returnString = new String(c);
return returnString;
}
/ **
*Para convertir el monto numérico a mayúsculas, escribe primero el número completo y luego reemplaza el monto por cero
*"");
}
if (s.length() < 1)
{
s = "整";
}
int parteentero = (int) Math.floor(n);
* @return Número chino en mayúscula
*/
public static String digitUppercase(double n)
{
for (int i = 0; i < unidad[0].length && integerPart > 0; i++)
{
String p = "";
for (int j = 0; j < unidad[1].longitud && n > 0; j++)
{
p = dígito[parteentero % 10] + unidad[1][j] + p;
parteentero = parteentero / 10;
}
s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unidad[0][i] + s;
}
return head + s.replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零" ).replaceAll("^整$", "零元整");
}
}
Si tipo convertidor--Convertir
Supongo que te gusta
Origin blog.csdn.net/snowing1997/article/details/131720195
Recomendado
Clasificación