jupyter/chapter21-wrapper.ipynb

{
  "cells": [{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["# Wrapper types\n", "Primitive types are not objects, but all data structures in Java (list, map, etc)\n", "are storing objects, so we need a mechanism to see all primitive values as objects.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["For that, the Java API defines the for each primitive type, a wrapper class,\n", "in the package java.lang which is a class with one field\n", "and the compiler as a mechanism named auto-boxing/auto-unboxing to convert\n", "from a primitive type to the corresponding wrapper and vice-versa.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["By example, to be able to type the list, we need an object type corresponding\n", "to the primitive type int\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["List<Integer> list = List.of(1, 2, 3);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Auto-boxing\n", "You can do the conversion explicitly calling the static method `valueOf` on the wrapper type\n", "or implicitly if the target type is Object\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### boolean -> java.lang.Boolean\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Object booleanBox = Boolean.valueOf(true);\n", "Object booleanBox = true;\n", "System.out.println(booleanBox);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### char -> java.lang.Character\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Object charBox = Character.valueOf('A');\n", "Object charBox = 'A';\n", "System.out.println(charBox);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### byte -> java.lang.Byte\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Object byteBox = Byte.valueOf((byte) 12);\n", "Object byteBox = (byte) 12;\n", "System.out.println(byteBox);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### short -> java.lang.Short\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Object shortBox = Short.valueOf((short) 712);\n", "Object shortBox = (short) 712;\n", "System.out.println(shortBox);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### int -> java.lang.Integer\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Object intBox = Integer.valueOf(100_000);\n", "Object intBox = 100_000;\n", "System.out.println(intBox);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### long -> java.lang.Long\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Object longBox = Long.valueOf(10_000_000_000L);\n", "Object longBox = 10_000_000_000L;\n", "System.out.println(longBox);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### float -> java.lang.Float\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Object floatBox = Float.valueOf(1.2f);\n", "Object floatBox = 1.2f;\n", "System.out.println(floatBox);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### double -> java.lang.Double\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Object doubleBox = Double.valueOf(42.0);\n", "Object doubleBox = 42.0;\n", "System.out.println(doubleBox);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## DON'T USE == on a wrapper, use equals()\n", "Because the wrapper are objects, the == will test the reference, not the value.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["In fact, it's worst than that, the methods `valueOf()` can use a cache,\n", "so depending on the weather (the startup parameters of the VM),\n", "`valueOf` may return the same object for the same value or not\n", "so you can not predict if == will returns true of false for a wrapper.\n", "__Never use == on a wrapper, use equals() __\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Object intBox1 = 8192;\n", "Object intBox2 = 8192;\n", "System.out.println(intBox1 == intBox2); // may return true or false ??\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Floating points\n", "equals() on Float and Double works correctly with NaN,\n", "unlike the primitive types float and double.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["double d = Double.NaN;\n", "System.out.println(d == d);\n", "Double d = Double.NaN;\n", "System.out.println(d.equals(d));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Auto-unboxing\n", "\n", "so reusing the variable `*box` defined above, we can write\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### java.lang.Boolean -> boolean\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["boolean z = ((Boolean) booleanBox).booleanValue();\n", "boolean z = (boolean) booleanBox;\n", "System.out.println(z);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### java.lang.Character -> char\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["char c = ((Character) charBox).charValue();\n", "char c = (char) charBox; \n", "System.out.println(c);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### java.lang.Byte -> byte\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["byte b = ((Byte) byteBox).byteValue();\n", "byte b = (byte) byteBox;\n", "System.out.println(b);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### java.lang.Short -> short\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["short s = ((Short) shortBox).shortValue();\n", "short s = (short) shortBox;\n", "System.out.println(s);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### java.lang.Integer -> int\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["int i = ((Integer) intBox).intValue();\n", "int i = (int) intBox;\n", "System.out.println(i);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### java.lang.Long -> long\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["long l = ((Long) longBox).longValue();\n", "long l = (long) longBox;\n", "System.out.println(l);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["###  java.lang.Float -> float\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["float f = ((Float) floatBox).floatValue();\n", "float f = (float) floatBox;\n", "System.out.println(f);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### java.lang.Double -> double\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["double d = ((Double) doubleBox).doubleValue();\n", "double d = (double) doubleBox; \n", "System.out.println(d);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Beware of null\n", "Trying to unbox null throws a NullPointerException\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Integer box = null;\n", "int i = (int) box;\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Where not to use a wrapper type\n", "Wrapper types should only appears in between '<' and '>'\n", "because the generics of Java doesn't support primitive type inside the '<' and '>'.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["So please don't use them as type of a field or a method parameter\n", "unless you have a very good reason.\n"]
}
],
  "metadata": {
    "kernelspec": {
      "display_name": "Java",
      "language": "java",
      "name": "java"
    },
    "language_info": {
      "codemirror_mode": "java",
      "file_extension": ".java",
      "mimetype": "text/x-java-source",
      "name": "Java",
      "pygments_lexer": "java",
      "version": "15"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}