Data conversies (Dutch)

Snelmenu Converteren van datatype naar String Converteren van String naar datatype Converteren van datatype naar wrapper object Converteren van wrapper object naar datatype Converteren tussen datatypen Converteren tussen nummerieke systemen Converteren tussen data streams

Converteren van datatype naar String

Dat kun je doen met de toString() methode van de wrapper object van de datatype: Boolean, Character, Byte, Short, Integer, Long, Float en Double.

public class Converters {

    // Converteer boolean naar String.
    public static String booleanToString(boolean b) {
        return Boolean.toString(b);
    }

    // Converteer byte naar String.
    public static String byteToString(byte b) {
        return Byte.toString(b);
    }

    // Converteer short naar String.
    public static String shortToString(short s) {
        return Short.toString(s);
    }

    // Converteer int naar String.
    public static String intToString(int i) {
        return Integer.toString(i);
    }

    // Converteer long naar String.
    public static String longToString(long l) {
        return Long.toString(l);
    }

    // Converteer float naar String.
    public static String floatToString(float f) {
        return Float.toString(f);
    }

    // Converteer double naar String.
    public static String doubleToString(double d) {
        return Double.toString(d);
    }

    // Converteer char naar String.
    public static String charToString(char c) {
        return Character.toString(c);
    }

}

Zo kan het overigens ook, met de valueOf() methode van de String klasse:

public class Converters {

    // Converteer boolean naar String.
    public static String booleanToString(boolean b) {
        return String.valueOf(b);
    }

    // Converteer byte naar String.
    public static String byteToString(byte b) {
        return String.valueOf(b);
    }

    // Converteer short naar String.
    public static String shortToString(short s) {
        return String.valueOf(s);
    }

    // Converteer int naar String.
    public static String intToString(int i) {
        return String.valueOf(i);
    }

    // Converteer long naar String.
    public static String longToString(long l) {
        return String.valueOf(l);
    }

    // Converteer float naar String.
    public static String floatToString(float f) {
        return String.valueOf(f);
    }

    // Converteer double naar String.
    public static String doubleToString(double d) {
        return String.valueOf(d);
    }

    // Converteer char naar String.
    public static String charToString(char c) {
        return String.valueOf(c);
    }

}

Terug naar boven

Converteren van String naar datatype

Dit kun je bij de booleanse datatype en bij de nummerieke datatypen doen met de parse...() methode van de wrapper object. Dit vraagt bij de nummerieke datatypen iets meer werk: je moet een NumberFormatException kunnen afvangen en daarbij bijvoorbeeld een standaard waarde of een foutmelding retourneren. Deze exceptie wordt namelijk afgeworpen wanneer de inhoud van de string niet nummeriek is.

public class Converters {

    // Converteer String naar boolean.
    public static boolean stringToBoolean(String s) {
        return Boolean.parseBoolean(s);

        // Let op, dit werkt alleen vanaf Java 5.0.
        // Anders moet je het als volgt doen:
        // return new Boolean(s).booleanValue();
    }

    // Converteer String naar byte.
    public static byte stringToByte(String s) {
        try {
            return Byte.parseByte(s);
        } catch (NumberFormatException e) {
            return (byte) 0;
        }
    }

    // Converteer String naar short.
    public static short stringToShort(String s) {
        try {
            return Short.parseShort(s);
        } catch (NumberFormatException e) {
            return (short) 0;
        }
    }

    // Converteer String naar int.
    public static int stringToInt(String s) {
        try {
            return Integer.parseInt(s);
        } catch (NumberFormatException e) {
            return 0;

            // Een downcast naar int is niet nodig, want de int
            // is immers de standaard nummerieke datatype.
        }
    }

    // Converteer String naar long.
    public static long stringToLong(String s) {
        try {
            return Long.parseLong(s);
        } catch (NumberFormatException e) {
            return (long) 0;
        }
    }

    // Converteer String naar float.
    public static float stringToFloat(String s) {
        try {
            return Float.parseFloat(s);
        } catch (NumberFormatException e) {
            return (float) 0;
        }
    }

    // Converteer String naar double.
    public static double stringToDouble(String s) {
        try {
            return Double.parseDouble(s);
        } catch (NumberFormatException e) {
            return (double) 0;
        }
    }

    // Converteer String naar char.
    // Dit retourneert inderdaad alleen de eerste karakter.
    // Een char datatype mag toch maar 1 karakter bevatten.
    public static char stringToChar(String s) {
        if (s.length() > 0) {
            return s.charAt(0);
        }

        return (char) 0;
    }

    // Converteer String naar char, met index.
    // Dit retourneert de char op de gegeven locatie (index).
    public static char stringToChar(String s, int i) {
        if (s.length() > i) {
            return s.charAt(i);
        }

        return (char) 0;
    }

}

