programming

Cách thay thế nhiều ký tự trong một chuỗi trong Java

Sử dụng phương pháp

str = str.replace[Regex["""[$,.]"""], ""]

6 để thay thế nhiều ký tự trong một chuỗi, e. g.

str = str.replace[Regex["""[$,.]"""], ""]

7. Tham số đầu tiên mà phương thức nhận là một biểu thức chính quy có thể khớp với nhiều ký tự. Phương thức trả về một chuỗi mới với các kết quả khớp được thay thế bằng chuỗi thay thế được cung cấp

Chúng tôi đã chuyển 2 đối số sau cho Chuỗi. phương pháp thay thế

một biểu thức chính quy mà chúng tôi muốn khớp trong chuỗi
sự thay thế cho mỗi trận đấu

Dấu gạch chéo về phía trước

str = str.replace[Regex["""[$,.]"""], ""]

8 đánh dấu phần đầu và phần cuối của biểu thức chính quy

Dấu ngoặc vuông

str = str.replace[Regex["""[$,.]"""], ""]

9 được gọi là một lớp ký tự và khớp với bất kỳ ký tự nào giữa các dấu ngoặc

Trong ví dụ đầu tiên, chúng tôi khớp dấu chấm, dấu gạch dưới và dấu gạch nối

Bạn có thể điều chỉnh biểu thức chính quy theo trường hợp sử dụng của mình bằng cách cập nhật các ký tự giữa dấu ngoặc vuông và chuỗi thay thế

Chúng tôi đã sử dụng cờ

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

0 [toàn cầu] vì chúng tôi muốn khớp tất cả các lần xuất hiện của các ký tự này trong chuỗi chứ không chỉ lần xuất hiện đầu tiên

Trong ví dụ đầu tiên, chúng tôi đã thay thế mỗi lần xuất hiện của dấu chấm, dấu gạch dưới hoặc dấu gạch ngang bằng dấu cách

Phương thức

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

1 không thay đổi chuỗi ban đầu, nó trả về một chuỗi mới. Các chuỗi là bất biến trong JavaScript

Nếu bạn cần trợ giúp để đọc một biểu thức chính quy, hãy xem biểu đồ regex này từ MDN

Ngoài ra, bạn có thể sử dụng Chuỗi. phương pháp thay thế tất cả

Thay thế nhiều ký tự trong một chuỗi bằng cách sử dụng replaceAll #

Để thay thế nhiều ký tự trong một chuỗi, hãy xâu chuỗi nhiều lời gọi đến phương thức

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

2, e. g.

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

3. Phương thức

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

4 sẽ trả về một chuỗi mới, trong đó tất cả các lần xuất hiện của các ký tự được thay thế bằng ký tự thay thế được cung cấp

Chúng tôi đã chuyển 2 đối số sau cho phương thức

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

Một chuỗi con chúng tôi muốn thay thế trong chuỗi
Sự thay thế cho mỗi trận đấu

Cách tiếp cận này dài dòng hơn một chút sau đó sử dụng biểu thức chính quy với một lớp ký tự. Tuy nhiên, nó cho phép chúng tôi tránh sử dụng biểu thức chính quy nếu chúng tôi có các ký tự cụ thể mà chúng tôi muốn thay thế

Sự khác biệt về hiệu suất hầu như không đáng kể, trừ khi bạn đang làm việc với một chuỗi dài hàng chục nghìn ký tự

Phương thức

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

4 trả về một chuỗi mới trong đó tất cả các lần xuất hiện của chuỗi con được thay thế bằng chuỗi thay thế được cung cấp. Điều này cho phép chúng tôi xâu chuỗi càng nhiều cuộc gọi đến phương thức càng tốt

Một cách tiếp cận khác, nhưng cũng rất phổ biến mà bạn có thể thấy là sử dụng ký tự

str = str.replace[Regex["""[$,.]"""], ""]

