שטריקל מעטהאָדס Java



ז'אבא שטריקל

אין Java פּראָגראַממינג שפּראַך, אַ שטריקל איז גאָרנישט אָבער אַ סיקוואַנס פון אותיות. עס איז די מערסט וויידלי געוויינט כייפעץ. Java String קלאַס האט פילע מעטהאָדס וואָס זענען געניצט פֿאַר פאַרשידן מאַניפּיאַליישאַנז. עס איז ימיוטאַבאַל, טייַטש, די ווערט קענען ניט זיין טשיינדזשד. א שטריקל איז עקוויוואַלענט צו אַ מענגע פון ​​אותיות.

שאפן אַ שטריקל אין Java

מיר קענען שאַפֿן אַ שטריקל מיט צוויי פאַרשידענע מעטהאָדס:

  • ניצן שטריקל פּשאַט - פּאָשעט
  • ניצן נייַ קיווערד

שאַפֿן אַ שטריקל ניצן אַ שטריקל ליטעראַל

דאָס איז די מערסט דירעקט וועג צו שאַפֿן אַ שטריקל אין Java. מיר קענען מאַכן אַ שטריקל דורך ענקלאָוזינג די ווערט אין טאָפּל קוואָטעס. דאָ די בייַטעוודיק "ווערט" פון טיפּ סטרינג האלט די שטריקל געהייסן ווי "Java שפּראַך"

String value = "Java language";