Uiteraard kun je de afhandeling van NumberFormatException naar smaak aanpassen.

Terug naar boven

Converteren van datatype naar wrapper object

Dat kun je doen door een nieuwe instantie van het wrapper object te maken, waarbij je de waarde van de datatype in de constructeur meegeeft.

public class Converters {

    // Converteer boolean naar Boolean.
    public static Boolean booleanToWrapper(boolean b) {
        return new Boolean(b);
    }

    // Converteer byte naar Byte.
    public static Byte byteToWrapper(byte b) {
        return new Byte(b);
    }

    // Converteer short naar Short.
    public static Short shortToWrapper(short s) {
        return new Short(s);
    }

    // Converteer int naar Integer.
    public static Integer intToWrapper(int i) {
        return new Integer(i);
    }

    // Converteer long naar Long.
    public static Long longToWrapper(long l) {
        return new Long(l);
    }

    // Converteer float naar Float.
    public static Float floatToWrapper(float f) {
        return new Float(f);
    }

    // Converteer double naar Double.
    public static Double doubleToWrapper(double d) {
        return new Double(d);
    }

    // Converteer char naar Character.
    public static Character charToWrapper(char c) {
        return new Character(c);
    }

}

Terug naar boven

Converteren van wrapper object naar datatype

Dat kun je doen met de ...Value() methode van de wrapper object.

public class Converters {

    // Converteer Boolean naar boolean.
    public static boolean wrapperToBoolean(Boolean b) {
        return b.booleanValue();
    }

    // Converteer Byte naar byte.
    public static byte wrapperToByte(Byte b) {
        return b.byteValue();
    }

    // Converteer Short naar short.
    public static short wrapperToShort(Short s) {
        return s.shortValue();
    }

    // Converteer Integer naar int.
    public static int wrapperToInt(Integer i) {
        return i.intValue();
    }

    // Converteer Long naar long.
    public static long wrapperToLong(Long l) {
        return l.longValue();
    }

    // Converteer Float naar float.
    public static float wrapperToFloat(Float f) {
        return f.floatValue();
    }

    // Converteer Double naar double.
    public static double wrapperToDouble(Double d) {
        return d.doubleValue();
    }

    // Converteer Character naar char.
    public static char wrapperToChar(Character c) {
        return c.charValue();
    }

}

Terug naar boven

Converteren tussen datatypen

Bij alle nummerieke datatypen kun je hiervoor de cast operator gebruiken. Zie ook Java tutorial - Datatypen - Integers. Hieronder worden niet alle mogelijkheden opgesomd, maar alleen de basisvoorbeelden op basis van de int datatype. Wat betreft de conversies tussen char en de Unicode code, de Unicode code staat uitgelegd in Java tutorial - Datatypen - Karakter.

public class Converters {

    // Converteer boolean naar int.
    // true wordt geretourneerd als 1.
    // false wordt geretourneerd als 0.
    public static int booleanToInt(boolean b) {
        return b ? 1 : 0;
    }

    // Converteer int naar boolean.
    // Alleen 0 wordt geretourneerd als false,
    // de rest wordt geretourneerd als true.
    public static boolean intToBoolean0(int i) {
        return i != 0;
    }

    // Converteer int naar boolean op de omgekeerde manier.
    // Alleen 1 wordt geretourneerd als true,
    // de rest wordt geretourneerd als false.
    public static boolean intToBoolean1(int i) {
        return i == 1;
    }

    // Converteer int naar byte.
    public static byte intToByte(int i) {
        return (byte) i;
    }

    // Converteer byte naar int.
    public static int byteToInt(byte b) {
        return b;
    }

    // Converteer int naar short.
    public static short intToShort(int i) {
        return (short) i;
    }

    // Converteer short naar int.
    public static int shortToInt(short s) {
        return s;
    }

    // Converteer int naar long.
    public static long intToLong(int i) {
        return (long) i;
    }

    // Converteer long naar int.
    public static int longToInt(long l) {
        return (int) l;
    }

    // Converteer int naar float.
    public static float intToFloat(int i) {
        return (float) i;
    }

    // Converteer float naar int.
    // Let op: er wordt naar beneden afgerond.
    public static int floatToInt(float f) {
        return (int) f;
    }

    // Converteer float naar afgeronde int.
    // Lager dan .5 wordt naar beneden afgerond.
    // .5 en hoger wordt naar boven afgerond.
    public static int floatToRoundInt(float f) {
        return Math.round(f);
    }

    // Converteer int naar double.
    public static double intToDouble(int i) {
        return (double) i;
    }

    // Converteer double naar int.
    // Let op: er wordt naar beneden afgerond.
    public static int doubleToInt(double d) {
        return (int) d;
    }

