यापूर्वी, आम्हाला IO API (इनपुट/आउटपुट ऍप्लिकेशन प्रोग्रामिंग इंटरफेस) आणि java.io पॅकेजची माहिती मिळाली , ज्यांचे वर्ग मुख्यतः Java मधील प्रवाहांसह काम करण्यासाठी आहेत. येथे मुख्य म्हणजे प्रवाहाची संकल्पना आहे .

आज आपण NIO API (नवीन इनपुट/आउटपुट) विचारात घेण्यास सुरुवात करू.

I/O मधील दोन पध्दतींमधील मुख्य फरक हा आहे की IO API स्ट्रीम-ओरिएंटेड आहे तर NIO API बफर-ओरिएंटेड आहे. म्हणून समजण्यासाठी मुख्य संकल्पना बफर आणि चॅनेल आहेत .

बफर काय आहे आणि चॅनेल काय आहे?

चॅनेल हे एक लॉजिकल पोर्टल आहे ज्याद्वारे डेटा आत आणि बाहेर जातो, तर बफर हा या प्रसारित डेटाचा स्रोत किंवा गंतव्यस्थान आहे. आउटपुट दरम्यान, आपण पाठवू इच्छित असलेला डेटा बफरमध्ये ठेवला जातो आणि बफर डेटा चॅनेलकडे पाठवतो. इनपुट दरम्यान, चॅनेलमधील डेटा बफरमध्ये टाकला जातो.

दुसऱ्या शब्दात:

  • बफर म्हणजे फक्त मेमरीचा एक ब्लॉक ज्यामध्ये आपण माहिती लिहू शकतो आणि ज्यातून आपण माहिती वाचू शकतो ,
  • चॅनेल हा एक गेटवे आहे जो फाइल्स किंवा सॉकेट्स सारख्या I/O साधनांमध्ये प्रवेश प्रदान करतो.

चॅनेल java.io पॅकेजमधील प्रवाहांसारखेच आहेत. सर्व डेटा जो कोठेही जातो (किंवा कुठूनही येतो) चॅनेल ऑब्जेक्टमधून जाणे आवश्यक आहे. सर्वसाधारणपणे, NIO प्रणाली वापरण्यासाठी, तुम्हाला I/O घटकासाठी एक चॅनेल आणि डेटा संचयित करण्यासाठी बफर मिळेल. मग तुम्ही आवश्यकतेनुसार बफर, इनपुट किंवा आउटपुट डेटासह कार्य करता.

तुम्ही बफरमध्ये पुढे आणि मागे जाऊ शकता, म्हणजे बफरमध्ये "चालणे", जे तुम्ही प्रवाहात करू शकत नाही. डेटावर प्रक्रिया करताना हे अधिक लवचिकता देते. मानक लायब्ररीमध्ये, बफर हे अमूर्त बफर वर्ग आणि त्याच्या अनेक वंशजांनी दर्शविले जातात:

Java webinar
  • बाइटबफर
  • चारबफर
  • शॉर्टबफर
  • इंटबफर
  • फ्लोटबफर
  • डबलबफर
  • लाँगबफर

उपवर्गांमधील मुख्य फरक म्हणजे ते संग्रहित केलेला डेटा प्रकार — बाइट्स , इंट्स , लाँग्स आणि इतर आदिम डेटा प्रकार.

बफर गुणधर्म

बफरमध्ये चार मुख्य गुणधर्म असतात. हे क्षमता, मर्यादा, स्थिती आणि चिन्ह आहेत.

क्षमता ही बफरमध्ये साठवता येणारी जास्तीत जास्त डेटा/बाइट्स आहे. बफरची क्षमता बदलली जाऊ शकत नाही . एकदा बफर भरले की, त्यावर अधिक लिहिण्यापूर्वी ते साफ करणे आवश्यक आहे.

लेखन मोडमध्ये, बफरची मर्यादा त्याच्या क्षमतेइतकीच असते, जी बफरवर लिहिता येणारी कमाल डेटा दर्शवते. रीड मोडमध्ये, बफरची मर्यादा बफरमधून वाचता येणार्‍या जास्तीत जास्त डेटाचा संदर्भ देते.

स्थिती बफरमधील कर्सरची वर्तमान स्थिती दर्शवते . सुरुवातीला, बफर तयार केल्यावर ते 0 वर सेट केले जाते. दुस-या शब्दात सांगायचे तर, ही पुढील घटकाची अनुक्रमणिका आहे जी वाचायची किंवा लिहायची आहे.

मार्क कर्सरची स्थिती जतन करण्यासाठी वापरला जातो . जसे आपण बफर हाताळतो, कर्सरची स्थिती सतत बदलते, परंतु आपण ती नेहमी पूर्वी चिन्हांकित स्थितीत परत करू शकतो.

बफरसह कार्य करण्याच्या पद्धती

