DEV Community: ライフポータル

4 Ways to Concatenate Arrays in Java: From System.arraycopy to Stream API

ライフポータル — Sun, 08 Feb 2026 03:50:21 +0000

When developing with Java, you often need to combine data from different sources—like a database and local logic—into a single array.

However, since Java arrays are fixed-length, you cannot simply use an operator like array1 + array2 as you might in other scripting languages. To join them, you must allocate a new array and copy the elements.

In this guide, we’ll explore the best techniques to concatenate arrays in Java, ranging from the high-performance System.arraycopy to the modern Stream API, and even handling binary data with byte[].

1. The Fastest Method: `System.arraycopy()`

System.arraycopy is the most fundamental and high-performance way to join arrays. While the syntax is a bit verbose, it works for both primitive types (int, byte, etc.) and reference types (String, Object).

Example: Concatenating two `int` arrays

import java.util.Arrays;

public class ArrayCopyExample {
    public static void main(String[] args) {
        int[] array1 = { 1, 2, 3 };
        int[] array2 = { 4, 5, 6 };

        // 1. Calculate and allocate the size for the new array
        int[] result = new int[array1.length + array2.length];

        // 2. Copy array1 to the beginning (index 0) of result
        System.arraycopy(array1, 0, result, 0, array1.length);

        // 3. Copy array2 to the end (index array1.length) of result
        System.arraycopy(array2, 0, result, array1.length, array2.length);

        System.out.println("Result: " + Arrays.toString(result));
    }
}

Output:
Result: [1, 2, 3, 4, 5, 6]

The method signature is System.arraycopy(src, srcPos, dest, destPos, length). This is the gold standard for handling large datasets or binary operations where performance is critical.

2. The Modern Way: Stream API (Java 8+)

If you are using Java 8 or later, the Stream API provides a more declarative and readable way to join arrays, especially for reference types like String[].

Example: Concatenating `String` arrays

import java.util.Arrays;
import java.util.stream.Stream;

public class StreamConcatExample {
    public static void main(String[] args) {
        String[] array1 = { "Java", "Python" };
        String[] array2 = { "C#", "Ruby" };

        // Use Stream.concat to join and convert back to an array
        String[] result = Stream.concat(Arrays.stream(array1), Arrays.stream(array2))
                                .toArray(String[]::new);

        System.out.println("Result: " + Arrays.toString(result));
    }
}

Note for Primitives: When dealing with primitive arrays like int[], you should use IntStream instead of the generic Stream.

int[] result = IntStream.concat(Arrays.stream(array1), Arrays.stream(array2)).toArray();

3. Joining Array Elements into a Single String

Sometimes "concatenating arrays" means you want to join all elements into a single delimited string (e.g., a CSV). In this case, String.join() is the best practice.

Example: Creating a comma-separated string

public class StringJoinExample {
    public static void main(String[] args) {
        String[] fruits = { "Apple", "Banana", "Orange" };

        // Join with a comma
        String csv = String.join(",", fruits);

        // Join without a delimiter
        String combined = String.join("", fruits);

        System.out.println("CSV Format: " + csv);
        System.out.println("Combined: " + combined);
    }
}

This approach is much cleaner than manually looping with a StringBuilder.

4. Using `List` (ArrayList) for Flexibility

If you need to add or remove elements frequently, it is often better to handle data as a List rather than a fixed-length array.

Example: Using `Collections.addAll()`

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ListJoinExample {
    public static void main(String[] args) {
        String[] array1 = { "A", "B" };
        String[] array2 = { "C", "D" };

        List<String> list = new ArrayList<>();

        // Add all elements from both arrays to the list
        Collections.addAll(list, array1);
        Collections.addAll(list, array2);

        System.out.println("List Content: " + list);
    }
}

If you absolutely need an array at the end, you can convert it back using list.toArray(new String[0]).

Extra: Concatenating `byte[]` for Binary Data

For image processing or network communication, you might want to join byte arrays. While System.arraycopy is common, ByteArrayOutputStream is more intuitive for streaming data.

import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class ByteJoinExample {
    public static void main(String[] args) throws IOException {
        byte[] b1 = { 0x01, 0x02 };
        byte[] b2 = { 0x03, 0x04 };

        try (ByteArrayOutputStream output = new ByteArrayOutputStream()) {
            output.write(b1);
            output.write(b2);
            byte[] result = output.toByteArray();
        }
    }
}

Conclusion

The right tool for joining arrays depends on your requirements:

Performance: Use System.arraycopy().
Readability (Modern Java): Use Stream.concat().
Formatting: Use String.join().
Dynamic Sizing: Use ArrayList.

