ஜாவாவுடன் தரவுகளைஉள்ளிடுதலும் வெளியிடுதலும்

ச. குப்பன் March 21, 2021 0 Comments

இந்த கட்டுரையில் ஜாவா எனும் கணினிமொழியானது தரவுகளை எவ்வாறுபடிப்பதையும் எழுதுவதையும் கையாளுகின்றது என்பதை அறிந்து கொள்ளமுடியும்.

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

ஜாவாவை நிறுவுகைசெய்தல்

தற்போதைய நிலையில் நம்முடைய கணினியின் தளத்தைப்(இயக்கமுறைமையை) பொருட்படுத்தாமல், AdoptOpenJDK இலிருந்து ஜாவாவை நிறுவுகைசெய்திடலாம். இந்த தளமானது ஜாவாவின் பாதுகாப்பான கட்டற்ற உருவாக்கங்களை வழங்குகிறது அதாவது இதனை எந்தவொரு இயக்கமுறைமை செயல்படும் கணினியிலும் நிறுவுகை செய்து கொள்ளலாம். . இதனுடய சமீபத்திய நீண்டகால ஆதரவு (LTS) பதிப்பைப் பயன்படுத்திகொள்ளுமாறு பரிந்துரைக்கப் படுகின்றது. சமீபத்திய ஜாவாவின் வசதிவாய்ப்புகளை முயற்சிக்க விரும்பும் மேம்படுத்துர்கள் இதனுடைய சமீபத்திய LTS அல்லாத பதிப்பினைபயன்படுத்தி கொள்வது நல்லது, ஆனால் இது பெரும்பாலான பயனாளர்கள் நிறுவியதை விட மிகவலுவாக அமைந்திருக்கும் பொதுவாக கணினியில் இதனுடைய இயல்பான பதிப்பு அல்லது வேறு சிலவகை பயன்பாட்டிற்கான ஜாவா பதிப்பு என்றவாறு நிறுவப்பட்டிருக்கும். ஆயினும் ஜாவாவின் LTS பதிப்பைப் பயன்படுத்துவது என்பது பெரும்பாலான பயனாளர்கள் தாம் ஏற்கனவே நிறுவியவற்றைப் புதுப்பித்த நிலையில் வைத்திருப்பதை இது உறுதி செய்கிறது.

அதனை தொடர்ந்து ஜாவாவை நிறுவுகைசெய்ததும், நமக்கு பிடித்த உரை திருத்தியைத் திறந்து குறிமுறைவரிகளை எழுதுத் தயாராகுக. ஆயினும் பெரும்பாலானவர்கள் ஜாவாவிற்கான ஒருங்கிணைந்த மேம்பாட்டு சூழலையும்(IDE) விரும்பலாம்.அதனால் புதியநிரலாளர்கள்எனில் BlueJ எனும் மேம்பாட்டு சூழல் சிறந்தது, Eclipse, Netbeansஆகிய இரு மேம்பாட்டு சூழலும் இடைநிலை நிரலாளர்களுக்கும் அனுபவம் வாய்ந்த நிரலாளர்களுக்கும் மிகபயனுள்ளதாக இருக்கும்.

ஜாவாவுடன் ஒரு கோப்பைப் படித்தல்

கோப்புகளை பதிவேற்றம் செய்வதற்காக ஜாவா ஆனது File எனும் நூலகத்தைப் பயன்படுத்திகொள்கிறது. இந்த கட்டுரையின் எடுத்துக்காட்டில் ஒரு கோப்பிலிருந்து தரவுகளைப் படிக்க Ingest என்ற இனத்தை உருவாக்குகிறது. ஜாவாவில் ஒரு கோப்பைத் திறக்கும்போது, நாம் Scanner
எனும்
ஒரு பொருளை உருவாக்குகின்றோம், இது நாம் வழங்கும் கோப்பை வருடுகிறது. உண்மையில், Scanner என்பது உரை பதிப்பானில் உள்ள இடம்சுட்டியின் அதே கருத்தமைவாகும், மேலும் nextLine போன்ற Scanner வழிமுறைகள் மூலம் படிப்பதற்கும் எழுதுவதற்கும் அந்த “இடம்சுட்டியை(cursor )” நாம் கட்டுப்படுத்தலாம்:

import java.io.File;

import java.util.Scanner;

import java.io.FileNotFoundException;


public class Ingest {

 public static void main(String[] args) {

  

   try {

     File myFile = new File("example.txt");

     Scanner myScanner = new Scanner(myFile);

     while (myScanner.hasNextLine()) {

       String line = myScanner.nextLine();

       System.out.println(line);

     }

     myScanner.close();

   } catch (FileNotFoundException ex) {

     ex.printStackTrace();  

   } //try

  } //main

} //class

தற்போது நம்கையிருப்பில் Example.txt என்ற கோப்பு உள்ளது என்ற அனுமானத்தின் கீழ் இந்த குறிமுறைவரிகளின் மாறியானது myfile என்பதை உருவாக்குகிறது. அந்த கோப்பு இல்லை என்றால், ஜாவா “ஒரு விதிவிலக்கை வீசுகிறது” (இதன் பொருள் நாம் முயற்சித்ததில் ஒரு பிழையைக் கண்டறிந்து கூறுகிறது), இது மிகவும் குறிப்பிட்ட FileNotFoundException எனும் நூலகத்தால் “பிடிபட்டது“. இந்த துல்லியமான பிழைக்கு குறிப்பிட்ட ஒரு நூலகம் உள்ளது என்பது இந்த பிழை எவ்வளவு பொதுவானது என்பதைக் காட்டிக் கொடுக்கிறது. அடுத்து, இது ஒரு Scannerஐ உருவாக்கி அதில் கோப்பை பதிவேற்றுகின்றது. அதன் பொதுவான இனம் ஆனது வார்ப்புருவில் இருந்து வேறுபடுத்தி கான்பதற்காக இதை myScanner என்று அழைக்கப்படுகின்றது. while loop ஆனதுஅடுத்த வரியைக் கொண்டிருக்கும் வரை, கோப்பின் வழியாக ஒவ்வொரு வரியாக myScanner
ஐ அனுப்புகிறது. HasNextLine எனும் வழிமுறையானது: “இடம்சுட்டிக்கு” பிறகு ஏதேனும் தரவு இருக்கிறதா என்பதை கண்டறிகின்றது. உரை பதிப்பாளரில் ஒரு கோப்பைத் திறப்பதன் மூலம் இதை உருவகப்படுத்தலாம்: இது இடம்சுட்டியை கோப்பின் ஆரம்பத்திலேயே துவங்குகிறது, மேலும் கோட்டிற்கு வெளியேசெல்லுவரை இடம்சுட்டியுடன் கோப்பை வருடுதல் செய்ய விசைப்பலகையை பயன்படுத்தலாம். அதே நேரத்தில் while loop ஒரு மாறியின் வரியை உருவாக்கி தற்போதைய வரியின் தரவுகளை ஒதுக்குகிறது. பின்னூட்டங்களை வழங்குவதற்காக அது வரியின் உள்ளடக்கங்களை அச்சிடுகிறது. மிகவும் பயனுள்ள நிரலாக்கமானது ஒவ்வொரு வரியையும் அதில் உள்ள முக்கியமான தரவுகளைப் பிரித்தெடுக்க அலசி ஆராய்கின்றது. செயலியின் முடிவில், myScanner எனும் பொருளானது மூடப்படுகின்றது.

குறிமுறைவரிகளை இயக்குதல்

நம்முடைய குறிமுறைவரிகளை Ingest.java ஆக சேமித்திடுக (இனங்களுக்கு துவக்கத்தில் பெரியஎழுத்தை வழங்குவதற்கும் பொருத்தமாக கோப்பிற்கு பெயரிடுவதற்கும் ஜாவாவில் இது வழக்கமாகும்). இந்த எளிய பயன்பாட்டை இயக்க முயற்சித்தால், ஒரு பிழையைப் பெறுவோம், ஏனெனில் பயன்பாடு இன்னும் பதிவேற்றுவதற்கு example.txt எனும் கோப்பு ஆனது கையிருப்பில் இல்லை:

$ java ./Ingest.java

java.io.FileNotFoundException:

example.txt (No such file or directory)

ஒரு கோப்பில் தரவுகளை எழுதுகின்ற ஜாவா பயன்பாட்டை எழுத என்னவொரு மிகச்சரியான வாய்ப்பு! பார்ததீர்களா !

ஜாவாவுடன் ஒரு கோப்பில் தரவுகளை எழுதுதல்

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

import java.io.FileWriter;

import java.io.IOException;


public class Exgest {

 public static void main(String[] args) {

  try {

    FileWriter myFileWriter = new FileWriter("example.txt", true);

    myFileWriter.write("Hello world\n");

    myFileWriter.close();

  } catch (IOException ex) {

    System.out.println(ex);

  } // try

 } // main

}

இந்த இனத்தின் தர்க்கமும் பாய்வும் ஒரு கோப்பைப் படிப்பதைப் போன்றது. இங்குScannerக்கு பதிலாக, இது ஒரு கோப்பின் பெயருடன் ஒரு FileWriterஎனும் பொருளை உருவாக்குகிறது. FileWriter அறிக்கையின் முடிவில் உள்ள true
எனும் கொடியானது FileWriter ஐ கோப்பின் முடிவில் உரையைச் சேர்க்குமாறு கூறுகிறது. அதனால் கோப்பின் உள்ளடக்கங்களை மேலெழுத, true என்பதை அகற்றுக:

FileWriter myFileWriter = new FileWriter("example.txt", true);  ஒரு கோப்பில் எளிய உரையை எழுதுவதால், கோப்பில் எழுதப்பட்ட தரவுகளின் ( Hello World) முடிவில்  சொந்த புதிய வரி எழுத்தை (\ n) சேர்க்கின்றது.  குறிமுறைவரிகளை செயல்படுத்திட முயற்சித்தல் இனத்தின் பெயருடன் பொருந்துமாறு கோப்பிற்கு பெயரிடும் ஜாவா வழக்கத்தை தொடர்ந்து, இந்த குறிமுறைவரிகளை Exgest.java என சேமித்திடுக. ஜாவாவுடன் தரவுகளை உருவாக்கவும் படிக்கவும் நமக்கு இப்போது வழி கிடைத்துவிட்டது, நம்மமுடைய புதிய பயன்பாடுகளை தலைகீழ் வரிசையில் முயற்சி செய்யலாம்: $ java ./Exgest.java $ java ./Ingest.java Hello World $ இது இறுதிவரை தரவுகளைச் சேர்ப்பதால், நம்முடைய கோப்பில் கூடுதல் தரவுகளைச் சேர்க்க விரும்பும் அளவிற்கு தரவுகளை எழுத நம்முடைய பயன்பாட்டை மீண்டும் சரிசெய்துகொள்க: $ java ./Exgest.java $ java ./Exgest.java $ java ./Exgest.java $ java ./Ingest.java Hello World Hello World Hello World $ ஜாவாஎனும் கணினிமொழியும் தரவுகளும் 


மூல
உரையை ஒரு கோப்பில் அடிக்கடி
எழுதவில்லை;
நிஜ
உலகில்,
அதற்கு
பதிலாக ஒரு குறிப்பிட்ட
வடிவமைப்பை எழுத கூடுதல்
நூலகத்தைப் பயன்படுத்தலாம்.
உதாரணமாக,
சிக்கலான
தரவுகளை
எழுதுவதற்காக
ஒரு XML
நூலகம்,
உள்ளமைவு
கோப்புகளை எழுதுவதற்காக
ஒரு INI
அல்லது
YAML
நூலகம்
அல்லது படங்கள் அல்லது ஒலி
போன்ற இரும
வடிவங்களை எழுதுவதற்காக
எந்தவொரு சிறப்பு நூலகங்களையும்
பயன்படுத்தலாம்.