71 dạng ống, đóng vai trò là một

str = str.replace[Regex["""[$,.]"""], ""]

72 trong biểu thức chính quy

Đây là một ví dụ thay thế từng khoảng trắng, dấu gạch dưới hoặc dấu chấm than bằng dấu chấm hỏi

Ký tự đặc biệt

str = str.replace[Regex["""[$,.]"""], ""]

73 khớp với khoảng trắng [dấu cách, tab, dòng mới]

Đường ống

str = str.replace[Regex["""[$,.]"""], ""]

71 cho phép chúng tôi khớp một trong các ký tự trong biểu thức chính quy

Bạn chọn cách tiếp cận nào là vấn đề sở thích cá nhân. Tôi sẽ sử dụng lớp ký tự

str = str.replace[Regex["""[$,.]"""], ""]

9 với phương pháp

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

1 nếu nhóm của tôi cảm thấy thoải mái với các biểu thức chính quy. Mặt khác, tôi có thể gọi chuỗi các cuộc gọi đến phương thức

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

________ 05 là biểu thức chính quy, là đầu vào dự kiến cho phương thức Java ________ 06. Tuy nhiên, Kotlin có một lớp gọi là

str = str.replace[Regex["""[$,.]"""], ""]

7 và

str = str.replace[Regex["""[$,.]"""], ""]

8 bị quá tải để lấy đối số Chuỗi hoặc Regex

Vì vậy, bạn phải gọi

str = str.replace[Regex["""[$,.]"""], ""]

9 một cách rõ ràng, nếu không, nó nghĩ rằng bạn muốn thay thế Chuỗi ký tự bằng chữ

str = str.replace[Regex["""[$,.]"""], ""]

5. Điều đáng nói là

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

1 trong Kotlin được sử dụng với các mẫu Chuỗi, nghĩa là trong các chuỗi thông thường, bạn phải thoát nó bằng dấu gạch chéo ngược. Kotlin hỗ trợ các Chuỗi thô [được đánh dấu bằng ba

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

2 thay vì một] mà không cần phải thoát các chuỗi này, nghĩa là bạn có thể làm điều này

________số 8

Nói chung, bạn cần một đối tượng Regex. Ngoài việc sử dụng

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

3 [có thể có hoặc không phải là đường cú pháp], bạn cũng có thể tạo một đối tượng Regex bằng cách sử dụng hàm tạo cho lớp

str = str.replace[Regex["""[$,.]"""], ""]

Cả hai tín hiệu này cho thấy chuỗi của bạn là biểu thức chính quy và đảm bảo sử dụng đúng ____ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

Giải pháp liên quan

Java – Cách nhanh nhất để xác định xem căn bậc hai của một số nguyên có phải là số nguyên hay không

Tôi đã tìm ra một phương pháp hoạt động nhanh hơn ~35% so với mã 6bits+Carmack+sqrt của bạn, ít nhất là với CPU [x86] và ngôn ngữ lập trình [C/C++] của tôi. Kết quả của bạn có thể khác, đặc biệt là vì tôi không biết yếu tố Java sẽ diễn ra như thế nào

Cách tiếp cận của tôi là gấp ba lần

