தப்பிக்கும் கதாபாத்திரங்கள்

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");

🔊

இப்போது உங்கள் ஜாவா புரோகிராம் கன்சோலில் ஈமோஜிகளை வெளியிட முடியும்