आता चॅनेलवर आणि वरून डेटा वाचण्यासाठी आणि लिहिण्यासाठी आमच्या बफर (मेमरी ब्लॉक) सह कार्य करू या पद्धतींचा मुख्य संच पाहू.

  1. allocate(int क्षमता) — ही पद्धत निर्दिष्ट क्षमतेसह नवीन बफर वाटप करण्यासाठी वापरली जाते. उत्तीर्ण क्षमता ऋण पूर्णांक असल्यास, allocate () पद्धत IllegalArgumentException टाकते .

  2. क्षमता() वर्तमान बफरची क्षमता परत करते .

  3. position() वर्तमान कर्सरची स्थिती परत करते. वाचन आणि लेखन ऑपरेशन्स कर्सरला बफरच्या शेवटी हलवतात. परतावा मूल्य नेहमी मर्यादेपेक्षा कमी किंवा समान असते.

  4. limit() वर्तमान बफरची मर्यादा परत करते.

  5. mark() चा वापर वर्तमान कर्सर स्थान चिन्हांकित (सेव्ह) करण्यासाठी केला जातो.

  6. reset() कर्सरला पूर्वी चिन्हांकित (सेव्ह केलेल्या) स्थितीत परत करते.

  7. clear() स्थिती शून्यावर सेट करते आणि क्षमतेची मर्यादा सेट करते. ही पद्धत बफरमधील डेटा साफ करत नाही . हे फक्त स्थान, मर्यादा आणि चिन्ह पुन्हा सुरू करते.

  8. flip() बफरला लेखन मोडमधून वाचन मोडवर स्विच करते. हे वर्तमान स्थितीची मर्यादा देखील सेट करते आणि नंतर स्थिती शून्यावर ठेवते.

  9. read() — चॅनेलची रीड पद्धत चॅनेलवरून बफरवर डेटा लिहिण्यासाठी वापरली जाते, तर बफरची पुट() पद्धत बफरमध्ये डेटा लिहिण्यासाठी वापरली जाते.

  10. write() — चॅनेलची लेखन पद्धत बफरमधून चॅनलवर डेटा लिहिण्यासाठी वापरली जाते, तर बफरमधून डेटा वाचण्यासाठी बफरची गेट() पद्धत वापरली जाते.

  11. rewind() बफर रिवाइंड करते. जेव्हा आपल्याला बफर पुन्हा वाचण्याची आवश्यकता असते तेव्हा ही पद्धत वापरली जाते — ती स्थिती शून्यावर सेट करते आणि मर्यादा बदलत नाही.

आणि आता चॅनेलबद्दल काही शब्द.

Java NIO मधील सर्वात महत्वाचे चॅनेल अंमलबजावणी खालील वर्ग आहेत:

  1. FileChannel — फाईलमधून/वरील डेटा वाचण्यासाठी आणि लिहिण्यासाठी एक चॅनेल.

  2. DatagramChannel — हा वर्ग UDP (User Datagram Protocol) द्वारे नेटवर्कवर डेटा वाचतो आणि लिहितो.

  3. SocketChannel — TCP (ट्रान्समिशन कंट्रोल प्रोटोकॉल) द्वारे नेटवर्कवर डेटा वाचण्यासाठी आणि लिहिण्यासाठी एक चॅनेल.

  4. ServerSocketChannel — TCP कनेक्शनवर डेटा वाचण्यासाठी आणि लिहिण्यासाठी एक चॅनेल, जसे वेब सर्व्हर करतो. प्रत्येक इनकमिंग कनेक्शनसाठी सॉकेट चॅनेल तयार केलेजाते .

सराव

कोडच्या दोन ओळी लिहिण्याची वेळ आली आहे. प्रथम, फाईल वाचू आणि कन्सोलवर त्यातील सामग्री प्रदर्शित करू, आणि नंतर फाइलवर काही स्ट्रिंग लिहू.

कोडमध्ये बर्‍याच टिप्पण्या आहेत — मला आशा आहे की ते सर्वकाही कसे कार्य करते हे समजून घेण्यास मदत करतील:

// Create a RandomAccessFile object, passing in the file path
// and a string that says the file will be opened for reading and writing
try (RandomAccessFile randomAccessFile = new RandomAccessFile("text.txt", "rw");
    // Get an instance of the FileChannel class
    FileChannel channel = randomAccessFile.getChannel();
) {
// Our file is small, so we'll read it in one go
// Create a buffer of the required size based on the size of our channel
   ByteBuffer byteBuffer = ByteBuffer.allocate((int) channel.size());
   // Read data will be put into a StringBuilder
   StringBuilder builder = new StringBuilder();
   // Write data from the channel to the buffer
   channel.read(byteBuffer);
   // Switch the buffer from write mode to read mode
   byteBuffer.flip();
   // In a loop, write data from the buffer to the StringBuilder
   while (byteBuffer.hasRemaining()) {
       builder.append((char) byteBuffer.get());
   }
   // Display the contents of the StringBuilder on the console
   System.out.println(builder);

   // Now let's continue our program and write data from a string to the file
   // Create a string with arbitrary text
   String someText = "Hello, Amigo!!!!!";
   // Create a new buffer for writing,
   // but let the channel remain the same, because we're going to the same file
   // In other words, we can use one channel for both reading and writing to a file
   // Create a buffer specifically for our string — convert the string into an array and get its length
   ByteBuffer byteBuffer2 = ByteBuffer.allocate(someText.getBytes().length);
   // Write our string to the buffer
   byteBuffer2.put(someText.getBytes());
   // Switch the buffer from write mode to read mode
   // so that the channel can read from the buffer and write our string to the file
   byteBuffer2.flip();
   // The channel reads the information from the buffer and writes it to our file
   channel.write(byteBuffer2);
} catch (FileNotFoundException e) {
   e.printStackTrace();
} catch (IOException e) {
   e.printStackTrace();
}

NIO API वापरून पहा — तुम्हाला ते आवडेल!