ืื ืื ืืืจืืืช ื-Java?
ืืชืื ืืช, ื ืขืฉื ืฉืืืืฉ ื ืคืืฅ ืืืื ืืืืจืืืืช. ืืืจืืืช ื-java ืืื ืืืืืืงื ืืืืืฆื ืจืฆืฃ ืฉื ืชืืืื ืืืืืื ืขื ืืื ืืขืจื char. ืืืืงืช ืืืจืืืช ื ืืชื ืช ืืฉืื ืื ื-Java ืืืืืืขื ืืืฉืงืื Comparable , Serializable ื- CharSequence . ืืืื ื ืกืชืื ืขื ืืืืื ืืื ืืืืื.String str = "string"
ืืื str ืืื ืืจืฆืฃ ืฉื 6 ืชืืืื ืฉืื s, t, r, i, n ื-g.
ืืื ืืงืก ืืขืจื Char | 0 | 1 | 2 | 3 | 4 | 5 |
---|---|---|---|---|---|---|
ืขืจื | ืก | ื | ืจ | ืื ื | ื | ื |
ืืชืืืช ืืืืจืื | 0x12824 | 0x12825 | 0x12826 | 0x12827 | 0x12828 | 0x12829 |
ืืจืืื ืืืชืืื ืืืจืืืืช
ืืฉื ื ืฉืชื ืืจืืื ืืืชืื ืืืจืืืช.- ืืืืืช ืืืชืจ
- ืืคืขืื ืืืฉ
ืืืจืืืช ืืืืืืืช
ืืืจื ืืงืื ืืืืฉืืจื ืืืืชืจ ืืืืจืื ืขื ืืืจืืืช ืืฉืืฉืช ืืืืืื ืืขืื. ืืื ืคืขื ืฉืืืืืจ ืืคืจืฉ ืืืจืืืช ืืืืืืืช, ืืื ืชืืื ืืืืจืช ืืืืืืืงื String.String str = "string";
ืืคืขืื ืืืฉ
ืื ื ืืืืืื ืื ืืืชืื ืืืจืืืช ืืืืฆืขืืช ืืืืคืจืืืจ ืืืืฉ.String strNew = new String("using new operator");
ืืืืื
import java.io.*;
import java.lang.*;
class StringInitializationExample {
public static void main(String[] args)
{
//declare java string with a string literal
String str = "a string literal";
System.out.println("String str = " + str);
//declare string using new operator
String strNew = new String("using new operator");
System.out.println("String strNew = " + strNew);
}
}
ืชึฐืคืึผืงึธื
String str = ืืืจืืืช ืืืืืืืช String strNew = ืืืืฆืขืืช ืืืคืจืืืจ ืืืฉ
String vs StringBuilder vs StringBuffer
ืืืจ ืื ื ืขื ืืื ืืืืืงื String ืื ื ืืื ืืฉืชื ืืืืืงืืช ืืืืจืืช ืืืืืจืชื, ืืื ืขื ืืกืืื ืฉืืืืื Java ืืฆืืื ืืช ืฉืชื ืืืืืงืืช ืืืื ืืืฉืจ ืืืจ ืืฉ ืื ืืช ืืืืืงื String ืขืืืจื ื. ืขืืืฃ ืื ืืืืช ืืจืืฉ ืืืขืฉืืช ืขืืืื ืืืืชื String ืืื ืืืืื ืืช ืื ืืฆืืจื ืืืื ืืืชืจ.ืกืืื
ืืคื ืฉืื ื ืืืืขืื ืฉืืืืืืงื ืืืืืงื String ืืื ืืืชื ื ืืชื ืืฉืื ืื, ืื ืืื ืคืขื ืฉืื ืื ื ืฆืจืืืื ืืฉื ืืช ืืช ืืืืจืืืช ืืื ืืฃ ืคืขื ืื ืืฉื ื ืืช ืืืืืืืงื ืื ืืืื, ืืื ืืขืจื ืฉืืฉืชื ื ื ืฉืืจ ืชืืื ืืืืืืืงื String ืืืฉ. ืื ืื ื ืฆืืจื ืืฉื ืืช ืืช ืืขืจื, ืฉืื ืืฉืื, ืื ืืืืืจืื ื ืฆืจื. ืฉืืืจื ืขื ื ืงืืื ืื Java ืกืืคืงื ืื ื ืืืืงืืช StringBuilder ื- StringBuffer . ืืขืช ื ืจืื ืืืฆื ืื ืฉืืืืฉืืื ืืชืจืืืฉ ืื.StringBuffer
ืืืจืืืช ืืื ืืืฆืื ืฉื ืจืฆืฃ ืฉื ืชืืืื ืืืชื ื ืืชื ืืฉืื ืื, ืื StringBuffer ืืื ืจืฆืฃ ืฉื ืชืืืื ืฉื ืืชื ืืฉืื ืื . ืืื ืืฉืชืืฉ ืืจืื ืฉืืืืช ืืืืืงื String ืืื ืขื ืืื ืืชืืืืช ืืฉืื ืืื ืืฉื ืืช ืืช ืืชืืื ืืจืฆืฃ ืืชืืืื. ืื ืืืื ืืฉืจืฉืืจ ืืืืืื ืฉืืฉืืืืช ืฉืื ืืกืื ืืจื ืืช ืืฉืืืืฉ ืขื ืืื ืฉืจืฉืืจืื ืืจืืืื, ืชืื ืฉืืืจื ืขื ืืกืืจ ืืืืจื. ืืื ืืืืฉื ืืช ืืืฉืงื Serializable , Appendable ื- CharSequence .ืชืืืืจ
StringBuffer str = new StringBuffer("Happy Java Programming");
StringBuilder
StringBuilder ืืืืฆื ืื ืืช ืจืฆืฃ ืืชืืืื ืื ืืชื ืื ืืฉืื ืื. ืืื ืืกืคืง API, ืืชืืื ืืืืืงื StringBuffer ืื ืืื ื ืืืื ืืฉืจืฉืืจ. ืื ืืืคื ืฉืื ืืขืืจืืื ืฉืจืฉืืจืื ืืจืืืื, ืขืืืฃ ืืืืช ืขื ืืืืืงื StringBuilder ืืืืืื ืฉืืื ืืืืจื ืืืชืจ ืืืืืงืช StringBuffer ืืืงืจืื ืจืืื. ืฉืืืืช ืืืคืชื ืฉื ืืืืงื ืื ืื ืืืกืคื ืืืืกืคื. ืื ืื ืืืืฉื ืืช ืืืฉืงื Serializable , Appendable ื- CharSequence .ืชืืืืจ
StringBuilder str = new StringBuilder("Happy Java Programming");
ืคืขืืืืช ืืืจืืืช
ืื'ืืืื ื ืืื ืืืฆืข ืคืขืืืืช ืืืจืืืืช ืืื ืฉืจืฉืืจ , ืืฉืืืื , ืคืืฆืื , ืืฆืืืช ืืืจื , ืืืืคืช ืืืจืืืืช ืืื ืืืื.ืฉืืืืช ืืืจืืืืช
ืืืืืงื Java String ืืกืคืงืช ืฉืืืืช ืฉืื ืืช ืืื ืืคืืืฆืื ืฉื ืืืืจืืืืช ืื ืืืืฆืืข ืืคืขืืืืช ืืืคืืจืืืช ืืขืื. ืืืื ื ืกืชืื ืืืืื ืืืื ืขืืืจ ืืื ืืฉืืืืช ืืืืจืืืืช ืืืื.ืฉืืืืช | ืชืืืืจ |
---|---|
Char charAt(int index) | ืืื ืืืืืจ ืืช ืขืจื ื-char ืืืื ืืืกืืคืง. |
String concat(String str) | ืืื ืืืืืจ ืืืจืืืช ืขื ืืื ืฉืืืื ืฉื ืืืจืืืช ืฉืฆืืื ื ืืกืืฃ ืืืืจืืืช ืืื. |
boolean contains(CharSequence s) | ืืื ืืืืืจ true ืื ืืืืจืืืช ืืืืื ืจืฆืฃ ืืืืืจ ืฉื ืขืจืื char. |
ืชืืื ืืืืืื ื ืฉืืื (CharSequence cs) | ืื ืืชืืื ืืืืจืืืช ืขื ืจืฆืฃ ืืชืืืื ืฉืกืืคืง. |
ืชืืื ืืืืืื ืEquals(StringBuffer sb) | ืืื ืชืืื ืืช ืืืืจืืืช ืืืืืจ ืืืืจืืืช ืฉืกืืคืง. |
Boolean endsWith(ืกืืืืช ืืืจืืืช) | ืื ืืฉืืื ืืช ืงืฆื ืืืืจืืืช ืขื ืืกืืืืช ืฉืกืืคืงื. |
ืืืืืื ื ืฉืืื (Object anObject) | ืื ืชืืื ืืช ืืืืจืืืช ืืืืืืืงื ืฉืกืืคืง. |
Boolean equalsIgnoreCase(String anotherString) | ืฉืืื ืื ืืฉืืื ืืื ืฉืชื ืืืจืืืืช ืืืื ืืงืืช ืืืฉืืื ืืช ืจืืืฉืืช ืืืงืจืื. |
ืชืื ืืช ืืืจืืืช ืกืืืืช (ืคืืจืื ืืืจืืืช, ืืืืืืงื... args) | ืืื ืืืืืจ ืืช ืืืืจืืืช ืืืขืืฆืืช ืืืืฆืขืืช ืืคืืจืื ืฉืกืืคืง ืืืืจืืืื ืืื. |
byte getBytes() | ืฉืืื ืื ืืฉืชืืฉืช ืืขืจืืช ืืชืืืื ืืืืืืจืช ืืืจืืจืช ืืืื ืฉื ืืคืืืคืืจืื ืืงืืืื ืืืืจืืืช ืืจืฆืฃ ืฉื ืืชืื, ืืฉืจ ืืืืืกื ืืืืจ ืืื ืืืขืจื ืืชืื ืืืฉ. |
void getChars(int begin, int end, char[] dst, int dstBegin) | ืืื ืืขืชืืง ืืช ืืชืืืื ืืืืืจืืืช ืื ืืขืจื ืชืืื ืืืขื. |
int hashCode() | ืื ืืืืืจ ืืช ืงืื ื-hash ืขืืืจ ืืืืจืืืช. |
int indexOf(int ch) | ืืื ืืืืืจ ืืช ืืืื ืืงืก ืขืืืจ ืืชื ืฉืฆืืื ืืืืคืืข ืจืืฉืื ืืืืืจืืืช. |
int indexOf(int ch, int fromIndex) | ืืื ืืืืืจ ืืช ืืืื ืืงืก ืขืืืจ ืืชื ืฉืฆืืื ืฉืืชืจืืฉ ืืจืืฉืื ื ืืื ืืืืื ืืงืก ืฉืกืืคืง ืืืืจืืืช ืื. |
int indexOf(String str) | ืืื ืืืคืฉ ืืช ืืืืจืืืช ืืืฉื ื ืฉืกืืคืงื ืืืืจืืืช ืืืืืืจ ืืช ืืืื ืืงืก ืืืชืจืืฉืืช ืืจืืฉืื ื. |
int indexOf(String str, int fromIndex) | ืืื ืืชืืื ืืืคืฉ ืืช ืืืืจืืืช ืืืฉื ื ืฉืกืืคืงื ืืืืจืืืช ืืืืื ืืงืก ืื ืชืื ืืืืืืจ ืืช ืืืื ืืงืก ืืืชืจืืฉืืช ืืจืืฉืื ื. |
String intern() | ืฉืืื ืื ืืืืืจื ืืช ืืืืฆืื ืืงื ืื ื ืฉื ืืืืจืืืช. |
int lastIndexOf(int ch) | ืฉืืื ืื ืืืคืฉืช ืืช ืืชื ืฉืกืืคืง ืืืืจืืืช ืืืืืืจื ืืช ืืืื ืืงืก ืฉื ืืืชืจืืฉืืช ืืืืจืื ื. |
int lastIndexOf(int ch, int fromIndex) | ืฉืืื ืื ืืืคืฉืช ืืืืจื ืืืืื ืืงืก ืื ืชืื ืขืืืจ ืืชื ืฉืกืืคืง ืืืืจืืืช ืืืืืืจื ืืช ืืืื ืืงืก ืฉื ืืืชืจืืฉืืช ืืืืจืื ื. |
int lastIndexOf(String str) | ืฉืืื ืื ืืืคืฉืช ืืช ืืืืจืืืช ืืืฉื ื ืฉืกืืคืงื ืืืืจืืืช ืืืืืืจื ืืช ืืืื ืืงืก ืฉื ืืืชืจืืฉืืช ืืืืจืื ื. |
int lastIndexOf(String str, int fromIndex) | ืฉืืื ืื ืืืคืฉืช ืืืืจื ืืืืื ืืงืก ืื ืชืื ืืืจ ืืืืจืืืช ืืืฉื ื ืฉืกืืคืงื ืืืืจืืืช ืืืืืืจื ืืช ืืืื ืืงืก ืฉื ืืืชืจืืฉืืช ืืืืจืื ื. |
int length() | ืฉืืื ืื ืืืืืจื ืืช ืืืจื ืืืืจืืืช. |
ืืชืืืืช ืืืืืื ืืืช (ืืืจืืืช ืจืืืื) | ืืื ืืืืืจ ื ืืื ืื ืื ื ืืื ืขื ืืื ืืชืืืช ืืืืจืืืช ืืืืืื ืืจืืืืจื ืฉืกืืคืง. |
String replace(char oldValue, char newValue) | ืฉืืื ืื ืืืืืจื ืืืจืืืช ืืืืจ ืืืืคืช ืื ื-oldValue ืฉืกืืคืง ื-newValue ืืืืจืืืช. |
String[] split(String regex) | ืฉืืื ืื ืืืฆืืช ืืช ืื ืืืชืืืืช ืืคื ืืืืืื ืืจืืืืจื ืืืกืืคืง ืืืืจืืืช ืืืคืฆืืช ืืืชื ืกืืื ืืชืืืืช ืืื. |
boolean startsWith(ืชืืืืืช ืืืจืืืช) | ืืื ืืืืืจ ื ืืื ืื ืื ื ืืื ืขื ืืื ืืืืงืช ืืืืจืืืช ืืืชืืื ืขื ืืงืืืืืช ืฉืกืืคืงื. |
ืืืจืืืช ืืฉื ื (int beginIndex) | ืฉืืื ืื ืืืืืจื ืืืจืืืช ืฉืืื ืืืืจืืืช ืืืฉื ื ืฉื ืืืจืืืช ืื. |
ืืืจืืืช toLowerCase() | ืื ืืืืจ ืืช ืื ืืชืืืื ืฉื ืืืืจืืืช ืืืืชืืืช ืงืื ืืช ืืืืฆืขืืช ืืืืืื ืฉื ืืงืื ืืจืืจืช ืืืืื. |
ืืืชืื ืืืจืืืช() | ืฉืืื ืื ืืกืืจื ืืช ืื ืืจืืืืื ืืืื ืื ืืืืืืืื ืืื ืืจืจืื ืืืืืจืืืช ืืืืืืจื ืืืชื. |
ืกืืื ืืืจืืืช valueOf(char c) | ืืื ืืืืืจ ืืช ืืืฆืื ืืืืจืืืช ืฉื ืืจืืืื ื ื-char. |
ืืืืื
import java.io.*;
import java.lang.*;
class JavaStringsExample {
public static void main(String[] args) {
//create a string
String greeting = "Hello! World";
System.out.println("String: " + greeting);
//getting the length of greeting object
int length = greeting.length();
System.out.println("Length: " + length);
//create first string
String first = "Java ";
System.out.println("First String: " + first);
//create second string
String second = "Programming";
System.out.println("Second String: " + second);
//joining two strings
String joinedString = first.concat(second);
System.out.println("Joined String: " + joinedString);
String jpf = "Java programming";
String jps = "Java programming";
String jpt = "Python programming";
//compare jpf and jps strings
boolean result1 = jpf.equals(jps);
System.out.println("Strings jpf and jps are equal: " + result1);
//compare jpf and jpt strings
boolean result2 = jpf.equals(jpt);
System.out.println("Strings jpf and jpt are equal: " + result2);
//converting jpf to uppercase
System.out.println("Upper case jpf: " + jpf.toUpperCase());
//replacing g character with v in jpf
System.out.println("Replacing g with v in jpf: "+jpf.replace("g", "v"));
}
}
ืชึฐืคืึผืงึธื
ืืืจืืืช: ืฉืืื! ืืืจื ืขืืื: 12 ืืืจืืืช ืจืืฉืื ื: Java ืืืจืืืช ืฉื ืืื: ืชืื ืืช ืืืจืืืช ืืฆืืจืคืช: Java ืชืื ืืช ืืืจืืืืช jpf ื-jps ืฉืืืื: ืืืช ืืืจืืืืช jpf ื-jpt ืฉืืืื: false ืืืชืืืช ืจืืฉืืืช jpf: JAVA PROGRAMMING ืืืืคืช g ื-v ื-jpf: java provramminv
GO TO FULL VERSION