తప్పించుకునే పాత్రలు

1. అక్షరాలు తప్పించుకోవడానికి గల కారణాలు

ఒకప్పుడు, కోడ్‌లో అక్షరాల స్ట్రింగ్‌ను వ్రాయడానికి, మీరు వాటిని డబుల్ కోట్‌లలో చుట్టాలని మీరు తెలుసుకున్నారు. ఫలితంగా ఒక స్ట్రింగ్ అక్షరార్థం .

అయితే స్ట్రింగ్ లిటరల్‌లో కొటేషన్ మార్కులు అవసరమైతే మనం ఏమి చేస్తాము? కోట్‌లను కలిగి ఉన్న స్ట్రింగ్ — ఏది సులభంగా ఉంటుంది?

మనం వచనాన్ని ప్రదర్శించాలనుకుంటున్నాము "Friends" was nominated for an "Oscar". మీరు అది ఎలా చేశారు?

String s = ""Friends" was nominated for an "Oscar"";

సమస్య ఏమిటంటే మీరు పూర్తిగా ఊహించని కోడ్‌ని వ్రాస్తున్నారని కంపైలర్ భావిస్తుంది:

String s = ""Friends" was nominated for an "Oscar"";

కంపైలర్ కోడ్‌లో డబుల్ కోట్‌లను ఎదుర్కొన్న తర్వాత, అది అనుసరించే వాటిని స్ట్రింగ్ లిటరల్‌గా పరిగణిస్తుంది. తదుపరి డబుల్ కొటేషన్ మార్క్ స్ట్రింగ్ యొక్క ముగింపును అక్షరార్థంగా సూచిస్తుంది.

కాబట్టి మీరు లిటరల్ లోపల డబుల్ కోట్‌లను ఎలా వ్రాస్తారు?

2. తప్పించుకునే పాత్రలు

ఒక మార్గం ఉంది. దానిని తప్పించుకునే పాత్రలు అంటారు . మీరు టెక్స్ట్ స్ట్రింగ్‌లో కొటేషన్ మార్కులను వ్రాయండి. మరియు కోట్‌లకు ముందు, మీరు \( బ్యాక్‌స్లాష్ ) చిహ్నాన్ని జోడించండి.

సరిగ్గా వ్రాసినప్పుడు స్ట్రింగ్ లిటరల్ ఎలా ఉంటుంది:

String s = "\"Friends\" was nominated for an \"Oscar\"";

కంపైలర్ ప్రతిదీ సరిగ్గా అర్థం చేసుకుంటుంది మరియు బ్యాక్‌స్లాష్ తర్వాత కొటేషన్ గుర్తును సాధారణ కొటేషన్ గుర్తుగా పరిగణించదు .

ఇంకా ఏమిటంటే, మీరు ఈ స్ట్రింగ్‌ను స్క్రీన్‌కి అవుట్‌పుట్ చేస్తే, బ్యాక్‌స్లాష్‌లతో కూడిన కోట్‌లు సరిగ్గా ప్రాసెస్ చేయబడతాయి మరియు టెక్స్ట్ ఎలాంటి బ్యాక్‌స్లాష్‌లు లేకుండా ప్రదర్శించబడుతుంది:"Friends" was nominated for an "Oscar"

మరో ముఖ్యమైన అంశం. బ్యాక్‌స్లాష్‌కు ముందు ఉన్న కొటేషన్ గుర్తు ఒకే అక్షరాన్ని సూచిస్తుంది: మేము మా కోడ్‌లోని స్ట్రింగ్ లిటరల్స్‌ను గుర్తించే కంపైలర్ సామర్థ్యానికి అంతరాయం కలిగించని స్లిక్ సంజ్ఞామానాన్ని ఉపయోగిస్తున్నాము. మీరు వేరియబుల్‌కు కోట్‌లను కేటాయించవచ్చు char:

char c = '\"';

char c = '"';

