jupyter/chapter10-string_formatting.ipynb

{
  "cells": [{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["# String formatting\n", "There are several ways to concatenate/format objects to strings in Java,\n", "mostly depending if there are a fixed number of values or\n", "if the values are in a list or any other data structures.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Let say we have some friends\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Friend(String name) {}\n", "var bob = new Friend(\"bob\");\n", "var ana = new Friend(\"ana\");\n", "var jul = new Friend(\"jul\");\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## With a fixed number of values\n", "If there is a fixed number of value, the concatenation using '+' is the\n", "most readable (ok, when your are used to) and the fastest \n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Concatenation with +\n", "Just do a '+' between the different values,\n", "this code is heavily optimized and will allocate only one String\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["System.out.println(bob.name() + \", \" + ana.name() + \", \" + jul.name());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Concatenation with String.format()\n", "If you want more control on the formatting, you can use `String.format`\n", "that reuse the C formatting style\n", "But the method `format()` is quite slow.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["System.out.println(String.format(\"%s, %s, %s\", bob, ana, jul));\n", "System.out.printf(\"%s, %s, %s\\n\", bob, ana, jul);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## with a variable number of values\n", "If there is a variable numbers of values, you have two cases,\n", "depending if it's a collection of String or not\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var strings = List.of(\"bob\", \"ana\", \"jul\");\n", "var friends = List.of(bob, ana, jul);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Concatenation with a +\n", "Never use '+' in this case, because the compiler is not smart enough\n", "to reuse the same buffer of characters for the whole loop, so it will\n", "create a new String for each loop trip.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["String concatenate(List<?> list) {\n", "  var string = \"\";\n", "  var separator = \"\";\n", "  for(var item: list) {\n", "    string = string + separator + item;  // creates two many strings, ahhhh\n", "    separator = \", \";\n", "  } \n", "  return string;\n", "}\n", "System.out.println(concatenate(strings));\n", "System.out.println(concatenate(friends));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Concatenation with a StringBuilder\n", "A StringBuilder is a modifiable version of String with an expandable buffer\n", "of characters. There is no notion of separators\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["String concatenate(List<?> list) {\n", "  var builder = new StringBuilder();\n", "  var separator = \"\";\n", "  for(var item: list) {\n", "    builder.append(separator).append(item);\n", "    separator = \", \";\n", "  } \n", "  return builder.toString();\n", "}\n", "System.out.println(concatenate(strings));\n", "System.out.println(concatenate(friends));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["> Don't use '+' inside a call to  `append()`, you already have a StringBuilder,\n", "so use append() instead\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Concatenation with String.join()\n", "If you have an array of strings or a collection of strings, `String.join`\n", "is the simplest way to concatenate the items with a separator\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["System.out.println(String.join(\", \", strings));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Concatenation with a StringJoiner\n", "If you don't have a list of strings by a list of objects, you can use the\n", "`StringJoiner` which let you specify a separator and is implemented\n", "using expandable buffer of strings (`StringJoiner.add` only accepts strings).\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["String concatenate(List<?> list) {\n", "  var joiner = new StringJoiner(\", \");\n", "  list.forEach(item -> joiner.add(item.toString()));\n", "  return joiner.toString();\n", "}\n", "System.out.println(concatenate(strings));\n", "System.out.println(concatenate(friends));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Concatenation with a Stream\n", "If you use a `Stream` and the collector `joining`, it will use a `StringJoiner` internally.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["import java.util.stream.Collectors;\n", "System.out.println(strings.stream().collect(Collectors.joining(\", \")));\n", "System.out.println(friends.stream().map(Friend::toString).collect(Collectors.joining(\", \")));\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
}