తీగలతో పని చేసే ఉదాహరణలు

1. సంయోగం (తీగలను విలీనం చేయడం)

మీరు జావాలో తీగలతో చేయగల ఈ వివేక మరియు సరళమైన విషయం ఉంది: మీరు వాటిని కలిసి జిగురు చేయవచ్చు. ఈ చర్యను సంయోగం అంటారు . మేము దానిని ఎలా గుర్తుంచుకుంటాము: కాన్-క్యాట్-ఎన్-నేషన్. దీనిని తరచుగా "జాయినింగ్ స్ట్రింగ్స్" లేదా "కంబైనింగ్ స్ట్రింగ్స్" అని పిలుస్తారు.

రెండు పంక్తులను కలపడానికి, మీరు +గుర్తును ఉపయోగించండి. ఇది చాలా సులభం:

"value1" + "value2"

ఉదాహరణలు:

String name = "Steve" + "Steve";

String city = "New York" + "Steve";

String message = "Hello! " + "Steve";

మరియు, వాస్తవానికి, మీరు ఒకే సమయంలో చాలా స్ట్రింగ్స్‌లో చేరవచ్చు మరియు మీరు స్ట్రింగ్స్ మరియు వేరియబుల్స్‌లో కూడా చేరవచ్చు.

ఉదాహరణలు:

String name = "Steve";
String city = "New York";
String message = "Hello!" + city + name + city;

చివరి ఉదాహరణలో, లో టెక్స్ట్ message చదవడం కష్టంగా ఉందని మీరు చూడవచ్చు, ఎందుకంటే అందులో ఖాళీలు లేవు. ఒకటి లేదా అంతకంటే ఎక్కువ ఖాళీలను సూచించడానికి, మీరు వాటిని కోడ్‌లో వ్రాసి, ఆపై వాటిని డబుల్ కోట్‌లలో చుట్టాలి. ఇది ధ్వనించే దాని కంటే సులభం:

" "

మార్గం ద్వారా, మీరు కోట్‌ల మధ్య ఎటువంటి ఖాళీలను ఉంచకపోతే (అంటే మీరు వరుసగా రెండు డబుల్ కోట్‌లను వ్రాస్తారు), మీరు "ఖాళీ స్ట్రింగ్" అని పిలవబడే దాన్ని పొందుతారు:

""

ఒక వైపు, మనకు స్ట్రింగ్ ఉన్నట్లు అనిపిస్తుంది. కానీ మరోవైపు, మేము ఈ స్ట్రింగ్‌ను ప్రదర్శించినప్పుడు, ఏమీ ప్రదర్శించబడదు. మరియు మేము దానిని ఇతర తీగలతో కలిపినప్పుడు, ఏమీ జరగదు. ఇది తీగలకు మాత్రమే అదనంగా సున్నా లాంటిది.

2. స్ట్రింగ్‌గా మార్చడం

పైన చెప్పినట్లుగా, జావా డెవలపర్లు ఖచ్చితంగా జావాలోని ప్రతి వేరియబుల్, ఆబ్జెక్ట్ మరియు ఎక్స్‌ప్రెషన్‌ను టైప్‌గా మార్చవచ్చని నిర్ధారించుకున్నారు String.

ఇంకా చెప్పాలంటే, మనం Stringవేరే రకంతో aని కలిపినప్పుడు ఇది స్వయంచాలకంగా జరుగుతుంది . ఉదాహరణలు:

int a = 5;
String name = "Steve" + a;

int a = 5;
String city = a + "New York" + a;

int number = 10;
String code = "Yo";
String message = "Hello! " + number + code;

మూడు సందర్భాల్లో, మేము ప్రశాంతంగా intమరియు Stringవేరియబుల్స్‌ని కలిపి ఉంచాము మరియు ఫలితం ఎల్లప్పుడూ ఒక String.

ఉదాహరణలు:

int a = 5;
String name = "1" + a;

int a = 5;
String city = a + "9" + a;

int number = 10;
String code = "10";
String message = "" + number + code;

