How do I format a date using DateTimeFormatter in Java?

Use DateTimeFormatter to turn a LocalDate into text. You can choose the order of the day, month, and year, and use a locale to control the language of the month name.

In this example, you will format the same date in two ways: 11/11/2026 and 11 November 2026.

Source code

Save the following code as DateFormattingExample.java:

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Locale;

public class DateFormattingExample {
    void main() {
        LocalDate date = LocalDate.of(2026, 11, 11);

        DateTimeFormatter numericFormat =
                DateTimeFormatter.ofPattern("dd/MM/uuuu");
        DateTimeFormatter longFormat =
                DateTimeFormatter.ofPattern("d MMMM uuuu", Locale.ENGLISH);

        IO.println("Numeric date: " + date.format(numericFormat));
        IO.println("Date with month name: " + date.format(longFormat));
    }
}

Explanation

LocalDate.of(2026, 11, 11) creates a date using the year, month, and day in that order. A LocalDate stores a calendar date without a time or time zone.

The ofPattern() method creates a formatter from a pattern. The letters are case-sensitive:

Pattern Meaning Example
d Day of the month without zero padding 5
dd Day of the month padded to two digits 05
MM Month number padded to two digits 03
MMMM Full month name March
uuuu Calendar year, padded to at least four digits 2026

Slashes and spaces in these patterns appear as written. Locale.ENGLISH makes the full month name appear in English regardless of the system’s default locale.

The date.format(...) call returns a string. You can format the same date in multiple ways because formatting leaves the LocalDate unchanged.

Use uuuu for the calendar year in these patterns. Uppercase YYYY means the week-based year, which can differ from the calendar year near the start or end of a year.

Run the example

Compile and run the file:

javac DateFormattingExample.java
java DateFormattingExample

Output

Numeric date: 11/11/2026
Date with month name: 11 November 2026

To see the difference between d and dd, change the date to LocalDate.of(2026, 3, 5). The numeric format displays 05/03/2026, and the format with the month name displays 5 March 2026.

How do I create an animated moiré pattern in Java Swing?

You can create a moiré pattern by drawing two sets of parallel lines on top of one another and rotating one set slightly. Their spacing produces broad bands that appear to move as the angle changes.

Rotating Moire

Rotating Moire

This SwingLoops example uses Java Swing and Java 2D to animate the effect. It requires no external libraries or image assets.

Source code

Save the following code as RotatingMoire.java:

package org.kodejava.swing.animation;

import java.awt.*;
import java.awt.geom.Line2D;
import javax.swing.*;

public class RotatingMoire extends JPanel {
    private static final int WIDTH = 450;
    private static final int HEIGHT = 800;
    private static final int EXTENT = 700;
    private static final int SPACING = 11;
    private static final double CYCLE = 12.0;

    private final Timer timer = new Timer(16, _ -> repaint());
    private long startedAt;
    private int mode = 3;

    public RotatingMoire() {
        setPreferredSize(new Dimension(WIDTH, HEIGHT));
        setBackground(new Color(9, 16, 29));

        for (int i = 1; i <= 3; i++) {
            final int selected = i;
            String action = "mode" + i;
            getInputMap(WHEN_IN_FOCUSED_WINDOW).put(
                    KeyStroke.getKeyStroke((char) ('0' + i)), action);
            getActionMap().put(action, new AbstractAction() {
                @Override
                public void actionPerformed(
                        java.awt.event.ActionEvent event) {
                    mode = selected;
                    repaint();
                }
            });
        }
    }

    @Override
    public void addNotify() {
        super.addNotify();
        startedAt = System.nanoTime();
        timer.start();
    }

    @Override
    public void removeNotify() {
        timer.stop();
        super.removeNotify();
    }

    private static void layer(Graphics2D parent,
                              double angle, Color color) {
        Graphics2D g = (Graphics2D) parent.create();
        try {
            g.rotate(angle);
            g.setColor(color);
            g.setStroke(new BasicStroke(3.5f));
            for (int x = -EXTENT; x <= EXTENT; x += SPACING) {
                g.draw(new Line2D.Double(
                        x, -EXTENT, x, EXTENT));
            }
        } finally {
            g.dispose();
        }
    }

    @Override
    protected void paintComponent(Graphics graphics) {
        super.paintComponent(graphics);
        Graphics2D g = (Graphics2D) graphics.create();

        try {
            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                    RenderingHints.VALUE_ANTIALIAS_ON);

            double scale = Math.min(
                    getWidth() / (double) WIDTH,
                    getHeight() / (double) HEIGHT);
            g.translate(getWidth() / 2.0, getHeight() / 2.0);
            g.scale(scale, scale);
            g.clipRect(-WIDTH / 2, -HEIGHT / 2, WIDTH, HEIGHT);

            double seconds = (System.nanoTime() - startedAt) / 1e9;
            double phase = 2 * Math.PI * (seconds % CYCLE) / CYCLE;
            double movingAngle = Math.toRadians(
                    10 + 7 * Math.sin(phase));

            layer(g, 0, new Color(62, 202, 226, 180));

            if (mode >= 2) {
                layer(g, mode == 2 ? Math.toRadians(10) : movingAngle,
                        new Color(244, 166, 123, 180));
            }
        } finally {
            g.dispose();
        }
    }

    static void main() {
        SwingUtilities.invokeLater(() -> {
            JFrame frame = new JFrame("SwingLoops - Rotating Moire");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setContentPane(new RotatingMoire());
            frame.pack();
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
        });
    }
}

