de-vraag
  • Preguntas
  • Etiquetas
  • Usuarios
Notificaciones
Recompensas
Registracion
Una vez que se registre, se le notificarán las respuestas y los comentarios a sus preguntas.
Entrar
Si ya tiene una cuenta, conéctese para comprobar las nuevas notificaciones.
Habrá recompensas por las preguntas, respuestas y comentarios añadidos.
Más
Fuente
Editar
Ryan P
Ryan P
Question

Decodificar los datos de Base64 en Java

Tengo una imagen que está codificada en Base64. ¿Cuál es la mejor manera de decodificarla en Java? Con suerte, usando sólo las librerías incluidas en Sun Java 6.

461 2009-01-22T15:55:18+00:00 20
Joachim Sauer
Joachim Sauer
Pregunta editada 24º octubre 2012 в 8:50
Programación
java
base64
Popular videos
Ejemplo de base64 (Encode and Decode) con spring boot
Ejemplo de base64 (Encode and Decode) con spring boot
hace 1 año
Base64 encoding/decoding in java 8
Base64 encoding/decoding in java 8
hace 5 años
Base64 Encoding and Decoding in java
Base64 Encoding and Decoding in java
hace 3 años
Python 3 - Receta 114: Uso del Módulo base64 para Codificar y Decodificar Datos Binarios
Python 3 - Receta 114: Uso del Módulo base64 para Codificar y Decodificar Datos Binarios
hace 2 años
How to Decode Base64 to Original Values | React Tutorial
How to Decode Base64 to Original Values | React Tutorial
hace 1 año
Java 8 Base64 Encoding and Decoding With Examples | Java Tutorial in Hindi
Java 8 Base64 Encoding and Decoding With Examples | Java Tutorial in Hindi
hace 1 año
Javascript #003 - Encriptar y Desencriptar en Base64
Javascript #003 - Encriptar y Desencriptar en Base64
hace 7 años
Píldora formativa 36: ¿Qué es el código Base64?
Píldora formativa 36: ¿Qué es el código Base64?
hace 5 años
Codificar e Decodificar em base64 [hacker fts315]
Codificar e Decodificar em base64 [hacker fts315]
hace 10 años
Codificar / Decodificar Base64 usando Python|Base64 | SkriptedSecurity
Codificar / Decodificar Base64 usando Python|Base64 | SkriptedSecurity
hace 4 años
Tutorial Java - Encoding com Base64 (e desencoding, claro)
Tutorial Java - Encoding com Base64 (e desencoding, claro)
hace 4 años
Codificar (Convertir) un Archivo a Base64 en React JS || Tutorial en Español
Codificar (Convertir) un Archivo a Base64 en React JS || Tutorial en Español
hace 1 año
Base64 y su uso
Base64 y su uso
hace 4 años
How to encode a text using Base64 and powershell
How to encode a text using Base64 and powershell
hace 1 año
Video 2  - Conexión   Encriptar y Desencriptar -  Parte 1
Video 2 - Conexión Encriptar y Desencriptar - Parte 1
hace 3 años
« Anterior
Siguiente »
Solution / Answer
Jeremy Ross
Jeremy Ross
13º enero 2010 в 3:42
2010-01-13T03:42:00+00:00
Más
Fuente
Editar
#8766008

A partir de la v6, el Java SE se envía con el JAXB. [javax.xml.bind.DatatypeConverter][1] tiene métodos estáticos que lo hacen fácil. Mira [parseBase64Binary()][2] y [printBase64Binary()][3].

[1]: http://download.oracle.com/javase/6/docs/api/javax/xml/bind/DatatypeConverter.html [2]: http://download.oracle.com/javase/6/docs/api/javax/xml/bind/DatatypeConverter.html#parseBase64Binary(java.lang.String) [3]: http://download.oracle.com/javase/6/docs/api/javax/xml/bind/DatatypeConverter.html#printBase64Binary%28byte[]%29

DatatypeConverter (Java Platform SE 6)
download.oracle.com
DatatypeConverter (Java Platform SE 6)
download.oracle.com
DatatypeConverter (Java Platform SE 6)
download.oracle.com
417
0
 Andrea
Andrea
26º marzo 2013 в 8:35
2013-03-26T20:35:05+00:00
Más
Fuente
Editar
#8766016

A partir de Java 8, hay una API oficialmente soportada para la codificación y decodificación de Base64. Con el tiempo esto probablemente se convertirá en la elección por defecto.

La API incluye la clase [java.util.Base64][1] y sus clases anidadas. Soporta tres sabores diferentes: básico, URL seguro, y MIME.

Código de muestra usando el "basic" codificación:

import java.util.Base64;

byte[] bytes = "Hello, World!".getBytes("UTF-8");
String encoded = Base64.getEncoder().encodeToString(bytes);
byte[] decoded = Base64.getDecoder().decode(encoded);

La [documentación de java.util.Base64][1] incluye varios métodos más para configurar los codificadores y decodificadores, y para utilizar diferentes clases como entradas y salidas (matrices de bytes, cadenas, ByteBuffers, corrientes java.io).

[1]: http://docs.oracle.com/javase/8/docs/api/java/util/Base64.html

 Ivar
Ivar
Respuesta editada 26º septiembre 2018 в 2:01
Base64 (Java Platform SE 8 )
docs.oracle.com
362
0
 MattK
MattK
22º enero 2009 в 4:05
2009-01-22T16:05:37+00:00
Más
Fuente
Editar
#8766006

No hay necesidad de usar los bienes comunes... Sun envía un codificador de base64 con Java. Puedes importarlo como tal:

import sun.misc.BASE64Decoder;

Y luego úsalo así:

BASE64Decoder decoder = new BASE64Decoder();
byte[] decodedBytes = decoder.decodeBuffer(encodedBytes);