3. అక్షరాలు తప్పించుకునేటప్పుడు సంభవించే సాధారణ పరిస్థితులు

డబుల్ కోట్‌లతో పాటు, కంపైలర్ ప్రత్యేక పద్ధతిలో నిర్వహించే అనేక ఇతర అక్షరాలు ఉన్నాయి. ఉదాహరణకు, ఒక లైన్ బ్రేక్.

లిటరల్‌కి లైన్ బ్రేక్‌ని ఎలా జోడించాలి? దీని కోసం ప్రత్యేక కలయిక కూడా ఉంది:

\n

మీరు స్ట్రింగ్ లిటరల్‌కి లైన్ బ్రేక్‌ను జోడించాలనుకుంటే, మీరు కేవలం రెండు అక్షరాలను జోడించాలి: \n.

ఉదాహరణ:

System.out.println("Best regards, \n Anonymous");
             

Best regards,
Anonymous

ఇలా మొత్తం 8 ప్రత్యేక కలయికలు ఉన్నాయి, వీటిని ఎస్కేప్ సీక్వెన్సులు అని కూడా అంటారు . వారు ఇక్కడ ఉన్నారు:

వాటిలో ఇద్దరితో మీకు బాగా తెలుసు, కానీ మిగిలిన 6 అర్థం ఏమిటి?

\tఅనేది ట్యాబ్ క్యారెక్టర్

ఈ వచనం టెక్స్ట్‌లో కనిపించినప్పుడు, Tabటైప్ చేస్తున్నప్పుడు కీని నొక్కడానికి ఇది సమానం. ఇది దానిని అనుసరించే వచనాన్ని మారుస్తుంది మరియు వచనాన్ని సమలేఖనం చేయడం సాధ్యం చేస్తుంది.

ఉదాహరణ:

System.out.println("0\t1\t2\t3");
System.out.println("0\t10\t20\t30");
System.out.println("0\t100\t200\t300");

0       1        2        3
0       10       20       30
0       100      200      300

\bఅంటే 'ఒక అక్షరం వెనక్కి వెళ్లు'

Backspaceస్ట్రింగ్‌లోని ఈ క్రమం కీబోర్డ్‌లోని కీని నొక్కడానికి సమానం . ఇది దాని ముందు ఉన్న అక్షరాన్ని తొలగిస్తుంది:

System.out.println("Hello\b\b World");

Hell World!

\rక్యారేజ్ రిటర్న్ క్యారెక్టర్

ఈ అక్షరం వచనాన్ని మార్చకుండా కర్సర్‌ను ప్రస్తుత పంక్తి ప్రారంభానికి తరలిస్తుంది. తదుపరి ఏది ప్రదర్శించబడినా అది ఇప్పటికే ఉన్న స్ట్రింగ్‌ను ఓవర్‌రైట్ చేస్తుంది.

ఉదాహరణ:

System.out.println("Greetings\r World!");

World!

\fఅనేది పేజీ ఫీడ్ క్యారెక్టర్

ఈ గుర్తు మొదటి డాట్ మ్యాట్రిక్స్ ప్రింటర్ల రోజుల నుండి మనకు వస్తుంది. ఈ క్రమాన్ని ప్రింటర్‌కి అవుట్‌పుట్ చేయడం వలన ప్రింటర్ కొత్త పేజీ ప్రారంభమయ్యే వరకు ఎటువంటి వచనాన్ని ముద్రించకుండా ప్రస్తుత షీట్‌ను ఫీడ్ చేస్తుంది.

ఇప్పుడు మనం దానిని పేజీ బ్రేక్ లేదా కొత్త పేజీ అని పిలుస్తాము .

\\ఒక బ్యాక్ స్లాష్

ఇక్కడ అంతా సూటిగా ఉంటుంది. మన టెక్స్ట్‌లోని అక్షరాలను తప్పించుకోవడానికి మనం బ్యాక్‌స్లాష్‌ని ఉపయోగిస్తే, స్ట్రింగ్‌లో బ్యాక్‌స్లాష్ క్యారెక్టర్‌ను ఎలా వ్రాయాలి?

ఇది చాలా సులభం: టెక్స్ట్‌కు బ్యాక్‌స్లాష్ జోడించండి — మీరు వరుసగా రెండు రాయాలి.

ఉదాహరణ:

System.out.println("c:\projects\my\first");

System.out.println("c:\\projects\\my\\first");

4. యూనికోడ్ ఎన్‌కోడింగ్

మీకు ఇప్పటికే తెలిసినట్లుగా, స్క్రీన్‌పై ప్రదర్శించబడే ప్రతి అక్షరం నిర్దిష్ట సంఖ్యా కోడ్‌కు అనుగుణంగా ఉంటుంది. ఈ కోడ్‌ల యొక్క ప్రామాణిక సెట్‌ను ఎన్‌కోడింగ్ అంటారు .

ఒకప్పుడు, కంప్యూటర్లు కొత్తగా కనిపెట్టినప్పుడు, ప్రతి అక్షరాన్ని ఎన్‌కోడ్ చేయడానికి ఏడు బిట్స్ (ఒక బైట్ కంటే తక్కువ) సరిపోయేవి. మొదటి ఎన్‌కోడింగ్‌లో 128 అక్షరాలు మాత్రమే ఉన్నాయి. ఈ ఎన్‌కోడింగ్‌ను ASCII అని పిలుస్తారు .

ASCII అంటే అమెరికన్ స్టాండర్డ్ కోడ్ ఫర్ ఇన్ఫర్మేషన్ ఇంటర్‌ఛేంజ్ — ముద్రించదగిన అక్షరాలు మరియు కొన్ని ప్రత్యేక కోడ్‌ల కోసం ఒక ప్రామాణిక అమెరికన్ కోడ్ టేబుల్.

ఇందులో 33 ముద్రించలేని నియంత్రణ అక్షరాలు (టెక్స్ట్ మరియు స్పేస్‌లు ఎలా ప్రాసెస్ చేయబడతాయో ప్రభావితం చేస్తాయి) మరియు 95 ముద్రించదగిన అక్షరాలు, సంఖ్యలు, పెద్ద అక్షరం మరియు చిన్న లాటిన్ అక్షరాలు మరియు అనేక విరామ చిహ్నాలు ఉన్నాయి.

కంప్యూటర్లు జనాదరణ పెరగడంతో, ప్రతి దేశం దాని స్వంత ఎన్‌కోడింగ్‌ను విడుదల చేయడం ప్రారంభించింది. సాధారణంగా, వారు ASCIIని ప్రారంభ బిందువుగా తీసుకున్నారు మరియు అరుదుగా ఉపయోగించే ASCII అక్షరాలను వాటి సంబంధిత వర్ణమాల నుండి గుర్తులతో భర్తీ చేస్తారు.

కాలక్రమేణా, ఒక ఆలోచన ఉద్భవించింది: ప్రపంచంలోని ప్రతి ఎన్‌కోడింగ్‌లోని అన్ని అక్షరాలను కలిగి ఉన్న ఒకే ఎన్‌కోడింగ్‌ను సృష్టించండి.

అందువలన, 1993లో, యూనికోడ్ ఎన్‌కోడింగ్ సృష్టించబడింది మరియు జావా భాష ఈ ఎన్‌కోడింగ్‌ను టెక్స్ట్ నిల్వ చేయడానికి ప్రమాణంగా ఉపయోగించిన మొదటి ప్రోగ్రామింగ్ భాషగా మారింది. ఇప్పుడు మొత్తం ఐటీ పరిశ్రమకు యూనికోడ్ ప్రమాణం.