ווען מיר מאַכן אַ שטריקל ליטעראַל, JVM טשעק אין די "שטריקל קעסיידערדיק בעקן" אויב די שטריקל יגזיסץ. אויב עס טוט נישט עקסיסטירן, דזשוום קריייץ אַ נייַע שטריקל בייַשפּיל, אַנדערש נאָר אַ רעפֿערענץ צו די פּולד בייַשפּיל וועט זיין אומגעקערט. אין ביישפּיל, ביידע שטריקל אַבדזשעקץ האָבן די זעלבע ווערט. דעריבער, בלויז 1 כייפעץ איז באשאפן (ד"ה s1) און s2 וועט האָבן די דערמאָנען צו s1. דעם מיטל, ראַגאַרדלאַס פון ווי פילע טאָמיד שטריקל וועריאַבאַלז מיר מאַכן מיט די זעלבע ווערט, בלויז 1 בייַשפּיל וועט זיין באשאפן אין די שטריקל קעסיידערדיק בעקן.

"סטרינג קעסיידערדיק בעקן" איז גאָרנישט אָבער די ספּעציעל זכּרון צו האַלטן די שטריקל אַבדזשעקץ.

String s1 = "Java language"; 
String s2 = "Java language";

שטריקל אין דזשאַוואַ

שאַפֿן אַ שטריקל ניצן די נייַע קיווערד

ווען מיר וועלן האָבן 2 פאַרשידענע אַבדזשעקץ מיט די זעלבע שטריקל ווערט, מיר מאַכן אַ שטריקל ניצן די נייַ קיווערד ווי דיסקרייבד אונטן. אין דעם פאַל, JVM קריייץ צוויי פאַרשידענע שטריקל אַבדזשעקץ אין אַ קופּע זכּרון

String s1 = new String("Java");
String s2 = new String("Java");

שטריקל אין דזשאַוואַ

שטריקל מעטהאָדס Java

די java.lang.String קלאַס שטיצט פאַרשידן מעטהאָדס וואָס זענען געניצט פֿאַר פאַרשידענע שטריקל מאַניפּיאַליישאַנז ווי דיסקרייבד אונטן:

מעטאָדבאַשרייַבונגפּאַראַמעטערס
טשאַר טשאַראַט (ינט אינדעקס)קערט דער כאַראַקטער אין די ספּעסאַפייד אינדעקס פון די ינפּוט שטריקלאינדעקס - דער אינדעקס ווערט פון די שטריקל
int codePointAt (int אינדעקס)קערט די אוניקאָד ווערט פון די כאַראַקטער אין די ספּעסאַפייד אינדעקסאינדעקס - דער אינדעקס ווערט פון די שטריקל
int codePointBefore (int אינדעקס)רעטורנס די אוניקאָד ווערט פון די כאַראַקטער פאָרשטעלן איידער די ספּעסאַפייד אינדעקסאינדעקס - דער אינדעקס ווערט פון די שטריקל
ינט קאָמפּאַרע צו (שטריקל אנדערן שטריקל)פאַרגלייכט 2 סטרינגס באזירט אויף די אוניקאָד ווערט פון די אותיות און קערט נעגאַטיוו ווערט אויב עס פּריסידז די אַרגומענט שטריקל, אַנדערש קערט positive. די צוריקקער ווערט איז 0 אויב ביידע סטרינגס זענען גלייַךאנדער סטרינג - שטריקל צו פאַרגלייַכן מיט די שטריקל כייפעץ
ינט קאָמפּאַרעToIgnoreCase (שטריקל אַנדערסטרינג)די מעטהאָדס זענען ענלעך צו די קאָמפּאַרע, אַחוץ אַז עס יגנאָרז דעם פאַל.אנדער סטרינג - שטריקל צו פאַרגלייַכן מיט די שטריקל כייפעץ
שטריקל קאָנקאַט (שטריקל סטר)קאַנקאַטאַנייץ צוויי שטריקל וואַלועסstr - די שטריקל צו קאַנקאַטאַנייט מיט די שטריקל כייפעץ ווערט
באָאָלעאַן כּולל (טשאַרסעקווענסע C)טשעקס אויב די שטריקל כּולל די ספּעסאַפייד כאַראַקטער סיקוואַנס און קערט אמת אויב עס איז פאָרשטעלןc - כאַראַקטער סיקוואַנס צו געפֿינען אין די שטריקל
באָאָלעאַן אינהאַלט עקוואַלז (טשאַרעקווענסע C)טשעקס אויב די שטריקל כּולל די פּינטלעך אותיות און ריטשאַז אמת אויב עס איז פאָרשטעלןc - כאַראַקטער סיקוואַנס צו געפֿינען אין די שטריקל
באָאָלעאַן אינהאַלט עקוואַלז (StringBuffer sb)טשעקס אויב די שטריקל כּולל די ספּעסאַפייד שטריקל באַפער און קערט אמת אויב עס איז פאָרשטעלןsb - שטריקל באַפער צופרידן
באָאָלעאַן ענדס מיט (שטריקל סאַפיקס)טשעקס אויב די שטריקל ענדס מיט די ספּעסאַפייד סאַפיקס און קערט אמת אויב עס איז פאָרשטעלןסופיקס - דער סופיקס צו קאָנטראָלירן די שטריקל
באָאָלעאַן יקוואַלז (כייפעץ אָבד)טשעקס די ענלעכקייט פון די שטריקל כייפעץ מיט די כייפעץ דורכגעגאנגען און קערט אמת אויב גלייַךobj - די כייפעץ צו פאַרגלייַכן
באָאָלעאַן יקוואַלז יגנאָרעקאַסע (סטרינג סטר)פאַרגלייכט צוויי שטריקל ראַגאַרדלאַס דורך איגנאָרירן דעם פאַל און קערט אמת אויב ביידע סטרינגס זענען גלייַךstr - די שטריקל צו פאַרגלייַכן
int indexOf (int ch)קערט דער אינדעקס פון דער ערשטער פּאַסירונג פון די ספּעציפיצירט אוניקאָד כאַראַקטער אין די שטריקלch - אוניקאָד ווערט פון די כאַראַקטער
int indexOf (String str)רעטורנס דער אינדעקס פון דער ערשטער פּאַסירונג פון די ספּעסאַפייד סאַבסטרינג אין די שטריקלstr - די סאַבסטרישאַן ווערט פאָרשטעלן אין די שטריקל
באָאָלעאַן isBlank ()קערט אמת איז די שטריקל איז ליידיק אָדער כּולל בלויז ליידיק ספּייסאַז
באָאָלעאַן isEmpty ()קערט אמת אויב די שטריקל איז ליידיק (ד"ה לענג איז 0)
int lastindexOf (int ch)קערט דער אינדעקס פון די לעצטע פּאַסירונג פון די ספּעציפיצירט אוניקאָד כאַראַקטער אין די שטריקלch - אוניקאָד ווערט פון די כאַראַקטער
int lastindexOf (String str)קערט דער אינדעקס פון די לעצטע פּאַסירונג פון די ספּעסאַפייד סאַבסטרינג אין די שטריקלstr - די סאַבסטרישאַן ווערט פאָרשטעלן אין די שטריקל
ינט לענג ()קערט די לענג פון די שטריקל
באָאָלעאַן שוועבעלעך (String regex)קערט אמת אויב די שטריקל גלייַכן מיט די ספּעסאַפייד רעגולער אויסדרוקregex - דער רעגולער אויסדרוק צו זיין אָפּגעשטעלט
שטריקל איבערחזרן (ינט ציילן)קאַנקאַטאַנייץ די שטריקל באזירט אויף דער ציילןציילן - נומער פון מאָל צו קאַנקאַטאַנייט די אַרייַנשרייַב שטריקל
שטריקל פאַרבייַטן (טשאַר אָלטשאַר, טשאַר ניוטשאַר)קערט דער נייַ שטריקל דורך ריפּלייסינג אַלע פֿאַלן פון די כאַראַקטער מיט די נייַע כאַראַקטערoldchar - כאַראַקטער צו פאַרבייַטן
newchar - כאַראַקטער צו זיין ריפּלייסט
שטריקל [] שפּאַלטן (שטריקל רעגעקספּ)ספּליץ די שטריקל באזירט אויף די רעגולער אויסדרוק. עס קערט מענגעregexp - דעלימיטאָר צו שפּאַלטן די שטריקל
שטריקל [] שפּאַלטן (שטריקל רעגעקספּ, ינט שיעור)ספּליץ די שטריקל באזירט אויף די רעגולער אויסדרוק און די נומער פון מאָל עס דאַרף זיין געווענדטregexp - דעלימיטאָר צו שפּאַלטן די שטריקל
שיעור - נומער פון מאָל דעם מוסטער דאַרף זיין געווענדט
באָאָלעאַן סטאַרץ מיט (שטריקל פּרעפיקס)טשעקס אויב די געגעבן שטריקל סטאַרץ מיט די ספּעסאַפייד פּרעפיקס. קערט אמת אויב פאָרשטעלןפּרעפיקס - די פּרעפיקס צו קאָנטראָלירן די שטריקל
באָאָלעאַן סטאַרץ מיט (שטריקל פּרעפיקס, ינט טאָפפסעט)טשעקס אויב די געגעבן שטריקל סטאַרץ מיט די ספּעסאַפייד פּרעפיקס באזירט אויף די tooffset פּאַראַמעטערפּרעפיקס - די פּרעפיקס צו קאָנטראָלירן די שטריקל
טאָפפסעט - דער אינדעקס פֿון וואָס דאַרף זוכן
שטריקל פּאַס ()קערט אַ שטריקל מיט אַלע ווייץ ספּייסאַז אַוועקגענומען, ביידע לידינג און טריילינג
שטריקל פּאַס לידינג ()קערט אַ סאַבסטרינג פון די שטריקל מיט אַלע לידינג ספּייסאַז אַוועקגענומען
שטריקל פּאַסקערט אַ סאַבסטרישאַן פון די שטריקל מיט אַלע טריילינג ספּייסאַז אַוועקגענומען
CharSequence סובסעקווענסע (int startIndex, int endIndex)רעטורנס אַ כאַראַקטער סיקוואַנס פון די שטריקל באזירט אויף אָנהייב און סוף אינדעקסstartIndex - דער אינדעקס פֿון וואָס די סאַבסטרינג זאָל זיין ריטריווד
endIndex - דער אינדעקס ביז וואָס סאַבסטריישאַן זאָל זיין ריטריווד
שטריקל סובסטרינג (ינט סטאַרטינדעקס)קערט אַ סאַבסטרינג פון די שטריקל באזירט אויף די אָנהייב אינדעקסstartIndex - דער אינדעקס פֿון וואָס די סאַבסטרינג זאָל זיין ריטריווד
שטריקל סובסטרינג (ינט סטאַרטינדעקס, ינט ענדינדעקס)קערט אַ סאַבסטריישאַן פון די שטריקל באזירט אויף די אָנהייב און סוף אינדעקסstartIndex - דער אינדעקס פֿון וואָס די סאַבסטרינג זאָל זיין ריטריווד
endIndex - דער אינדעקס ביז וואָס סאַבסטריישאַן זאָל זיין ריטריווד
char [] צו CharArray ()קאָנווערץ די שטריקל צו כאַראַקטער מענגע
שטריקל צו לאָווערקאַסע ()קאַנווערץ אַלע אותיות אין די שטריקל צו קליין אותיות
שטריקל צו לאָווערקאַסע (לאָקאַל לאָקאַל)קאָנווערץ אַלע אותיות אין די שטריקל צו קליין אותיות באזירט אויף די היגע כּלליםlocale - די היגע כּללים צו זיין געווענדט
שטריקל צו שטריקל ()רעטורנס די שטריקל זיך
שטריקל טאָופּערקאַסע ()קאָנווערץ אַלע אותיות אין די שטריקל צו הויפּט קאַסעס
שטריקל toUpperCase (לאקאלע לאָקאַל)קאָנווערץ אַלע אותיות אין די שטריקל צו הויפּט קאַסעס באזירט אויף די היגע כּלליםlocale - די היגע כּללים צו זיין געווענדט
שטריקל טרים ()קערט אַ שטריקל מיט אַלע לידינג און טריילינג ספּייסאַז אַוועקגענומען
שטריקל פֿאָרמאַט שטריקל (שטריקל פֿאָרמאַט, אָבדזשעקט ... אַרגז)קערט אַ פאָרמאַטטעד שטריקל באזירט אויף די פֿאָרמאַט און טענותפֿאָרמאַטירונג - פֿאָרמאַטירונג ספּעציפיציר
args - טענות ריפערד צו דורך דעם פֿאָרמאַטירונג ספּעציפיציר
שטריקל פאַרבינדן (CharSequence דעלימיטער, CharSequence ... עלעמענטן)דזשאָינס די כאַראַקטער סיקוואַנס עלעמענטן ניצן די דעלימיטערדעלימיטאָר - דער דעלימיטער צו פאַרבינדן
עלעמענטן - די שטריקל עלעמענטן צו פאַרבינדן
שטריקל ווערט אָף (באָאָלעאַן b)רעטורנס די שטריקל פאַרטרעטונג פון די באָאָלעאַן אַרגומענט. אויב אמת איז דורכגעגאנגען, קערט אמתb - באָאָלעאַן ווערט ווי אמת אָדער פאַלש
שטריקל ווערט אָף (טשאַר C)רעטורנס שטריקל פאַרטרעטונג פון די כאַראַקטער אַרגומענטc - כאַראַקטער
שטריקל ווערט פון (טשאַר [] דאַטן)רעטורנס שטריקל פאַרטרעטונג פון די כאַראַקטער מענגע אַרגומענטדאַטן - כאַראַקטער מענגע
שטריקל ווערט אָף (טאָפּל ד)רעטורנס שטריקל פאַרטרעטונג פון די טאָפּל אַרגומענטד - טאָפּל ווערט
שטריקל ווערט אָף (לאָזנ שווימען F)רעטורנס שטריקל פאַרטרעטונג פון די לאָזנ שווימען אַרגומענטf - לאָזנ שווימען ווערט
שטריקל ווערט פון (ינט איך)רעטורנס שטריקל פאַרטרעטונג פון די ינטעגער אַרגומענטאיך - גאַנץ ווערט
שטריקל ווערט יף (לאַנג ל)רעטורנס שטריקל פאַרטרעטונג פון די לאַנג אַרגומענטך - לאַנג ווערט
שטריקל ווערט פון (כייפעץ אָבדזש)רעטורנס די שטריקל פאַרטרעטונג פון די כייפעץ אַרגומענטobj - כייפעץ
שטריקל ווערט פון (טשאַר [] דאַטן, ינט פאָטאָ, ינט ציילן)רעטורנס אַ שטריקל פאַרטרעטונג פון די ספּעציפיש סאַבסטרינג כאַראַקטער מענגע אַרגומענט באזירט אויף די פאָטאָ און ציילןדאַטן - כאַראַקטער מענגע
פאָטאָ - אָנהייב אינדעקס
ציילן - סאַבסטרינג לענג

בייַשפּיל: Java פּראָגראַם צו שאַפֿן אַ שטריקל פֿון מענגע אותיות

אין די אונטן ביישפּיל, מיר קאָנווערט אַן מענגע פון אותיות צו אַ שטריקל אין Java ניצן די נייַע קיווערד.

public class StringDemo1 {

  public static void main(String[] args) {
    char[] c = {'j','a','v','a'};
    String s = new String(c);
    System.out.println(s);
    
  }

}
Output:
java

בייַשפּיל: ניצן מעטהאָדס (), charAt () און indexOf ()

די אונטן ביישפּיל ווייזט איר ווי צו באַקומען אַ כאַראַקטער אין אַ באַזונדער אינדעקס, באַקומען די לענג פון אַ שטריקל און צוריקקריגן דעם אינדעקס פון אַ באַזונדער כאַראַקטער.

public class StringDemo2 {

  public static void main(String[] args) {
    String s1 = new String("Java tutorial");
    System.out.println("The character at index 6 is : " + s1.charAt(6));
    System.out.println("The length of the input string is : " + s1.length());
    System.out.println("The index of letter 'v' is : " + s1.indexOf('v'));
  }

}
Output:
The character at index 6 is : u
The length of the input string is : 13
The index of letter 'v' is : 2

בייַשפּיל: ניצן CompareTo (), contentEquals () און כּולל ()

דער בייַשפּיל ווייזט אַ פאַרגלייַך פון 2 סטרינגס אין Java

  1. קאָמפּאַרעטאָ () קערט דאָ אַ positive ינטאַדזשער זינט די אַרייַנשרייַב שטריקל סאַקסידאַד די אַרגומענט שטריקל.
  2. comparToIgnoreCase () קערט 0 ווייַל ביידע סטרינגס זענען גלייַך ראַגאַרדלאַס פון דעם פאַל.
  3. כּולל () קערט אמת זינט די אַרייַנשרייַב שטריקל כּולל די אַרגומענט שטריקל
  4. contentEquals () קערט פאַלש זינט די ינפּוט שטריקל כּולל נישט די פּינטלעך אַרגומענט שטריקל.
public class StringDemo2 {

  public static void main(String[] args) {
    String s1 = new String("Java tutorial");
    System.out.println("Comparison of input string with argument is : " + s1.compareTo("C++"));
    System.out.println("Comparison of input string with argument ignoring case is : " + s1.compareToIgnoreCase("JAVA TUTORIAL"));
    System.out.println("Output of contains method: " + s1.contains("tutorial"));
    System.out.println("Output of contentEquals method: " + s1.contentEquals("Java"));
    }
}
Output:
Comparison of input string with argument is : 7
Comparison of input string with argument ignoring case is : 0
Output of contains method: true
Output of contentEquals method: false

בייַשפּיל: ניצן יקוואַלז ()

1 רעזולטאַט איז פאַלש ווייַל דער פאַל איז ניט גלייך, כאָטש די אינהאַלט איז די זעלבע. 2 פּראָדוקציע איז אמת זינט אינהאַלט און פאַל גלייַכן.

3 פּראָדוקציע איז פאַלש ווייַל ביידע אינהאַלט איז אַנדערש.

public class StringDemo3 {

  public static void main(String[] args) {
    String s1 = "java tutorial";
    String s2 = "Java Tutorial";
    String s3 = "java tutorial";
    String s4 = "Tutorial cup";
    System.out.println(s1.equals(s2));
    System.out.println(s1.equals(s3));
    System.out.println(s1.equals(s4));
  }

}
Output:
false
true
false

בייַשפּיל: קאַנקאַטאַניישאַן פון סטרינגס

מיר קענען קאַנקאַטאַנייט 2 סטרינגס אין Java מיט קאָנקאַט () מעטאָד פון די Java שטריקל קלאַס. "+" איז אויך געניצט צו קאַנקאַטאַנייט 2 אָדער מער סטרינגס וואָס זענען יוזשאַוואַלי געניצט אין דרוק סטייטמאַנץ. בשעת קאַנקאַטאַנייטינג 2 סטרינגס, פּלאַץ איז נישט אַרייַנגערעכנט צווישן די סטרינגס. אין די אונטן ביישפּיל, שטריקל s3 כּולל די קאַנקאַטאַנייטיד ווערט פון s1 און s2 וואָס איז געניצט צוזאַמען מיט אַ נייַע שטריקל אין די דרוק ויסזאָגונג.

מיר קענען אויך קאַנקאַטאַנייט 2 סטרינגס אין Java מיט די מעטהאָדע (). דאָס וועט פאַרבינדן די ווערטער וואָס זענען דורכגעגאנגען אין דעם אַרגומענט מיט אַ ספּעציפיצירט דעלימיטער.

public class StringConcat {

  public static void main(String[] args) {
    String s1 = "Hello,";
    String s2 = "how are you";
    String s3 = s1.concat(s2);
    System.out.println(s3 + " today");
    System.out.println(s1.join(",", "welcome","to","tutorialcup"));
  }

}
Output:
Hello,how are you today
welcome,to,tutorialcup

בייַשפּיל: Java פּראָגראַם צו בייַטן שטריקל צווישן גרויס און קליין פאַל

public class StringCase {

  public static void main(String[] args) {
    String s1 = "Welcome to tutorialcup";
    System.out.println("Convert to lower case: " + s1.toLowerCase());
    System.out.println("Convert to upper case: " + s1.toUpperCase());

  }

}
Output:
Convert to lower case: welcome to tutorialcup
Convert to upper case: WELCOME TO TUTORIALCUP

בייַשפּיל: ניצן סאַבסטרינג אין Java

מיר קענען צוריקקריגן טייל פון די שטריקל אין Java מיט די סאַבסטרינג מעטאָד. דער אינדעקס ווערט סטאַרץ ביי 0.

public class StringDemo3 {

  public static void main(String[] args) {
    String s1 = "java tutorial";
    System.out.println(s1.substring(3));
    System.out.println(s1.substring(1, 10));
  }

}
Output:
a tutorial
ava tutor

בייַשפּיל: ניצן שפּאַלטן און פאַרבייַטן

שפּאַלטן איז אן אנדער מערסט געוויינט מעטהאָדס פון סטרינג אין Java. אין דעם בייַשפּיל, מיר ערשטער שפּאַלטן די אַרייַנשרייַב שטריקל מיט די דעלימיטער "". דעריבער דאָס פּרינץ יעדער וואָרט סעפּעראַטלי. דערנאָך מיר שפּאַלטן באזירט אויף די דעלימיטער, אָבער ספּעציפיצירן אַ שיעור ווי 2, וואָס מיטל אַז עס ספּליץ בלויז אין צוויי שטריקל מענגע וואַלועס.

אין די 1 בייַשפּיל פון ריפּלייסינג, מיר פאַרבייַטן די יחיד כאַראַקטער. אין דער ווייַטער, מיר פאַרבייַטן די כאַראַקטער סיקוואַנס.

public class StringDemo4 {

  public static void main(String[] args) {
    String str1 = "Welcome to java programming";
    System.out.println("Split output using delimiter:");
    //Split using only delimiter
    String[] arrval = str1.split(" ");
    for(int i=0;i<arrval.length;i++) {
      System.out.println(arrval[i]);
    }
    System.out.println("\nSplit output using delimiter and limit:");
    //Split using delimiter and limit
    String[] arrval2 = str1.split(" ", 2);
    for(int i=0;i<arrval2.length;i++) {
      System.out.println(arrval2[i]);
    }
    
    System.out.println("\nReplace output with character:");
    //Replace character
    String str2 = str1.replace('j', 'J');
    System.out.println(str2);
    System.out.println("\nReplace output with character sequence:");
    String str3 = str1.replace("java", "javascript");
    System.out.println(str3);
  }

}


Output:
Split output using delimiter:
Welcome
to
java
programming

Split output using delimiter and limit:
Welcome
to java programming

Replace output with character:
Welcome to Java programming

Replace output with character sequence:
Welcome to javascript programming

בייַשפּיל: Java Format string

מיר קענען פֿאָרמאַט קיין טיפּ פון דאַטן צו אַ שטריקל ניצן די פֿאָרמאַט אופֿן. דאָ, מיר נוצן שטריקל ("% s"), לאָזנ שווימען (% f ") און באָאָלעאַן ("% b ") ווי ביישפילן.

public class StringFormat {

  public static void main(String[] args) {
    String str = "Java";
    String formatstring1 = String.format("Programming language is %s",str);
    String formatstring2 = String.format("Float value is %f", 55.6789);
    String formatstring3 = String.format("Boolean value is %b", true);
    System.out.println(formatstring1);
    System.out.println(formatstring2);
    System.out.println(formatstring3);
  }

}
Output:
Programming language is Java
Float value is 55.678900
Boolean value is true

סאָף

אין דעם טוטאָריאַל, איר האָט געלערנט וועגן סטרינג אין Java, פאַרשידענע וועגן צו מאַכן עס און פאַרשידענע שטריקל מעטהאָדס און ביישפילן.

דערמאָנען