Donde "codificado por Bytes" es una "cadena de Java.lang" o una "cadena de entrada". Sólo ten en cuenta que las clases "sun" no están oficialmente respaldadas; por Sun.

...EDITAR:..; ¿Quién sabía que esta sería la respuesta más controvertida que yo 'd publicaría? Yo sé que los paquetes de Sun.* no están apoyados o garantizados para seguir existiendo, y sé de los Comunes y los uso todo el tiempo. Sin embargo, el cartel pedía una clase que estaba incluida en Sun Java 6; y eso es lo que estaba tratando de responder. Estoy de acuerdo en que los Bienes Comunes es la mejor manera de ir en general.

EDITORIAL 2:____; Como amir75 señala a continuación, Java 6+ se envía con JAXB, que contiene el código soportado para codificar/decodificar la Base64. Por favor, vea [Jeremy Ross' respuesta][1] a continuación.

[1]: https://stackoverflow.com/a/2054226/33311

 Community
Community
Respuesta editada 23º mayo 2017 в 12:18
97
0
Yuval Adam
Yuval Adam
22º enero 2009 в 4:01
2009-01-22T16:01:02+00:00
Más
Fuente
Editar
#8766005

Específicamente en [Commons Codec][1]: clase [Base64][2] a decode(byte[] array) o encode(byte[] array)

[1]: http://commons.apache.org/codec/ [2]: http://commons.apache.org/codec/apidocs/org/apache/commons/codec/binary/Base64.html

Codec – Home
commons.apache.org
Base64 (Apache Commons Codec 1.15 API)
commons.apache.org
55
0
 jontro
jontro
17º diciembre 2012 в 7:12
2012-12-17T19:12:03+00:00
Más
Fuente
Editar
#8766015

La guayaba ahora tiene la decodificación de la Base64 incorporada.

Usa [BaseEncoding.base64().decode()][1]

En cuanto al tratamiento de los posibles espacios en blanco en el uso de insumos

"BaseEncoding.base64().decode(CharMatcher.WHITESPACE.removeFrom(...))".

Ver [esta discusión][2] para más información

[1]: http://google.github.io/guava/releases/snapshot-jre/api/docs/com/google/common/io/BaseEncoding.html [2]: https://github.com/google/guava/issues/1252

 jontro
jontro
Respuesta editada 1º noviembre 2017 в 11:27
BaseEncoding (Guava: Google Core Libraries for Java HEAD-jre-SNAPSHOT API)
google.github.io
BaseEncoder.base64() should accept newlines · Issue #1252 · google/guava · GitHub
Original issue created by progoth on 2013-01-09 at 07:28 PM It looks like we encoded some old data with an older version of commons-io Base64 (or perhaps some other encoder) that inserted CR/LFs into the encoded string. This is probably ...
github.com
36
0
 GeorgeK
GeorgeK
24º noviembre 2010 в 9:57
2010-11-24T09:57:12+00:00
Más
Fuente
Editar
#8766009

Mi solución es la más rápida y fácil.

public class MyBase64 {

    private final static char[] ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();

    private static int[]  toInt   = new int[128];

    static {
        for(int i=0; i< ALPHABET.length; i++){
            toInt[ALPHABET[i]]= i;
        }
    }

    /**
     * Translates the specified byte array into Base64 string.
     *
     * @param buf the byte array (not null)
     * @return the translated Base64 string (not null)
     */
    public static String encode(byte[] buf){
        int size = buf.length;
        char[] ar = new char[((size + 2) / 3) * 4];
        int a = 0;
        int i=0;
        while(i < size){
            byte b0 = buf[i++];
            byte b1 = (i < size) ? buf[i++] : 0;
            byte b2 = (i < size) ? buf[i++] : 0;

            int mask = 0x3F;
            ar[a++] = ALPHABET[(b0 >> 2) & mask];
            ar[a++] = ALPHABET[((b0 << 4) | ((b1 & 0xFF) >> 4)) & mask];
            ar[a++] = ALPHABET[((b1 << 2) | ((b2 & 0xFF) >> 6)) & mask];
            ar[a++] = ALPHABET[b2 & mask];
        }
        switch(size % 3){
            case 1: ar[--a]  = '=';
            case 2: ar[--a]  = '=';
        }
        return new String(ar);
    }

    /**
     * Translates the specified Base64 string into a byte array.
     *
     * @param s the Base64 string (not null)
     * @return the byte array (not null)
     */
    public static byte[] decode(String s){
        int delta = s.endsWith( "==" ) ? 2 : s.endsWith( "=" ) ? 1 : 0;
        byte[] buffer = new byte[s.length()*3/4 - delta];
        int mask = 0xFF;
        int index = 0;
        for(int i=0; i< s.length(); i+=4){
            int c0 = toInt[s.charAt( i )];
            int c1 = toInt[s.charAt( i + 1)];
            buffer[index++]= (byte)(((c0 << 2) | (c1 >> 4)) & mask);
            if(index >= buffer.length){
                return buffer;
            }
            int c2 = toInt[s.charAt( i + 2)];
            buffer[index++]= (byte)(((c1 << 4) | (c2 >> 2)) & mask);
            if(index >= buffer.length){
                return buffer;
            }
            int c3 = toInt[s.charAt( i + 3 )];
            buffer[index++]= (byte)(((c2 << 6) | c3) & mask);
        }
        return buffer;
    } 

}
33
0
 aleroot
aleroot
24º mayo 2012 в 10:59
2012-05-24T10:59:18+00:00
Más
Fuente
Editar
#8766014

Aquí's mi propia aplicación, si puede ser útil para alguien :

public class Base64Coder {

    // The line separator string of the operating system.
    private static final String systemLineSeparator = System.getProperty("line.separator");

    // Mapping table from 6-bit nibbles to Base64 characters.
    private static final char[] map1 = new char[64];
       static {
          int i=0;
          for (char c='A'; c<='Z'; c++) map1[i++] = c;
          for (char c='a'; c<='z'; c++) map1[i++] = c;
          for (char c='0'; c<='9'; c++) map1[i++] = c;
          map1[i++] = '+'; map1[i++] = '/'; }

    // Mapping table from Base64 characters to 6-bit nibbles.
    private static final byte[] map2 = new byte[128];
       static {
          for (int i=0; i<map2.length; i++) map2[i] = -1;
          for (int i=0; i<64; i++) map2[map1[i]] = (byte)i; }

    /**
    * Encodes a string into Base64 format.
    * No blanks or line breaks are inserted.
    * @param s  A String to be encoded.
    * @return   A String containing the Base64 encoded data.
    */
    public static String encodeString (String s) {
       return new String(encode(s.getBytes())); }

    /**
    * Encodes a byte array into Base 64 format and breaks the output into lines of 76 characters.
    * This method is compatible with <code>sun.misc.BASE64Encoder.encodeBuffer(byte[])</code>.
    * @param in  An array containing the data bytes to be encoded.
    * @return    A String containing the Base64 encoded data, broken into lines.
    */
    public static String encodeLines (byte[] in) {
       return encodeLines(in, 0, in.length, 76, systemLineSeparator); }

    /**
    * Encodes a byte array into Base 64 format and breaks the output into lines.
    * @param in            An array containing the data bytes to be encoded.
    * @param iOff          Offset of the first byte in <code>in</code> to be processed.
    * @param iLen          Number of bytes to be processed in <code>in</code>, starting at <code>iOff</code>.
    * @param lineLen       Line length for the output data. Should be a multiple of 4.
    * @param lineSeparator The line separator to be used to separate the output lines.
    * @return              A String containing the Base64 encoded data, broken into lines.
    */
    public static String encodeLines (byte[] in, int iOff, int iLen, int lineLen, String lineSeparator) {
       int blockLen = (lineLen*3) / 4;
       if (blockLen <= 0) throw new IllegalArgumentException();
       int lines = (iLen+blockLen-1) / blockLen;
       int bufLen = ((iLen+2)/3)*4 + lines*lineSeparator.length();
       StringBuilder buf = new StringBuilder(bufLen);
       int ip = 0;
       while (ip < iLen) {
          int l = Math.min(iLen-ip, blockLen);
          buf.append (encode(in, iOff+ip, l));
          buf.append (lineSeparator);
          ip += l; }
       return buf.toString(); }

    /**
    * Encodes a byte array into Base64 format.
    * No blanks or line breaks are inserted in the output.
    * @param in  An array containing the data bytes to be encoded.
    * @return    A character array containing the Base64 encoded data.
    */
    public static char[] encode (byte[] in) {
       return encode(in, 0, in.length); }

    /**
    * Encodes a byte array into Base64 format.
    * No blanks or line breaks are inserted in the output.
    * @param in    An array containing the data bytes to be encoded.
    * @param iLen  Number of bytes to process in <code>in</code>.
    * @return      A character array containing the Base64 encoded data.
    */
    public static char[] encode (byte[] in, int iLen) {
       return encode(in, 0, iLen); }

    /**
    * Encodes a byte array into Base64 format.
    * No blanks or line breaks are inserted in the output.
    * @param in    An array containing the data bytes to be encoded.
    * @param iOff  Offset of the first byte in <code>in</code> to be processed.
    * @param iLen  Number of bytes to process in <code>in</code>, starting at <code>iOff</code>.
    * @return      A character array containing the Base64 encoded data.
    */
    public static char[] encode (byte[] in, int iOff, int iLen) {
       int oDataLen = (iLen*4+2)/3;       // output length without padding
       int oLen = ((iLen+2)/3)*4;         // output length including padding
       char[] out = new char[oLen];
       int ip = iOff;
       int iEnd = iOff + iLen;
       int op = 0;
       while (ip < iEnd) {
          int i0 = in[ip++] & 0xff;
          int i1 = ip < iEnd ? in[ip++] & 0xff : 0;
          int i2 = ip < iEnd ? in[ip++] & 0xff : 0;
          int o0 = i0 >>> 2;
          int o1 = ((i0 &   3) << 4) | (i1 >>> 4);
          int o2 = ((i1 & 0xf) << 2) | (i2 >>> 6);
          int o3 = i2 & 0x3F;
          out[op++] = map1[o0];
          out[op++] = map1[o1];
          out[op] = op < oDataLen ? map1[o2] : '='; op++;
          out[op] = op < oDataLen ? map1[o3] : '='; op++; }
       return out; }

    /**
    * Decodes a string from Base64 format.
    * No blanks or line breaks are allowed within the Base64 encoded input data.
    * @param s  A Base64 String to be decoded.
    * @return   A String containing the decoded data.
    * @throws   IllegalArgumentException If the input is not valid Base64 encoded data.
    */
    public static String decodeString (String s) {
       return new String(decode(s)); }

    /**
    * Decodes a byte array from Base64 format and ignores line separators, tabs and blanks.
    * CR, LF, Tab and Space characters are ignored in the input data.
    * This method is compatible with <code>sun.misc.BASE64Decoder.decodeBuffer(String)</code>.
    * @param s  A Base64 String to be decoded.
    * @return   An array containing the decoded data bytes.
    * @throws   IllegalArgumentException If the input is not valid Base64 encoded data.
    */
    public static byte[] decodeLines (String s) {
       char[] buf = new char[s.length()];
       int p = 0;
       for (int ip = 0; ip < s.length(); ip++) {
          char c = s.charAt(ip);
          if (c != ' ' && c != '\r' && c != '\n' && c != '\t')
             buf[p++] = c; }
       return decode(buf, 0, p); }

    /**
    * Decodes a byte array from Base64 format.
    * No blanks or line breaks are allowed within the Base64 encoded input data.
    * @param s  A Base64 String to be decoded.
    * @return   An array containing the decoded data bytes.
    * @throws   IllegalArgumentException If the input is not valid Base64 encoded data.
    */
    public static byte[] decode (String s) {
       return decode(s.toCharArray()); }

    /**
    * Decodes a byte array from Base64 format.
    * No blanks or line breaks are allowed within the Base64 encoded input data.
    * @param in  A character array containing the Base64 encoded data.
    * @return    An array containing the decoded data bytes.
    * @throws    IllegalArgumentException If the input is not valid Base64 encoded data.
    */
    public static byte[] decode (char[] in) {
       return decode(in, 0, in.length); }

    /**
    * Decodes a byte array from Base64 format.
    * No blanks or line breaks are allowed within the Base64 encoded input data.
    * @param in    A character array containing the Base64 encoded data.
    * @param iOff  Offset of the first character in <code>in</code> to be processed.
    * @param iLen  Number of characters to process in <code>in</code>, starting at <code>iOff</code>.
    * @return      An array containing the decoded data bytes.
    * @throws      IllegalArgumentException If the input is not valid Base64 encoded data.
    */
    public static byte[] decode (char[] in, int iOff, int iLen) {
       if (iLen%4 != 0) throw new IllegalArgumentException ("Length of Base64 encoded input string is not a multiple of 4.");
       while (iLen > 0 && in[iOff+iLen-1] == '=') iLen--;
       int oLen = (iLen*3) / 4;
       byte[] out = new byte[oLen];
       int ip = iOff;
       int iEnd = iOff + iLen;
       int op = 0;
       while (ip < iEnd) {
          int i0 = in[ip++];
          int i1 = in[ip++];
          int i2 = ip < iEnd ? in[ip++] : 'A';
          int i3 = ip < iEnd ? in[ip++] : 'A';
          if (i0 > 127 || i1 > 127 || i2 > 127 || i3 > 127)
             throw new IllegalArgumentException ("Illegal character in Base64 encoded data.");
          int b0 = map2[i0];
          int b1 = map2[i1];
          int b2 = map2[i2];
          int b3 = map2[i3];
          if (b0 < 0 || b1 < 0 || b2 < 0 || b3 < 0)
             throw new IllegalArgumentException ("Illegal character in Base64 encoded data.");
          int o0 = ( b0       <<2) | (b1>>>4);
          int o1 = ((b1 & 0xf)<<4) | (b2>>>2);
          int o2 = ((b2 &   3)<<6) |  b3;
          out[op++] = (byte)o0;
          if (op<oLen) out[op++] = (byte)o1;
          if (op<oLen) out[op++] = (byte)o2; }
       return out; }

    // Dummy constructor.
    private Base64Coder() {}
}
11
0
 RealHowTo
RealHowTo
23º enero 2009 в 3:09
2009-01-23T15:09:46+00:00
Más
Fuente
Editar
#8766007

Como alternativa a "tsun.misc.BASE64Decoder" o a las librerías no centrales, mira en "javax.mail.internet.MimeUtility.decode()`.

public static byte[] encode(byte[] b) throws Exception {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    OutputStream b64os = MimeUtility.encode(baos, "base64");
    b64os.write(b);
    b64os.close();
    return baos.toByteArray();
}
public static byte[] decode(byte[] b) throws Exception {
    ByteArrayInputStream bais = new ByteArrayInputStream(b);
    InputStream b64is = MimeUtility.decode(bais, "base64");
    byte[] tmp = new byte[b.length];
    int n = b64is.read(tmp);
    byte[] res = new byte[n];
    System.arraycopy(tmp, 0, res, 0, n);
    return res;
}

Enlace con el código completo: [Codificar/Decodificar a/desde Base64][1]

[1]: http://www.rgagnon.com/javadetails/java-0598.html

 RealHowTo
RealHowTo
Respuesta editada 19º junio 2018 в 9:37
11
0
KARASZI Istv&#225;n
KARASZI István
22º mayo 2012 в 2:56
2012-05-22T14:56:40+00:00
Más
Fuente
Editar
#8766013

Otra respuesta tardía, pero mi evaluación comparativa muestra que el codificador de [Jetty's implementation of Base64][1] es bastante rápido. No tan rápida como [MiGBase64][2] pero más rápida que [iHarder Base64][3].

import org.eclipse.jetty.util.B64Code;

final String decoded = B64Code.decode(encoded, "UTF-8");

También hice algunos puntos de referencia:

      library     |    encode    |    decode   
------------------+--------------+-------------
 'MiGBase64'      |  10146001.00 |  6426446.00
 'Jetty B64Code'  |   8846191.00 |  3101361.75
 'iHarder Base64' |   3259590.50 |  2505280.00
 'Commons-Codec'  |    241318.04 |   255179.96

Estas son carreras/segundos, así que más alto es mejor.

[1]: http://download.eclipse.org/jetty/stable-7/apidocs/org/eclipse/jetty/util/B64Code.html [2]: http://migbase64.sourceforge.net/ [3]: http://iharder.sourceforge.net/current/java/base64/

9
0
Vassilis Blazos
Vassilis Blazos
14º febrero 2015 в 10:14
2015-02-14T10:14:31+00:00
Más
Fuente
Editar
#8766017

Dado un ejemplo de test codificar/decodificar de [javax.xml.bind.DatatypeConverter][1] usando los métodos [parseBase64Binary()][2] y [printBase64Binary()][3] refiriéndose a @jeremy-ross y @nightfirecat answer.

[1]: http://download.oracle.com/javase/6/docs/api/javax/xml/bind/DatatypeConverter.html [2]: http://download.oracle.com/javase/6/docs/api/javax/xml/bind/DatatypeConverter.html#parseBase64Binary%28java.lang.String%29 [3]: http://download.oracle.com/javase/6/docs/api/javax/xml/bind/DatatypeConverter.html#printBase64Binary%28byte%5B%5D%29

@Test
public void EncodeDecode() {
    //ENCODE
    String hello = "Hello World";
    byte[] helloBytes = hello.getBytes(StandardCharsets.UTF_8);
    String encodedHello = DatatypeConverter.printBase64Binary(helloBytes);
    LOGGER.info(hello + " encoded=> " + encodedHello);

    //DECODE
    byte[] encodedHelloBytes = DatatypeConverter.parseBase64Binary(encodedHello);
    String helloAgain = new String(encodedHelloBytes, StandardCharsets.UTF_8) ;
    LOGGER.info(encodedHello + " decoded=> " + helloAgain);

    Assert.assertEquals(hello, helloAgain);
}

Resultado:

INFO - Hello World encoded=> SGVsbG8gV29ybGQ=
INFO - SGVsbG8gV29ybGQ= decoded=> Hello World
DatatypeConverter (Java Platform SE 6)
download.oracle.com
DatatypeConverter (Java Platform SE 6)
download.oracle.com
DatatypeConverter (Java Platform SE 6)
download.oracle.com
8
0
Usuario anónimo
20º febrero 2012 в 3:34
2012-02-20T15:34:39+00:00
Más
Fuente
Editar
#8766012

Si prefiere una solución basada en el rendimiento, puede usar "MiGBase64"

http://migbase64.sourceforge.net/

public class Base64Test {
    public static void main(String[] args) {
    String encodeToString = Base64.encodeToString("JavaTips.net".getBytes(), true);
    System.out.println("encodeToString " + encodeToString);
    byte[] decodedBytes = Base64.decode(encodeToString.getBytes());
    System.out.println("decodedBytes " + new String(decodedBytes));
    }
}
6
0
 diyism
diyism
5º diciembre 2011 в 4:25
2011-12-05T04:25:55+00:00
Más
Fuente
Editar
#8766011

Espero que esto te ayude:

import com.sun.org.apache.xml.internal.security.utils.Base64;
String str="Hello World";
String base64_str=Base64.encode(str.getBytes("UTF-8"));

O:

String str="Hello World";
String base64_str="";
try
   {base64_str=(String)Class.forName("java.util.prefs.Base64").getDeclaredMethod("byteArrayToBase64", new Class[]{byte[].class}).invoke(null, new Object[]{str.getBytes("UTF-8")});
   }
catch (Exception ee) {}

"Java.util.prefs.Base64" funciona en la "jarra de arte" local,

Pero no está en La Lista Blanca de la Clase JRE

y no en Clases disponibles no incluidas en la lista blanca de GAE/J

¡Qué lástima!

P.D. En androide, es fácil porque ese "androide.util.Base64" ha sido incluido desde el nivel 8 de la API de Android.

 soumya
soumya
Respuesta editada 28º julio 2016 в 9:49
3
0
Buhake Sindi
Buhake Sindi
26º septiembre 2011 в 5:35
2011-09-26T05:35:55+00:00
Más
Fuente
Editar
#8766010

Esta es una respuesta tardía, pero Joshua Bloch cometió su clase "Base64" (cuando trabajaba para Sun, ejem, Oracle) bajo el paquete "java.util.prefs". Esta clase existió desde JDK 1.4.

Por ejemplo

String currentString = "Hello World";
String base64String = java.util.prefs.Base64.byteArrayToBase64(currentString.getBytes("UTF-8"));
2
0
Tell  Me How
Tell Me How
30º noviembre 2015 в 9:24
2015-11-30T09:24:47+00:00
Más
Fuente
Editar
#8766018

Puedes escribir o descargar el archivo desde una cadena de código Base64:

Base64 base64 = new Base64(); 
String encodedFile="JVBERi0xLjUKJeLjz9MKMSAwIG9iago8PCAKICAgL1R5cGUgL0NhdGFsb2cKICAgL1BhZ2VzIDIgMCBSCiAgIC9QYWdlTGF5b3V0IC9TaW5"; 
              byte[] dd=encodedFile.getBytes();
            byte[] bytes = Base64.decodeBase64(dd);

 response.setHeader("Content-disposition", "attachment; filename=\""+filename+"\"");
            response.setHeader("Cache-Control", "no-cache");
            response.setHeader("Expires", "-1");

            // actually send result bytes
            response.getOutputStream().write(bytes);

Funcionó para mí y espero que para ti también...

2
0
 beyeriii
beyeriii
21º junio 2016 в 1:05
2016-06-21T01:05:05+00:00
Más
Fuente
Editar
#8766019

La implementación en Java 8 de "java.util.Base64" no tiene dependencias en otras clases específicas de Java 8.

No estoy seguro de si esto funcionará para el proyecto Java 6, pero es posible copiar y pegar el archivo Base64.java en un proyecto Java 7 y compilarlo sin más modificación que la importación de java.util.Arrays y java.util.Objects.

Nota: el archivo Base64.java está cubierto por la GPL2 de GNU

 hackjutsu
hackjutsu
Respuesta editada 6º junio 2017 в 11:03
2
0
 auselen
auselen
12º agosto 2016 в 12:07
2016-08-12T12:07:54+00:00
Más
Fuente
Editar
#8766020

Si ya está añadiendo [AWS SDK para Java][1], puede usar [com.amazonaws.util.Base64][2].

[1]: https://aws.amazon.com/sdk-for-java/ [2]: http://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/util/Base64.html

Base64 (AWS SDK for Java - 1.12.202)
docs.aws.amazon.com
AWS SDK for Java
Develop and deploy applications with the AWS SDK for Java. The SDK makes it easy to call AWS services using idiomatic Java APIs.
aws.amazon.com
2
0
Maxim Shoustin
Maxim Shoustin
23º agosto 2017 в 8:22
2017-08-23T08:22:52+00:00
Más
Fuente
Editar
#8766021

Usé "androide.util.base64" que funciona bastante bien sin ninguna dependencia:

Uso:

byte[] decodedKey = Base64.decode(encodedPublicKey, Base64.DEFAULT);

paquete com.test;

import java.io.UnsupportedEncodingException;

/**
 * Utilities for encoding and decoding the Base64 representation of
 * binary data.  See RFCs <a
 * href="http://www.ietf.org/rfc/rfc2045.txt">2045</a> and <a
 * href="http://www.ietf.org/rfc/rfc3548.txt">3548</a>.
 */
public class Base64 {

    public static final int DEFAULT = 0;

    public static final int NO_PADDING = 1;

    public static final int NO_WRAP = 2;

    public static final int CRLF = 4;

    public static final int URL_SAFE = 8;

    public static final int NO_CLOSE = 16;

    //  --------------------------------------------------------
    //  shared code
    //  --------------------------------------------------------

    /* package */ static abstract class Coder {
        public byte[] output;
        public int op;

        public abstract boolean process(byte[] input, int offset, int len, boolean finish);

        public abstract int maxOutputSize(int len);
    }

    //  --------------------------------------------------------
    //  decoding
    //  --------------------------------------------------------

    public static byte[] decode(String str, int flags) {
        return decode(str.getBytes(), flags);
    }

    public static byte[] decode(byte[] input, int flags) {
        return decode(input, 0, input.length, flags);
    }

    public static byte[] decode(byte[] input, int offset, int len, int flags) {
        // Allocate space for the most data the input could represent.
        // (It could contain less if it contains whitespace, etc.)
        Decoder decoder = new Decoder(flags, new byte[len*3/4]);

        if (!decoder.process(input, offset, len, true)) {
            throw new IllegalArgumentException("bad base-64");
        }

        // Maybe we got lucky and allocated exactly enough output space.
        if (decoder.op == decoder.output.length) {
            return decoder.output;
        }

        // Need to shorten the array, so allocate a new one of the
        // right size and copy.
        byte[] temp = new byte[decoder.op];
        System.arraycopy(decoder.output, 0, temp, 0, decoder.op);
        return temp;
    }

   static class Decoder extends Coder {       
        private static final int DECODE[] = {
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
            52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
            -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
            15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
            -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
            41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        };

        /**
         * Decode lookup table for the "web safe" variant (RFC 3548
         * sec. 4) where - and _ replace + and /.
         */
        private static final int DECODE_WEBSAFE[] = {
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,
            52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
            -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
            15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,
            -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
            41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        };

        /** Non-data values in the DECODE arrays. */
        private static final int SKIP = -1;
        private static final int EQUALS = -2;

        private int state;   // state number (0 to 6)
        private int value;

        final private int[] alphabet;

        public Decoder(int flags, byte[] output) {
            this.output = output;

            alphabet = ((flags & URL_SAFE) == 0) ? DECODE : DECODE_WEBSAFE;
            state = 0;
            value = 0;
        }

        public int maxOutputSize(int len) {
            return len * 3/4 + 10;
        }

        /**
         * Decode another block of input data.
         *
         * @return true if the state machine is still healthy.  false if
         *         bad base-64 data has been detected in the input stream.
         */
        public boolean process(byte[] input, int offset, int len, boolean finish) {
            if (this.state == 6) return false;

            int p = offset;
            len += offset;

            int state = this.state;
            int value = this.value;
            int op = 0;
            final byte[] output = this.output;
            final int[] alphabet = this.alphabet;

            while (p < len) {                
                if (state == 0) {
                    while (p+4 <= len &&
                           (value = ((alphabet[input[p] & 0xff] << 18) |
                                     (alphabet[input[p+1] & 0xff] << 12) |
                                     (alphabet[input[p+2] & 0xff] << 6) |
                                     (alphabet[input[p+3] & 0xff]))) >= 0) {
                        output[op+2] = (byte) value;
                        output[op+1] = (byte) (value >> 8);
                        output[op] = (byte) (value >> 16);
                        op += 3;
                        p += 4;
                    }
                    if (p >= len) break;
                }

                int d = alphabet[input[p++] & 0xff];

                switch (state) {
                case 0:
                    if (d >= 0) {
                        value = d;
                        ++state;
                    } else if (d != SKIP) {
                        this.state = 6;
                        return false;
                    }
                    break;

                case 1:
                    if (d >= 0) {
                        value = (value << 6) | d;
                        ++state;
                    } else if (d != SKIP) {
                        this.state = 6;
                        return false;
                    }
                    break;

                case 2:
                    if (d >= 0) {
                        value = (value << 6) | d;
                        ++state;
                    } else if (d == EQUALS) {
                        // Emit the last (partial) output tuple;
                        // expect exactly one more padding character.
                        output[op++] = (byte) (value >> 4);
                        state = 4;
                    } else if (d != SKIP) {
                        this.state = 6;
                        return false;
                    }
                    break;

                case 3:
                    if (d >= 0) {
                        // Emit the output triple and return to state 0.
                        value = (value << 6) | d;
                        output[op+2] = (byte) value;
                        output[op+1] = (byte) (value >> 8);
                        output[op] = (byte) (value >> 16);
                        op += 3;
                        state = 0;
                    } else if (d == EQUALS) {
                        // Emit the last (partial) output tuple;
                        // expect no further data or padding characters.
                        output[op+1] = (byte) (value >> 2);
                        output[op] = (byte) (value >> 10);
                        op += 2;
                        state = 5;
                    } else if (d != SKIP) {
                        this.state = 6;
                        return false;
                    }
                    break;

                case 4:
                    if (d == EQUALS) {
                        ++state;
                    } else if (d != SKIP) {
                        this.state = 6;
                        return false;
                    }
                    break;

                case 5:
                    if (d != SKIP) {
                        this.state = 6;
                        return false;
                    }
                    break;
                }
            }

            if (!finish) {
                // We're out of input, but a future call could provide
                // more.
                this.state = state;
                this.value = value;
                this.op = op;
                return true;
            }

            switch (state) {
            case 0:
                break;
            case 1:
                this.state = 6;
                return false;
            case 2:
                output[op++] = (byte) (value >> 4);
                break;
            case 3:
               output[op++] = (byte) (value >> 10);
                output[op++] = (byte) (value >> 2);
                break;
            case 4:
                this.state = 6;
                return false;
            case 5:
                break;
            }

            this.state = state;
            this.op = op;
            return true;
        }
    }

    //  --------------------------------------------------------
    //  encoding
    //  --------------------------------------------------------    
    public static String encodeToString(byte[] input, int flags) {
        try {
            return new String(encode(input, flags), "US-ASCII");
        } catch (UnsupportedEncodingException e) {
            // US-ASCII is guaranteed to be available.
            throw new AssertionError(e);
        }
    }

    public static String encodeToString(byte[] input, int offset, int len, int flags) {
        try {
            return new String(encode(input, offset, len, flags), "US-ASCII");
        } catch (UnsupportedEncodingException e) {
            // US-ASCII is guaranteed to be available.
            throw new AssertionError(e);
        }
    }

    public static byte[] encode(byte[] input, int flags) {
        return encode(input, 0, input.length, flags);
    }

    public static byte[] encode(byte[] input, int offset, int len, int flags) {
        Encoder encoder = new Encoder(flags, null);

        // Compute the exact length of the array we will produce.
        int output_len = len / 3 * 4;

        // Account for the tail of the data and the padding bytes, if any.
        if (encoder.do_padding) {
            if (len % 3 > 0) {
                output_len += 4;
            }
        } else {
            switch (len % 3) {
                case 0: break;
                case 1: output_len += 2; break;
                case 2: output_len += 3; break;
            }
        }

        // Account for the newlines, if any.
        if (encoder.do_newline && len > 0) {
            output_len += (((len-1) / (3 * Encoder.LINE_GROUPS)) + 1) *
                (encoder.do_cr ? 2 : 1);
        }

        encoder.output = new byte[output_len];
        encoder.process(input, offset, len, true);

        assert encoder.op == output_len;

        return encoder.output;
    }

    /* package */ static class Encoder extends Coder {
        /**
         * Emit a new line every this many output tuples.  Corresponds to
         * a 76-character line length (the maximum allowable according to
         * <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>).
         */
        public static final int LINE_GROUPS = 19;

        /**
         * Lookup table for turning Base64 alphabet positions (6 bits)
         * into output bytes.
         */
        private static final byte ENCODE[] = {
            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
            'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
            'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
            'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/',
        };

        /**
         * Lookup table for turning Base64 alphabet positions (6 bits)
         * into output bytes.
         */
        private static final byte ENCODE_WEBSAFE[] = {
            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
            'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
            'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
            'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_',
        };

        final private byte[] tail;
        /* package */ int tailLen;
        private int count;

        final public boolean do_padding;
        final public boolean do_newline;
        final public boolean do_cr;
        final private byte[] alphabet;

        public Encoder(int flags, byte[] output) {
            this.output = output;

            do_padding = (flags & NO_PADDING) == 0;
            do_newline = (flags & NO_WRAP) == 0;
            do_cr = (flags & CRLF) != 0;
            alphabet = ((flags & URL_SAFE) == 0) ? ENCODE : ENCODE_WEBSAFE;

            tail = new byte[2];
            tailLen = 0;

            count = do_newline ? LINE_GROUPS : -1;
        }

        /**
         * @return an overestimate for the number of bytes {@code
         * len} bytes could encode to.
         */
        public int maxOutputSize(int len) {
            return len * 8/5 + 10;
        }

        public boolean process(byte[] input, int offset, int len, boolean finish) {
            // Using local variables makes the encoder about 9% faster.
            final byte[] alphabet = this.alphabet;
            final byte[] output = this.output;
            int op = 0;
            int count = this.count;

            int p = offset;
            len += offset;
            int v = -1;

            // First we need to concatenate the tail of the previous call
            // with any input bytes available now and see if we can empty
            // the tail.

            switch (tailLen) {
                case 0:
                    // There was no tail.
                    break;

                case 1:
                    if (p+2 <= len) {
                        // A 1-byte tail with at least 2 bytes of
                        // input available now.
                        v = ((tail[0] & 0xff) << 16) |
                            ((input[p++] & 0xff) << 8) |
                            (input[p++] & 0xff);
                        tailLen = 0;
                    };
                    break;

                case 2:
                    if (p+1 <= len) {
                        // A 2-byte tail with at least 1 byte of input.
                        v = ((tail[0] & 0xff) << 16) |
                            ((tail[1] & 0xff) << 8) |
                            (input[p++] & 0xff);
                        tailLen = 0;
                    }
                    break;
            }

            if (v != -1) {
                output[op++] = alphabet[(v >> 18) & 0x3f];
                output[op++] = alphabet[(v >> 12) & 0x3f];
                output[op++] = alphabet[(v >> 6) & 0x3f];
                output[op++] = alphabet[v & 0x3f];
                if (--count == 0) {
                    if (do_cr) output[op++] = '\r';
                    output[op++] = '\n';
                    count = LINE_GROUPS;
                }
            }

            // At this point either there is no tail, or there are fewer
            // than 3 bytes of input available.

            // The main loop, turning 3 input bytes into 4 output bytes on
            // each iteration.
            while (p+3 <= len) {
                v = ((input[p] & 0xff) << 16) |
                    ((input[p+1] & 0xff) << 8) |
                    (input[p+2] & 0xff);
                output[op] = alphabet[(v >> 18) & 0x3f];
                output[op+1] = alphabet[(v >> 12) & 0x3f];
                output[op+2] = alphabet[(v >> 6) & 0x3f];
                output[op+3] = alphabet[v & 0x3f];
                p += 3;
                op += 4;
                if (--count == 0) {
                    if (do_cr) output[op++] = '\r';
                    output[op++] = '\n';
                    count = LINE_GROUPS;
                }
            }

            if (finish) {

                if (p-tailLen == len-1) {
                    int t = 0;
                    v = ((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 4;
                    tailLen -= t;
                    output[op++] = alphabet[(v >> 6) & 0x3f];
                    output[op++] = alphabet[v & 0x3f];
                    if (do_padding) {
                        output[op++] = '=';
                        output[op++] = '=';
                    }
                    if (do_newline) {
                        if (do_cr) output[op++] = '\r';
                        output[op++] = '\n';
                    }
                } else if (p-tailLen == len-2) {
                    int t = 0;
                    v = (((tailLen > 1 ? tail[t++] : input[p++]) & 0xff) << 10) |
                        (((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 2);
                    tailLen -= t;
                    output[op++] = alphabet[(v >> 12) & 0x3f];
                    output[op++] = alphabet[(v >> 6) & 0x3f];
                    output[op++] = alphabet[v & 0x3f];
                    if (do_padding) {
                        output[op++] = '=';
                    }
                    if (do_newline) {
                        if (do_cr) output[op++] = '\r';
                        output[op++] = '\n';
                    }
                } else if (do_newline && op > 0 && count != LINE_GROUPS) {
                    if (do_cr) output[op++] = '\r';
                    output[op++] = '\n';
                }

                assert tailLen == 0;
                assert p == len;
            } else {
                // Save the leftovers in tail to be consumed on the next
                // call to encodeInternal.

                if (p == len-1) {
                    tail[tailLen++] = input[p];
                } else if (p == len-2) {
                    tail[tailLen++] = input[p];
                    tail[tailLen++] = input[p+1];
                }
            }

            this.op = op;
            this.count = count;

            return true;
        }
    }

    private Base64() { }   // don't instantiate
}
2
0
Ninad Pingale
Ninad Pingale
10º junio 2019 в 2:54
2019-06-10T14:54:46+00:00
Más
Fuente
Editar
#8766023

Usando Java 8 -

    public static String encodeString(String plainString) {
        return  Base64.getEncoder().encodeToString(plainString.getBytes());
    }

    public static String decodeString(String encodedString) {
        byte[] bytes = Base64.getDecoder().decode(encodedString);
        return new String(bytes);
    }
1
0
Petr Kozelka
Petr Kozelka
20º octubre 2018 в 4:11
2018-10-20T04:11:17+00:00
Más
Fuente
Editar
#8766022

En un código compilado con Java 7 pero potencialmente ejecutado en una versión superior de Java, parece útil detectar la presencia de la clase "Java.util.Base64" y usar el enfoque más adecuado para la JVM mencionada en otras preguntas aquí.

Yo usé este código:

private static final Method JAVA_UTIL_BASE64_GETENCODER;

static {
    Method getEncoderMethod;
    try {
        final Class<?> base64Class = Class.forName("java.util.Base64");
        getEncoderMethod = base64Class.getMethod("getEncoder");
    } catch (ClassNotFoundException | NoSuchMethodException e) {
        getEncoderMethod = null;
    }
    JAVA_UTIL_BASE64_GETENCODER = getEncoderMethod;
}

static String base64EncodeToString(String s) {
    final byte[] bytes = s.getBytes(StandardCharsets.ISO_8859_1);
    if (JAVA_UTIL_BASE64_GETENCODER == null) {
        // Java 7 and older // TODO: remove this branch after switching to Java 8
        return DatatypeConverter.printBase64Binary(bytes);
    } else {
        // Java 8 and newer
        try {
            final Object encoder = JAVA_UTIL_BASE64_GETENCODER.invoke(null);
            final Class<?> encoderClass = encoder.getClass();
            final Method encodeMethod = encoderClass.getMethod("encode", byte[].class);
            final byte[] encodedBytes = (byte[]) encodeMethod.invoke(encoder, bytes);
            return new String(encodedBytes);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            throw new IllegalStateException(e);
        }
    }
}
0
0
 Dushan
Dushan
18º octubre 2019 в 10:58
2019-10-18T10:58:14+00:00
Más
Fuente
Editar
#8766024

Puedes simplemente probar esto.

byte[] data = Base64.getDecoder().decode(base64fileContent);

"Base64.getDecode()" devuelve un Decodificador Base64 que puede ser decodificado. Entonces necesitas decodificarlo de nuevo usando ".decode(<tu base64;)"

0
0
Comunidades relacionadas 3
Spring Boot & Java ES
Spring Boot & Java ES
703 usuarios
Gracias por unirte! al grupo 🔥 _Spring Boot & Java ES_🔥 comunidad LATAM, donde podrás consultar dudas, compartir material y proyectos sobre esta tecnología. Invita a tus amigos ... 👇👇👇 https://t.me/SpringBootFtJAVA
Abrir telegram
JAVA SE ESPAÑA
JAVA SE ESPAÑA
50 usuarios
JAVA SE Español
Abrir telegram
Java | Spring Boot Español
Java | Spring Boot Español
22 usuarios
Abrir telegram
Añadir pregunta
Categorías
Todo
Tecnología
Cultura / Recreación
Vida / Artes
Ciencia
Profesional
Negocios
Usuarios
Todo
Nuevo
Popular
1
365
Registrado hace 1 día
2
True Image
Registrado hace 1 día
3
archana agarwal
Registrado hace 3 días
4
Maxim Zhilyaev
Registrado hace 6 días
5
adambotsfford adambotsfford
Registrado hace 1 semana
DE
EL
ES
FR
ID
IT
JA
LV
NL
PT
RO
RU
ZH
© de-vraag 2022
Fuente
stackoverflow.com
bajo licencia cc by-sa 3.0 con atribución