ืืื ืฉืืืืช replace() ืื ืคืืฆืืช ืฉื ืืืืงืช String ื-Java?
ืืืืืงื String ืืกืคืงืช ืืจืืขื ืกืืืื ืฉืื ืื ืฉื ืฉืืืืช replace() ื-Java. ืื ืืืช ืืืฉืืืืช ืืชืืืืกืช ืืืงืจื ืฉืืืืฉ ืกืคืฆืืคื. ืฉืืืชืืื ืืคืืจืืื ืืืื:- ืืืืืืฃ (char, char)
- ืืืืืืฃ (ืืืจืืืช, ืืืจืืืช)
- replaceAll(ืืืจืืืช, ืืืจืืืช)
- replaceFirst(ืืืจืืืช, ืืืจืืืช)
ืฉืืืช Java String replace()โ
ืฉืืืช Java String replace() ืืฉืืฉืช ืืืืืคืช ืชื ืฉืฆืืื ืืชื ืื ืชืื ืฉื ืืื ืืืขืืจืื ืืคืจืืืจืื. ืฉืืื ืื ืืชืืืื ืืืืืคืช ืื ืชื ืืืืจืืืช ืืืืืช ืืืจืช ืฉืชืืืจ.ืืืชืจืช ืฉืืื
public String replace(char oldCharacter, char newCharacter)
ืคืจืืืจืื ืฉื ืฉืืื
ืืฉืืื ืืืงืืช ืฉื ื ืคืจืืืจืื ืื ืืจืืืื ืืื ืืกืื 'char'.-
char oldCharacter ืืืื ืืช ืืืืืช ืฉืืฉ ืืืืืืฃ.
-
char newCharacter ืืืืืง ืืช ืืืืืช ืฉืชืฉืืฉ ืืืงืื ื-oldCharacter.
ืกืื ืืืืจื
ืืฉืืื String replace ืืืืืจื ืืช ืืืืจืืืช ืืืขืืืื ืช ืืืืจ ืืืืคืช ืืชื ืืจืฆืื.ืืืืื
ืืืื ื ืกืชืื ืขื ืืืืืืืช ืคืฉืืืืช ืฉืื ืืช ืืื ืืืืื ืืืฆื ืฉืืื ืื ืคืืขืืช.public class Driver {
public static void main(String[] args) {
String myString = "An apple a day, keeps the doctor away!";
System.out.println("Original Sentence: \t\t\t" + myString);
// Example 1 using String replace(char, char)
char oldCharacter = 'a'; // replacing character
char newCharacter = 'A'; // character to be replaced
String updatedString = myString.replace(oldCharacter, newCharacter);
System.out.println("After replacing '" + oldCharacter + "' with '" +
// 'a' is replaced and not with 'A' as the method is case sensitive
newCharacter + "': \t\t" + updatedString);
// Example 2 using String replace(String, String)
String oldString = "apple";
String newString = "orange";
// using the method String replace
String updatedString1 = myString.replace(oldString, newString);
System.out.println("Replacing '" + oldString + "' with '" +
newString + "': \t" + updatedString1 + "\n");
}
}
ืชึฐืคืึผืงึธื
ืืฉืคื ืืงืืจื: ืชืคืื ืืืื, ืืจืืืง ืืช ืืจืืคื! ืืืืจ ืืืืคืช 'a' ื-'A': ืชืคืื ืืืื, ืืจืืืง ืืช ืืจืืคื! ืืืืคืช 'ืชืคืื' ื'ืชืคืื': ืชืคืื ืืืื, ืืจืืืง ืืช ืืจืืคื!
ืืขืจื: ืืืืืฅ ืืืืืจ ืืช ืืืืืืืื ืืจืืืืจืืื
, ืืืืื ืื regex, ืืคื ื ืฉืชืชืงืื.
ืฉืืืช Java String replaceAll()โ
ืืฉืืื Java String replaceAll() ืืืืืคื ืื ืืืคืข ืืืื ืฉื ืืืืื ืจืืืืจื ืืืืขืืจ ืืคืจืืืจ ืืืืจืืืช ืืจืฆืืื . ืืืฉืืขืืช ืืื ืฉืื ืขืืชืง ืฉื ืืืืื ืจืืืืจื ืืชืขืืื ืขื ืืื ืืืืจืืืช ืืืืคื.ืืืชืจืช ืฉืืื
public String replaceAll(String regularExpression, String replacementStr)
ืคืจืืืจืื ืฉื ืฉืืื
ืฉืืื ืื ืืืงืืช ืฉื ื ืืจืืืื ืืื ืืกืื 'ืืืจืืืช'.-
ืืืจืืืช regularExpression ืืืืืงื ืืช ื-Regex (ืืชืื ืืช) ืฉืืฉ ืืืืืืฃ.
-
String replacementStr ืืื ืืืืจืืืช ืฉืชืฉืืฉ ืืืงืื ื-Regex.
ืกืื ืืืืจื
ืืฉืืื ืืืืืจื ืืืจืืืช ืืืฉื ืืืืจ ืืืืคืช ืื ืืืืคืขืื ืฉื ืืืืืื ืืจืืืืจื.ืืืืื
ืฉืืื ืื ืืฉืืฉืช ืืืจื ืืื ืืขืืืื ืจืฉืืืืช ื ืชืื ืื ืขื ืงืืืช. ืืืื ื ืืขืืืงื ืืืชืจ, ืืืื ื ืกืชืื ืขื ืืืืืืืช ืฉืื ืืช ืฉื ืฉืืืช replaceAll() .public class Driver1 {
public static void main(String[] args) {
String myString = "Mastering a programming language begins with great logic building!";
System.out.println("Original Sentence: \t\t\t" + myString);
String regex = "[\sa]"; // This regex is used to remove all spaces and a(s) in the string
String replacementStr = "";
// using the method String replaceAll(); to remove ALL spaces
System.out.println("After replacing \"" + regex + "\" with \"" + replacementStr + "\": \t"
+ myString.replaceAll(regex, replacementStr) + "\n");
}
}
ืชึฐืคืึผืงึธื
ืืฉืคื ืืงืืจื: ืฉืืืื ืืฉืคืช ืชืื ืืช ืืชืืืื ืืื ืืืช ืืืืืื ื ืืืจืช! ืืืืจ ืืืืคืช "[ a]" ื"": Msteringprogrmminglngugebeginswithgretlogicbuilding!
ืฉืืืช Java String replaceFirst()โ
ืืฉืืื Java String replaceFirst() ืืืืืคื ืืช ืืืืคืข ืืจืืฉืื ืืืืื ืฉื ื-Regex ืืืืขืืจ ืืฉืืื ืื.ืืืชืจืช ืฉืืื
public String replaceFirst(String regularExpression, String replacementStr)
ืคืจืืืจืื ืฉื ืฉืืื
ืฉืืื ืื ืืืงืืช ืฉื ื ืืจืืืื ืืื ืืกืื 'ืืืจืืืช'.-
ืืืจืืืช regularExpression ืืืืืงื ืืช ื-Regex (ืืชืื ืืช) ืฉืืฉ ืืืืืืฃ.
-
String replacementStr ืืื ืืืืจืืืช ืฉืชืฉืืฉ ืืืงืื ื-Regex.
ืกืื ืืืืจื
ืืฉืืื ืืืืืจื ืืืจืืืช ืืืฉื ืืืืจ ืืืืคืช ืจืง ืืืืคืข ืืจืืฉืื ืฉื ื-Regex.ืืืืื
ื ืืชื ืืืฉืชืืฉ ืืฉืืื ืื ืืืฉืจ ืืจืฆืื ื ืืขืืื ืจืง ืืช ืืจืฉืืื ืืจืืฉืื ื ืฉื ืืฆืื ืฉื ืืืจืืืื ื ืืชืืื ืฉืื. ืืืื ื ืืงืืจ ืืื ืื ืขืืื ืืืืืื ืืืื.public class Driver2 {
public static void main(String[] args) {
String myString = "Good Morning. You wonders of Nature. Today is a great day to be happy.";
System.out.println("Original Sentence: \t\t" + myString);
String regex = "\\."; // regex to update period / full stop
String replacementStr = "!";
// using the method String replaceFirst();
// to remove first period(.) with exclamation(!) mark
System.out.println("After replacing '" + regex + "' with '" + replacementStr + "': \t"
+ myString.replaceFirst(regex, replacementStr));
}
}
ืชึฐืคืึผืงึธื
ืืฉืคื ืืงืืจื: ืืืงืจ ืืื. ืืชื ืคืืื ืืืืข. ืืืื ืืื ืืื ื ืืืจ ืืฉืืื. ืืืืจ ืืืืคืช '\.' ืขื '!': ืืืงืจ ืืื! ืืชื ืคืืื ืืืืข. ืืืื ืืื ืืื ื ืืืจ ืืฉืืื.
GO TO FULL VERSION