Լարային մեթոդներ Java



Java String

Java ծրագրավորման լեզվով տողը ոչ այլ ինչ է, քան նիշերի հաջորդականություն: Դա առավել լայնորեն օգտագործվող օբյեկտ է: Java String դասը ունի բազմաթիվ մեթոդներ, որոնք օգտագործվում են տարբեր մանիպուլյացիաների համար: Դա անփոփոխ է, նշանակում է, դրա արժեքը չի կարող փոխվել: Լարը համարժեք է նիշերի զանգվածի:

Java- ում տողի ստեղծում

Մենք կարող ենք տող ստեղծել ՝ օգտագործելով 2 տարբեր մեթոդներ.

  • Տողի օգտագործումը բառացիորեն
  • Օգտագործելով նոր հիմնաբառ

Ստեղծեք տող ՝ օգտագործելով տող բառացի

Սա ա – ի ստեղծման ամենաուղղակի միջոցն է լարային Javaավայում: Մենք կարող ենք տող ստեղծել ՝ արժեքը կրկնապատկերի մեջ ներառելով: Այստեղ String տիպի «արժեք» փոփոխականը պահում է «Java լեզու» անվամբ տողը:

String value = "Java language";

Երբ տողը ստեղծում ենք բառացիորեն, JVM- ն նախ ստուգում է «լարային կայուն լողավազանում», եթե այդ տողը գոյություն ունի: Եթե ​​դա գոյություն չունի, JVM- ն ստեղծում է լարային նոր օրինակ, այլապես կվերադարձվի միայն հղումը համակցված օրինակին: Օրինակ, ստորև նշված դեպքում երկու լարային օբյեկտներն ունեն նույն արժեքը: Այսպիսով, ստեղծվում է ընդամենը 1 օբյեկտ (այսինքն s1) և s2- ը կունենա հղում s1- ին: Սա նշանակում է, անկախ նրանից, թե երբևէ քանի լարային փոփոխական ենք ստեղծում նույն արժեքով, լարի կայուն լողավազանում կստեղծվի միայն 1 օրինակ:

«Լարային կայուն լողավազան» - ը ոչ այլ ինչ է, քան լարային առարկաները պահելու հատուկ հիշողություն:

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

Լար java- ում

Լար ստեղծում ՝ օգտագործելով նոր հիմնաբառ

Երբ մենք ուզում ենք ունենալ երկու տարբեր օբյեկտներ, որոնք ունեն նույն լարային արժեքը, ապա մենք ստեղծում ենք մի լար ՝ օգտագործելով նոր ստորև նկարագրված հիմնաբառ: Այս դեպքում JVM- ն կույտ հիշողության մեջ ստեղծում է 2 տարբեր լարային օբյեկտ

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

Լար java- ում

Լարային մեթոդներ Java

Java.lang.String դասը աջակցում է տարբեր մեթոդների, որոնք օգտագործվում են տարբեր լարային մանիպուլյացիաների համար, ինչպես նկարագրված է ստորև:

ՄեթոդՆկարագրությունՊարամետրեր
char charAt (int ինդեքս)Վերադարձնում է նիշը մուտքային տողի նշված ինդեքսումindex - տողի ինդեքսի արժեքը
int codePointAt (int ինդեքս)Վերադարձնում է նիշի միաոդ կոդային արժեքը նշված ինդեքսումindex - տողի ինդեքսի արժեքը
int codePointBefore (int ինդեքս)Վերադարձնում է նշված նիշից առաջ առկա նիշի միաոդ կոդային արժեքըindex - տողի ինդեքսի արժեքը
int համեմատել To (String anotherstring)Համեմատում է նիշերի յունիկոդ արժեքի հիման վրա 2 տող և վերադարձնում է բացասական արժեք, եթե այն նախորդում է փաստարկի տողին, հակառակ դեպքում ՝ դրական: Վերադարձի արժեքը 0 է, եթե երկու տողերը հավասար ենanotherstring - լար ՝ լարային օբյեկտի հետ համեմատելու համար
int compareToIgnoreCase (String anotherstring)Նման է համեմատության To մեթոդով, բացառությամբ, որ այն անտեսում է գործը:anotherstring - լար ՝ լարային օբյեկտի հետ համեմատելու համար
Լարային բծախնդրություն (String str)Միացնում է տողի երկու արժեքstr - Լարը, որը կցվելու է լարային օբյեկտի արժեքին
բուլյան պարունակություն (CharSekuence գ)Ստուգում է ՝ արդյոք տողը պարունակում է նշված նիշերի հաջորդականություն, և եթե առկա է, վերադառնում է trueգ - Նիշերի հաջորդականություն `լարում գտնելու համար
բուլյան բովանդակություն Equals (CharSekuence գ)Ստուգում է ՝ արդյոք տողը պարունակում է ճշգրիտ նիշերի հավասարություն, և եթե առկա է, վերադառնում է trueգ - Նիշերի հաջորդականություն `լարում գտնելու համար
բուլյան բովանդակություն Equals (StringBuffer sb)Ստուգում է ՝ արդյոք տողը պարունակում է նշված լարային բուֆեր, և եթե առկա է, վերադառնում է truesb - Լարային բուֆերային պարունակություն
բուլյան ծայրեր With (լարային ածանց)Ստուգում է ՝ արդյոք տողը ավարտվում է նշված վերջածանցով, և եթե առկա է, վերադառնում է trueածանց - տողում ստուգելու ածանց
բուլյան հավասար (օբյեկտի օբյեկտ)Ստուգում է լարային օբյեկտի նմանությունն անցած օբյեկտի հետ և հավասարության դեպքում վերադառնում է ճշմարիտobj - Համեմատության առարկա
boolean հավասար է IgnoreCase (String str)Անկախորեն համեմատում է երկու տող ՝ անտեսելով գործը և վերադառնում ճշմարիտ, եթե երկու տողերն էլ հավասար ենstr - Լարը համեմատելու համար
int indexOf (int ch)Վերադարձնում է տողում նշված միաունոդ նիշի առաջին առաջացման ինդեքսըch - նիշի յունիկոդային արժեք
int indexOf (String str)Վերադարձնում է լարում նշված ենթալարի առաջին առաջացման ինդեքսըstr - տողում առկա ենթալարային արժեքը
բուլյան isBlank ()Վերադարձնում է ճշմարիտը, որ տողը դատարկ է կամ պարունակում է միայն դատարկ տարածություններ
բուլյան is դատարկ ()Վերադառնում է ճիշտ, եթե տողը դատարկ է (այսինքն երկարությունը 0 է)
int lastindexOf (int ch)Վերադարձնում է լարում նշված միաունոդի նշանի վերջին առաջացման ինդեքսըch - նիշի յունիկոդային արժեք
int lastindexOf (String str)Վերադարձնում է լարում նշված ենթալարի վերջին առաջացման ինդեքսըstr - տողում առկա ենթալարային արժեքը
int երկարություն ()Վերադարձնում է տողի երկարությունը
բուլյան համընկնումներ (լարային regex)Վերադառնում է true, եթե տողը համապատասխանում է նշված կանոնավոր արտահայտությանըregex - Ստուգվող կանոնավոր արտահայտությունը
String կրկնում (int հաշիվ)Միացնում է լարը ՝ հիմնվելով հաշվարկի վրահաշվել - մուտքային տողը միացնելու համար մի քանի անգամ
Լարի փոխարինում (char oldchar, char newchar)Վերադառնում է նոր տողը ՝ նիշի բոլոր դեպքերը փոխարինելով նոր նիշովoldchar - փոխարինող նիշ
newchar - փոխարինվող նիշ
String [] split (string regexp)Պարբերաբար բաժանում է տողը: Այն վերադարձնում է զանգվածըregexp - տողը բաժանելու համար բաժանարար
String [] split (String regexp, int limit)Բաժանում է տողը `ելնելով կանոնավոր արտահայտությունից և կիրառման անհրաժեշտ քանակիցregexp - տողը բաժանելու համար բաժանարար
սահման - օրինակի կիրառման քանի անգամ
boolean startWith (Լարի նախածանց)Ստուգում է ՝ արդյոք տրված տողը սկսվում է նշված նախածանցով: Եթե ​​առկա է, ճշմարիտ է վերադառնումնախածանց - տողը ստուգելու նախածանց
boolean startWith (String նախածանց, int tooffset)Ստուգում է, արդյոք տրված տողը սկսվում է նշված նախածանցով ՝ ելնելով tooffset պարամետրից: Վերադարձնում է true, եթե առկա էնախածանց - տողը ստուգելու նախածանց
tooffset - ինդեքսը, որից պետք է սկսել որոնումը
Լարային ժապավեն ()Վերադարձնում է տողը հեռացված բոլոր սպիտակ տարածություններով ՝ և առաջատար, և հետևյալ
Լարային շերտի առաջատար ()Վերադառնում է տողի ենթալար `հեռացված բոլոր առաջատար տարածություններով
Լարային ժապավեն Traililing ()Վերադառնում է տողի ենթալար `հեռացված բոլոր հետևյալ տարածություններով
CharSequence ենթահաջորդություն (int startIndex, int endIndex)Վերադարձնում է տողի նիշերի հաջորդականությունը `հիմնվելով սկզբի և վերջի ցուցիչի վրաstartIndex - ինդեքսը, որից ենթաշարքը պետք է որոնվի
endIndex - ինդեքսը, մինչև որ ենթաշարքը պետք է որոնվի
Լարի ենթաշղթա (int startIndex)Վերադարձնում է տողի ենթալարը `ելակետային ինդեքսի հիման վրաstartIndex - ինդեքսը, որից ենթաշարքը պետք է որոնվի
Լարի ենթաշղթա (int startIndex, int endIndex)Վերադարձնում է տողի ենթալարը ՝ ելնելով մեկնարկի և վերջի ցուցանիշիցstartIndex - ինդեքսը, որից ենթաշարքը պետք է որոնվի
endIndex - ինդեքսը, մինչև որ ենթաշարքը պետք է որոնվի
char [] CharArray- ին ()Լարը վերափոխում է նիշերի զանգվածի
String toLowerCase ()Տողի բոլոր նիշերը վերափոխում է փոքրատառի
String toLowerCase (տեղային տեղայնացում)Լարի բոլոր նիշերը վերափոխում է փոքրատառի ՝ հիմնվելով տեղայնացման կանոնների վրաlocale - տեղական կանոնները, որոնք պետք է կիրառվեն
String toString ()Վերադառնում է տողը ինքը
String toUpperCase ()Տողի բոլոր նիշերը վերափոխում է մեծատառի
String toUpperCase (տեղային տեղայնացում)Լարի բոլոր նիշերը վերափոխում է մեծատառերի ՝ հիմնվելով տեղայնացման կանոնների վրաlocale - տեղական կանոնները, որոնք պետք է կիրառվեն
Լարային կտրվածք ()Վերադարձնում է տողը հեռացված բոլոր առաջատար և հետևյալ տարածություններով
String formatString (String format, Object ... args)Վերադարձնում է ձևաչափված տողը ՝ հիմնվելով ձևաչափի և փաստարկների վրաձևաչափ - ձևաչափի նշիչ
args - ձևաչափի նշիչի կողմից վկայակոչված փաստարկներ
Լարային միացում (CharSequence սահմանազատող, CharSequence ... տարրեր)Միանում է նիշերի հաջորդականության տարրերին ՝ օգտագործելով սահմանազատիչըսահմանազատող - միանալու սահմանազատող
տարրեր - լարային տարրերը, որոնք պետք է միանան
Լարի արժեքը (բուլյան բ)Վերադարձնում է բուլյան փաստարկի լարային ներկայացումը: Եթե ​​ճշմարտությունն անցել է, վերադառնում է ճշմարիտբ - բուլյան արժեքը որպես ճշմարիտ կամ կեղծ
Լարի արժեքը (char գ)Վերադարձնում է նիշի արգումենտի տողի ներկայացումըգ - բնույթ
String valueOf (char [] տվյալներ)Վերադարձնում է նիշերի զանգվածի փաստարկի տողի ներկայացումըտվյալներ - նիշերի զանգված
Լարի արժեքը (կրկնակի դ)Վերադարձնում է կրկնակի փաստարկի տողի ներկայացումըd - կրկնակի արժեք
Լարի արժեքը (բոց f)Վերադարձնում է float արգումենտի տողի ներկայացումըf - բոց արժեք
Լարի արժեքը (int i)Վերադարձնում է ամբողջ փաստարկի տողի ներկայացումըi - ամբողջ արժեք
Լարի արժեքը If (երկար l)Վերադարձնում է երկար փաստարկի տողի ներկայացումըլ - երկար արժեք
Լարի արժեքO (օբյեկտի օբյեկտ)Վերադարձնում է օբյեկտի փաստարկի լարային ներկայացումըobj - առարկա
String valueOf (char [] data, int offset, int count)Վերադարձնում է տողի ներկայացումը հատուկ ենթալարի նիշի զանգվածի փաստարկին `հիմնված օֆսեթի և հաշվարկի վրատվյալներ - նիշերի զանգված
օֆսեթ - սկսել ինդեքսը
հաշվարկ - ենթաշարքի երկարությունը