    // Converteer double naar afgeronde int.
    // Lager dan .5 wordt naar beneden afgerond.
    // .5 en hoger wordt naar boven afgerond.
    public static int doubleToRoundInt(double d) {
        return Math.round(d);
    }

    // Converteer char naar Unicode code.
    public static String charToUnicode(char c) {
        return Integer.toHexString(c);
    }

    // Converteer Unicode code naar char.
    public static char unicodeToChar(String s) {
        try {
            return (char) Integer.parseInt(s, 16);
        } catch (NumberFormatException e) {
            return (char) 0;
        }
    }

}

Terug naar boven

Converteren tussen nummerieke systemen

De datatype wrapper objecten Integer en Long kennen ook een tal functies om te converteren tussen de verschillende nummerieke systemen, te weten binair (binary, base 2), octaal (octal, base 8), decimaal (decimal, base 10) en hexadecimaal (hexadecimal, base 16). Hieronder staan voorbeelden op basis van de Integer. De Long werkt op dezelfde manier.

public class Converters {

    // Converteer decimaal naar binair.
    public static String decimalToBinary(int i) {
        return Integer.toBinaryString(i);
    }

    // Converteer decimaal naar octaal.
    public static String decimalToOctal(int i) {
        return Integer.toOctalString(i);
    }

    // Converteer decimaal naar hexadecimaal.
    public static String decimalToHexadecimal(int i) {
        return Integer.toHexString(i);
    }

    // Converteer binair naar decimaal.
    public static int binaryToDecimal(String s) {
        return Integer.parseInt(s, 2);
    }

    // Converteer octaal naar decimaal.
    public static int octalToDecimal(String s) {
        return Integer.parseInt(s, 8);
    }

    // Converteer hexadecimaal naar decimaal.
    public static int hexadecimalToDecimal(String s) {
        return Integer.parseInt(s, 16);
    }

}

Terug naar boven

Converteren tussen data streams

Met de data streams worden dus o.a. de byte[] en de char[] array's bedoeld. Deze worden in regel gebruikt bij bestandsbewerkingen. In sommige gevallen kun je ook de Charset opgeven. Als je deze niet opgeeft, dan wordt er uitgegaan van de standaard charset van de Java Virtual Machine, vaak is dit UTF-8.

import java.io.UnsupportedEncodingException;

public class Converters {

    // Converteer byte array naar String.
    public static String byteArrayToString(byte[] b) {
        return new String(b);

        // Zo kan het ook: return b.toString();
    }

    // Converteer encoded byte array naar String.
    public static String byteArrayToString(byte[] b, String charset) {
        try {
            return new String(b, charset);
        } catch (UnsupportedEncodingException e) {
            return null;
        }
    }

    // Converteer char array naar String.
    public static String charArrayToString(char[] c) {
        return new String(c);

        // Zo kan het ook: return c.toString();
    }

    // Converteer String naar byte array.
    public static byte[] stringToByteArray(String s) {
        return s.getBytes();
    }

    // Converteer String naar encoded byte array.
    public static byte[] stringToByteArray(String s, String charset) {
        try {
            return s.getBytes(charset);
        } catch (UnsupportedEncodingException e) {
            return null;
        }
    }

    // Converteer String naar char array.
    public static char[] stringToCharArray(String s) {
        return s.toCharArray();
    }

    // Converteer byte array naar char array.
    public static char[] byteArrayToCharArray(byte[] b) {
        return new String(b).toCharArray();

        // Zo kan het ook: return b.toString().toCharArray();
    }

    // Converteer encoded byte array naar char array.
    public static char[] byteArrayToCharArray(byte[] b, String charset) {
        try {
            return new String(b, charset).toCharArray();
        } catch (UnsupportedEncodingException e) {
            return null;
        }
    }

    // Converteer char array naar byte array.
    public static byte[] charArrayToByteArray(char[] c) {
        return new String(c).getBytes();

        // Zo kan het ook: return c.toString().getBytes();
    }

    // Converteer char array naar encoded byte array.
    public static byte[] charArrayToByteArray(char[] c, String charset) {
        try {
            return new String(c).getBytes(charset);

            // Zo kan het ook: return c.toString().getBytes(charset);
        } catch (UnsupportedEncodingException e) {
            return null;
        }
    }

}

Uiteraard kun je de afhandeling van UnsupportedEncodingException naar smaak aanpassen. Verder zijn er klassen beschikbaar om tijdens I/O bewekingen tussen byte[] en char[] te kunnen converteren. Het is netter om daarvan gebruik te maken, zie dus ook het onderdeel Bestandsbewerkingen.

Terug naar boven

Copyright - Er is geen copyright op de code. Je kunt het naar believen overnemen, aanpassen danwel verspreiden.

(C) Juni 2006, BalusC