Run the example

With a JDK 25 installed, open a terminal in the directory containing the source file:

javac RotatingMoire.java
java RotatingMoire

A desktop environment is required to display the Swing window. Close the window to stop the application.

Use these keys while the window is active:

Key View
1 Show only the fixed cyan lines.
2 Add a stationary second layer at 10 degrees.
3 Animate the second layer.

Draw the two layers

The layer() method draws equally spaced vertical lines. Each line has the same width and extends beyond the visible canvas.

Before drawing the second layer, the code rotates its copied graphics context:

g.rotate(angle);

Java 2D transforms all subsequent line coordinates. The method disposes the copied context afterward, so its rotation does not affect the other layer.

The broad bands are not separate shapes. They emerge where the two repeating line patterns overlap.

Why do broad bands appear?

When two line grids have similar orientations, their relative alignment changes slowly across the image. Some regions contain closely aligned lines; elsewhere, the lines separate and cross. This creates a larger repeating pattern over the fine line structure.

For two ideal grids with the same spacing s and an angle difference θ, the moiré spacing is approximately:

D = s / (2 × sin(θ / 2))

Angles in this formula are in radians. As the angle difference becomes smaller, the broad bands become farther apart.

For example, with a line spacing of 11 pixels and an angle difference of 10 degrees, the idealized band spacing is about 63 pixels. Stroke width, transparency, and the screen’s sampling affect the final appearance.

This example deliberately constructs the effect from two layers. It is different from unwanted aliasing caused solely by insufficient display resolution, although resizing can introduce additional sampling effects.

Animate the rotation

The rotating layer follows this angle:

double movingAngle = Math.toRadians(
        10 + 7 * Math.sin(phase));

Sine varies from −1 to 1, so the angle varies smoothly between 3 and 17 degrees. Keeping it away from zero avoids the extremely wide band spacing near perfect alignment.

The time phase completes one turn every 12 seconds:

double phase = 2 * Math.PI * (seconds % CYCLE) / CYCLE;

At the cycle boundary, the angle returns to its starting value with matching motion, allowing the animation to repeat smoothly.

Paint safely with Swing

A Swing timer requests repaints approximately every 16 milliseconds. Actual repaint frequency depends on the event queue and system performance.

The angle uses elapsed time rather than a frame counter, so delayed frames do not change the intended cycle duration. The interface, timer callbacks, and painting run on Swing’s event-dispatch thread.

The drawing is centered, scaled uniformly, and clipped to a logical 450 × 800 canvas. This preserves its proportions when the window is resized.

Customize the effect

Try changing one setting at a time:

Setting Effect
SPACING Distance between lines; changes the scale of the moiré pattern.
3.5f stroke width Changes how much each layer covers the background.
10 in the angle calculation Average angle between layers.
7 in the angle calculation Amount of angular variation.
CYCLE Duration of one back-and-forth rotation.
Layer colors and alpha values Change the contrast and overlap colors.

Start by increasing SPACING from 11 to 15. The fine lines and the broad pattern will both become more widely spaced.

The complete source code above is free to copy and run. Explore the SwingLoops repository for more Java animation examples.

How do I close a file automatically using try-with-resources in Java?

Use a try-with-resources statement to close a file reader automatically. Java closes the reader when execution leaves the try block, even if reading fails.

In this example, you will open a UTF-8 text file with a BufferedReader and print it one line at a time.

Source code

Save the following code as TryWithResourcesExample.java:

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;

public class TryWithResourcesExample {
    void main() {
        Path path = Path.of("greeting.txt");

        try (BufferedReader reader =
                Files.newBufferedReader(path, StandardCharsets.UTF_8)) {
            String line;

            while ((line = reader.readLine()) != null) {
                IO.println(line);
            }
        } catch (IOException exception) {
            System.err.println(
                    "Could not open, read, or close the file: "
                            + exception.getMessage());
        }
    }
}

Explanation

The declaration inside the parentheses after try opens the file and creates a BufferedReader:

try (BufferedReader reader =
        Files.newBufferedReader(path, StandardCharsets.UTF_8)) {

A BufferedReader implements AutoCloseable, so Java can call its close() method automatically. Closing the reader also closes the underlying file resource.

Inside the block, readLine() returns the next line without its line separator. It returns null when there are no more lines. The while condition assigns each result to line and checks whether it is null. A blank line returns an empty string, so it is still printed.

When the loop ends, Java closes the reader. If reading throws an exception, Java still attempts to close the reader before running the catch block. You do not need to call close() yourself or add a finally block for cleanup.

Run the example

Reuse greeting.txt from the previous example, or create it as a UTF-8 file with these contents:

Hello, Java!
Learning Java one snippet at a time.

From the directory containing both files, compile and run the program:

javac TryWithResourcesExample.java
java TryWithResourcesExample

Output

Hello, Java!
Learning Java one snippet at a time.

Use try-with-resources when you open a reader or writer yourself. Convenience methods such as Files.readString() and Files.writeString() already manage the file resource for you.

How do I write text to a file using Files.writeString() in Java?

Use Files.writeString() to save a string to a text file. By default, it uses UTF-8, creates the file if it does not exist, and replaces its contents if it already exists.

In this example, you will write a two-line message to a file named greeting.txt.

Source code

Save the following code as WriteStringExample.java:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class WriteStringExample {
    void main() {
        Path path = Path.of("greeting.txt");

        String message = """
                Hello, Java!
                Learning Java one snippet at a time.
                """;

        try {
            Files.writeString(path, message);
            IO.println("Text written to " + path);
        } catch (IOException exception) {
            System.err.println(
                    "Could not write the file: " + exception.getMessage());
        }
    }
}

Explanation

Path.of("greeting.txt") creates a relative path. The program writes the file in its current working directory, which is normally the directory from which you run the java command.

The triple quotes (""") define a text block. This lets you write multiple lines without adding \n between them. Because the closing quotes are on their own line, the string also ends with a newline.

The following statement saves the message:

Files.writeString(path, message);

Files.writeString() encodes the string as UTF-8 and writes it as supplied. It does not add a newline of its own. The method handles opening and closing the file, so there is no writer to close in your code.

The catch block handles an IOException, which can occur if the directory is not writable. The success message appears only if the write completes without throwing an exception.

Run the example

Compile and run the file from a directory where you can create greeting.txt:

javac WriteStringExample.java
java WriteStringExample

The program prints:

Text written to greeting.txt

Open greeting.txt to see its contents:

Hello, Java!
Learning Java one snippet at a time.

Appending instead of replacing

To keep existing contents and add the message at the end, import java.nio.file.StandardOpenOption and replace the write statement with:

Files.writeString(
        path, message,
        StandardOpenOption.CREATE,
        StandardOpenOption.APPEND);

CREATE creates the file if it is missing, and APPEND writes at the end if it already exists. If the existing text does not end with a newline, the appended text starts on the same line.

How do I read a text file using Files.readString() in Java?

You can use Files.readString() to read an entire text file into a single string. It preserves the file’s line separators, so the result can contain multiple lines.

In this example, you will read a UTF-8 text file and display its contents.

Source code

Save the following code as ReadStringExample.java:

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;

public class ReadStringExample {
    void main() {
        Path path = Path.of("message.txt");

        try {
            String content = Files.readString(path, StandardCharsets.UTF_8);

            IO.print(content);
        } catch (IOException exception) {
            System.err.println("Could not read the file: " + exception.getMessage());
        }
    }
}

Prepare the text file

Create a file named message.txt in the directory from which you will run the program. Save it using UTF-8 encoding with the following contents:

Hello, Java!
Learning Java one snippet at a time.

Explanation

The example creates a Path representing the file location:

Path path = Path.of("message.txt");

This is a relative path. Java resolves it against the program’s current working directory, which may differ from the directory containing the source file.

Reading the contents

The following statement reads the entire file:

String content = Files.readString(path, StandardCharsets.UTF_8);

The first argument identifies the file. The second specifies how its bytes are decoded into characters.

Using StandardCharsets.UTF_8 makes the expected encoding explicit. The overload Files.readString(path) also uses UTF-8.

The method returns one string containing all the text, including any line separators in the file.

Displaying the text

The program prints the contents using:

IO.print(content);

IO.print() does not append a line separator. This lets the program display the text without adding an extra newline beyond those already in the file.

Handling read failures

Files.readString() can throw an IOException, for example when the file is missing or cannot be read.

The catch block handles that failure:

catch (IOException exception) {
    System.err.println("Could not read the file: " + exception.getMessage());
}

The error message goes to standard error, while the file contents go to standard output.

You do not need to close a reader yourself. Files.readString() manages the file resource and closes it when reading finishes or an error occurs.

Run the example

With message.txt in your current directory, compile and run the program:

javac ReadStringExample.java
java ReadStringExample

Output

Hello, Java!
Learning Java one snippet at a time.

Use Files.readString() for files that comfortably fit in memory. For large files, process the contents incrementally with a buffered reader or Files.lines() instead.