programming javascript

Có trình tạo chuỗi trong JavaScript không?

Đối tượng 

public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
7 giống như đối tượng 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
8, ngoại trừ việc chúng có thể được sửa đổi. Bên trong, các đối tượng này được xử lý giống như các mảng có độ dài thay đổi chứa một chuỗi các ký tự. Tại bất kỳ thời điểm nào, độ dài và nội dung của chuỗi có thể được thay đổi thông qua các lời gọi phương thức

Các chuỗi phải luôn được sử dụng trừ khi các trình tạo chuỗi cung cấp lợi thế về mã đơn giản hơn [xem chương trình mẫu ở cuối phần này] hoặc hiệu suất tốt hơn. Ví dụ: nếu bạn cần nối một số lượng lớn các chuỗi, việc thêm vào một đối tượng 

public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
7 sẽ hiệu quả hơn

Chiều dài và công suất

Lớp 

public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
7, giống như lớp 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
8, có phương thức 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
2 trả về độ dài của chuỗi ký tự trong trình tạo

Không giống như chuỗi, mọi trình tạo chuỗi cũng có dung lượng, số khoảng cách ký tự đã được cấp phát. Dung lượng, được trả về bởi phương thức 

public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
3, luôn lớn hơn hoặc bằng độ dài [thường lớn hơn] và sẽ tự động mở rộng khi cần thiết để chứa các phần bổ sung cho trình tạo chuỗi

public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
7 ConstructorsConstructorDescription
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
1Tạo một trình tạo chuỗi trống với dung lượng 16 [16 phần tử trống]. 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
2Xây dựng một trình tạo chuỗi chứa các ký tự giống như 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
3 đã chỉ định, cộng thêm 16 phần tử trống theo sau 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
3. 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
5Tạo trình tạo chuỗi trống với dung lượng ban đầu được chỉ định. 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
6Tạo trình tạo chuỗi có giá trị được khởi tạo bởi chuỗi đã chỉ định, cộng thêm 16 phần tử trống ở cuối chuỗi

Ví dụ, đoạn mã sau

// creates empty builder, capacity 16
StringBuilder sb = new StringBuilder[];
// adds 9 character string at beginning
sb.append["Greetings"];

sẽ tạo ra một trình tạo chuỗi có độ dài 9 và dung lượng 16

Lớp 

public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
7 có một số phương thức liên quan đến độ dài và dung lượng mà lớp 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
8 không có

Độ dài và dung lượng MethodsMethodDescription_______09Đặt độ dài của chuỗi ký tự. Nếu 
public class StringBuilderDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
         
        StringBuilder sb = new StringBuilder[palindrome];
        
        sb.reverse[];  // reverse it
        
        System.out.println[sb];
    }
}
0 nhỏ hơn 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
2, các ký tự cuối cùng trong chuỗi ký tự sẽ bị cắt bớt. Nếu 
public class StringBuilderDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
         
        StringBuilder sb = new StringBuilder[palindrome];
        
        sb.reverse[];  // reverse it
        
        System.out.println[sb];
    }
}
0 lớn hơn 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
2, các ký tự rỗng sẽ được thêm vào cuối chuỗi ký tự. 
public class StringBuilderDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
         
        StringBuilder sb = new StringBuilder[palindrome];
        
        sb.reverse[];  // reverse it
        
        System.out.println[sb];
    }
}
4Đảm bảo rằng công suất ít nhất bằng mức tối thiểu đã chỉ định

Một số thao tác [ví dụ: 

public class StringBuilderDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
         
        StringBuilder sb = new StringBuilder[palindrome];
        
        sb.reverse[];  // reverse it
        
        System.out.println[sb];
    }
}
5, 
public class StringBuilderDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
         
        StringBuilder sb = new StringBuilder[palindrome];
        
        sb.reverse[];  // reverse it
        
        System.out.println[sb];
    }
}
6 hoặc 
public class StringBuilderDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
         
        StringBuilder sb = new StringBuilder[palindrome];
        
        sb.reverse[];  // reverse it
        
        System.out.println[sb];
    }
}
7] có thể tăng độ dài của chuỗi ký tự trong trình tạo chuỗi sao cho kết quả là 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
2 sẽ lớn hơn 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
3 hiện tại. Khi điều này xảy ra, dung lượng sẽ tự động tăng lên