ప్లస్ కార్యకలాపాలు ఎడమ నుండి కుడికి అమలు చేయబడతాయి, కాబట్టి ఫలితం కొంతవరకు ఊహించనిది కావచ్చు. ఉదాహరణ:

int a = 5;
String name = a + a + "1" + a;

3. స్ట్రింగ్‌ను సంఖ్యగా మార్చడం

జావాలో సంఖ్యను స్ట్రింగ్‌గా మార్చడం, దానిని ఖాళీ స్ట్రింగ్‌గా మార్చడం అంత సులభం:

String str = "" + number;

కానీ మీరు స్ట్రింగ్‌ను నంబర్‌గా మార్చాల్సిన అవసరం ఉంటే? సరే, ప్రతి స్ట్రింగ్ సంఖ్యగా మార్చబడదు. కానీ స్ట్రింగ్ సంఖ్యలను మాత్రమే కలిగి ఉంటే, మీరు చేయవచ్చు. తరగతిలో దీని కోసం ఒక ప్రత్యేక పద్ధతి ఉంది Integer.

సంబంధిత ప్రకటన ఇలా కనిపిస్తుంది:

int x = Integer.parseInt(string);

 పూర్ణాంక వేరియబుల్ యొక్క డిక్లరేషన్ ఎక్కడ ఉంది మరియు  ఇది ఒక సంఖ్యను సూచించే స్ట్రింగ్ (అంటే అంకెలతో కూడిన స్ట్రింగ్).int xxstring

ఉదాహరణలు:

String str = "123";
int number = Integer.parseInt(str);

int number = Integer.parseInt("321");

int number = Integer.parseInt("321" + 0);

int number = "321";

4. ఆబ్జెక్ట్/ప్రిమిటివ్‌ని స్ట్రింగ్‌గా మార్చడం

String.valueOf()ఏదైనా జావా క్లాస్ లేదా ఏదైనా ఆదిమ డేటా రకాన్ని స్ట్రింగ్‌గా మార్చడానికి, మీరు ఈ పద్ధతిని ఉపయోగించవచ్చు :

public class StringExamples {
    public static void main(String[] args) {
        String a = String.valueOf(1);
        String b = String.valueOf(12.0D);
        String c = String.valueOf(123.4F);
        String d = String.valueOf(123456L);
        String s = String.valueOf(true);

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(s);
        
        /*
        Output:
        1
        12.0
        123.4
        123456
        true
         */
    }
}

5. తీగలతో పనిచేయడానికి కొన్ని పద్ధతులు

చివరకు, నేను తరగతి యొక్క అనేక పద్ధతుల గురించి మాట్లాడాలనుకుంటున్నాను String.

length()పద్ధతి

స్ట్రింగ్ యొక్క పొడవును పొందేందుకు ఈ length() పద్ధతి మిమ్మల్ని అనుమతిస్తుంది , అంటే అందులో ఎన్ని అక్షరాలు ఉన్నాయి.

ఉదాహరణలు:

String name = "Rome";
int count = name.length();

int count = "".length();

String name = "Rom";
int count = (name + 12).length();

మీరు ఈ పద్ధతులను దేనిలోనైనా కాల్ చేయవచ్చు, దీని రకం String, వ్యక్తీకరణ కూడా:

(name + 12).length()

toLowerCase()పద్ధతి

toLowerCase() స్ట్రింగ్‌లోని అన్ని అక్షరాలను చిన్న అక్షరానికి మార్చడానికి ఈ పద్ధతి మిమ్మల్ని అనుమతిస్తుంది :

ఉదాహరణలు:

String name = "Rom";
String name2 = name.toLowerCase();

String name = "".toLowerCase();

String name = "ROM123";
String name2 = name.toLowerCase();

toUpperCase()పద్ధతి

toUpperCase() స్ట్రింగ్‌లోని అన్ని అక్షరాలను పెద్ద అక్షరానికి మార్చడానికి ఈ పద్ధతి మిమ్మల్ని అనుమతిస్తుంది :

ఉదాహరణలు:

String name = "Rom";
String name2 = name.toUpperCase();

String name = "rom123";
String name2 = name.toUpperCase();