Đầu tiên, lọc ra những câu trả lời rõ ràng. Điều này bao gồm các số âm và nhìn vào 4 bit cuối cùng. [Tôi thấy nhìn vào sáu cái cuối cùng không giúp được gì. ] Tôi cũng trả lời có cho 0. [Khi đọc mã bên dưới, lưu ý rằng đầu vào của tôi là
```
if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;
```
5. ]
```
if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;
```
Tiếp theo, kiểm tra xem đó có phải là hình vuông modulo 255 = 3 * 5 * 17 không. Vì đó là tích của ba số nguyên tố phân biệt nên chỉ khoảng 1/8 số dư mod 255 là số chính phương. Tuy nhiên, theo kinh nghiệm của tôi, việc gọi toán tử modulo [%] tốn kém hơn lợi ích mà người ta nhận được, vì vậy tôi sử dụng các thủ thuật bit liên quan đến 255 = 2^8-1 để tính phần dư. [Dù tốt hay xấu, tôi không sử dụng thủ thuật đọc các byte riêng lẻ của một từ, chỉ sử dụng bitwise-and và shifts. ]
```
str = str.replace[Regex["""[$,.]"""], ""]
```
4Để kiểm tra xem phần dư có phải là hình vuông hay không, tôi tra đáp án trong bảng tính sẵn.
```
str = str.replace[Regex["""[$,.]"""], ""]
```
5
Cuối cùng, hãy thử tính căn bậc hai bằng phương pháp tương tự như bổ đề Hensel. [Tôi không nghĩ nó có thể áp dụng trực tiếp, nhưng nó hoạt động với một số sửa đổi. ] Trước khi làm điều đó, tôi chia tất cả lũy thừa của 2 bằng tìm kiếm nhị phân.
```
str = str.replace[Regex["""[$,.]"""], ""]
```
6Tại thời điểm này, để số của chúng ta là số chính phương, nó phải là 1 mod 8.
```
str = str.replace[Regex["""[$,.]"""], ""]
```
7Cấu trúc cơ bản của bổ đề Hensel như sau. [Ghi chú. mã chưa được kiểm tra; . ]
```
str = str.replace[Regex["""[$,.]"""], ""]
```
8Ý tưởng là ở mỗi lần lặp lại, bạn thêm một bit vào r, căn bậc hai "hiện tại" của x; . Cuối cùng, r và t/2-r sẽ là căn bậc hai của x modulo t/2. [Lưu ý rằng nếu r là căn bậc hai của x thì -r cũng vậy. Điều này đúng với số modulo chẵn, nhưng hãy cẩn thận, modulo một số số, mọi thứ thậm chí có thể có nhiều hơn 2 căn bậc hai; . ] Bởi vì căn bậc hai thực tế của chúng ta nhỏ hơn 2^32, tại thời điểm đó, chúng ta thực sự có thể kiểm tra xem r hoặc t/2-r có phải là căn bậc hai thực hay không. Trong mã thực tế của tôi, tôi sử dụng vòng lặp sửa đổi sau.
```
str = str.replace[Regex["""[$,.]"""], ""]
```
9Tăng tốc ở đây có được theo ba cách. giá trị bắt đầu được tính toán trước [tương đương với ~10 lần lặp lại vòng lặp], thoát khỏi vòng lặp sớm hơn và bỏ qua một số giá trị t. Đối với phần cuối cùng, tôi xem xét
```
if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;
```
6 và đặt t thành lũy thừa lớn nhất của 2 chia z bằng một mẹo nhỏ. Điều này cho phép tôi bỏ qua các giá trị t mà sẽ không ảnh hưởng đến giá trị của r. Giá trị bắt đầu được tính toán trước trong trường hợp của tôi chọn ra modulo căn bậc hai "dương nhỏ nhất" 8192

Ngay cả khi mã này không hoạt động nhanh hơn đối với bạn, tôi hy vọng bạn thích một số ý tưởng trong đó. Mã hoàn chỉnh, đã kiểm tra theo sau, bao gồm các bảng được tính toán trước

str = str.replace["""[$,.]""".toRegex[], ""]

Java – Cách đọc/chuyển đổi InputStream thành Chuỗi trong Java

Tóm tắt các câu trả lời khác Tôi đã tìm thấy 11 cách chính để thực hiện việc này [xem bên dưới]. Và tôi đã viết một số bài kiểm tra hiệu suất [xem kết quả bên dưới]

Các cách chuyển đổi InputStream thành String

Sử dụng

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

7 [Apache Utils]

str = str.replace["""[$,.]""".toRegex[], ""]

Sử dụng

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

8 [Ổi]