Thao tác StringBuilder

Các hoạt động chính trên 

public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
7 không có sẵn trong 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
8 là các phương thức 
public class StringBuilderDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
         
        StringBuilder sb = new StringBuilder[palindrome];
        
        sb.reverse[];  // reverse it
        
        System.out.println[sb];
    }
}
5 và 
public class StringBuilderDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
         
        StringBuilder sb = new StringBuilder[palindrome];
        
        sb.reverse[];  // reverse it
        
        System.out.println[sb];
    }
}
6, được quá tải để chấp nhận bất kỳ loại dữ liệu nào. Mỗi chuyển đổi đối số của nó thành một chuỗi và sau đó nối thêm hoặc chèn các ký tự của chuỗi đó vào chuỗi ký tự trong trình tạo chuỗi. Phương thức chắp thêm luôn thêm các ký tự này vào cuối chuỗi ký tự hiện có, trong khi phương thức chèn thêm các ký tự tại một điểm đã chỉ định

Dưới đây là một số phương thức của lớp 

public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
7

Khác nhau 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
7 MethodsMethodDescription
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
76Nối đối số vào trình tạo chuỗi này. Dữ liệu được chuyển thành chuỗi trước khi thao tác chắp thêm diễn ra. 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
77Phương thức đầu tiên xóa chuỗi con từ đầu đến cuối-1 [bao gồm] trong chuỗi ký tự của 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
7. Phương pháp thứ hai xóa ký tự nằm ở 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
79. 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
80Chèn đối số thứ hai vào trình tạo chuỗi. Đối số nguyên đầu tiên cho biết chỉ mục trước đó dữ liệu sẽ được chèn vào. Dữ liệu được chuyển đổi thành chuỗi trước khi thao tác chèn diễn ra. 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
81Thay thế [các] ký tự đã chỉ định trong trình tạo chuỗi này. 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
82Đảo ngược chuỗi ký tự trong trình tạo chuỗi này. 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
83Trả về một chuỗi chứa chuỗi ký tự trong trình tạoGhi chú. Bạn có thể sử dụng bất kỳ phương thức 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
8 nào trên đối tượng 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
7 bằng cách chuyển đổi trình tạo chuỗi thành chuỗi bằng phương thức 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
86 của lớp 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
7 trước tiên. Sau đó chuyển đổi chuỗi trở lại thành trình tạo chuỗi bằng cách sử dụng hàm tạo 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
88

Một ví dụ

Chương trình 

public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
89 được liệt kê trong phần có tiêu đề "Chuỗi" là một ví dụ về chương trình sẽ hiệu quả hơn nếu sử dụng 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
7 thay vì 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
8

public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
89 đảo ngược một bảng màu. Đây, một lần nữa, là danh sách của nó

public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}

Chạy chương trình tạo ra kết quả này

Để thực hiện đảo ngược chuỗi, chương trình chuyển đổi chuỗi thành một mảng ký tự [vòng lặp 

public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
73 đầu tiên], đảo ngược mảng thành mảng thứ hai [vòng lặp 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
73 thứ hai], sau đó chuyển đổi ngược lại thành chuỗi

Nếu bạn chuyển đổi chuỗi 

public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
75 thành trình tạo chuỗi, bạn có thể sử dụng phương thức 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
76 trong lớp 
public class StringDemo {
    public static void main[String[] args] {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length[];
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];
        
        // put original string in an 
        // array of chars
        for [int i = 0; i < len; i++] {
            tempCharArray[i] = 
                palindrome.charAt[i];
        } 
        
        // reverse array of chars
        for [int j = 0; j < len; j++] {
            charArray[j] =
                tempCharArray[len - 1 - j];
        }
        
        String reversePalindrome =
            new String[charArray];
        System.out.println[reversePalindrome];
    }
}
7. Nó làm cho mã đơn giản và dễ đọc hơn

Làm cách nào để tạo chuỗi trong JavaScript?