Օրինակ ՝ Java ծրագիր ՝ զանգվածի նիշերից տող ստեղծելու համար

Ստորև բերված օրինակում մենք փոխարկում ենք an- ը դասավորություն նիշերի նիշերը 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

Օրինակ. Օգտագործելով համեմատել To (), contentEquals () և պարունակում է ()

Այս օրինակը ցույց է տալիս Java- ի 2 տողի համեմատությունը

  1. compareTo () –ն այստեղ վերադարձնում է դրական ամբողջ թիվ, քանի որ մուտքային տողը հաջորդում է փաստարկային տողին:
  2. compareToIgnoreCase () - ը վերադարձնում է 0, քանի որ երկու տողերն էլ անկախ գործից հավասար են:
  3. պարունակում է () true է վերադառնում, քանի որ մուտքային տողը պարունակում է փաստարկի տող
  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

Օրինակ ՝ տողերի միացում

Մենք կարող ենք Java- ում միացնել 2 տող ՝ օգտագործելով concat () Java- ի մեթոդը Լարային դաս: «+» - ը նաև օգտագործվում է 2 կամ ավելի տողերի միացման համար, որոնք սովորաբար օգտագործվում են տպագիր հայտարարություններում: 2 լարերը միացնելիս տարածությունը տողերի մեջ չի ներառվում: Ստորև բերված օրինակում, s3 տողը պարունակում է s1 և s2 համակցված արժեքը, որն օգտագործվում է տպման հայտարարության մեջ նոր տողի հետ միասին:

Java- ում կարող ենք նաև միացնել 2 տող ՝ օգտագործելով join () մեթոդը: Սա կմիանա վեճում ընդունված բառերը սահմանված սահմանաչափի հետ:

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- ում substring օգտագործելը

Մենք կարող ենք 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

Օրինակ ՝ օգտագործելով պառակտել և փոխարինել

Split- ը String- ում 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 Ձևաչափի տող

Մենք կարող ենք ցանկացած ձևաչափել տվյալների տեսակը մի տողի ՝ օգտագործելով ձևաչափի մեթոդը: Այստեղ որպես օրինակ օգտագործում ենք տող («% 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- ում String- ի, դրա ստեղծման տարբեր ձևերի և լարային տարբեր մեթոդների մասին:

Մանրամասն