యూనికోడ్ ప్రామాణికమైనప్పటికీ, దీనికి అనేక ప్రాతినిధ్యాలు లేదా యూనికోడ్ పరివర్తన ఫార్మాట్‌లు (UTF) ఉన్నాయి: UTF-8, UTF-16 మరియు UTF-32, మొదలైనవి.

జావా యూనికోడ్ ఎన్‌కోడింగ్ యొక్క అధునాతన సంస్కరణను ఉపయోగిస్తుంది — UTF-16: ప్రతి అక్షరం 16 బిట్‌లలో (2 బైట్లు) ఎన్‌కోడ్ చేయబడింది. ఇది గరిష్టంగా 65,536 అక్షరాలను కలిగి ఉంటుంది!

మీరు ఈ ఎన్‌కోడింగ్‌లో ప్రపంచంలోని ప్రతి వర్ణమాలలోని దాదాపు ప్రతి అక్షరాన్ని కనుగొనవచ్చు. సహజంగానే, ఎవరికీ మొత్తం కంఠస్థం లేదు. మీరు ప్రతిదీ తెలుసుకోలేరు, కానీ మీరు ప్రతిదీ గూగుల్ చేయవచ్చు.

\uమీ ప్రోగ్రామ్‌లో యూనికోడ్ అక్షరాన్ని దాని కోడ్‌ని ఉపయోగించి వ్రాయడానికి, మీరు + కోడ్‌ని హెక్సాడెసిమల్‌లో వ్రాయాలి . ఉదాహరణకి,\u00A9

System.out.println("\u00A9 CodeGym");

© CodeGym

5. యూనికోడ్: కోడ్ పాయింట్

"640 కిలోబైట్‌లు అందరికీ సరిపోవాలి! లేదా". (బిల్ గేట్స్‌కి ఆపాదించబడిన కోట్)

జీవితం కఠినమైనది మరియు కాలక్రమేణా, UTF-16 ఎన్‌కోడింగ్ సరిపోదు. ఆసియా భాషలు చాలా ఉన్నాయని మరియు వాటికి చాలా గ్లిఫ్‌లు ఉన్నాయని తేలింది. మరియు ఈ అన్ని గ్లిఫ్‌లు కేవలం 2 బైట్‌లుగా క్రామ్ చేయబడవు.

ఏమి చేయవచ్చు? మరిన్ని బైట్‌లను ఉపయోగించండి !

కానీ చార్ రకం 2 బైట్‌లు మాత్రమే మరియు దానిని 4కి మార్చడం అంత సులభం కాదు: ప్రపంచవ్యాప్తంగా బిలియన్ల కొద్దీ జావా కోడ్‌లు వ్రాయబడ్డాయి, చార్ రకం అకస్మాత్తుగా 4 బైట్‌లు జావా మెషీన్‌గా మారితే అది విచ్ఛిన్నమవుతుంది. కాబట్టి మేము చార్ రకాన్ని మార్చలేము!

మరొక విధానం ఉంది. పాత్రల ముందు బ్యాక్‌స్లాష్‌ని ఉంచడం ద్వారా మనం ఎలా తప్పించుకుంటామో గుర్తుంచుకోండి. ప్రాథమికంగా, మేము బహుళ అక్షరాలను ఉపయోగించి ఒకే అక్షరాన్ని ఎన్‌కోడ్ చేసాము.

జావా సృష్టికర్తలు అదే విధానాన్ని ఉపయోగించాలని నిర్ణయించుకున్నారు.

దృశ్యమానంగా ఒకే అక్షరంగా కనిపించే కొన్ని అక్షరాలు charస్ట్రింగ్‌లో రెండు సెకన్లుగా ఎన్‌కోడ్ చేయబడ్డాయి:

System.out.println("\uD83D\uDD0A");

🔊

ఇప్పుడు మీ జావా ప్రోగ్రామ్ కన్సోల్‌కి ఎమోజీలను కూడా అవుట్‌పుట్ చేయగలదు 😎