str = str.replace["""[$,.]""".toRegex[], ""]

Sử dụng

if[ x < 0 || [x&2] || [[x & 7] == 5] || [[x & 11] == 8] ]
    return false;
if[ x == 0 ]
    return true;

9 [JDK]

str = str.replace["""[$,.]""".toRegex[], ""]

Sử dụng API luồng [Java 8]. Cảnh báo. Giải pháp này chuyển đổi các ngắt dòng khác nhau [như

str = str.replace[Regex["""[$,.]"""], ""]

40] thành

str = str.replace[Regex["""[$,.]"""], ""]

str = str.replace["""[$,.]""".toRegex[], ""]

Sử dụng API luồng song song [Java 8]. Cảnh báo. Giải pháp này chuyển đổi các ngắt dòng khác nhau [như
```
str = str.replace[Regex["""[$,.]"""], ""]
```
40] thành
```
str = str.replace[Regex["""[$,.]"""], ""]
```
41
```
str = str.replace["""[$,.]""".toRegex[], ""]
```
5

Sử dụng

str = str.replace[Regex["""[$,.]"""], ""]

44 và

str = str.replace[Regex["""[$,.]"""], ""]

45 [JDK]

str = str.replace["""[$,.]""".toRegex[], ""]

Sử dụng

str = str.replace[Regex["""[$,.]"""], ""]

46 và

str = str.replace[Regex["""[$,.]"""], ""]

47 [Apache Commons]

str = str.replace["""[$,.]""".toRegex[], ""]

Sử dụng

str = str.replace[Regex["""[$,.]"""], ""]

48 và

str = str.replace[Regex["""[$,.]"""], ""]

49 [JDK]

str = str.replace["""[$,.]""".toRegex[], ""]

Sử dụng
```
str = str.replace[Regex["""[$,.]"""], ""]
```
50 [JDK]. Cảnh báo. Giải pháp này chuyển đổi các dấu ngắt dòng khác nhau [như
```
str = str.replace[Regex["""[$,.]"""], ""]
```
51] thành thuộc tính hệ thống
```
str = str.replace[Regex["""[$,.]"""], ""]
```
52 [ví dụ: trong Windows thành "\r\n"]
```
str = str.replace["""[$,.]""".toRegex[], ""]
```
9

Sử dụng

str = str.replace[Regex["""[$,.]"""], ""]

53 và

str = str.replace[Regex["""[$,.]"""], ""]

48 [JDK]

str = str.replace[Regex["""[$,.]"""], ""]

Sử dụng
```
str = str.replace[Regex["""[$,.]"""], ""]
```
55 và
```
str = str.replace[Regex["""[$,.]"""], ""]
```
45 [JDK]. Cảnh báo. Giải pháp này có vấn đề với Unicode, ví dụ như với văn bản tiếng Nga [chỉ hoạt động chính xác với văn bản không phải Unicode]
```
str = str.replace[Regex["""[$,.]"""], ""]
```
1

Cảnh báo

Giải pháp 4, 5 và 9 chuyển đổi các ngắt dòng khác nhau thành một
Giải pháp 11 không thể hoạt động chính xác với văn bản Unicode

Kiểm tra hiệu năng

Kiểm tra hiệu suất cho

str = str.replace[Regex["""[$,.]"""], ""]

57 nhỏ [độ dài = 175], url trong github [chế độ = Thời gian trung bình, hệ thống = Linux, điểm 1.343 là tốt nhất]

str = str.replace[Regex["""[$,.]"""], ""]

Kiểm tra hiệu suất cho lớn

str = str.replace[Regex["""[$,.]"""], ""]

57 [độ dài = 50100], url trong github [chế độ = Thời gian trung bình, hệ thống = Linux, điểm số 200,715 là tốt nhất]

Thay thế nhiều ký tự trong một chuỗi bằng cách sử dụng replaceAll #

Giải pháp liên quan

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề