{"title":"String Basics","description":"","content":"A `String` in Java is how we hold text: a product name, a customer email, an order status, a city in a shipping address. Almost every program touches strings somewhere, and Java has more rules around them than around any other built-in type. This lesson covers what a `String` actually is, the two ways to create one, the core methods you'll use every day, and the small pitfalls that catch beginners.\n\n---\n\n# What a `String` Is\n\nA `String` is an object of type `java.lang.String`. Unlike `int` or `double`, it is not a primitive. The variable on your side holds a reference, and the actual character data lives on the heap inside the `String` object.\n\n\n```java\npublic class WhatIsAString {\n public static void main(String[] args) {\n String productName = \"Wireless Mouse\";\n System.out.println(\"Product: \" + productName);\n System.out.println(\"Type: \" + productName.getClass().getName());\n }\n}\n```\n\n\n`getClass().getName()` returns the fully qualified class name. Every string you write, even a short literal like `\"Wireless Mouse\"`, is an instance of `java.lang.String`. The `String` class is so common that Java imports it automatically. You never have to write `import java.lang.String;` at the top of your file.\n\nInternally, a `String` is a sequence of characters. Java uses UTF-16, which means each character position represents a 16-bit code unit. Most everyday characters (English letters, digits, common punctuation) fit in a single code unit. A few characters, like some emojis or rare scripts, take two code units. A `String` is an ordered list of characters with the first character at position `0`.\n\nSince Java 9, the JVM stores the character data as a `byte[]` rather than a `char[]` when the string contains only Latin-1 characters (the standard ASCII set plus a few extras). This is called Compact Strings, and it cuts memory use roughly in half for typical English text. It's an implementation detail you don't have to manage yourself.\n\n\n```mermaid\nflowchart LR\n Var[productName
local variable]:::cyan --> Obj[String object on heap]:::orange\n Obj --> Hdr[Object header
length, hash]:::teal\n Obj --> Data[byte array
W, i, r, e, l, e, s, s]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThe variable on the left is just a reference. The object on the heap holds a small header and the backing array with the actual character data.\n\n---\n\n# Two Ways to Create a String\n\nJava gives you two ways to write down a new string.\n\nThe first is a string literal, which is just text between double quotes.\n\n\n```java\npublic class StringLiteral {\n public static void main(String[] args) {\n String productName = \"Laptop Stand\";\n System.out.println(productName);\n }\n}\n```\n\n\nThe second is the `new String(...)` constructor, which explicitly asks the JVM to allocate a fresh `String` object.\n\n\n```java\npublic class StringWithNew {\n public static void main(String[] args) {\n String productName = new String(\"Laptop Stand\");\n System.out.println(productName);\n }\n}\n```\n\n\nBoth lines produce a `String` whose characters are `Laptop Stand`, and you can use both variables the same way. The difference is what happens inside the JVM. The literal form reuses a shared instance from a structure called the string pool, while `new String(...)` always allocates a brand-new object on the heap, even if an identical string already exists in the pool. That distinction matters when you compare strings with `==` versus `.equals()`.\n\nOne practical rule: prefer the literal form. It's shorter, common across Java codebases, and lets the JVM share memory across copies of the same text.\n\nEach `new String(\"text\")` allocates a fresh object on the heap, even when an identical literal already exists in the pool. In a tight loop, that adds up. Use the literal form unless you need a distinct object.\n\nThe `String` class has several other constructors too, including one that takes a `char[]` and one that takes a `byte[]`.\n\n---\n\n# `length()` and `charAt(int)`\n\nTwo methods show up everywhere: `length()` tells you how many characters a string has, and `charAt(i)` returns the character at position `i`.\n\n\n```java\npublic class LengthAndCharAt {\n public static void main(String[] args) {\n String productName = \"Laptop\";\n System.out.println(\"Length: \" + productName.length());\n System.out.println(\"First: \" + productName.charAt(0));\n System.out.println(\"Last: \" + productName.charAt(productName.length() - 1));\n }\n}\n```\n\n\n`length()` has parentheses. That's a difference from arrays, where `arr.length` is a field with no parens. For strings, `length()` is a method. Both run in constant time, but the syntax differs and the compiler will not let you mix them up.\n\n\n| Type | Syntax | What it returns |\n| -------- | ------------- | -------------------------------- |\n| Array | `arr.length` | The fixed size of the array |\n| `String` | `str.length()` | The number of characters |\n\n\nIndexing into a string follows the same rules as indexing into an array. The first character is at position `0`, and the last character is at position `length() - 1`. Going outside that range throws `StringIndexOutOfBoundsException`.\n\n\n```java\npublic class CharAtBounds {\n public static void main(String[] args) {\n String orderStatus = \"Shipped\";\n System.out.println(orderStatus.charAt(0));\n System.out.println(orderStatus.charAt(orderStatus.length() - 1));\n // System.out.println(orderStatus.charAt(7)); // throws StringIndexOutOfBoundsException\n }\n}\n```\n\n\nThe commented line would throw, because the valid indices for `\"Shipped\"` are `0` through `6`. Index `7` is one past the end.\n\nBoth `length()` and `charAt(i)` run in O(1). The length is stored once when the string is constructed, and `charAt(i)` is a direct lookup into the backing array.\n\nA common pattern is to walk through every character with a simple loop.\n\n\n```java\npublic class WalkCharacters {\n public static void main(String[] args) {\n String customerName = \"Alice\";\n for (int i = 0; i < customerName.length(); i++) {\n char c = customerName.charAt(i);\n System.out.println(\"Position \" + i + \": \" + c);\n }\n }\n}\n```\n\n\nThis pattern is how a lot of string-processing code starts: a loop, an index, a `charAt` call.\n\n---\n\n# `isEmpty()` and `isBlank()`\n\nTwo short methods check whether a string contains any useful content.\n\n`isEmpty()`, available since Java 6, returns `true` when the string has zero characters. It's just shorthand for `str.length() == 0`.\n\n\n```java\npublic class IsEmptyExample {\n public static void main(String[] args) {\n String emptySearch = \"\";\n String realSearch = \"wireless mouse\";\n System.out.println(\"emptySearch.isEmpty(): \" + emptySearch.isEmpty());\n System.out.println(\"realSearch.isEmpty(): \" + realSearch.isEmpty());\n }\n}\n```\n\n\n`isBlank()`, added in Java 11, goes one step further. It returns `true` when the string has zero characters **or** every character is a whitespace character (spaces, tabs, newlines, and other Unicode whitespace).\n\n\n```java\npublic class IsBlankExample {\n public static void main(String[] args) {\n String emptyReview = \"\";\n String spacesReview = \" \";\n String realReview = \"Great product\";\n\n System.out.println(\"emptyReview.isBlank(): \" + emptyReview.isBlank());\n System.out.println(\"spacesReview.isBlank(): \" + spacesReview.isBlank());\n System.out.println(\"realReview.isBlank(): \" + realReview.isBlank());\n }\n}\n```\n\n\nUse `isEmpty()` to check strictly whether there are zero characters. Use `isBlank()` when whitespace-only input should count as empty, which fits user-entered fields like search boxes, review text, or coupon codes. A customer who types four spaces into a search bar didn't really search for anything.\n\n\n| Input | `isEmpty()` | `isBlank()` |\n| -------------- | ----------- | ----------- |\n| `\"\"` | `true` | `true` |\n| `\" \"` | `false` | `true` |\n| `\"\\t\\n\"` | `false` | `true` |\n| `\"a\"` | `false` | `false` |\n| `\" hello \"` | `false` | `false` |\n\n\nNeither method handles `null`. If the variable might be `null`, check that first, which the last section of this lesson covers.\n\n---\n\n# Concatenation with `+`\n\nYou can join two strings with the `+` operator. The result is a new string containing the characters of the left operand followed by the characters of the right.\n\n\n```java\npublic class BasicConcat {\n public static void main(String[] args) {\n String firstName = \"Alice\";\n String lastName = \"Khan\";\n String fullName = firstName + \" \" + lastName;\n System.out.println(\"Customer: \" + fullName);\n }\n}\n```\n\n\nThe expression `firstName + \" \" + lastName` builds the full name in two steps: first it joins `\"Alice\"` and `\" \"` into `\"Alice \"`, then it joins `\"Alice \"` and `\"Khan\"` into `\"Alice Khan\"`. Each step produces a new `String` object, because strings in Java cannot be modified after creation. That immutability property is worth understanding in its own right.\n\nThe `+` operator also works when one side is a string and the other is a number, a boolean, or any other type. Java converts the non-string operand to a `String` automatically before joining.\n\n\n```java\npublic class ConcatWithNumbers {\n public static void main(String[] args) {\n String productName = \"USB Cable\";\n double price = 9.99;\n int stock = 42;\n boolean inStock = true;\n\n String summary = productName + \" | $\" + price + \" | stock: \" + stock + \" | available: \" + inStock;\n System.out.println(summary);\n }\n}\n```\n\n\nThe price, stock count, and boolean were each turned into their text form before being glued onto the rest of the string. This is convenient, but it can surprise users in one case: when the expression starts with two numbers.\n\n\n```java\npublic class ConcatGotcha {\n public static void main(String[] args) {\n System.out.println(\"Total items: \" + 2 + 3);\n System.out.println(\"Total items: \" + (2 + 3));\n }\n}\n```\n\n\nIn the first line, Java reads left to right. It sees `\"Total items: \" + 2`, treats that as a string operation, produces `\"Total items: 2\"`, then concatenates `3` onto that, producing `\"Total items: 23\"`. In the second line, the parentheses force `2 + 3` to be evaluated as integer addition first, giving `5`, which then gets concatenated. When mixing numbers and strings, parentheses around arithmetic save you from this trap.\n\nEach `+` between strings allocates a new `String` object. For a handful of concatenations like a customer name or a status line, this cost is invisible. For long loops that build up text piece by piece, it adds up fast, and you'll want `StringBuilder` instead.\n\n---\n\n# Converting Between `String` and `char[]`\n\nA `String` is a sequence of characters, and sometimes you need to work with that sequence as a raw `char[]`. The method `toCharArray()` gives you exactly that.\n\n\n```java\npublic class StringToCharArray {\n public static void main(String[] args) {\n String productCode = \"MOUSE\";\n char[] letters = productCode.toCharArray();\n\n System.out.println(\"Length: \" + letters.length);\n System.out.println(\"First: \" + letters[0]);\n System.out.println(\"Last: \" + letters[letters.length - 1]);\n }\n}\n```\n\n\n`toCharArray()` allocates a new `char[]` of the right size and copies every character from the string into it. The array is independent: writing to a slot in `letters` does not change the original string. That makes sense, because strings can never change anyway.\n\nGoing the other direction is just as easy. The constructor `new String(char[])` builds a string from an array of characters.\n\n\n```java\npublic class CharArrayToString {\n public static void main(String[] args) {\n char[] letters = {'C', 'A', 'R', 'T'};\n String productCode = new String(letters);\n System.out.println(\"Product code: \" + productCode);\n System.out.println(\"Length: \" + productCode.length());\n }\n}\n```\n\n\nThe constructor copies the array into a new `String` object. Modifying `letters` afterward will not affect the string.\n\n\n```java\npublic class StringCopyProof {\n public static void main(String[] args) {\n char[] letters = {'C', 'A', 'R', 'T'};\n String productCode = new String(letters);\n letters[0] = 'D';\n System.out.println(\"Array now: \" + new String(letters));\n System.out.println(\"String: \" + productCode);\n }\n}\n```\n\n\nEven after we changed `letters[0]`, the string still reads `\"CART\"`. The two are decoupled.\n\nThese conversions matter for two common situations. The first is when an algorithm needs random read access to individual characters (a `char[]` is sometimes easier to reason about than calling `charAt` over and over). The second is when you're building a string one character at a time from arbitrary sources. Many interview problems use `toCharArray()` as their first line.\n\nBoth `toCharArray()` and `new String(char[])` allocate a new array or a new string and copy every character. They are O(n) in the length. Don't call them in a loop if you can avoid it.\n\n---\n\n# `String.valueOf(...)` and `toString()`\n\nConverting other types into a `String` comes up often. A price has to be displayed in a confirmation message. A stock count has to be written into a log line. Java offers two related tools for this: the static method `String.valueOf(...)` and the instance method `toString()`.\n\n`String.valueOf(...)` is overloaded for every primitive type and for `Object`. Pass any value and it returns the text form.\n\n\n```java\npublic class ValueOfBasics {\n public static void main(String[] args) {\n String priceText = String.valueOf(29.99);\n String stockText = String.valueOf(42);\n String availableText = String.valueOf(true);\n\n System.out.println(\"Price as text: '\" + priceText + \"'\");\n System.out.println(\"Stock as text: '\" + stockText + \"'\");\n System.out.println(\"Flag as text: '\" + availableText + \"'\");\n }\n}\n```\n\n\nEach call produces a `String` whose characters match the printed form of the value. `29.99` becomes `\"29.99\"`, `42` becomes `\"42\"`, and `true` becomes `\"true\"`. The single quotes in the output are just there to make the boundaries of the string visible.\n\nFor object references, every class inherits a `toString()` method from `Object`. The default implementation returns something like `ClassName@hashcode`, which is rarely useful, so well-designed classes override it to return a sensible text form. The `String` class itself defines `toString()` to return the string itself.\n\n\n```java\npublic class ToStringExample {\n public static void main(String[] args) {\n Integer stock = 42;\n Double price = 9.99;\n\n String stockText = stock.toString();\n String priceText = price.toString();\n\n System.out.println(\"Stock: \" + stockText);\n System.out.println(\"Price: \" + priceText);\n }\n}\n```\n\n\n`String.valueOf(x)` and `x.toString()` usually produce the same output for non-null `x`. There's one important difference: `String.valueOf(null)` returns the literal string `\"null\"`, while calling `.toString()` on a `null` reference throws `NullPointerException`.\n\n\n```java\npublic class ValueOfNull {\n public static void main(String[] args) {\n String maybe = null;\n System.out.println(\"Via valueOf: \" + String.valueOf(maybe));\n // System.out.println(maybe.toString()); // throws NullPointerException\n }\n}\n```\n\n\n`String.valueOf(...)` is the safer default when the value might be `null`.\n\n\n| Call | Behavior on `null` |\n| ------------------------- | --------------------------------- |\n| `String.valueOf(x)` | Returns `\"null\"`, no exception |\n| `x.toString()` | Throws `NullPointerException` |\n| `\"\" + x` | Returns `\"null\"`, no exception |\n\n\nThe third option, `\"\" + x`, works because the `+` operator internally calls `String.valueOf` on each operand. Some codebases use it as a one-character shortcut, though `String.valueOf(x)` is clearer about intent.\n\n---\n\n# Strings Can Be `null`\n\nA `String` variable is a reference. Like any reference, it can point at an actual `String` object, or it can be `null`, meaning it points at nothing. Calling a method on a `null` reference throws `NullPointerException`, abbreviated NPE.\n\n**What's wrong with this code?**\n\n\n```java\npublic class NullStringBug {\n public static void main(String[] args) {\n String couponCode = null;\n System.out.println(\"Length: \" + couponCode.length());\n }\n}\n```\n\n\nThe variable `couponCode` is set to `null`, so it doesn't refer to any `String` object. Calling `.length()` on it throws `NullPointerException`:\n\n\n```shell\nException in thread \"main\" java.lang.NullPointerException:\n Cannot invoke \"String.length()\" because \"couponCode\" is null\n```\n\n\n**Fix:**\n\nCheck for `null` before calling a method on the variable.\n\n\n```java\npublic class NullStringFix {\n public static void main(String[] args) {\n String couponCode = null;\n if (couponCode != null) {\n System.out.println(\"Length: \" + couponCode.length());\n } else {\n System.out.println(\"No coupon applied.\");\n }\n }\n}\n```\n\n\nThe same idea applies to `isEmpty()` and `isBlank()`. Both throw NPE on a `null` reference because there's no object to call them on.\n\nOne useful pattern is to flip the comparison so the constant comes first:\n\n\n```java\nString couponCode = readCouponFromUser();\nif (\"WELCOME10\".equals(couponCode)) {\n // safe even if couponCode is null\n}\n```\n\n\nIf `couponCode` is `null`, the comparison returns `false` rather than throwing. The reverse, `couponCode.equals(\"WELCOME10\")`, would throw NPE when `couponCode` is `null`. Comparison comes back in lesson 08 of this section.\n\nWhen you don't have a real string value yet, prefer the empty string `\"\"` over `null` if the code can tolerate it. An empty string is a real `String` object on which every method works, so `\"\".length()` returns `0` and `\"\".isEmpty()` returns `true`. A `null` is a missing reference that fails the moment you touch it.","pageType":"java"}

String Basics

Get Premium