Լարերը կերպարների հաջորդականություն են: Օրինակ ՝ «Բարև»: լար է, քանի որ այն կազմված է «H», «e», «l», «l», «o» և «!» կերպարներից: Java- ում տողերը օբյեկտներ են, ինչը նշանակում է, որ կա String դաս, որն ունի դաշտեր և մեթոդներ: Մենք կարող ենք օգտագործել String դասի մեթոդները ՝ տողերը շահարկելու համար:
Քայլեր
Մեթոդ 1 5 -ից. Ստեղծեք տող
Քայլ 1. Ստեղծեք տող `օգտագործելով String դասի կոնստրուկտորը:
String str = new String («Բարև Ձեզ»);
Քայլ 2. Ստեղծեք տող `ուղղակիորեն նշանակելով տող:
Քայլ 3. Փորձեք օրինակ:
Ահա մի օրինակելի ծրագիր, որը ստեղծում է լար երկու տարբեր եղանակներով:
public class StringManipulation {public static void main (String args) {String str1 = new String («Լարը ստեղծվել է կոնստրուկտորով»); String str2 = "Լարը ստեղծվել է առանց կոնստրուկտորի:"; System.out.println (str1); System.out.println (str2); }}
Մեթոդ 2 5 -ից. Գտեք տողի երկարությունը
Քայլ 1. Հասկացեք, թե ինչ է նշանակում գտնել տողի երկարությունը:
Լարի երկարությունը տողի պարունակող նիշերի քանակն է: Օրինակ ՝ «Բարև!» Տողի երկարությունը: 6 է, քանի որ այն ունի 6 նիշ:
Քայլ 2. Հրավիրեք
երկարություն ()
մեթոդը String օբյեկտի վրա և արդյունքը պահեք ամբողջ փոփոխականում:
int strLength = str.length ();
Քայլ 3. Տվեք այն:
Ահա մի օրինակելի ծրագիր, որը գտնում է տողի երկարությունը:
public class StringManipulation {public static void main (String args) {String str = "Hello!"; int strLength = str.length (); System.out.println ("\" " + str +" / " - ի երկարությունը" + strLength + "."); }}
Մեթոդ 3 5 -ից. Հակադարձել տողը
Քայլ 1. Հասկացեք, թե ինչ է նշանակում փոխել տողը:
Լարի հակադարձումը նշանակում է տողի մեջ նիշերի կարգի փոփոխություն: Օրինակ ՝ «Բարև!» Տողի հակառակ կողմը: է "! olleH": Java- ում տողը հակադարձելու բազմաթիվ եղանակներ կան:
Քայլ 2. Օգտագործեք StringBuffer դասի հակառակ մեթոդը:
Ստեղծեք StringBuffer օբյեկտ, որը վերցնում է այն տողը, որը ցանկանում եք հակադարձել որպես պարամետր: Օգտագործեք StringBuffer- ի հակադարձ () մեթոդը և այնուհետև ստացեք նոր հակադարձ տողը ՝ օգտագործելով toString () մեթոդը:
public class StringManipulation {public static void main (String args) {String str = "Hello!"; StringBuffer բուֆեր = նոր StringBuffer (փող); String reversedStr = buffer.reverse (). ToString (); System.out.println ("Տողի հակադարձ \" " + փող +" / "է \" " + հակադարձ STR +" / "."); }}
Քայլ 3. Կրկնեք տողի սիմվոլները հակառակ ձևով ՝ յուրաքանչյուր կրկնության դեպքում դրանք կցելով StringBuffer- ին:
Ստեղծեք նոր StringBuffer օբյեկտ, որը նախաստորագրված է տողի երկարությամբ, որը ցանկանում եք հակադարձել որպես պարամետր: Այնուհետև օգտագործեք for loop ՝ տողի միջով կրկնվելու համար ՝ սկսած տողի վերջին նիշից և վերջացրած տողի առաջին նիշով: Յուրաքանչյուր կրկնության ժամանակ կցեք այդ ցուցանիշի բնույթը StringBuffer- ին: Առբերեք նոր հակադարձ տողը ՝ օգտագործելով toString () մեթոդը:
public class StringManipulation {public static void main (String args) {String str = "Hello!"; StringBuffer բուֆեր = նոր StringBuffer (str.length ()); համար (int i = str.length ()-1; i> = 0; i--) {buffer.append (str.charAt (i)); } String reversedStr = buffer.toString (); System.out.println ("Տողի հակադարձ \" " + փող +" / "է \" " + հակադարձ STR +" / "."); }}
Քայլ 4. Գրեք հետադարձ գործառույթ ՝ տողը հակադարձելու համար:
Ռեկուրսիվ ֆունկցիայում հիմնական գործը / պայմանն այն է, եթե տողը զրո է կամ եթե տողի երկարությունը ոչ մեկից փոքր է կամ հավասար: Հակառակ դեպքում, հակառակ () մեթոդը կրկին կանչվում է տողից հանած առաջին նիշը, իսկ առաջին նիշը ամրացվում է վերջում: Այսպիսով, եթե մենք ընդունենք «Բարև!» Տողը, ապա դրանից հետո առաջին հակադարձ () կանչը կունենա «ello!» Պարամետրը:
public class StringManipulation {public static void main (String args) {String str = "Hello!"; Լարը փոխված է Str = հակառակ (փող); System.out.println ("Տողի հակադարձ \" " + փող +" / "է \" " + հակադարձ STR +" / "."); } private static String հակառակ (String str) {if (str == null || str.length () <= 1) return str; վերադարձ հակառակ (str.substring (1)) + str.charAt (0); }}
Քայլ 5. Տողը փոխակերպեք նիշերի զանգվածի, այնուհետև փոխեք առաջինը և վերջինը, երկրորդը և երկրորդը վերջինին և այլն:
կերպարներ: Սկզբում տողը փոխակերպեք կերպարների զանգվածի ՝ օգտագործելով տողի toCharArray () մեթոդը: Ստացեք զանգվածի վերջին նիշի ինդեքսը, որը հավասար է զանգվածի մինուս մեկին: Այնուհետև կրկնեք զանգվածի միջով ՝ փոխելով i- ըրդ նիշը և indexOfLastChar - ըրդ բնավորությունը յուրաքանչյուր կրկնում. Ի վերջո, բնույթի զանգվածը վերադարձրեք տողի:
public class StringManipulation {public static void main (String args) {String str = "Hello!"; char charArray = str.toCharArray (); int indexOfLastChar = charArray.length - 1; համար (int i = 0; i <charArray.length/2; i ++) {char temp = charArray ; charArray = charArray [indexOfLastChar - i]; charArray [indexOfLastChar - i] = ջերմաստիճան; } String reversedStr = նոր տող (charArray); System.out.println ("Տողի հակադարձ \" " + փող +" / "է \" " + հակադարձ STR +" / "."); }}
Քայլ 6. Վերանայեք ձեր արդյունքը:
Ահա ելքը, որը ստացվում է տողերի հակադարձման այս մեթոդներից որևէ մեկից:
Մեթոդ 4 -ից 5 -ը. Կտրեք սպիտակը տողում
Քայլ 1. Հասկացեք, թե ինչ է նշանակում լարերի մեջ սպիտակ տարածություն կտրել:
Java- ում տողը կտրելը նշանակում է հեռացնել տողի առաջատար և հետևող սպիտակ տարածությունը: Օրինակ, եթե ունեք տողը"
Բարեւ աշխարհ!
և ցանկանում եք, որ այն ասի «Բարև, աշխարհ», առանց սկզբի և վերջի սպիտակ տարածության, կարող եք կտրել տողը: Լարերի դասը տրամադրում է կտրելու () մեթոդը, որը վերադարձնում է տողի պատճենը հեռացվող կամ հեռացող սպիտակ տարածությունը կամ սկզբնական տողը, եթե այն չունի առաջատար կամ հետին սպիտակ տարածք:
Քայլ 2. Սպիտակ տարածությունը կտրելու համար օգտագործեք String դասի trim () մեթոդը String օբյեկտի վրա:
Նկատի ունեցեք, որ trim () մեթոդը բացառություն կանի, եթե տողը զրո է: Trim () մեթոդը չի փոխի սկզբնական տողի բովանդակությունը, քանի որ Java- ում տողերը անփոփոխ են, ինչը նշանակում է, որ տողի վիճակը չի կարող փոփոխվել այն ստեղծվելուց հետո: Ավելի շուտ, trim () մեթոդը կվերադարձնի նոր տող, որի սպիտակ տարածքը կտրված է:
String trimmedStr = str.trim ();
Քայլ 3. Փորձեք օրինակ:
Ահա մի օրինակելի ծրագիր, որը կրճատում է տողի սպիտակ տարածությունը.
public class StringManipulation {public static void main (String args) {String str = "Hello!"; String trimmedStr = str.trim (); System.out.println ("Original String is \" " + str +" / "."); System.out.println ("Կտրված տողը \" " + trimmedStr +" / "."); }}
Մեթոդ 5 -ից 5 -ը ՝ Լարը պառակտել
Քայլ 1. Հասկացեք, թե ինչ է նշանակում տող բաժանել:
Լարը Java- ում պառակտելը նշանակում է որոշակի սահմանազատիչով տողը բաժանել ենթատողերի զանգվածի: Օրինակ, եթե «կարմիր, կապույտ, կանաչ, դեղին, վարդագույն» տողը բաժանեմ ստորակետով `որպես սահմանազատիչ, ես կստանամ զանգվածը {" կարմիր "," կապույտ "," կանաչ "," դեղին "," վարդագույն " "}. Ահա տողը բաժանելու երեք տարբեր եղանակներ:
Քայլ 2. Օգտագործեք
StringTokenizer
տողը նշանավորելու համար:
Ներմուծում
java.util. StringTokenizer
. Այնուհետեւ ստեղծեք a- ի նոր օրինակ
StringTokenizer
նշանավորելու տողը և սահմանաչափը ՝ որպես պարամետրեր: Եթե սահմանաչափը որպես պարամետր չեք մուտքագրում, սահմանազատիչը ինքնաբերաբար լռելյայն կդառնա սպիտակ տարածություն: Այն բանից հետո, երբ դուք ունեք
StringTokenizer
կարող եք օգտագործել
nextToken ()
յուրաքանչյուր նշան ստանալու եղանակը:
ներմուծում java.util. Arrays; ներմուծել java.util. StringTokenizer; public class StringManipulation {public static void main (String args) {String str = "կարմիր, կանաչ, կապույտ, դեղին, վարդագույն"; StringTokenizer tokenizer = նոր StringTokenizer (փող, ","); int numberOfTokens = tokenizer.countTokens (); Լար splitArr = նոր Լար [numberOfTokens]; համար (int i = 0; i <numberOfTokens; i ++) {splitArr = tokenizer.nextToken (); } System.out.println ("\ nOriginal String:" + str); System.out.println ("Split Array:" + Arrays.toString (splitArr) + "\ n"); }}
Java 1.4 -ից առաջ,
StringTokenizer
class- ն օգտագործվում էր Java- ում տողեր բաժանելու համար: Բայց հիմա, օգտագործման
StringTokenizer
հուսալքված է և դրա օգտագործումը
պառակտում ()
մեթոդը մեջ
Լարային
դասը կամ դրա օգտագործումը
java.util.regex
Քայլ 3. Օգտագործեք
Լարային
դասարանների
պառակտում ()
մեթոդը:
The
պառակտում ()
մեթոդը սահմանաչափը կընդունի որպես պարամետր և կվերադարձնի ենթալարերի զանգված, որոնք նույնն են
StringTokenizer
ներմուծում java.util. Arrays; public class StringManipulation {public static void main (String args) {String str = "կարմիր, կանաչ, կապույտ, դեղին, վարդագույն"; Լար splitArr = str.split (","); System.out.println ("\ nOriginal String:" + str); System.out.println ("Split Array:" + Arrays.toString (splitArr) + "\ n"); }}
Քայլ 4. Օգտագործեք սովորական արտահայտություններ `տողը պառակտելու համար:
Ներմուծում
java.util.regex. Pattern
. Օգտագործեք ՝
կազմել ()
-ի մեթոդը
Կաղապար
դասը սահմանել սահմանազատիչը և այնուհետև տալ
պառակտում ()
մեթոդ այն տողը, որը ցանկանում եք պառակտել: The
Կաղապար
կվերադարձնի ենթալարերի զանգված:
ներմուծում java.util. Arrays; ներմուծել java.util.regex. Pattern; public class StringManipulation {public static void main (String args) {String str = "կարմիր, կանաչ, կապույտ, դեղին, վարդագույն"; Լար splitArr = Pattern.compile (",").split (str); System.out.println ("\ nOriginal String:" + str); System.out.println ("Split Array:" + Arrays.toString (splitArr) + "\ n"); }}
Քայլ 5. Վերանայեք ձեր արդյունքը:
Ահա ելքը, որը ստացվում է տողերի պառակտման այս մեթոդներից որևէ մեկից:
