எழுத்து குறியாக்கங்கள்

"ஹாய், அமிகோ!"

"இப்போது மற்றொரு சுவாரஸ்யமான தலைப்புக்கான நேரம் இது: குறியாக்கங்கள்."

"ஒவ்வொரு எழுத்துக்கும் ஒரு குறியீடு (எண்) இருப்பதாக நீங்கள் ஏற்கனவே எங்காவது கேள்விப்பட்டிருக்கலாம். அதனால்தான் கரி வகை குறியீடுகள் மற்றும் எண்கள் இரண்டையும் குறிக்கும்."

"உதாரணமாக, ஆங்கில எழுத்துக்களில் 'A' என்ற எழுத்தின் குறியீடு 65. 'B' என்பது 66, 'C' என்பது 67, மற்றும் பல. பெரிய எழுத்துக்கள், சிறிய எழுத்துக்கள், சிரிலிக் எழுத்துக்கள், சீன எழுத்துக்கள் ஆகியவற்றிற்கு தனித்துவமான குறியீடுகள் உள்ளன. எழுத்துக்கள் (ஆமாம், நிறைய மற்றும் நிறைய குறியீடுகள்), எண்கள் மற்றும் பல்வேறு குறியீடுகள். சுருக்கமாக, நீங்கள் எழுத்து என்று அழைக்கும் நடைமுறையில் அனைத்திற்கும் ஒரு குறியீடு உள்ளது."

"எனவே, ஒவ்வொரு எழுத்தும் எழுத்தும் ஏதாவது ஒரு எண்ணுக்கு ஒத்திருக்கிறதா?"

"துல்லியமாக."

"ஒரு எழுத்தை எண்ணாகவும், எண்ணை ஒரு எழுத்தாகவும் மாற்றலாம். ஜாவா பொதுவாக அவற்றுக்கிடையே வேறுபாட்டைக் காணாது:"

char c = 'A'; //The code (number) for 'A' is 65
c++; //Now c contains the number 66, which is the code for 'B'

"சுவாரஸ்யமானது."

"எனவே, குறியாக்கம் என்பது குறியீடுகளின் தொகுப்பு மற்றும் அவற்றுடன் தொடர்புடைய குறியீடுகளின் தொகுப்பாகும். ஆனால் ஒரு குறியாக்கம் மட்டும் கண்டுபிடிக்கப்படவில்லை - சில உள்ளன. ஒரு பொதுவான உலகளாவிய குறியாக்கம், யூனிகோட் கண்டுபிடிக்கப்பட்டது."

"ஆனால் எத்தனை உலகளாவிய தரநிலைகள் கண்டுபிடிக்கப்பட்டாலும், பழையவற்றைக் கைவிட யாரும் அவசரப்படுவதில்லை. இந்த கார்ட்டூனில் உள்ளதைப் போலவே எல்லாம் நடக்கும்:"

"வின்சென்ட் மற்றும் நிக் தங்கள் சொந்த குறியாக்கங்களை உருவாக்க முடிவு செய்கிறார்கள் என்று கற்பனை செய்து பாருங்கள்."

"வின்சென்ட்டின் குறியாக்கம் இதோ:"

"இதோ நிக்கின் என்கோடிங்:"

"அவர்கள் அதே எழுத்துக்களைப் பயன்படுத்துகிறார்கள், ஆனால் எழுத்துக்களுக்கான குறியீடுகள் வேறுபட்டவை."

"ABC-123' என்ற சரம் வின்சென்ட்டின் குறியாக்கத்தைப் பயன்படுத்தி ஒரு கோப்பில் எழுதப்பட்டால், பின்வரும் பைட்டுகளின் தொகுப்பைப் பெறுவோம்:

"இப்போது நிக்கின் குறியாக்கத்தைப் பயன்படுத்தும் மற்றொரு நிரல் கோப்பைப் படிக்க விரும்புகிறது:"

"345-IJK" என்று அது வாசிக்கும்.

"மேலும் மோசமான விஷயம் என்னவென்றால், குறியீட்டு முறைகள் பொதுவாக கோப்புகளில் எங்கும் சேமிக்கப்படுவதில்லை, எனவே டெவலப்பர்கள் யூகிக்க வேண்டும்."

"சரி, அவர்கள் எப்படி யூகிக்கிறார்கள்?"