Trong JavaScript, có ba cách để viết một chuỗi — chúng có thể được viết bên trong dấu nháy đơn [ ' ' ], dấu nháy kép [ " " ] hoặc dấu nháy ngược [ ` ` . Kiểu trích dẫn được sử dụng phải phù hợp với cả hai bên, tuy nhiên có thể sử dụng cả ba kiểu trong cùng một kịch bản. . The type of quote used must match on both sides, however it is possible that all three styles can be used throughout the same script.

StringBuffer hay trình xây dựng nào tốt hơn?

Chuỗi là bất biến trong khi StringBuffer và StringBuilder là các lớp có thể thay đổi. StringBuffer an toàn cho luồng và được đồng bộ hóa trong khi StringBuilder thì không. Đó là lý do tại sao StringBuilder nhanh hơn StringBuffer .

StringBuilder có nhanh hơn chuỗi không?

StringBuilder thực thi nhanh hơn đáng kể so với lớp String khi thực hiện thao tác nối hoặc sửa đổi . Sửa đổi Chuỗi tạo Chuỗi mới trong bộ nhớ heap. Để thay đổi nội dung của String, chúng ta nên xem xét lớp StringBuilder.

Trình tạo chuỗi là gì?

StringBuilder trong Java là một lớp được sử dụng để tạo một biến có thể thay đổi, hay nói cách khác, một chuỗi ký tự có thể sửa đổi được . Giống như StringBuffer, lớp StringBuilder là một lớp thay thế cho Lớp Chuỗi Java, vì lớp Chuỗi cung cấp một chuỗi ký tự bất biến.

Bài Viết Liên Quan

How many days until January 2, 2023?
Bạn có thể kiếm được bao nhiêu với html và css?
Lưu hộp thoại javascript
Cách xóa danh sách khỏi Excel
Ford Escape PHEV 2023 mpg
10 ml bằng bao nhiêu mét khối
Gửi email mẫu HTML
Excel Hiển thị công thức thay vì giá trị
Nhận danh mục loại bài đăng wordpress
Hướng dẫn dùng string ends python
Who are the top 2023 football recruits?
Bảng Bootstrap với phân trang và tìm kiếm và sắp xếp codepen
Python không có trong hoặc không có trong
Học python có tốt không oop
Cập nhật theo id trong PHP
Python mã hóa Base64
Cách cài đặt bootstrap 4 trong góc
What will happen in Chile in 2023?
Python lấy chỉ số bảng chữ cái
Làm thế nào để bạn thêm các biến chuỗi trong python?

Toplist mới

#1
Top 7 sự tích hồ gươm - ngữ văn lớp 6 2023
7 tháng trước
#2
Top 7 gdcd 6 bài 1 kết nối tri thức 2023
7 tháng trước
#3
Top 7 ý nghĩa của xây dựng gia đình văn hóa 2023
7 tháng trước
#4
Top 6 mẫu hợp đồng mượn đất làm nhà xưởng 2023
7 tháng trước
#5
Top 3 tổng tài biến thái tôi yêu anh tập 27 2023
7 tháng trước
#6
Top 6 kết thực phim mỹ nhân vô lệ 2023
7 tháng trước
#7
Top 9 trong những câu thơ sau câu nào sử dụng thành ngữ 2023
7 tháng trước
#8
Top 8 đề tài và chủ de của tác phẩm tắt đèn 2023
7 tháng trước
#9
Top 5 tiểu sử của thầy thích pháp hòa 2023
7 tháng trước

Bài mới nhất

Cách dạy con học toán lớp 1 hiệu quả năm 2024
Hàm trung bình cộng trong thư viện math.h năm 2024
Khi chạy chương trình báo lỗi invalid missing system.setup năm 2024
Bài giảng sự lai hóa các obitan phân tử năm 2024

Chủ Đề

programming Hỏi Đáp Toplist Là gì Bài Tập Địa Điểm Hay Mẹo Hay Học Tốt Nghĩa của từ Công Nghệ Khỏe Đẹp bao nhiêu Top List Tiếng anh Bao nhiêu Sản phẩm tốt Xây Đựng Ngôn ngữ javascript Ở đâu Đại học Hướng dẫn Bài tập Tại sao Dịch So Sánh Máy tính Món Ngon mẹo hay Bao lâu Thế nào So sánh Khoa Học Vì sao Lớp 9 Lớp 10