This article details how to generate a dot string of specified length in Java and replace one of the dots with other characters (such as '#') at a specific position without using an array. The tutorial will demonstrate an efficient and easy-to-understand string building strategy through StringBuilder and the String.repeat() method, and cover boundary condition handling to ensure the robustness and reusability of the code.

Tutorial: Replace characters in dot string at specified position in Java

In Java programming, we often need to operate on strings, such as inserting, replacing, or deleting characters at specific positions. This tutorial teaches you how to implement a method that accepts two integer parameters: one that specifies the total length of the string, and one that specifies the position of the replacement character. Ultimately, it will generate a string consisting of dots, replacing a dot with a special character (e.g. '#') at the specified position.

Problem statement

Our goal is to create a Java method that accepts two integer parameters:

1. length: The total length of the generated string.
2. position: The index position (0-based) at which the replacement character (e.g. '#') should appear.

For example, if length is 10 and position is 4, the expected output should be....#.... During implementation, we will focus on solutions that do not use Java arrays.

Core concepts and methods

Implementing this function mainly relies on the following Java string manipulation tools:

1. String.repeat(int count) : This method was introduced in Java 11 and above and is used to repeat the current string a specified number of times. This makes it very concise to generate a string of identical characters (such as dots).
2. StringBuilder : String objects in Java are immutable. When strings need to be modified frequently, StringBuilder provides a variable sequence that can more efficiently append, insert, and replace characters without generating a large number of intermediate String objects.

Initial ideas and improvements

When solving such problems, a common idea is to first generate a complete dot string, and then use StringBuilder's setCharAt() method to replace characters at the specified position.

 public static String replaceCharWithSetCharAt(int length, int position) {
    if (position = length) {
        // Handle the situation where the position is out of bounds System.err.println("Error: The position exceeds the string length range.");
        return ""; // or throw an exception}
    String initialDots = ".".repeat(length);
    StringBuilder sb = new StringBuilder(initialDots);
    sb.setCharAt(position, '#');
    return sb.toString();
}

The above method works, it first creates all points and then modifies specific locations. However, we can also adopt a more direct construction method by concatenating it piecewise to avoid the process of building the entire dot string first and then modifying it, especially when considering the reusability of the method return value.

Recommended solution: Build the string in pieces

The recommended solution utilizes String.repeat() and the append() method of StringBuilder to directly build the target string in a more declarative and efficient manner. This method clearly expresses the composition logic of the string: prefix dots replace character suffix dots.

 public class StringManipulation {

    /**
     * Generate a dot string of specified length and replace it with the '#' character at the specified position.
     *
     * @param length The total length of the string.
     * @param position The index position (0-based) of the replacement character ('#').
     * @return The replaced string. If position exceeds the valid range, '#' or an empty string is returned depending on the situation.
     */
    public static String generateAndReplaceChar(int length, int position) {
        // 1. Boundary condition check // If position exceeds or equals length, it means that the replacement character should be at the end of the string or outside.
        // Depending on specific needs, different results can be returned here.
        // For example, if position == length, it can be regarded as being added at the end.
        // In the example here, if position >= length, a '#' is returned directly, indicating a special case.
        // A more rigorous judgment can be: if (position = length) { throw new IllegalArgumentException(...); }
        if (position = length) {
            // If the position is outside the length, only the replacement character is returned, or a full-dot string can be returned if required.
            // For the sake of simplicity here, '#' is returned directly, indicating that the replacement position is illegal or at the end.
            // Actual applications may require more sophisticated error handling or default behavior.
            return "#";
        }

        // 2. Use StringBuilder to build a string in segments return new StringBuilder()
                //Append position points as prefix.append(".".repeat(position))
                //Append replacement characters.append("#")
                //Append the remaining length - position - 1 point as suffix.append(".".repeat(length - position - 1))
                // Convert StringBuilder to final String
                .toString();
    }

    public static void main(String[] args) {
        // Example usage System.out.println("length 10, position 4: " generateAndReplaceChar(10, 4)); // Output: ....#.....
        System.out.println("Length 5, position 0: " generateAndReplaceChar(5, 0)); // Output: #....
        System.out.println("Length 7, position 6: " generateAndReplaceChar(7, 6)); // Output: ......#
        System.out.println("length 3, position 3: " generateAndReplaceChar(3, 3)); // Output: # (position exceeds the length, special processing)
        System.out.println("Length 5, position -1: " generateAndReplaceChar(5, -1)); // Output: Error: Position cannot be negative. (error handling)
        System.out.println("Length 1, position 0: " generateAndReplaceChar(1, 0)); // Output: #
    }
}

Code analysis

1. if (position = length) : This is the key boundary condition check.
   • position
   • position >= length: If the position is equal to or exceeds the total length of the string, it is also considered illegal or a special case. In the example code, we choose to return "#" to indicate this situation, but in actual application, you may need to throw IllegalArgumentException or return an empty string, depending on your business requirements.
2. new StringBuilder() : Create a new StringBuilder instance for efficient construction of strings.
3. .append(".".repeat(position)) : Generate position points as the part before the replacement character. For example, if position is 4, then....
4. .append("#") : Append the replacement character #.
5. .append(".".repeat(length - position - 1)) : Generate remaining points. The total length minus the used position points and 1 replacement character is the number of suffix points. For example, if length is 10 and position is 4, then the number of suffix points is 10 - 4 - 1 = 5, generating...
6. .toString() : Finally, convert the contents of the StringBuilder to an immutable String object and return it.

Things to note and best practices

• 0-based Indexing : String indexing in Java starts from 0. Please ensure that the position parameter conforms to this convention.
• Error handling : The sample code simply handles the situation where position is out of bounds. In a production environment, it is more robust to throw an IllegalArgumentException so that the caller can handle invalid input explicitly.
• Method Responsibilities : Ensure that methods do only one thing. In this case, the method is responsible for generating and returning the string, rather than printing it. This increases the generality and testability of the method.
• Java version : String.repeat() method requires Java 11 or higher. If your project uses an older Java version, you will need to manually loop to generate repeated strings, or use StringUtils.repeat() from the Apache Commons Lang library.

Summarize

Through this tutorial, you learned how to use StringBuilder and the String.repeat() method to efficiently and elegantly construct a dotted string with characters replaced at specified positions in Java. This method not only avoids the use of arrays, but also makes the code logically clear, easy to understand and maintain, and takes into account common boundary conditions. Mastering these string manipulation skills is essential for daily Java development.

The above is the detailed content of Replace characters in dotted string at specified position in Java. For more information, please follow other related articles on the PHP Chinese website!