"இது வேறு தலைப்பு. ஆனால் குறியாக்கங்களுடன் எவ்வாறு செயல்படுவது என்பதை நான் விளக்க விரும்புகிறேன். உங்களுக்கு ஏற்கனவே தெரியும், ஜாவாவில் ஒரு கரியின் அளவு இரண்டு பைட்டுகள். ஜாவா ஸ்டிரிங்ஸ் யூனிகோட் வடிவமைப்பைப் பயன்படுத்துகிறது."

"ஆனால் Java உங்களுக்குத் தெரிந்த எந்த என்கோடிங்கிலும் ஒரு சரத்தை பைட்டுகளின் தொகுப்பாக மாற்ற உங்களை அனுமதிக்கிறது. ஸ்ட்ரிங் வகுப்பில் இதற்கான சிறப்பு முறைகள் உள்ளன. ஜாவாவில் ஒரு குறிப்பிட்ட குறியாக்கத்தை விவரிக்கும் ஒரு சிறப்பு சார்செட் வகுப்பும் உள்ளது."

1) ஜாவா ஆதரிக்கும் அனைத்து குறியாக்கங்களின் பட்டியலை எவ்வாறு பெறுவது?

"அதற்கு கிடைக்கக்கூடிய எழுத்துக்கள் என்று அழைக்கப்படும் ஒரு சிறப்பு நிலையான முறை உள்ளது. "இந்த முறை ஜோடிகளின் தொகுப்பை வழங்குகிறது (குறியீட்டு பெயர், குறியாக்கத்தை விவரிக்கும் பொருள்):"

SortedMap<String,Charset> charsets = Charset.availableCharsets();

"ஒவ்வொரு குறியாக்கத்திற்கும் ஒரு தனித்துவமான பெயர் உள்ளது. அவற்றில் சில இதோ: UTF-8, UTF-16, Windows-1251, KOI8-R,..."

2) தற்போதைய செயலில் உள்ள குறியாக்கத்தை (யூனிகோட்) எவ்வாறு பெறுவது?

" அதற்கு defaultCharset என்ற ஒரு சிறப்பு முறை உள்ளது .

Charset currentCharset = Charset.defaultCharset();

3) ஒரு சரத்தை ஒரு குறிப்பிட்ட குறியாக்கத்திற்கு எவ்வாறு மாற்றுவது?

"ஜாவாவில், ஜாவாவுக்குத் தெரிந்த எந்த குறியாக்கத்திலும் ஒரு சரத்தை பைட் வரிசையாக மாற்றலாம்:"

byte[] getBytes()

String s = "Good news, everyone!";
byte[] buffer = s.getBytes()

byte[] getBytes(Charset charset)

String s = "Good news, everyone!";
Charset koi8 = Charset.forName("KOI8-R");
byte[] buffer = s.getBytes(koi8);

byte[] getBytes(String charsetName)

String s = "Good news, everyone!";
byte[] buffer = s.getBytes("Windows-1251")

4) நான் படித்த பைட் வரிசையை ஒரு கோப்பிலிருந்து சரமாக மாற்றுவது எப்படி?

"இது இன்னும் எளிதானது. சரம் வகுப்பில் ஒரு சிறப்பு கட்டமைப்பாளர் உள்ளது:"

String(byte bytes[])

byte[] buffer = new byte[1000];
inputStream.read(buffer);

String s = new String(buffer);

String(byte bytes[], Charset charset)

byte[] buffer = new byte[1000];
inputStream.read(buffer);

Charset koi8 = Charset.forName("KOI8-R");
String s = new String(buffer, koi8);

String(byte bytes[], String charsetName)

byte[] buffer = new byte[1000];
inputStream.read(buffer);

String s = new String(buffer, "Windows-1251");

5) ஒரு பைட் வரிசையை ஒரு குறியாக்கத்திலிருந்து மற்றொன்றுக்கு எவ்வாறு மாற்றுவது?

"பல வழிகள் உள்ளன. இதோ எளிமையான ஒன்று:"

Charset koi8 = Charset.forName("KOI8-R");
Charset windows1251 = Charset.forName("Windows-1251");

byte[] buffer = new byte[1000];
inputStream.read(buffer);
String s = new String(buffer, koi8);
buffer = s.getBytes(windows1251);
outputStream.write(buffer);

"அதுதான் நினைச்சேன். சுவாரசியமான பாடத்துக்கு நன்றி ரிஷி."