Originally published at: [https://code-izumi.com/java/combine-arrays/]

Python Block Comments: Best Practices, Shortcuts, and Docstrings Explained

ライフポータル — Sat, 07 Feb 2026 07:27:51 +0000

When writing Python code, you often need to comment out multiple lines at once or write detailed descriptions for functions and classes.

Unlike C or Java, Python does not have a dedicated syntax for block comments (like /* ... */).

This leads to common questions:

"Do I really have to type # on every single line?"
"Can I just use triple quotes """ as a comment?"

In this guide, we’ll explore the best practices for writing block comments in Python, how to use editor shortcuts for bulk commenting, and the crucial difference between comments and docstrings.

Does Python Have a Block Comment Syntax?

The short answer is no. Python’s language specification only defines the # (hash) character to ignore everything from that point until the end of the line.

However, in practice, developers achieve block-style comments using two methods:

Prepending # to each line (The Recommended Way)
Using Triple Quotes """ (The "Pseudo-comment" Way)

Method 1: Using "#" on Every Line (Recommended)

This is the standard approach recommended by PEP 8, Python’s official style guide. While it looks like you have to type a lot, modern editors make this instantaneous.

# ==================================
# This is a block comment.
# When writing long descriptions,
# start each line with a hash symbol.
# ==================================

print("Hello, Python!")

Why this is the Best Practice:

Official Standard: It’s the universally accepted way among Python developers.
Indentation Safe: It works anywhere in your code without triggering syntax errors.

Pro Tip: Editor Shortcuts for Bulk Commenting

Don't type hashes manually! You can toggle comments for multiple lines at once using keyboard shortcuts.

Editor	Shortcut (Windows / Mac)
VS Code	`Ctrl` + `/` (Mac: `Cmd` + `/`)
PyCharm	`Ctrl` + `/` (Mac: `Cmd` + `/`)
Jupyter / Colab	`Ctrl` + `/` (Mac: `Cmd` + `/`)

Method 2: Using Triple Quotes `"""` (The Pseudo-comment)

Triple quotes (triple-double or triple-single quotes) are technically used to create multi-line strings. However, if a string is not assigned to a variable, Python’s interpreter evaluates it and then moves on, effectively ignoring it.

print("Process Start")

"""
This part is not executed.
Since it's not assigned to a variable,
it acts like a comment.
"""

print("Process End")

⚠️ Warning: The Indentation Trap

Because triple quotes are technically "string data," they must follow Python’s strict indentation rules. If your triple quotes are not aligned with the surrounding code, you will get an IndentationError.

def my_function():
    print("Start")

"""
Error! This is not aligned with the 
function's indentation level.
"""

Verdict: Use this only for temporary "parking" of large blocks of code during debugging. Do not leave these in your final production code as "comments."

Block Comments vs. Docstrings

Python has a special feature called Docstrings (Documentation Strings). While they use triple quotes, their purpose is entirely different from comments.

def add(a, b):
    """
    Adds two numbers and returns the result.

    Args:
        a (int): The first number.
        b (int): The second number.

    Returns:
        int: The sum of a and b.
    """
    return a + b

Docstrings placed immediately after a function or class definition are recognized by Python as official documentation. You can access them via help(add) or by hovering over the function in editors like VS Code.

Type	Syntax	Purpose
Comment	`#`	Notes for developers (Why/How).
Docstring	`"""`	Documentation for users (What it does).

Conclusion

To write clean, "Pythonic" code:

Use hashes (#) for all internal comments.
Master the Ctrl + / shortcut to save time.
Reserve triple quotes (""") exclusively for Docstrings and temporary debugging.

Originally published at: [https://code-izumi.com/python/block-comment/]

Mastering "uv" in VS Code: The Ultra-Fast Python Setup Guide

ライフポータル — Fri, 06 Feb 2026 01:48:09 +0000

In the Python ecosystem, managing packages and virtual environments has always been a point of friction. While tools like pip, poetry, and pipenv have served us well, a new Rust-based contender called "uv" has taken the community by storm with its incredible speed and simplicity.

Are you facing these challenges?

"I want to try uv but don't know how to set it up in VS Code."
"The VS Code interpreter won't recognize my uv environment."
"I'm struggling to get the debugger working with uv."

In this guide, we’ll walk through the best practices for using uv with Visual Studio Code. We’ll cover everything from installation to virtual environment recognition, debugging, and integrating with Ruff for the ultimate Python development experience.

What is "uv"?

Developed by Astral (the team behind Ruff) and written in Rust, uv is an extremely fast Python package installer and resolver.

It is designed to be a "one-stop-shop" replacement for pip, pip-tools, and virtualenv. Benchmarks show it to be 10x to 100x faster than traditional tools. For VS Code users, this means:

Instant Environment Setup: No more waiting for dependency resolution.
Disk Space Efficiency: Optimized global caching.
Consistency: The uv.lock file ensures your team is always on the exact same environment.

Step 1: Installing uv

First, install uv using the official recommended installer.

Mac / Linux

curl -LsSf [https://astral.sh/uv/install.sh](https://astral.sh/uv/install.sh) | sh

Windows (PowerShell)

powershell -c "irm [https://astral.sh/uv/install.ps1](https://astral.sh/uv/install.ps1) | iex"

After installation, verify it by running uv --version in your terminal.

Step 2: Getting VS Code to Recognize uv

To make VS Code's Python extension work seamlessly with uv, follow these steps to manage your virtual environment (.venv).

1. Initialize and Create venv

In your project directory, run:

# Initialize the project (creates pyproject.toml)
uv init

# Create the virtual environment (creates .venv folder)
uv venv

2. Select the Interpreter

Open the Command Palette (Ctrl+Shift+P or Cmd+Shift+P).
Type and select "Python: Select Interpreter".
You should see the Python version located inside .venv. Select it.

Tip: If the environment doesn't appear, add the following to your VS Code settings.json to ensure the .venv folder is indexed:

{
  "python.venvPath": ".",
  "python.venvFolders": [".venv"]
}

Step 3: Package Management (`uv add` / `sync`)

Adding libraries is straightforward. uv automatically updates your pyproject.toml and uv.lock files.

# Add a production package
uv add fastapi

# Add a development package
uv add --dev pytest

When team members join the project, they can sync their entire environment in a split second using:

uv sync

Step 4: Debugging Configuration (`launch.json`)

To enable debugging (F5), create a .vscode/launch.json file. While the standard Python debugger works, it’s best to be explicit.

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Current File (uv)",
            "type": "python",
            "request": "launch",
            "program": "${file}",
            "console": "integratedTerminal",
            "justMyCode": true
        }
    ]
}

Now you can set breakpoints and debug your code directly within the uv-managed environment.

Pro Tip: Integration with Ruff

Since Ruff (the linter/formatter) is made by the same developers, it pairs perfectly with uv.

Install the Ruff extension for VS Code.
Add Ruff to your project: uv add --dev ruff.
Set Ruff as your default formatter in settings.json:

{
  "[python]": {
    "editor.defaultFormatter": "charliermarsh.ruff",
    "editor.formatOnSave": true,
    "editor.codeActionsOnSave": {
      "source.fixAll": "explicit",
      "source.organizeImports": "explicit"
    }
  }
}

Now, your code will be linted and formatted at lightning speed every time you save.

Conclusion

Switching to uv is perhaps the single most impactful change you can make to improve your Python developer experience in 2026. Combined with the power of VS Code and Ruff, you get a development environment that is not only fast but also robust and modern.

Originally published at: [https://code-izumi.com/python/uv-vscode/]

PHP Random String Generation: Best Practices for Passwords, IDs, and Tokens

ライフポータル — Thu, 05 Feb 2026 01:42:47 +0000

In web application development, you often need to generate random strings for various purposes:

"Generating temporary passwords for users."
"Creating unique, non-colliding filenames for uploads."
"Issuing secure CSRF tokens or API keys."

However, PHP offers several functions—rand, mt_rand, uniqid, random_bytes, and more. Choosing the wrong one can lead to security vulnerabilities. In this guide, we’ll break down the best methods for generating random strings based on security requirements and specific use cases.

1. Security First: Cryptographically Secure Strings

When handling sensitive data like passwords, session IDs, or tokens, you must use "cryptographically secure" methods. Standard functions like rand(), mt_rand(), or str_shuffle() are predictable and should never be used for security.

Recommended: `random_bytes` and `bin2hex`

Since PHP 7, random_bytes() has been the industry standard for generating unpredictable random data. To turn that data into a readable string, we typically use bin2hex().

<?php
// Generate 16 bytes of random data and convert to a 32-character hex string
$token = bin2hex(random_bytes(16));

echo "Generated Token: " . $token;
?>

Output Example:
Generated Token: a3f9e2b1c8d7e6f5a4b3c2d1e0f9a8b7

Because each byte is represented by two hex characters, random_bytes(16) results in a 32-character string. This is the best practice for CSRF tokens and secure keys.

2. Generating Custom Alphanumeric Strings

If you need a string with a specific set of characters (e.g., uppercase, lowercase, and numbers for a password), the best way is to pick characters randomly using random_int().

Flexible and Secure Generator Function

<?php
/**
 * Generates a secure random string of a specified length.
 * @param int $length
 * @return string
 */
function generateRandomString($length = 10) {
    $chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
    $max = strlen($chars) - 1;
    $result = '';

    for ($i = 0; $i < $length; $i++) {
        // random_int is cryptographically secure
        $index = random_int(0, $max);
        $result .= $chars[$index];
    }

    return $result;
}

// Generate a 12-character password
echo "Password: " . generateRandomString(12);
?>

By using random_int(), this function remains secure enough for passwords while giving you full control over the character set.

3. Simple Strings for Non-Secure Use Cases

For scenarios where security isn't a priority—such as generating dummy test data or temporary non-sensitive filenames—you can use a quicker, more concise method.

Using `str_shuffle`

<?php
// Shuffle a string and take the first 8 characters
$randomStr = substr(str_shuffle('1234567890abcdefghijklmnopqrstuvwxyz'), 0, 8);

echo "Simple ID: " . $randomStr;
?>

Note: This method is fast but predictable. Use it only for internal testing or UI elements where security doesn't matter.

4. Generating Unique IDs with `uniqid`

If your goal is to generate an identifier that is unlikely to collide (be duplicated), uniqid() is a specialized function that generates IDs based on the current time in microseconds.

Basic vs. High-Precision IDs

<?php
// Standard uniqid (13 characters)
echo "Standard: " . uniqid() . "\n";

// With a prefix
echo "With Prefix: " . uniqid("user_") . "\n";

// High-precision with more entropy (23 characters)
echo "High Precision: " . uniqid("", true) . "\n";
?>

Pro Tip: For database primary keys or critical filenames, always set the second parameter to true. This adds additional entropy (randomness) at the end of the string, making collisions nearly impossible even if multiple IDs are generated at the exact same microsecond.

Conclusion

The right tool depends on your goal:

For Tokens/Security: Use random_bytes().
For Passwords: Use random_int() with a custom character loop.
For Unique Filenames: Use uniqid('', true).
For Mock Data: str_shuffle() is fine.

By choosing the correct function, you ensure your PHP applications are both functional and secure.

Originally published at: [https://code-izumi.com/php/random-string/]

PHP Database Connection: A Beginner’s Guide to PDO (MySQL & PostgreSQL)

ライフポータル — Wed, 04 Feb 2026 05:26:18 +0000

In web development, connecting to a database to manage user info or product data is an essential task. For those new to PHP, this first step can often feel like a hurdle.

Common questions include:

"What exactly is PDO, and should I use it over mysqli?"
"Why do I keep getting error screens when trying to connect?"
"How do I connect to PostgreSQL as well as MySQL?"

In this guide, we’ll dive deep into PDO (PHP Data Objects)—the industry-standard way to handle database connections in PHP. We’ll cover everything from basic connection scripts to essential security options and troubleshooting.

1. Why Choose PDO Over mysqli?

There are two main ways to connect to a database in PHP: mysqli and PDO.

Modern PHP development strongly recommends PDO. The biggest advantage is that PDO acts as a "Database Abstraction Layer." This means you can use the same code structure regardless of which database you are using.

If you decide to switch from MySQL to PostgreSQL later, you only need to change your connection string (DSN) slightly. mysqli, on the other hand, is for MySQL only. Mastering PDO makes you a more versatile and future-proof developer.

2. Connecting to MySQL with PDO

To connect, you need four pieces of information: Hostname, Database name, Username, and Password.

The Basic Connection Script

<?php
// Connection Settings
$dsn = 'mysql:dbname=my_database;host=localhost;charset=utf8mb4';
$user = 'db_user';
$password = 'password123';

try {
    // Establishing the connection
    $dbh = new PDO($dsn, $user, $password);

    echo "Successfully connected to the database!\n";

    // Disconnect (Optional: setting it to null or waiting for script to end)
    $dbh = null;

} catch (PDOException $e) {
    // Handle failures
    echo "A connection error occurred.";

    // Debugging only (Avoid showing this in production!)
    // echo "Detail: " . $e->getMessage();

    exit();
}
?>

Key Concepts

DSN (Data Source Name): A string containing your database info. Always specify charset=utf8mb4 here to prevent security vulnerabilities like SQL injection.
try-catch Block: Database connections can fail for many reasons (wrong password, server down). Always wrap your connection in a try-catch to handle the PDOException gracefully.
Security Tip: Never display $e->getMessage() in a production environment. It can leak sensitive internal info like your database username or host.

3. Essential "Option Settings" for Professionals

You can customize PDO's behavior by passing an "options array" as the fourth argument to new PDO. Here is the standard setup used in professional environments:

<?php
$options = [
    // Throw exceptions on SQL errors (Essential for debugging)
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
    // Return results as an associative array by default
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    // Disable prepared statement emulation for better security
    PDO::ATTR_EMULATE_PREPARES => false,
];

try {
    $dbh = new PDO($dsn, $user, $password, $options);
    echo "Connected with optimized settings!";
} catch (PDOException $e) {
    error_log($e->getMessage()); // Record details in the server log instead of the screen
}
?>

ATTR_ERRMODE: Ensures that any SQL error triggers an exception that you can catch.
ATTR_DEFAULT_FETCH_MODE: Setting this to FETCH_ASSOC ensures you get clean associative arrays (column names as keys) without duplicated numeric indices, saving memory.
ATTR_EMULATE_PREPARES: Setting this to false forces PDO to use the database's native prepared statements, which is safer.

4. Connecting to PostgreSQL

The beauty of PDO is that the code structure remains the same. You only change the DSN prefix.

// PostgreSQL DSN uses 'pgsql:' instead of 'mysql:'
$dsn = 'pgsql:dbname=my_database;host=localhost;port=5432';
$user = 'postgres_user';
$password = 'password123';

5. Troubleshooting Checklist

If you see an error like SQLSTATE[...], check these points:

Credentials: Double-check for typos in your DB name, username, or password.
Host and Port: If your DB is in a Docker container or on a remote server, localhost won't work. Also, check if your port (MySQL: 3306, Postgres: 5432) is custom.
Drivers: Ensure the PDO driver is enabled in your php.ini. Check phpinfo() for pdo_mysql or pdo_pgsql.
Localhost vs. 127.0.0.1: On Linux/Mac, localhost attempts a socket connection. If that fails, using 127.0.0.1 switches to a TCP/IP connection, which often solves the issue.

Conclusion

PDO is the gold standard for database interaction in PHP. By mastering the DSN structure and using proper exception handling, you can write secure, portable, and professional-grade code that works across multiple database systems.

Originally published at: [https://code-izumi.com/php/database-connection/]

Java Naming Conventions: The Definitive Guide for Class Names and Best Practices

ライフポータル — Tue, 03 Feb 2026 01:09:23 +0000

In Java programming, naming conventions for classes are a critical factor that determines code quality. If you follow the mindset of "it doesn't matter as long as it works," you risk creating significant confusion for your future self and your teammates.

Naming is not just about aesthetics; it’s about communication. In this guide, we’ll cover the absolute rules for Java class names, good vs. bad examples, and how they differ from methods and variables.

Mastering these global standards is the first step toward writing beautiful, professional code.

1. Core Rules for Java Class Names

Java class names follow a set of long-established conventions and official recommendations. Adhering to these allows any developer to identify a "Class" at a glance, drastically improving development efficiency.

Use PascalCase (UpperCamelCase)

The golden rule for Java class names is PascalCase (also known as UpperCamelCase). This means the first letter of every word is capitalized, and no underscores are used as separators.

For example, a class representing a "user account" should be named UserAccount, not useraccount or user_account. This distinction makes classes instantly distinguishable from methods and variables, which typically start with a lowercase letter.

Use Nouns

Since a class is a blueprint for an "object" or a "concept," its name should be a noun. Verbs are reserved for methods (actions).

Correct: Calculator
Incorrect: Calculate

Try to choose words that represent the "subject" or the "object" performing the task, rather than the task itself.

Be Specific and Meaningful

An ideal class name tells the reader exactly what the class does or what data it holds. Avoid overly abstract names like Manager or Data, as they tend to become "God Classes" (classes that do too much).

Instead, add context: LoginManager or CustomerData. Don't fear long names; accuracy is far more valuable than brevity in modern software engineering.

2. Good vs. Bad Examples

Let’s compare some practical examples to see these rules in action.

The "Good" List

These names follow PascalCase, use nouns, and have clear roles:

// Represents customer information
public class Customer { ... }

// Handles business logic for product orders
public class OrderService { ... }

// Processes HTTP requests
public class HttpRequestHandler { ... }

The "Bad" List

Avoid these patterns to keep your codebase maintainable:

// BAD: Starts with lowercase (looks like a variable)
public class customer { }

// BAD: Uses underscores (not standard for Java classes)
public class Order_Service { }

// BAD: Use of a verb
public class Save { }

// BAD: Too vague
public class Info { }

// BAD: Cryptic abbreviations
public class CustMngSys { }

3. Comparison with Other Java Identifiers

To avoid confusion, it is essential to understand how class naming differs from other elements in Java.

Element	Convention	Example
Class	PascalCase	`UserProfile`
Method	camelCase	`updateEmail()`
Variable	camelCase	`userName`
Constant	UPPER_SNAKE_CASE	`MAX_RETRY_COUNT`
Package	lowercase	`com.example.project`

By following these distinct styles, you can look at a line of code and instantly know whether you are looking at a Type (Class), an action (Method), or a fixed value (Constant).

4. Why Follow Naming Conventions?

Readability: Consistent naming makes code read like a story. You won't waste mental energy wondering "is this a class or an instance?"
Team Collaboration: Conventions act as a "common language." During code reviews, teams can focus on logic rather than debating formatting.
Bug Prevention: When things are named correctly, incorrect usage "looks" wrong. Assigning a Product instance to a variable named customer triggers an immediate mental red flag.

5. FAQs and Precautions

Can I use numbers or Japanese?

Technically, Java allows numbers in class names, but they cannot be at the beginning (e.g., 1stClass is a syntax error). While Japanese characters are supported, they are strongly discouraged in professional environments due to encoding issues and input friction. Stick to alphanumeric English.

Should I use abbreviations?

Use only universally recognized abbreviations (e.g., ID, URL, HTTP). Avoid custom abbreviations like Mgr for Manager or Svc for Service. Modern IDEs have excellent auto-completion, so there is no penalty for using full, descriptive names.

Avoid Reserved Keywords

You cannot use Java keywords (e.g., class, public, int, return) as class names. If you need a similar name, combine it with another word, such as MainClass or InternalData.

Conclusion

Naming is a fundamental skill of a professional developer. By sticking to PascalCase, using Nouns, and prioritizing Specific Meaning, you ensure that your Java code remains clean, understandable, and scalable.

Originally published at: [https://code-izumi.com/java/class-naming-conventions/]

Mastering Python Substrings: Guide to Extract, Check, Search, and Replace

ライフポータル — Mon, 02 Feb 2026 06:28:46 +0000

When working with text data in Python, performing operations like checking for a specific word or extracting a particular segment is fundamental to almost every program.

Do you find yourself asking:

"How do I cut out text between two specific characters?"
"How can I find strings in a list that match a certain pattern?"
"How do I extract just the last few characters of a string?"

These common string manipulation hurdles can be solved instantly by mastering Python’s built-in features. In this guide, we’ll break down the essential techniques for Extracting, Checking, Searching, and Replacing substrings in a way that’s easy to understand for beginners and pros alike.

1. Checking if a Substring "Exists"

Checking for a keyword is one of the most frequent operations in conditional logic. Python provides the intuitive in operator and specific methods for checking the start or end of a string.

The Simple `in` Operator

The most Pythonic way to check if a string contains another string is using the in operator.

text = "Python is a powerful language for data analysis."
keyword = "data analysis"

if keyword in text:
    print(f"Found: '{keyword}'")
else:
    print("Not found.")

The result is a boolean (True/False), making it perfect for if statements. To check for the absence of a word, use not in for highly readable code.

Using `startswith` and `endswith`

To check if a string matches a specific pattern at the beginning or end, these dedicated methods are extremely useful.

filename = "report_2026_analysis.csv"

# Check prefix
if filename.startswith("report"):
    print("This is a report file.")

# Check suffix
if filename.endswith(".csv"):
    print("This is a CSV format file.")

2. Extraction: The Power of "Slicing"

Extracting a specific range of characters (e.g., from the 3rd to the 8th character) is called "Slicing."

Basic Slicing Logic

Slicing uses the format [start:end]. Remember: Python indices start at 0, and the character at the "end" index is NOT included.

s = "Programming"

# Extract from index 0 to 3 (0, 1, 2)
print("First 3 chars:", s[0:3]) # Pro

# Omit start to begin from the beginning
print("Up to index 5:", s[:5]) # Progr

# Omit end to go to the very end
print("From index 2 onwards:", s[2:]) # ogramming

Negative Indexing (From the end)

To count from the end of the string, use negative numbers. This is perfect when the string length is dynamic.

url = "[https://example.com/item/12345](https://example.com/item/12345)"

# Extract the last 5 characters
item_id = url[-5:]
print("Item ID:", item_id) # 12345

# Remove the last character
prefix = url[:-1]
print("All but last char:", prefix)

In Python, the last character is -1, the second to last is -2, and so on.

3. Searching: Locating Substrings

If you need to know where a word starts, you need a search method.

`find` vs. `index`

Both locate a substring, but they handle missing items differently:

find(): Returns the starting index if found, and -1 if not found.
index(): Raises a ValueError if not found.

Generally, find() is preferred for safety unless you specifically want to trigger an error.

sentence = "Python is easy to learn and has many libraries."
pos = sentence.find("easy")

if pos != -1:
    print(f"The word 'easy' starts at index {pos}.")

Dynamic Extraction

By combining search and slicing, you can extract text up to a certain symbol, such as an email username.

email = "suzuki_ichiro@example.jp"
at_pos = email.find("@")

if at_pos != -1:
    user_name = email[:at_pos]
    print("Username:", user_name)

4. Advanced: Regex and Replacement

Extracting "Enclosed" Text

For complex patterns like "extracting text inside brackets," use the re (regular expression) module.

import re

text = "Price: [1,200 JPY], Shipping: [500 JPY]"

# Extract everything between [ ] using non-greedy match (?)
results = re.findall(r"\[(.*?)\]", text)

for price in results:
    print("Found:", price)

The ? in .*? is crucial. It ensures "shortest match" so that Python extracts content from each pair of brackets individually instead of merging them into one big block.

Replacing Substrings

Use the replace() method to swap parts of a string.

original = "The weather is sunny. Let's enjoy the sunny day."

# Replace "sunny" with "rainy"
new_text = original.replace("sunny", "rainy")
print(new_text)

Conclusion

Mastering substrings turns messy text data into structured information.

Use in for simple checks.
Use Slicing [:] for position-based extraction.
Use find() to locate starting points dynamically.
Use Regex for complex "enclosed" patterns.

Originally published at: [https://code-izumi.com/python/substring/]

Java Infinite Loops: How to Create, Stop, and Debug (while and for Loops)

ライフポータル — Sun, 01 Feb 2026 05:44:40 +0000

While learning Java, you might intentionally want to keep a process running forever, or you might accidentally create a program that won't stop. Both scenarios involve what we call an Infinite Loop.

Used correctly, infinite loops are powerful tools for resident programs or servers. However, when triggered unintentionally, they become bugs that cause application freezes and CPU spikes.

In this guide, we’ll cover how to correctly implement infinite loops in Java using while and for statements, how to safely exit them using break, and how to perform an emergency stop in modern development environments like Eclipse and IntelliJ.

1. Two Basic Syntaxes for Infinite Loops

There are two primary ways to create a never-ending loop in Java. While they function identically, the choice usually comes down to readability and coding style.

Using `while(true)`

This is the most common and readable method. By passing the boolean literal true as the condition, the loop continues indefinitely.

public class WhileLoopExample {
    public static void main(String[] args) {
        // Infinite loop using 'while'
        while (true) {
            System.out.println("This process repeats forever...");

            // Adding a sleep to prevent overwhelming the console
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Since it clearly states "loop while true," it's the most intuitive choice for most developers.

Using `for(;;)`

You can also create an infinite loop by omitting all three expressions in a for statement.

public class ForLoopExample {
    public static void main(String[] args) {
        // Infinite loop using 'for'
        for (;;) {
            System.out.println("Inside a for-based infinite loop.");

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

The for(;;) syntax is a traditional idiom inherited from C. It’s interpreted as "no condition = no end." While slightly less intuitive for beginners, it is frequently seen in legacy code or high-performance libraries.

2. Exiting Safely with the `break` Statement

In reality, very few programs truly need to run "forever." Most systems require a way to exit the loop once a specific condition is met. This is achieved using the break statement.

Example: Exit via User Input

import java.util.Scanner;

public class BreakLoopExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter text (type 'exit' to quit):");

        while (true) {
            System.out.print("> ");
            String input = scanner.nextLine();

            if ("exit".equals(input)) {
                System.out.println("Exiting loop...");
                break; // Jumps out of the while block
            }

            System.out.println("You entered: " + input);
        }

        System.out.println("Program terminated.");
        scanner.close();
    }
}

In this pattern, the loop runs indefinitely until the if condition triggers the break. This is the standard best practice for handling "deliberate" infinite loops.

3. How to Force-Stop a Running Loop

If a loop gets out of control due to a bug, you need to know how to kill the process.

In IDEs (Eclipse / IntelliJ IDEA)

Look for the Red Square Icon in your console view.

Eclipse: Click the "Terminate" button in the Console toolbar.
IntelliJ IDEA: Click the "Stop" icon on the left side of the Run window.

In Terminal / Command Line

If you are running the java command directly:

Windows / Mac / Linux: Press Ctrl + C. This sends an interrupt signal to the process and kills it immediately.

4. Common Pitfalls and Prevention

Unintended infinite loops often stem from logic errors. Here are the most common culprits:

Forgetting to Update the Counter: If you use a manual counter in a while loop but forget to increment it (e.g., i++), the condition will never become false.
Logic Flaws in Conditions: Using > when you meant < can result in a condition that is always true.
Floating Point Comparison: Avoid using == with double or float types for loop control. Precision errors can prevent the value from ever being exactly equal to your target, causing the loop to skip its exit point.

5. Real-World Use Cases

"Infinite loop" doesn't always mean a bug. Here are three common professional uses:

Server Applications: Web servers and chatbots use infinite loops to "listen" for incoming requests 24/7.
Input Validation: Prompting a user repeatedly until they enter a valid value.
Game Loops: Games use a main loop to constantly update graphics and calculate character movement at 60+ frames per second.

Conclusion

Understanding infinite loops is key to mastering program control flow. Whether you use while(true) for its readability or for(;;) for its classic style, always ensure you have a clear exit strategy to keep your applications stable and efficient.

Originally published at: [https://code-izumi.com/java/infinite-loop/]

PHP Memory Management: How to Monitor Usage, Peaks, and Limits

ライフポータル — Sat, 31 Jan 2026 09:02:11 +0000

When processing large datasets or running long-running batch scripts in PHP, you may encounter the dreaded error: "Fatal error: Allowed memory size of... exhausted".

To maintain application performance and prevent unexpected crashes, it is essential to accurately monitor how much memory your script is consuming. In this guide, we’ll explain how to use built-in functions like memory_get_usage(), how to format the output into human-readable units (MB/KB), and how to adjust memory limits (memory_limit) to suit your environment.

1. Checking Current Usage: `memory_get_usage()`

To find out the "instantaneous" memory consumption at any point in your script, use memory_get_usage(). This function returns the amount of memory allocated to the script in bytes (int).

Basic Usage and Real Memory

Running the function without arguments returns the memory currently used by the PHP memory manager. By passing true as the first argument, you can get the total memory actually allocated from the system (OS).

<?php
// Memory before creating an array
echo "Initial: " . number_format(memory_get_usage()) . " bytes\n";

// Consume memory by creating a large array
$array = range(1, 100000);

// Memory after creation
echo "After Array: " . number_format(memory_get_usage()) . " bytes\n";

// Total memory allocated from the system
echo "Real Memory: " . number_format(memory_get_usage(true)) . " bytes\n";
?>

Why check real memory?
The value returned by memory_get_usage(true) is often larger than the actual usage because PHP allocates memory in chunks. Checking this value is helpful when designing server resource requirements.

2. Checking Peak Usage: `memory_get_peak_usage()`

A script might crash not because its average usage is high, but because it hit a peak limit for a split second. To find the highest memory point reached during script execution, use memory_get_peak_usage().

<?php
$data = [];
for ($i = 0; $i < 50000; $i++) {
    $data[] = md5($i);
}

// Release memory
unset($data);

echo "Current: " . number_format(memory_get_usage()) . " bytes\n";
echo "Peak: " . number_format(memory_get_peak_usage()) . " bytes\n";
?>

Even if you use unset() to free up memory later, memory_get_peak_usage() will remember the maximum point reached. This is critical for troubleshooting memory-intensive batch processes.

3. Formatting Bytes to Human-Readable Units

Since these functions return raw bytes, the numbers can get very long. It's much easier to read "12 MB" than "12582912 bytes." Here is a standard helper function to format the output:

<?php
/**
 * Formats bytes into KB, MB, GB, etc.
 */
function formatBytes($bytes, $precision = 2) {
    $units = ['B', 'KB', 'MB', 'GB', 'TB'];

    if ($bytes <= 0) return '0 B';

    $pow = floor(log($bytes) / log(1024));
    $unit = isset($units[$pow]) ? $units[$pow] : 'TB';

    // Convert bytes using bit shifting (1024^pow)
    $bytes /= (1 << (10 * $pow));

    return round($bytes, $precision) . ' ' . $unit;
}

echo "Current Usage: " . formatBytes(memory_get_usage()) . "\n";
echo "Peak Usage: " . formatBytes(memory_get_peak_usage()) . "\n";
?>

4. Managing the `memory_limit`

PHP has a built-in safety cap for how much memory a single script can use.

Checking the Current Limit

You can retrieve the memory_limit value defined in your php.ini using ini_get():

<?php
echo "Current Limit: " . ini_get('memory_limit'); // e.g., "128M"
?>

Temporarily Increasing the Limit

If you have a specific heavy task, you can override the limit for that script's duration using ini_set().

<?php
// Increase limit to 512MB
ini_set('memory_limit', '512M');

// Set to unlimited (use with extreme caution)
// ini_set('memory_limit', '-1');

5. Tips for Reducing Memory Consumption

Monitoring is the first step, but writing memory-efficient code is the ultimate goal.

Use unset(): Manually destroy large arrays or objects once they are no longer needed.
Avoid fetchAll() for Large Queries: When fetching thousands of rows from a database, don't load them all into an array at once. Use fetch() row-by-row or use Generators (yield).
Chunking Data: In frameworks like Laravel, use methods like chunk() or cursor() to load only a subset of data into memory at a time.

Conclusion

Effective memory management in PHP is about knowing your peaks, not just your averages. By integrating memory_get_peak_usage() into your logging and using ini_set judiciously, you can build robust applications that scale without crashing.

Originally published at: [https://code-izumi.com/php/check-memory-usage/]

Python for Loops with Index: Mastering the enumerate() Function

ライフポータル — Fri, 30 Jan 2026 01:58:02 +0000

When working with lists or tuples in Python, using a for loop to iterate through elements is a daily task for any developer.

Often, you'll encounter a specific need:

"I want to get the value of the element, but I also need to know its index (position) at the same time."

If you're coming from languages like C or Java, you might be tempted to manually manage a counter variable or loop through the length of the array. However, Python offers a more elegant and "Pythonic" way to handle this.

In this guide, we’ll explore the enumerate() function—the best practice for indexed loops—and compare it with other common methods.

1. The Best Practice: `enumerate()`

The most recommended way to get both the index and the element in a loop is by using the built-in enumerate() function. It eliminates the need to track a counter manually or call len() on your list.

Basic Usage

To use enumerate(), simply pass your list to the function. It returns pairs of (index, element), which you can "unpack" directly in the for statement.

fruits = ["apple", "banana", "cherry"]

# Get index and element simultaneously
for i, fruit in enumerate(fruits):
    print(f"Index: {i}, Value: {fruit}")

Output:

Index: 0, Value: apple
Index: 1, Value: banana
Index: 2, Value: cherry

Starting the Index from 1 (or any number)

By default, Python indices start at 0. If you’re displaying a ranking or a list for human readers, you might want to start from 1 instead. You can do this easily with the start argument.

fruits = ["apple", "banana", "cherry"]

# Start counting from 1
for i, fruit in enumerate(fruits, start=1):
    print(f"Item {i}: {fruit}")

Output:

Item 1: apple
Item 2: banana
Item 3: cherry

This is much cleaner than writing i + 1 inside your loop and makes your intention clear to anyone reading your code.

2. Alternative Methods (and why they are less ideal)

While enumerate() is the standard, you might see other methods in older codebases. It’s important to understand why they are generally avoided in modern Python.

Using `range()` and `len()`

This is the "traditional" style often seen in C-style programming.

fruits = ["apple", "banana", "cherry"]

for i in range(len(fruits)):
    print(f"Index: {i}, Value: {fruits[i]}")

The Downside: This is more verbose and requires you to access the list via fruits[i] in every iteration. It’s harder to read and more prone to errors.

Manual Counter Management

fruits = ["apple", "banana", "cherry"]

i = 0
for fruit in fruits:
    print(f"Index: {i}, Value: {fruit}")
    i += 1  # Incrementing manually

The Risk: If you forget to increment i, your index stays at 0. In while loops, forgetting this can even lead to infinite loops. There is almost no reason to use this pattern in a for loop.

3. Advanced Usage

Combining `enumerate()` with `zip()`

If you need to loop through two lists at once (e.g., Names and Ages) and still need an index, you can combine enumerate and zip.

names = ["Tanaka", "Sato", "Suzuki"]
ages = [25, 30, 28]

for i, (name, age) in enumerate(zip(names, ages)):
    print(f"ID: {i}, Name: {name}, Age: {age}")

Pro Tip: Notice the parentheses in (name, age). This explicitly unpacks the tuple returned by zip.

Using `enumerate()` with Dictionaries

Since Python 3.7+, dictionaries maintain insertion order. You can use enumerate on .items() to track how many records you’ve processed.

user_scores = {"Tanaka": 80, "Sato": 95, "Suzuki": 60}

for i, (name, score) in enumerate(user_scores.items()):
    print(f"User #{i+1}: {name} scored {score}")

Conclusion

The enumerate() function is a prime example of why Python is loved for its readability. It turns a common, potentially messy task into a clean, one-line operation.

Use enumerate(list) for standard index tracking.
Use start=1 for human-readable numbering.
Avoid range(len()) unless you have a specific reason to modify the list by index.

Originally published at: [https://code-izumi.com/python/for-index-enumerate/]

PHP Associative Arrays: Mastering array_keys, foreach, and Search Functions

ライフポータル — Thu, 29 Jan 2026 09:53:25 +0000

In PHP web development, you deal with complex associative arrays almost every day—whether they are database results or API responses.

Commonly, you'll find yourself needing to:

"Extract the keys instead of the values."
"Identify keys that meet a specific condition."
"Look up a key based on a known value."

PHP offers a vast array of built-in functions, and choosing the right one is key to writing clean, efficient code. In this guide, we’ll cover everything from the standard array_keys to modern best practices introduced in PHP 7.3+.

1. Extracting All Keys: `array_keys()`

If you need a list of every key in an associative array, the standard array_keys() function is your go-to tool. It returns a new indexed array containing only the keys.

Basic Usage

<?php
$userData = [
    'name'   => 'Taro Tanaka',
    'age'    => 28,
    'gender' => 'male',
    'city'   => 'Tokyo'
];

// Get all keys
$keys = array_keys($userData);

print_r($keys);
?>

Output:

Array
(
    [0] => name
    [1] => age
    [2] => gender
    [3] => city
)

This is particularly useful when you need to generate header rows for CSV exports or verify if a set of required parameters is present.

Filtering by Value

A lesser-known feature of array_keys() is its second argument, which allows you to extract only the keys that match a specific value.

$scores = ['UserA' => 80, 'UserB' => 100, 'UserC' => 80];
$targetKeys = array_keys($scores, 80);

// Result: ['UserA', 'UserC']

2. Iterating Through Keys: `foreach`

In real-world applications, you often need to process both the key and the value simultaneously. The foreach loop is the most common and readable way to achieve this.

The Key-Value Syntax

<?php
$products = [
    'apple'  => 150,
    'orange' => 100,
    'banana' => 200
];

foreach ($products as $name => $price) {
    echo "The price of " . $name . " is " . $price . " yen.\n";
}
?>

By using the $key => $value syntax, you gain direct access to the key within the loop. Choosing descriptive variable names (like $name and $price instead of $k and $v) is a pro-tip for keeping your code maintainable.

3. Reverse Lookup: `array_search()`

If you have a value and want to find its corresponding key, use array_search().

Important Limitation

<?php
$members = [101 => 'Suzuki', 102 => 'Tanaka', 103 => 'Yamada', 104 => 'Tanaka'];

// Search for the key where the value is 'Tanaka'
$id = array_search('Tanaka', $members);

var_dump($id); // int(102)
?>

Caution: array_search() only returns the first matching key and then stops. In the example above, even though 'Tanaka' exists at ID 104, only 102 is returned. If no match is found, it returns false.

4. Modern Best Practices: First and Last Keys

Before PHP 7.3, getting the first or last key of an array required messy pointer manipulations. Now, we have dedicated functions that are both safe and fast.

`array_key_first()` and `array_key_last()`

<?php
$fruits = ['red' => 'Apple', 'yellow' => 'Banana', 'purple' => 'Grape'];

$firstKey = array_key_first($fruits); // 'red'
$lastKey  = array_key_last($fruits);  // 'purple'
?>

These functions do not affect the internal array pointer, making them highly efficient for quick lookups at the boundaries of your data.

5. Checking for Existence: `array_key_exists()`

Before trying to retrieve or use a key, it’s often necessary to check if it actually exists.

Why not `isset()`?

While isset() is commonly used, it returns false if the key exists but the value is null. To strictly check for the presence of a key, always use array_key_exists().

<?php
$config = ['host' => 'localhost', 'pass' => null];

array_key_exists('pass', $config); // true
isset($config['pass']);            // false
?>

Conclusion

Choosing the right array function depends on your specific needs:

Bulk extraction? Use array_keys().
Looping? Use foreach.
Reverse lookup? Use array_search().
Existence check? Use array_key_exists().

Mastering these basic but powerful tools is essential for any professional PHP developer aiming for clean and robust codebases.

Originally published at: [https://code-izumi.com/php/associative-array-keys/]

Python String Manipulation: Every Way to Delete Specific Characters

ライフポータル — Wed, 28 Jan 2026 04:12:07 +0000

When processing text data in Python, you frequently run into these scenarios:

"I want to remove extra whitespace."
"I need to bulk-delete specific symbols."
"I want to remove elements from a list that contain certain words."

While it all falls under "deletion," the method you should use depends on whether you are modifying a String or a List. Python has also introduced more intuitive methods in recent versions that make these tasks much simpler.

In this guide, we’ll dive into every major technique for deleting characters in Python, covering both string and list operations with practical code examples and modern best practices.

Basic Techniques for String Deletion

In Python, strings are immutable, meaning you cannot modify the original string directly. Instead, these methods return a new string with the characters removed.

1. `replace()`: Delete All Occurrences

To remove a specific character or substring everywhere it appears, use the replace() method by replacing it with an empty string "".

text = "Python-is-fun-and-powerful"

# Replace hyphen "-" with an empty string ""
cleaned_text = text.replace("-", "")

print(f"Original: {text}")
print(f"Cleaned : {cleaned_text}")
# Output: Pythonisfunandpowerful

You can also limit the number of deletions by providing a third argument: text.replace("-", "", 2) will only remove the first two hyphens.

2. `strip()`: Remove Leading and Trailing Characters

To clean up unwanted characters (like spaces or newlines) only at the start or end of a string, use the strip family of methods:

strip(): Removes from both ends.
lstrip(): Removes from the left (start) only.
rstrip(): Removes from the right (end) only.

text = "   Hello Python!   "

print(f"strip : '{text.strip()}'")   # 'Hello Python!'
print(f"lstrip: '{text.lstrip()}'")  # 'Hello Python!   '
print(f"rstrip: '{text.rstrip()}'")  # '   Hello Python!'

By default, these remove whitespace, but you can specify a set of characters like text.strip("*").

3. `removeprefix()` and `removesuffix()` (Python 3.9+)

Added in Python 3.9, these are the best practices for removing a specific word only if it appears at the very beginning or end of a string.

filename = "report_2026.txt"

# Remove prefix "report_"
name_only = filename.removeprefix("report_")

# Remove suffix ".txt"
base_name = filename.removesuffix(".txt")

print(f"Prefix removed: {name_only}") # 2026.txt
print(f"Suffix removed: {base_name}") # report_2026

Unlike lstrip(), which treats the input as a set of individual characters to prune, removeprefix() treats it as a single exact string, making it much safer for filenames and IDs.

Advanced Pattern Deletion

1. `translate()`: Delete Multiple Different Characters at Once

If you need to delete a whole set of symbols (e.g., vowels or punctuation), chaining replace() multiple times is inefficient. Using translate() with str.maketrans() is much faster.

text = "p-y+t=h/o.n"

# Create a mapping table (the 3rd argument specifies characters to delete)
table = str.maketrans("", "", "-+=/.")

cleaned_text = text.translate(table)
print(cleaned_text) # python

2. `re.sub()`: Regex-Based Deletion

For pattern-based deletion—like "remove all numbers" or "remove everything except letters"—the re (regular expression) module is your best friend.

import re

text = "Python 3.14 is released in 2025."

# Delete all digits (\d)
no_digits = re.sub(r"\d+", "", text)

# Delete everything except letters and spaces
only_alpha = re.sub(r"[^a-zA-Z\s]", "", text)

print(f"No digits: {no_digits}")
print(f"Letters only: {only_alpha}")

Deleting Specific Elements from a List

When dealing with a list of strings, the logic changes from "modifying a string" to "filtering a collection."

1. `remove()` vs. `pop()`

remove(value): Deletes the first occurrence of a specific value.
pop(index): Deletes the element at a specific position and returns it.

fruits = ["apple", "banana", "orange", "banana"]

fruits.remove("banana") # Removes only the first banana
print(fruits) # ['apple', 'orange', 'banana']

removed_item = fruits.pop(1) # Removes 'orange'
print(fruits) # ['apple', 'banana']

2. List Comprehension: Bulk Filtering

The most Pythonic way to remove all elements that meet a certain condition is to use a List Comprehension. Instead of "deleting," you "keep" the ones you want.

files = ["data.csv", "image.jpg", "backup.csv", "memo.txt"]

# Remove all files containing ".csv" (Keep files if ".csv" is NOT in f)
filtered_files = [f for f in files if ".csv" not in f]

print(filtered_files) # ['image.jpg', 'memo.txt']

Conclusion

The right way to "delete" in Python depends on the scope. For exact matches in strings, replace() or removeprefix() are your best bets. For complex patterns, use re.sub(). When cleaning up lists, List Comprehension is almost always the most efficient and readable choice.

Originally published at: [https://code-izumi.com/python/delete-specific-character/]

DEV Community: ライフポータル

4 Ways to Concatenate Arrays in Java: From System.arraycopy to Stream API

1. The Fastest Method: System.arraycopy()

Example: Concatenating two int arrays

2. The Modern Way: Stream API (Java 8+)

Example: Concatenating String arrays

3. Joining Array Elements into a Single String

Example: Creating a comma-separated string

4. Using List (ArrayList) for Flexibility

Example: Using Collections.addAll()

Extra: Concatenating byte[] for Binary Data

Conclusion

Python Block Comments: Best Practices, Shortcuts, and Docstrings Explained

Does Python Have a Block Comment Syntax?

Method 1: Using "#" on Every Line (Recommended)

Why this is the Best Practice:

Pro Tip: Editor Shortcuts for Bulk Commenting

Method 2: Using Triple Quotes """ (The Pseudo-comment)

⚠️ Warning: The Indentation Trap

Block Comments vs. Docstrings

Conclusion

Mastering "uv" in VS Code: The Ultra-Fast Python Setup Guide

What is "uv"?

Step 1: Installing uv

Mac / Linux

Windows (PowerShell)

Step 2: Getting VS Code to Recognize uv

1. Initialize and Create venv

2. Select the Interpreter

Step 3: Package Management (uv add / sync)

Step 4: Debugging Configuration (launch.json)

Pro Tip: Integration with Ruff

Conclusion

PHP Random String Generation: Best Practices for Passwords, IDs, and Tokens

1. Security First: Cryptographically Secure Strings

Recommended: random_bytes and bin2hex

2. Generating Custom Alphanumeric Strings

Flexible and Secure Generator Function

3. Simple Strings for Non-Secure Use Cases

Using str_shuffle

4. Generating Unique IDs with uniqid

Basic vs. High-Precision IDs

Conclusion

PHP Database Connection: A Beginner’s Guide to PDO (MySQL & PostgreSQL)

1. Why Choose PDO Over mysqli?

2. Connecting to MySQL with PDO

The Basic Connection Script

Key Concepts

3. Essential "Option Settings" for Professionals

4. Connecting to PostgreSQL

5. Troubleshooting Checklist

Conclusion

Java Naming Conventions: The Definitive Guide for Class Names and Best Practices

1. Core Rules for Java Class Names

Use PascalCase (UpperCamelCase)

Use Nouns

Be Specific and Meaningful

2. Good vs. Bad Examples

The "Good" List

The "Bad" List

3. Comparison with Other Java Identifiers

4. Why Follow Naming Conventions?

5. FAQs and Precautions

Can I use numbers or Japanese?

Should I use abbreviations?

Avoid Reserved Keywords

Conclusion

Mastering Python Substrings: Guide to Extract, Check, Search, and Replace

1. Checking if a Substring "Exists"

The Simple in Operator

Using startswith and endswith

2. Extraction: The Power of "Slicing"

Basic Slicing Logic

Negative Indexing (From the end)

3. Searching: Locating Substrings

find vs. index

Dynamic Extraction

4. Advanced: Regex and Replacement

Extracting "Enclosed" Text

Replacing Substrings

1. The Fastest Method: `System.arraycopy()`

Example: Concatenating two `int` arrays

Example: Concatenating `String` arrays

4. Using `List` (ArrayList) for Flexibility

Example: Using `Collections.addAll()`

Extra: Concatenating `byte[]` for Binary Data

Method 2: Using Triple Quotes `"""` (The Pseudo-comment)

Step 3: Package Management (`uv add` / `sync`)

Step 4: Debugging Configuration (`launch.json`)

Recommended: `random_bytes` and `bin2hex`

Using `str_shuffle`

4. Generating Unique IDs with `uniqid`

The Simple `in` Operator

Using `startswith` and `endswith`

`find` vs. `index`

Using `while(true)`

Using `for(;;)`

2. Exiting Safely with the `break` Statement

1. Checking Current Usage: `memory_get_usage()`

2. Checking Peak Usage: `memory_get_peak_usage()`

4. Managing the `memory_limit`

1. The Best Practice: `enumerate()`

Using `range()` and `len()`

Combining `enumerate()` with `zip()`

Using `enumerate()` with Dictionaries

1. Extracting All Keys: `array_keys()`

2. Iterating Through Keys: `foreach`

3. Reverse Lookup: `array_search()`

`array_key_first()` and `array_key_last()`

5. Checking for Existence: `array_key_exists()`

Why not `isset()`?

1. `replace()`: Delete All Occurrences

2. `strip()`: Remove Leading and Trailing Characters

3. `removeprefix()` and `removesuffix()` (Python 3.9+)

1. `translate()`: Delete Multiple Different Characters at Once

2. `re.sub()`: Regex-Based Deletion

1. `remove()` vs. `pop()`