जावा एनआईओ - त्वरित गाइड

जावा .nio पैकेज को java 1.4 में पेश किया गया था। जावा एनआईओ में जावा आई / ओ के विपरीत आई / ओ संचालन के लिए बफर और चैनल उन्मुख डेटा प्रवाह शुरू किया गया है, जिसके परिणामस्वरूप तेजी से निष्पादन और बेहतर प्रदर्शन मिलता है।

इसके अलावा NIO API उन चयनकर्ताओं की पेशकश करता है जो अतुल्यकालिक या गैर अवरुद्ध तरीके से IO घटनाओं के लिए कई चैनलों को सुनने की कार्यक्षमता का परिचय देते हैं। NIO में सबसे अधिक समय लेने वाली I / O गतिविधियों में बफ़र्स को भरने और निकालने सहित ऑपरेटिंग सिस्टम जो गति में बढ़ता है।

NIO API के केंद्रीय सार निम्नलिखित हैं -

बफ़र, जो डेटा, चार्टसेट और उनके संबंधित डिकोडर और एनकोडर के लिए कंटेनर हैं, जो बाइट्स और यूनीकोड वर्णों के बीच अनुवाद करते हैं।
विभिन्न प्रकार के चैनल, जो I / O संचालन करने में सक्षम संस्थाओं के कनेक्शन का प्रतिनिधित्व करते हैं
चयनकर्ता और चयन कुंजी, जो चयन योग्य चैनलों के साथ मिलकर एक बहुसंकेतन, गैर-अवरुद्ध I / O सुविधा को परिभाषित करते हैं।

यह अनुभाग आपको अपनी मशीन पर जावा डाउनलोड और सेट करने के तरीके के बारे में बताता है। पर्यावरण को स्थापित करने के लिए कृपया निम्नलिखित चरणों का पालन करें।

जावा एसई डाउनलोड जावा से लिंक से स्वतंत्र रूप से उपलब्ध है । इसलिए आप अपने ऑपरेटिंग सिस्टम के आधार पर एक संस्करण डाउनलोड करते हैं।

जावा डाउनलोड करने और चलाने के लिए निर्देशों का पालन करें .exeअपनी मशीन पर जावा स्थापित करने के लिए। एक बार जब आप अपनी मशीन पर जावा स्थापित करते हैं, तो आपको इंस्टॉलेशन निर्देशिकाओं को सही करने के लिए पर्यावरण चर सेट करना होगा -

विंडोज़ 2000 / XP के लिए पथ सेट करना

मान लें कि आपने c: \ Program Files \ java \ jdk निर्देशिका में Java स्थापित किया है -

'मेरा कंप्यूटर' पर राइट-क्लिक करें और 'गुण' चुनें।
'उन्नत' टैब के अंतर्गत 'पर्यावरण चर' बटन पर क्लिक करें।
अब 'Path' वेरिएबल को बदल दें ताकि इसमें Java एक्जीक्यूटेबल का भी पथ शामिल हो। उदाहरण के लिए, यदि पथ वर्तमान में 'C: \ WINDOWS \ SYSTEM32' पर सेट है, तो 'C: \ WINDOWS \ SYSTEM32; c: \ Program Files \ java \ jdk \ bin' पढ़ने के लिए अपना पथ परिवर्तित करें।

विंडोज़ 95/98 / ME के लिए पथ सेट करना

मान लें कि आपने c: \ Program Files \ java \ jdk निर्देशिका में Java स्थापित किया है -

'C: \ autoexec.bat' फ़ाइल संपादित करें और अंत में निम्न पंक्ति जोड़ें:
'PATH =% PATH%; C: \ Program Files \ java \ jdk \ bin'

लिनक्स, यूनिक्स, सोलारिस, फ्रीबीएसडी के लिए रास्ता तय करना

पर्यावरण चर पथ को उस बिंदु पर सेट किया जाना चाहिए जहां जावा बायनेरिज़ स्थापित किए गए हैं। यदि आपको ऐसा करने में परेशानी होती है, तो अपने शेल दस्तावेज़ देखें।

उदाहरण, यदि आप अपने शेल के रूप में बैश का उपयोग करते हैं, तो आप अपने '.bashrc: PATH = / path / to / java: $ PATH' के अंत में निम्नलिखित पंक्ति जोड़ेंगे।

विवरण

जैसा कि नाम से पता चलता है कि चैनल एक छोर से दूसरे छोर तक डेटा प्रवाह के माध्यम के रूप में उपयोग किया जाता है। java NIO चैनल में बफर के समान कार्य करते हैं और दूसरे शब्दों में चैनल के दूसरे छोर पर एक इकाई डेटा को बफर में पढ़ने के लिए उपयोग किया जाता है और बफर से डेटा भी लिखता है।

पारंपरिक जावा आईओ चैनलों में उपयोग की जाने वाली धाराओं के विपरीत, दो तरह से हैं, साथ ही लिख सकते हैं। जावा एनआईओ चैनल अवरुद्ध और गैर-अवरुद्ध मोड दोनों में डेटा के अतुल्यकालिक प्रवाह का समर्थन करता है।

चैनल का कार्यान्वयन

जावा एनआईओ चैनल मुख्य रूप से निम्नलिखित वर्गों में लागू किया जाता है -

FileChannel- फाइल से डेटा पढ़ने के लिए हम फाइल चैनल का उपयोग करते हैं। फ़ाइल चैनल का ऑब्जेक्ट केवल फ़ाइल ऑब्जेक्ट पर getChannel () पद्धति को कॉल करके बनाया जा सकता है क्योंकि हम सीधे फ़ाइल ऑब्जेक्ट नहीं बना सकते हैं।
DatagramChannel - डेटाग्राम चैनल यूडीपी (उपयोगकर्ता डेटाग्राम प्रोटोकॉल) के माध्यम से नेटवर्क पर डेटा को पढ़ और लिख सकता है। डेटाग्रैमचैनेल का विशेषण कारखाने के तरीकों का उपयोग करके बनाया जा सकता है।
SocketChannel- सॉकेटचैनल चैनल टीसीपी (ट्रांसमिशन कंट्रोल प्रोटोकॉल) के माध्यम से नेटवर्क पर डेटा पढ़ और लिख सकता है। यह नई वस्तु बनाने के लिए कारखाने के तरीकों का भी उपयोग करता है।
ServerSocketChannel- ServerSocketChannel एक वेब सर्वर के समान टीसीपी कनेक्शन पर डेटा पढ़ता और लिखता है। हर आने वाले कनेक्शन के लिए एक सॉकेटचैनल बनाया जाता है।

उदाहरण

निम्नलिखित उदाहरण एक पाठ फ़ाइल से पढ़ता है C:/Test/temp.txt और सामग्री को कंसोल पर प्रिंट करता है।

temp.txt

Hello World!

ChannelDemo.java

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class ChannelDemo {
   public static void main(String args[]) throws IOException {
      RandomAccessFile file = new RandomAccessFile("C:/Test/temp.txt", "r");
      FileChannel fileChannel = file.getChannel();
      ByteBuffer byteBuffer = ByteBuffer.allocate(512);
      while (fileChannel.read(byteBuffer) > 0) {
         // flip the buffer to prepare for get operation
         byteBuffer.flip();
         while (byteBuffer.hasRemaining()) {
            System.out.print((char) byteBuffer.get());
         }
      }
      file.close();
   }
}

उत्पादन

Hello World!

विवरण

जैसा कि पहले ही उल्लेख किया गया है कि फाइल एनएचआई चैनल के फाइलचैनल कार्यान्वयन को फाइल के मेटा डेटा गुणों तक पहुंचने के लिए पेश किया गया है, जिसमें निर्माण, संशोधन, आकार आदि शामिल हैं। इस फाइल चैनल के साथ बहु थ्रेडेड हैं जो जावा आईओ की तुलना में फिर से जावा एनआईओ को अधिक कुशल बनाता है।

सामान्य तौर पर हम कह सकते हैं कि FileChannel एक चैनल है जो एक ऐसी फ़ाइल से जुड़ा है जिसके द्वारा आप किसी फ़ाइल से डेटा पढ़ सकते हैं, और किसी फ़ाइल में डेटा लिख सकते हैं। FileChannel की महत्वपूर्ण विशेषता यह है कि इसे गैर-अवरोधन मोड में सेट नहीं किया जा सकता है। और हमेशा अवरुद्ध मोड में चलता है।

हम सीधे फ़ाइल चैनल ऑब्जेक्ट प्राप्त नहीं कर सकते, फ़ाइल चैनल का ऑब्जेक्ट या तो प्राप्त किया जाता है -

getChannel() किसी भी FileInputStream, FileOutputStream या RandomAccessFile पर विधि।
open() - फ़ाइल चैनल की विधि जो डिफ़ॉल्ट रूप से चैनल खोलती है।

फ़ाइल चैनल का ऑब्जेक्ट प्रकार ऑब्जेक्ट निर्माण से वर्ग के प्रकार पर निर्भर करता है अर्थात यदि ऑब्जेक्ट FileInputStream की getchannel विधि को कॉल करके बनाया जाता है तो फ़ाइल चैनल पढ़ने के लिए खोला जाता है और इसे लिखने के मामले में NonWritableChannelException को फेंक देगा।

उदाहरण

निम्नलिखित उदाहरण जावा एनआईओ फाइलचैनल से डेटा को पढ़ने और लिखने का तरीका दिखाता है।

temp.txt

Hello World!

FileChannelDemo.java

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.HashSet;
import java.util.Set;

public class FileChannelDemo {
   public static void main(String args[]) throws IOException {
      //append the content to existing file 
      writeFileChannel(ByteBuffer.wrap("Welcome to TutorialsPoint".getBytes()));
      //read the file
      readFileChannel();
   }
   public static void readFileChannel() throws IOException {
      RandomAccessFile randomAccessFile = new RandomAccessFile("C:/Test/temp.txt",
      "rw");
      FileChannel fileChannel = randomAccessFile.getChannel();
      ByteBuffer byteBuffer = ByteBuffer.allocate(512);
      Charset charset = Charset.forName("US-ASCII");
      while (fileChannel.read(byteBuffer) > 0) {
         byteBuffer.rewind();
         System.out.print(charset.decode(byteBuffer));
         byteBuffer.flip();
      }
      fileChannel.close();
      randomAccessFile.close();
   }
   public static void writeFileChannel(ByteBuffer byteBuffer)throws IOException {
      Set<StandardOpenOption> options = new HashSet<>();
      options.add(StandardOpenOption.CREATE);
      options.add(StandardOpenOption.APPEND);
      Path path = Paths.get("C:/Test/temp.txt");
      FileChannel fileChannel = FileChannel.open(path, options);
      fileChannel.write(byteBuffer);
      fileChannel.close();
   }
}

उत्पादन

Hello World! Welcome to TutorialsPoint

जावा एनआईओ डाटाग्राम का उपयोग चैनल के रूप में किया जाता है जो एक कनेक्शन कम प्रोटोकॉल पर यूडीपी पैकेट भेज और प्राप्त कर सकता है। लेकिन डिफ़ॉल्ट डाटाग्राम चैनल अवरुद्ध है, जबकि इसका उपयोग गैर अवरुद्ध मोड में किया जा सकता है। इसे गैर-अवरुद्ध करने के लिए हम कॉन्फिगरिंग का उपयोग कर सकते हैं ( असत्य) विधि। DataGram चैनल को इसकी एक स्थिर विधि के नाम से खोला जा सकता है open() जो आईपी एड्रेस को पैरामीटर के रूप में भी ले सकता है ताकि इसका उपयोग मल्टी कास्टिंग के लिए किया जा सके।

FileChannel का डेटाग्राम चैनल समान रूप से जुड़ा हुआ नहीं है, इसे जोड़ने के लिए हमें स्पष्ट रूप से इसके कनेक्ट () विधि को कॉल करना होगा। जब भी इसे कनेक्ट करना होगा, तो भेजने और प्राप्त करने के तरीकों के लिए डेटाग्राम चैनल की आवश्यकता नहीं होगी। पढ़ने और लिखने के तरीकों का उपयोग करने के लिए, क्योंकि वे तरीके सॉकेट पतों को स्वीकार या वापस नहीं करते हैं।

हम डेटाग्राम चैनल की कनेक्शन स्थिति को कॉल करके जांच सकते हैं isConnected() पद्धति। जुड़ा हुआ है, जब तक कि डिस्कनेक्ट या बंद नहीं किया जाता है, तब तक एक डेटाग्राम चैनल जुड़ा रहता है। डटाग्राम चैनल थ्रेड सुरक्षित होते हैं और एक साथ मल्टी-थ्रेडिंग और कॉन्सिलेटर का समर्थन करते हैं।

डेटाग्राम चैनल के महत्वपूर्ण तरीके

bind(SocketAddress local) - यह विधि डेटाग्राम चैनल के सॉकेट को स्थानीय पते पर बांधने के लिए उपयोग की जाती है जो इस विधि के पैरामीटर के रूप में प्रदान की जाती है।
connect(SocketAddress remote) - इस विधि का उपयोग सॉकेट को दूरस्थ पते से जोड़ने के लिए किया जाता है।
disconnect() - इस विधि का उपयोग सॉकेट को दूरस्थ पते पर डिस्कनेक्ट करने के लिए किया जाता है।
getRemoteAddress() - यह विधि रिमोट लोकेशन के पते को लौटाती है जिससे चैनल का सॉकेट जुड़ा होता है।
isConnected() - जैसा कि पहले ही उल्लेख किया गया है कि यह विधि डेटाग्राम चैनल के कनेक्शन की स्थिति लौटाती है अर्थात यह जुड़ा हुआ है या नहीं।
open() and open(ProtocolFamily family) - ओपन मेथड का इस्तेमाल सिंगल एड्रेस के लिए एक डाटाग्राम चैनल खोलने के लिए किया जाता है, जबकि पैराट्रिमेड ओपन मेथड ओपन चैनल मल्टीपल एड्रेस के लिए प्रोटोकॉल परिवार के रूप में दर्शाया जाता है।
read(ByteBuffer dst) - इस विधि का उपयोग डेटाग्राम चैनल के माध्यम से दिए गए बफर से डेटा पढ़ने के लिए किया जाता है।
receive(ByteBuffer dst) - इस चैनल के माध्यम से डेटाग्राम प्राप्त करने के लिए इस विधि का उपयोग किया जाता है।
send(ByteBuffer src, SocketAddress target) - इस चैनल के माध्यम से डेटाग्राम भेजने के लिए इस विधि का उपयोग किया जाता है।

उदाहरण

निम्न उदाहरण जावा NIO DataGramChannel से डेटा भेजने का तरीका दिखाता है।

सर्वर: DatagramChannelServer.java

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;

public class DatagramChannelServer {
   public static void main(String[] args) throws IOException {
      DatagramChannel server = DatagramChannel.open();
      InetSocketAddress iAdd = new InetSocketAddress("localhost", 8989);
      server.bind(iAdd);
      System.out.println("Server Started: " + iAdd);
      ByteBuffer buffer = ByteBuffer.allocate(1024);
      //receive buffer from client.
      SocketAddress remoteAdd = server.receive(buffer);
      //change mode of buffer
      buffer.flip();
      int limits = buffer.limit();
      byte bytes[] = new byte[limits];
      buffer.get(bytes, 0, limits);
      String msg = new String(bytes);
      System.out.println("Client at " + remoteAdd + "  sent: " + msg);
      server.send(buffer,remoteAdd);
      server.close();
   }
}

उत्पादन

Server Started: localhost/127.0.0.1:8989

ग्राहक: DatagramChannelClient.java

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;

public class DatagramChannelClient {
   public static void main(String[] args) throws IOException {
      DatagramChannel client = null;
      client = DatagramChannel.open();

      client.bind(null);

      String msg = "Hello World!";
      ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
      InetSocketAddress serverAddress = new InetSocketAddress("localhost",
        8989);

      client.send(buffer, serverAddress);
      buffer.clear();
      client.receive(buffer);
      buffer.flip();
    
      client.close();
   }
}

उत्पादन

क्लाइंट चलाने से सर्वर पर निम्न आउटपुट प्रिंट होगा।

Server Started: localhost/127.0.0.1:8989
Client at /127.0.0.1:64857  sent: Hello World!

Java NIO सॉकेट चैनल एक चयन करने योग्य प्रकार का चैनल है जिसका अर्थ है कि इसे चयनकर्ता का उपयोग करके गुणा किया जा सकता है, जो धारा उन्मुख डेटा प्रवाह को सॉकेट से कनेक्ट करने के लिए उपयोग किया जाता है। सॉकेट चैनल को अपने स्थैतिक को शामिल करके बनाया जा सकता है open() विधि, कोई भी पहले से मौजूद सॉकेट प्रदान करना पहले से मौजूद नहीं है। सॉकेट चैनल खुली विधि को लागू करके बनाया गया है लेकिन अभी तक जुड़ा नहीं है। सॉकेट चैनल को जोड़ने के लिए connect() विधि को कहा जाता है। यहां उल्लेख किया जाना चाहिए। यदि चैनल कनेक्ट नहीं है और किसी भी I / O ऑपरेशन का प्रयास करने की कोशिश की जाती है, तो NotYetConnectedException को इस चैनल द्वारा फेंक दिया जाता है। कोई भी यह सुनिश्चित करना चाहिए कि चैनल किसी भी IO से पहले जुड़ा हुआ है ऑपरेशन। एक चैनल जुड़ा हुआ है, यह बंद रहने तक जुड़ा रहता है। सॉकेट चैनल की स्थिति को इसके द्वारा निर्धारित किया जा सकता है isConnected तरीका।

सॉकेट चैनल का कनेक्शन इसे लागू करके समाप्त किया जा सकता है finishConnect() विधि। कोई कनेक्शन ऑपरेशन प्रगति पर है या नहीं, इसे आईकनेक्ट बनाने की विधि द्वारा निर्धारित किया जा सकता है। विधि डिफ़ॉल्ट सॉकेट चैनल नॉन-ब्लॉकिंग कनेक्शन का समर्थन करता है। इसके अलावा यह एसिंक्रोनस शटडाउन का समर्थन करता है, जो चैनल वर्ग में निर्दिष्ट एसिंक्रोनस क्लोज ऑपरेशन के समान है।

सॉकेट चैनल कई समवर्ती धागे द्वारा उपयोग के लिए सुरक्षित हैं। वे समवर्ती पढ़ने और लिखने का समर्थन करते हैं, हालांकि अधिकांश एक धागा पढ़ने में हो सकता है और किसी एक समय में एक ही धागे में लिखा जा सकता है। कनेक्ट और खत्म करने के तरीके परस्पर एक-दूसरे के खिलाफ सिंक्रनाइज़ किए जाते हैं, और एक पढ़ने या लिखने की कार्रवाई शुरू करने का प्रयास किया जाता है, जबकि इनमें से किसी एक तरीके का आह्वान प्रगति पर है जब तक कि मंगलाचरण पूरा नहीं हो जाता।

सॉकेट चैनल के महत्वपूर्ण तरीके

bind(SocketAddress local) - इस विधि का उपयोग सॉकेट चैनल को स्थानीय पते पर बाँधने के लिए किया जाता है जो इस विधि के पैरामीटर के रूप में प्रदान किया जाता है।
connect(SocketAddress remote) - इस विधि का उपयोग सॉकेट को दूरस्थ पते से जोड़ने के लिए किया जाता है।
finishConnect() - इस विधि का उपयोग सॉकेट चैनल को जोड़ने की प्रक्रिया को पूरा करने के लिए किया जाता है।
getRemoteAddress() - यह विधि रिमोट लोकेशन के पते को लौटाती है जिससे चैनल का सॉकेट जुड़ा होता है।
isConnected() - जैसा कि पहले ही उल्लेख किया गया है कि यह विधि सॉकेट चैनल के कनेक्शन की स्थिति लौटाती है अर्थात यह जुड़ा हुआ है या नहीं।
open() and open((SocketAddress remote) - ओपन मेथड का उपयोग बिना किसी निर्दिष्ट पते के लिए सॉकेट चैनल खोलने के लिए किया जाता है, जबकि निर्दिष्ट रिमोट एड्रेस के लिए ओपन मेथड ओपन मेथड ओपन चैनल भी होता है और इससे कनेक्ट भी होता है। यह सुविधा विधि इस तरह काम करती है जैसे कि ओपन () विधि को लागू करने के बाद, कनेक्ट करने की विधि सॉकेट चैनल, इसे दूरस्थ रूप से पारित करना, और फिर उस चैनल को वापस करना।
read(ByteBuffer dst) - इस विधि का उपयोग सॉकेट चैनल के माध्यम से दिए गए बफर से डेटा पढ़ने के लिए किया जाता है।
isConnectionPending() - यह विधि बताती है कि इस चैनल पर कनेक्शन ऑपरेशन जारी है या नहीं।

उदाहरण

निम्न उदाहरण दिखाता है कि जावा एनआईओ सॉकेटचैनल से डेटा कैसे भेजा जाए।

सी: /Test/temp.txt

Hello World!

ग्राहक: सॉकेटचैनलाइन Client.java

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.EnumSet;

public class SocketChannelClient {
   public static void main(String[] args) throws IOException {
      ServerSocketChannel serverSocket = null;
      SocketChannel client = null;
      serverSocket = ServerSocketChannel.open();
      serverSocket.socket().bind(new InetSocketAddress(9000));
      client = serverSocket.accept();
      System.out.println("Connection Set:  " + client.getRemoteAddress());
      Path path = Paths.get("C:/Test/temp1.txt");
      FileChannel fileChannel = FileChannel.open(path, 
         EnumSet.of(StandardOpenOption.CREATE, 
            StandardOpenOption.TRUNCATE_EXISTING,
            StandardOpenOption.WRITE)
         );      
      ByteBuffer buffer = ByteBuffer.allocate(1024);
      while(client.read(buffer) > 0) {
         buffer.flip();
         fileChannel.write(buffer);
         buffer.clear();
      }
      fileChannel.close();
      System.out.println("File Received");
      client.close();
   }
}

उत्पादन

क्लाइंट को चलाने से सर्वर शुरू होने तक कुछ भी प्रिंट नहीं होगा।

सर्वर: सॉकेटचैनलाइनरवर। जावा

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Path;
import java.nio.file.Paths;

public class SocketChannelServer {
   public static void main(String[] args) throws IOException {
      SocketChannel server = SocketChannel.open();
      SocketAddress socketAddr = new InetSocketAddress("localhost", 9000);
      server.connect(socketAddr);

      Path path = Paths.get("C:/Test/temp.txt");
      FileChannel fileChannel = FileChannel.open(path);
      ByteBuffer buffer = ByteBuffer.allocate(1024);
      while(fileChannel.read(buffer) > 0) {
         buffer.flip();
         server.write(buffer);
         buffer.clear();
      }
      fileChannel.close();
      System.out.println("File Sent");
      server.close();
   }
}

उत्पादन

सर्वर चलाने से निम्नलिखित प्रिंट होगा।

Connection Set:  /127.0.0.1:49558
File Received

Java NIO सर्वर सॉकेट चैनल फिर से एक चुनिंदा प्रकार का चैनल है जो धारा उन्मुख डेटा प्रवाह को सॉकेट से कनेक्ट करने के लिए उपयोग किया जाता है। Sver सॉकेट चैनल को अपने स्थिर को शामिल करके बनाया जा सकता है open() विधि, कोई भी पहले से मौजूद सॉकेट प्रदान करना पहले से मौजूद नहीं है। सेवर सॉकेट चैनल खुली विधि को लागू करके बनाया गया है, लेकिन अभी तक बाध्य नहीं है। सॉकेट चैनल को बाध्य करने के लिए bind() विधि कहलाती है।

यहां उल्लेख किया जाने वाला एक बिंदु यह है कि यदि चैनल बाध्य नहीं है और किसी भी I / O ऑपरेशन का प्रयास करने की कोशिश की जाती है, तो NotYetBoundException को इस चैनल द्वारा फेंक दिया जाता है। कोई भी यह सुनिश्चित करना चाहिए कि चैनल किसी IO ऑपरेशन को करने से पहले बाध्य है।

सर्वर सॉकेट चैनल के लिए आने वाले कनेक्शन ServerSocketChannel.accept () विधि को कॉल करके सुनते हैं। जब स्वीकार () विधि वापस आती है, तो यह एक सॉकेटचैनल को एक आने वाले कनेक्शन के साथ देता है। इस प्रकार, आवक कनेक्शन आने तक स्वीकार () विधि अवरुद्ध हो जाती है। यदि चैनल गैर-अवरोधक मोड में है, तो स्वीकार विधि तुरंत लंबित होने पर शून्य वापस आ जाएगी। अन्यथा यह अनिश्चित काल तक अवरुद्ध रहेगा जब तक कि एक नया कनेक्शन उपलब्ध न हो या I / O त्रुटि न हो।

नए चैनल का सॉकेट शुरू में अनबाउंड है; यह कनेक्शन स्वीकार किए जाने से पहले अपने सॉकेट के बाइंड तरीकों में से एक के माध्यम से एक विशिष्ट पते पर होना चाहिए। इसके अलावा, नया चैनल सिस्टम-वाइड डिफॉल्ट सेलेक्टरप्रॉइडर ऑब्जेक्ट के ओपनसर्वर सॉकेटचैनल विधि को लागू करके बनाया जाता है।

सॉकेट चैनल सर्वर सॉकेट चैनल की तरह डेटा का उपयोग कर पढ़ सकता है read()पद्धति। पूरी तरह से बफर आवंटित किया गया है। ServerSocketChannel से पढ़ा गया डेटा बफर में स्टोर हो जाता है। इसके अलावा, हम ServerSocketChannel.read () विधि को कॉल करते हैं और यह ServerSocketChannel के डेटा को बफर में पढ़ता है। रीड () विधि का पूर्णांक मान बफर में कितने बाइट्स लिखा गया था

इसी तरह डेटा को सर्वर सॉकेट चैनल का उपयोग करके लिखा जा सकता है write() बफ़र को पैरामीटर के रूप में उपयोग करने की विधि। एक समय में लूप में लिखने की विधि का उपयोग करता है जब तक कि बफ़र को लिखने के लिए उपलब्ध न हो तब तक लिखने () विधि को दोहराने की आवश्यकता होती है।

सॉकेट चैनल के महत्वपूर्ण तरीके

bind(SocketAddress local) - इस विधि का उपयोग सॉकेट चैनल को स्थानीय पते पर बाँधने के लिए किया जाता है जो इस विधि के पैरामीटर के रूप में प्रदान किया जाता है।
accept() - इस विधि का उपयोग इस चैनल के सॉकेट में किए गए कनेक्शन को स्वीकार करने के लिए किया जाता है।
connect(SocketAddress remote) - इस विधि का उपयोग सॉकेट को दूरस्थ पते से जोड़ने के लिए किया जाता है।
finishConnect() - इस विधि का उपयोग सॉकेट चैनल को जोड़ने की प्रक्रिया को पूरा करने के लिए किया जाता है।
getRemoteAddress() - यह विधि रिमोट लोकेशन के पते को लौटाती है जिससे चैनल का सॉकेट जुड़ा होता है।
isConnected() - जैसा कि पहले ही उल्लेख किया गया है कि यह विधि सॉकेट चैनल के कनेक्शन की स्थिति लौटाती है अर्थात यह जुड़ा हुआ है या नहीं।
open() - ओपन मेथड का उपयोग बिना किसी निर्दिष्ट पते के लिए सॉकेट चैनल खोलने के लिए किया जाता है। यह सुविधा विधि इस तरह काम करती है जैसे कि ओपन () विधि को लागू करने से, परिणामस्वरूप सर्वर सॉकेट चैनल पर कनेक्ट विधि को लागू करना, इसे दूरस्थ रूप से पारित करना, और फिर उस चैनल को वापस करना।
read(ByteBuffer dst) - इस विधि का उपयोग सॉकेट चैनल के माध्यम से दिए गए बफर से डेटा पढ़ने के लिए किया जाता है।
setOption(SocketOption<T> name, T value) - यह विधि सॉकेट विकल्प का मान सेट करती है।
socket() - यह विधि इस चैनल से जुड़े सर्वर सॉकेट को पुनः प्राप्त करती है।
validOps() - यह विधि इस चैनल के समर्थित संचालनों की पहचान करते हुए एक ऑपरेशन सेट लौटाती है। सेवर-सॉकेट चैनल केवल नए कनेक्शन स्वीकार करने का समर्थन करते हैं, इसलिए यह विधि SelectionKey.OP_ACCEPT देता है।

उदाहरण

निम्न उदाहरण जावा NIO ServerShanChannel से डेटा भेजने का तरीका दिखाता है।

सी: /Test/temp.txt

Hello World!

ग्राहक: सॉकेटचैनलाइन Client.java

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.EnumSet;

public class SocketChannelClient {
   public static void main(String[] args) throws IOException {
      ServerSocketChannel serverSocket = null;
      SocketChannel client = null;
      serverSocket = ServerSocketChannel.open();
      serverSocket.socket().bind(new InetSocketAddress(9000));
      client = serverSocket.accept();
      System.out.println("Connection Set:  " + client.getRemoteAddress());
      Path path = Paths.get("C:/Test/temp1.txt");
      FileChannel fileChannel = FileChannel.open(path, 
         EnumSet.of(StandardOpenOption.CREATE, 
            StandardOpenOption.TRUNCATE_EXISTING,
            StandardOpenOption.WRITE)
         );      
      ByteBuffer buffer = ByteBuffer.allocate(1024);
      while(client.read(buffer) > 0) {
         buffer.flip();
         fileChannel.write(buffer);
         buffer.clear();
      }
      fileChannel.close();
      System.out.println("File Received");
      client.close();
   }
}

उत्पादन

क्लाइंट को चलाने से सर्वर शुरू होने तक कुछ भी प्रिंट नहीं होगा।

सर्वर: सॉकेटचैनलाइनरवर। जावा

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Path;
import java.nio.file.Paths;

public class SocketChannelServer {
   public static void main(String[] args) throws IOException {
      SocketChannel server = SocketChannel.open();
      SocketAddress socketAddr = new InetSocketAddress("localhost", 9000);
      server.connect(socketAddr);
      Path path = Paths.get("C:/Test/temp.txt");
      FileChannel fileChannel = FileChannel.open(path);
      ByteBuffer buffer = ByteBuffer.allocate(1024);
      while(fileChannel.read(buffer) > 0) {
         buffer.flip();
         server.write(buffer);
         buffer.clear();
      }
      fileChannel.close();
      System.out.println("File Sent");
      server.close();
   }
}

उत्पादन

सर्वर चलाने से निम्नलिखित प्रिंट होगा।

Connection Set:  /127.0.0.1:49558
File Received

जैसा कि हम जानते हैं कि Java NIO, जावा के पारंपरिक IO API की तुलना में डेटा IO परिचालनों के लिए एक अधिक अनुकूलित API है। अधिक अतिरिक्त समर्थन जो Java NIO प्रदान करता है, जिसमें / से कई बफ़र्स के डेटा को पढ़ना / लिखना है। और लेखन समर्थन को स्कैटर और इकट्ठा के रूप में कहा जाता है, जिसमें डेटा को रीड डेटा के मामले में एकल चैनल से कई बफ़र्स तक फैलाया जाता है, जबकि राइट डेटा के मामले में डेटा को कई बफ़र्स से सिंगल चैनल में इकट्ठा किया जाता है।

चैनल से इस मल्टीपल रीड एंड राइट को प्राप्त करने के लिए ScatteringByteChannel और GatheringByteChannel API है जो जावा NIO डेटा को उदाहरण के रूप में पढ़ने और लिखने के लिए प्रदान करता है।

ScatteringByteChannel

Read from multiple channels - इसमें हमने एक चैनल से डेटा को कई बफ़र्स में पढ़ने के लिए बनाया है। इसके लिए इस मल्टीपल बफ़र को आवंटित किया जाता है और इसे बफर टाइप ऐरे में जोड़ा जाता है। फिर इस सरणी को स्केटरिंगबाइटचैनल रीड () विधि के पैरामीटर के रूप में पास किया जाता है, फिर उससे डेटा लिखते हैं। इस क्रम में चैनल बफ़र्स सरणी में होता है। एक बफ़र भर जाने के बाद, चैनल अगले बफ़र को भरने के लिए आगे बढ़ता है।

निम्न उदाहरण से पता चलता है कि जावा एनआईओ में डेटा का प्रकीर्णन कैसे किया जाता है

सी: /Test/temp.txt

Hello World!

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ScatteringByteChannel;

public class ScatterExample {	
   private static String FILENAME = "C:/Test/temp.txt";
   public static void main(String[] args) {
      ByteBuffer bLen1 = ByteBuffer.allocate(1024);
      ByteBuffer bLen2 = ByteBuffer.allocate(1024);
      FileInputStream in;
      try {
         in = new FileInputStream(FILENAME);
         ScatteringByteChannel scatter = in.getChannel();
         scatter.read(new ByteBuffer[] {bLen1, bLen2});
         bLen1.position(0);
         bLen2.position(0);
         int len1 = bLen1.asIntBuffer().get();
         int len2 = bLen2.asIntBuffer().get();
         System.out.println("Scattering : Len1 = " + len1);
         System.out.println("Scattering : Len2 = " + len2);
      } 
      catch (FileNotFoundException exObj) {
         exObj.printStackTrace();
      }
      catch (IOException ioObj) {
         ioObj.printStackTrace();
      }
   }
}

उत्पादन

Scattering : Len1 = 1214606444
Scattering : Len2 = 0

अंत में यह निष्कर्ष निकाला जा सकता है कि जावा एनआईओ में बिखराव / इकट्ठा दृष्टिकोण को एक अनुकूलित और मल्टीटास्क के रूप में पेश किया जाता है जब इसे ठीक से इस्तेमाल किया जाता है। यह आपको ऑपरेटिंग सिस्टम को सौंपने की अनुमति देता है जो आपके द्वारा एकाधिक बाल्टियों में पढ़े गए डेटा को अलग करने, या कोडांतरण का काम करता है। डेटा के पूरे विखंडन को पूरी तरह से करें। कोई संदेह नहीं है कि यह समय बचाता है और बफर कॉपी से बचने के लिए अधिक कुशलता से ऑपरेटिंग सिस्टम का उपयोग करता है, और कोड की मात्रा को लिखने और डिबग करने की आवश्यकता को कम करता है।

GatheringByteChannel

write to multiple channels - इसमें हमने एक ही चैनल में कई बफ़र्स से डेटा लिखने के लिए बनाया था। इसके लिए फिर से कई बफ़र्स आवंटित किए जाते हैं और उन्हें बफर टाइप सरणी में जोड़ दिया जाता है। फिर इस सरणी को गैदरिंगबाइटचैनल लिखने () विधि के पैरामीटर के रूप में पारित किया जाता है, फिर डेटा लिखते हैं अनुक्रम में कई बफ़र्स से बफ़र सरणी में होते हैं। यहाँ याद रखने की बात यह है कि केवल पोज़िशन और बफ़र्स की सीमा के बीच का डेटा ही लिखा गया है।

निम्न उदाहरण दिखाता है कि जावा एनआईओ में डेटा एकत्रीकरण कैसे किया जाता है

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.GatheringByteChannel;

public class GatherExample {
   private static String FILENAME = "C:/Test/temp.txt";
   public static void main(String[] args) {
      String stream1 = "Gather data stream first";
      String stream2 = "Gather data stream second";
      ByteBuffer bLen1 = ByteBuffer.allocate(1024);
      ByteBuffer bLen2 = ByteBuffer.allocate(1024);
      // Next two buffer hold the data we want to write
      ByteBuffer bstream1 = ByteBuffer.wrap(stream1.getBytes());
      ByteBuffer bstream2 = ByteBuffer.wrap(stream2.getBytes());
      int len1 = stream1.length();
      int len2 = stream2.length();
      // Writing length(data) to the Buffer
      bLen1.asIntBuffer().put(len1);
      bLen2.asIntBuffer().put(len2);
      System.out.println("Gathering : Len1 = " + len1);
      System.out.println("Gathering : Len2 = " + len2);
      // Write data to the file
      try { 
         FileOutputStream out = new FileOutputStream(FILENAME);
         GatheringByteChannel gather = out.getChannel();						
         gather.write(new ByteBuffer[] {bLen1, bLen2, bstream1, bstream2});
         out.close();
         gather.close();
      }
      catch (FileNotFoundException exObj) {
         exObj.printStackTrace();
      }
      catch(IOException ioObj) {
         ioObj.printStackTrace();
      }
   }
}

उत्पादन

Gathering : Len1 = 24
Gathering : Len2 = 25

जावा एनआईओ में बफ़र्स को एक साधारण वस्तु के रूप में माना जा सकता है जो डेटा चंक्स के एक निश्चित आकार के कंटेनर के रूप में कार्य करता है जिसका उपयोग चैनल से डेटा लिखने या चैनल से डेटा पढ़ने के लिए किया जा सकता है ताकि बफ़र्स चैनलों के लिए एंडपॉइंट के रूप में कार्य करें।

यह उन तरीकों का सेट प्रदान करता है जो चैनलों से और डेटा को पढ़ने और लिखने के लिए मेमोरी ब्लॉक से निपटने के लिए अधिक सुविधाजनक बनाते हैं।

बफ़र्स क्लासिक IO की तुलना में NIO पैकेज को अधिक कुशल और तेज़ बनाता है क्योंकि IO डेटा धाराओं के रूप में व्यवहार किया जाता है जो डेटा के अतुल्यकालिक और समवर्ती प्रवाह का समर्थन नहीं करते हैं। इसके अलावा IO chunk या बाइट्स के समूह में डेटा निष्पादन की अनुमति नहीं देता है ।

जावा NIO बफर को परिभाषित करने वाले प्राथमिक मापदंडों को निम्न के रूप में परिभाषित किया जा सकता है -

Capacity - बफ़र में संग्रहीत किए जा सकने वाले डेटा / बाइट की अधिकतम मात्रा। बफर की क्षमता को परिवर्तित नहीं किया जा सकता है। बफ़र पूर्ण होने पर इसे लिखने से पहले इसे साफ़ कर देना चाहिए।
Limit - सीमा का अर्थ बफ़र के मोड के अनुसार होता है अर्थात बफ़र सीमा के लिखित मोड में क्षमता के बराबर है जिसका अर्थ है कि अधिकतम डेटा जो बफर में लिखा जा सकता है। बफर मोड के रीड मोड में अधिकतम सीमा का मतलब है कि कितना डेटा हो सकता है बफ़र से पढ़ें।
Position - बफर में कर्सर के वर्तमान स्थान की ओर इशारा करता है। आमतौर पर बफर के निर्माण के समय 0 के रूप में बसाया जाता है या दूसरे शब्दों में यह पढ़ने या लिखे जाने वाले अगले तत्व का सूचकांक है जो स्वचालित रूप से अपडेट होकर प्राप्त होता है () और डाल () ) तरीके।
Mark - बफर में स्थिति का एक बुकमार्क चिह्नित करें। जब चिह्न () विधि को वर्तमान स्थिति दर्ज की जाती है और जब रीसेट () को चिह्नित स्थिति कहा जाता है बहाल किया जाता है।

बफर प्रकार

Java NIO बफ़र को निम्न प्रकार के डेटा के आधार पर निम्न प्रकारों में वर्गीकृत किया जा सकता है -

ByteBuffer
MappedByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
ShortBuffer

बफर के महत्वपूर्ण तरीके

जैसा कि पहले ही उल्लेख किया जा चुका है कि बफर मेमोरी ऑब्जेक्ट के रूप में कार्य करता है जो मेमोरी ब्लॉक से निपटने के लिए अधिक सुविधाजनक बनाने वाले तरीकों का सेट प्रदान करता है। फ़्लोरिंग बफर के महत्वपूर्ण तरीके हैं -

allocate(int capacity) - यह विधि पैरामीटर के रूप में क्षमता के साथ एक नया बफर आवंटित करने के लिए उपयोग की जाती है। पारित विधि एक नकारात्मक पूर्णांक है मामले में IllegalArgumentException को फेंकता है।
read() and put() - चैनल की रीड मेथड का उपयोग चैनल से बफर में डेटा लिखने के लिए किया जाता है जबकि पुट बफर की एक विधि है जिसका उपयोग बफर में डेटा लिखने के लिए किया जाता है।
flip() - फ्लिप विधि बफ़र के मोड को लेखन से रीडिंग मोड पर स्विच करती है। यह स्थिति को वापस 0 पर सेट करता है, और लिखने के समय उस स्थान को सेट करता है जहां स्थिति थी।
write() and get() - चैनल लिखने की विधि का उपयोग बफर से चैनल में डेटा लिखने के लिए किया जाता है, जबकि बफर बफर की एक विधि है जिसका उपयोग बफर से डेटा पढ़ने के लिए किया जाता है।
rewind() - रिवाइंड विधि का उपयोग तब किया जाता है जब रीड की आवश्यकता होती है क्योंकि यह स्थिति को शून्य पर सेट करता है और सीमा के मूल्य में परिवर्तन नहीं करता है।
clear() and compact() - क्लियर और कॉम्पैक्ट दोनों तरीकों का उपयोग रीड से राइट मोड में बफर बनाने के लिए किया जाता है।clear() विधि शून्य करने की स्थिति बनाती है और सीमा क्षमता के बराबर होती है, इस विधि में बफर में डेटा को केवल क्लीयर नहीं किया जाता है।

दुसरी तरफ compact() विधि का उपयोग तब होता है जब कुछ अन-रीड डेटा रहता है और फिर भी हम बफर के लेखन मोड का उपयोग करते हैं, इस मामले में कॉम्पैक्ट विधि बफर की शुरुआत में सभी अपठित डेटा को कॉपी करती है और अंतिम अपठित तत्व के बाद स्थिति को सही सेट करती है। सीमा संपत्ति अभी भी है क्षमता के लिए सेट।
mark() and reset() - जैसा कि नाम से पता चलता है कि मार्क विधि का उपयोग बफर में किसी विशेष स्थिति को चिह्नित करने के लिए किया जाता है जबकि रीसेट स्थिति को चिह्नित स्थिति में वापस कर देता है।

उदाहरण

निम्नलिखित उदाहरण उपरोक्त परिभाषित तरीकों के कार्यान्वयन को दर्शाता है।

import java.nio.ByteBuffer;
import java.nio.CharBuffer;

public class BufferDemo {
   public static void main (String [] args) {
      //allocate a character type buffer.
      CharBuffer buffer = CharBuffer.allocate(10);
      String text = "bufferDemo";
      System.out.println("Input text: " + text);
      for (int i = 0; i < text.length(); i++) {
         char c = text.charAt(i);
         //put character in buffer.
		 buffer.put(c);
      }
      int buffPos = buffer.position();
      System.out.println("Position after data is written into buffer: " + buffPos);
      buffer.flip();
      System.out.println("Reading buffer contents:");
      while (buffer.hasRemaining()) {
         System.out.println(buffer.get());                   
      }
      //set the position of buffer to 5.
      buffer.position(5);
      //sets this buffer's mark at its position
      buffer.mark();
      //try to change the position
      buffer.position(6);
      //calling reset method to restore to the position we marked.
      //reset() raise InvalidMarkException if either the new position is less
      //than the position marked or merk has not been setted.
      buffer.reset();
      System.out.println("Restored buffer position : " + buffer.position());
   }
}

उत्पादन

Input text: bufferDemo
Position after data is written into buffer: 10
Reading buffer contents:
b
u
f
f
e
r
D
e
m
o
Restored buffer position : 5

जैसा कि हम जानते हैं कि जावा एनआईओ एक या अधिक एनआईओ चैनल की जांच करने के लिए चैनलों और बफर से कई लेनदेन का समर्थन करता है। और यह निर्धारित करता है कि कौन से चैनल डेटा लेनदेन के लिए तैयार हैं या जावा एनआईओ चयनकर्ता को पढ़ते या लिखते हैं।

चयनकर्ता के साथ हम यह जानने के लिए एक धागा बना सकते हैं कि कौन सा चैनल डेटा लिखने और पढ़ने के लिए तैयार है और उस विशेष चैनल का सौदा कर सकता है।

हम इसकी स्थैतिक विधि को कॉल करके चयनकर्ता उदाहरण प्राप्त कर सकते हैं open()। खुले चयनकर्ता के बाद हमें इसके साथ एक नॉन ब्लॉकिंग मोड चैनल रजिस्टर करना होगा जो SelectionKey का एक उदाहरण देता है।

SelectionKey मूल रूप से संचालन का एक संग्रह है जिसे चैनल के साथ किया जा सकता है या हम कह सकते हैं कि हम चयन कुंजी की सहायता से चैनल की स्थिति जान सकते हैं।

चयन कुंजी द्वारा प्रस्तुत चैनल के प्रमुख संचालन या स्थिति हैं -

SelectionKey.OP_CONNECT - चैनल जो सर्वर से कनेक्ट करने के लिए तैयार है।
SelectionKey.OP_ACCEPT - चैनल जो आने वाले कनेक्शनों को स्वीकार करने के लिए तैयार है।
SelectionKey.OP_READ - चैनल जो डेटा पढ़ने के लिए तैयार है।
SelectionKey.OP_WRITE - चैनल जो डेटा लिखने के लिए तैयार है।

पंजीकरण के बाद प्राप्त चयन कुंजी में कुछ महत्वपूर्ण विधियां हैं जैसा कि नीचे वर्णित है -

attach() - इस विधि का उपयोग किसी वस्तु को कुंजी के साथ संलग्न करने के लिए किया जाता है। किसी चैनल को एक वस्तु संलग्न करने का मुख्य उद्देश्य उसी चैनल को पहचानना है।
attachment() - इस विधि का उपयोग चैनल से जुड़ी वस्तु को बनाए रखने के लिए किया जाता है।
channel() - इस विधि का उपयोग चैनल प्राप्त करने के लिए किया जाता है जिसके लिए विशेष कुंजी बनाई जाती है।
selector() - इस विधि का उपयोग चयनकर्ता को प्राप्त करने के लिए किया जाता है जिसके लिए विशेष कुंजी बनाई जाती है।
isValid() - यह विधि मौसम की कुंजी वैध है या नहीं लौटाती है।
isReadable() - यह विधि बताती है कि मौसम की कुंजी का चैनल पढ़ने के लिए तैयार है या नहीं।
isWritable() - यह विधि बताती है कि मौसम की कुंजी का चैनल लिखने के लिए तैयार है या नहीं।
isAcceptable() - यह विधि बताती है कि आने वाले कनेक्शन को स्वीकार करने के लिए मौसम की कुंजी का चैनल तैयार है या नहीं।
isConnectable() - यह विधि परीक्षण करती है कि क्या इस कुंजी का चैनल या तो समाप्त हो गया है, या समाप्त होने में विफल है, इसका सॉकेट-कनेक्शन ऑपरेशन।
isAcceptable() - यह विधि परीक्षण करती है कि क्या यह कुंजी चैनल नए सॉकेट कनेक्शन को स्वीकार करने के लिए तैयार है।
interestOps() - यह विधि इस कुंजी के ब्याज सेट को पुनः प्राप्त करती है।
readyOps() - यह विधि तैयार सेट को पुनः प्राप्त करती है जो कि ऑपरेशन का सेट है जिसके लिए चैनल तैयार है।

हम चयनकर्ता से इसकी स्थैतिक विधि कहकर एक चैनल का चयन कर सकते हैं select()चयनकर्ता की चयन विधि इस तरह से भरी हुई है -

select() - यह विधि वर्तमान थ्रेड को तब तक अवरुद्ध करती है जब तक कि कम से कम एक चैनल उन घटनाओं के लिए तैयार न हो जाए जिनके लिए यह पंजीकृत है।
select(long timeout) - यह विधि चुनिंदा के रूप में ही करती है () इसके अलावा यह थ्रेड को अधिकतम टाइमआउट मिलीसेकंड (पैरामीटर) के लिए ब्लॉक करता है।
selectNow() - यह विधि बिल्कुल भी ब्लॉक नहीं होती है। जो भी चैनल तैयार हैं, उनके साथ यह तुरंत लौटता है।

इसके अलावा एक ब्लॉक किए गए धागे को छोड़ने के लिए जो चुनिंदा विधि को कॉल करता है,wakeup() विधि को चयनकर्ता उदाहरण से बुलाया जा सकता है जिसके बाद चयन () के अंदर प्रतीक्षा धागा तुरंत वापस आ जाएगा।

अंत में हम चयनकर्ता को कॉल करके बंद कर सकते हैं close() विधि जो चयनकर्ता को बंद करने के साथ इस चयनकर्ता के साथ पंजीकृत सभी SelectionKey उदाहरणों को भी अमान्य करती है।

उदाहरण

import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class SelectorDemo {
   public static void main(String[] args) throws IOException {
      String demo_text = "This is a demo String";	
      Selector selector = Selector.open();
      ServerSocketChannel serverSocket = ServerSocketChannel.open();
      serverSocket.bind(new InetSocketAddress("localhost", 5454));
      serverSocket.configureBlocking(false);
      serverSocket.register(selector, SelectionKey.OP_ACCEPT);
      ByteBuffer buffer = ByteBuffer.allocate(256);
      while (true) {
         selector.select();
         Set<SelectionKey> selectedKeys = selector.selectedKeys();
         Iterator<SelectionKey> iter = selectedKeys.iterator();
         while (iter.hasNext()) {
            SelectionKey key = iter.next();
            int interestOps = key.interestOps();
            System.out.println(interestOps);
            if (key.isAcceptable()) {
               SocketChannel client = serverSocket.accept();
               client.configureBlocking(false);
               client.register(selector, SelectionKey.OP_READ);
            }
            if (key.isReadable()) {
               SocketChannel client = (SocketChannel) key.channel();
               client.read(buffer);
               if (new String(buffer.array()).trim().equals(demo_text)) {
                  client.close();
                  System.out.println("Not accepting client messages anymore");
               }
               buffer.flip();
               client.write(buffer);
               buffer.clear();
            }
            iter.remove();
         }
      }
   }
}

जावा में NIO पाइप एक घटक है जो दो थ्रेड्स के बीच डेटा लिखने और पढ़ने के लिए उपयोग किया जाता है। मुख्य रूप से दो चैनल होते हैं जो डेटा प्रसार के लिए जिम्मेदार होते हैं।

दो घटक चैनलों में से एक को सिंक चैनल कहा जाता है जो मुख्य रूप से डेटा लिखने के लिए है और अन्य स्रोत चैनल है जिसका मुख्य उद्देश्य सिंक चैनल के डेटा को पढ़ना है।

डेटा सिंक्रनाइज़ेशन को डेटा लिखने और पढ़ने के दौरान रखा जाता है क्योंकि यह सुनिश्चित किया जाना चाहिए कि डेटा को उसी क्रम में पढ़ा जाना चाहिए जिसमें यह पाइप को लिखा गया है।

यह ध्यान में रखा जाना चाहिए कि यह पाइप में डेटा का एक अप्रत्यक्ष प्रवाह है अर्थात डेटा केवल सिंक चैनल में लिखा गया है और केवल स्रोत चैनल से पढ़ा जा सकता है।

जावा में NIO पाइप को मुख्य रूप से तीन विधियों के साथ एक सार वर्ग के रूप में परिभाषित किया गया है जिसमें से दो सार हैं।

पाइप वर्ग के तरीके

open() - इस विधि का उपयोग पाइप का एक उदाहरण प्राप्त करने के लिए किया जाता है या हम कह सकते हैं कि इस विधि को कॉल करके पाइप बनाया जाता है।
sink() - यह विधि पाइप के सिंक चैनल को लौटाती है जिसका उपयोग इसकी लेखन विधि को कॉल करके डेटा लिखने के लिए किया जाता है।
source() - यह विधि पाइप के स्रोत चैनल को लौटाती है जिसका उपयोग उसकी रीड विधि को कॉल करके डेटा पढ़ने के लिए किया जाता है।

उदाहरण

निम्न उदाहरण जावा एनआईओ पाइप के कार्यान्वयन को दर्शाता है।

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Pipe;

public class PipeDemo {
   public static void main(String[] args) throws IOException {
      //An instance of Pipe is created
      Pipe pipe = Pipe.open();
      // gets the pipe's sink channel
      Pipe.SinkChannel skChannel = pipe.sink();
      String testData = "Test Data to Check java NIO Channels Pipe.";
      ByteBuffer buffer = ByteBuffer.allocate(512);
      buffer.clear();
      buffer.put(testData.getBytes());
      buffer.flip();
      //write data into sink channel.
      while(buffer.hasRemaining()) {
         skChannel.write(buffer);
      }
      //gets  pipe's source channel
      Pipe.SourceChannel sourceChannel = pipe.source();
      buffer = ByteBuffer.allocate(512);
      //write data into console     
      while(sourceChannel.read(buffer) > 0){
         //limit is set to current position and position is set to zero
         buffer.flip();
         while(buffer.hasRemaining()){
            char ch = (char) buffer.get();
            System.out.print(ch);
         }
         //position is set to zero and limit is set to capacity to clear the buffer.
         buffer.clear();
      }
   }
}

उत्पादन

Test Data to Check java NIO Channels Pipe.

मान लें कि हमारे पास एक पाठ फ़ाइल है c:/test.txt, जिसमें निम्नलिखित सामग्री है। यह फ़ाइल हमारे उदाहरण कार्यक्रम के लिए एक इनपुट के रूप में उपयोग की जाएगी।

जैसा कि नाम से पता चलता है कि पथ एक इकाई का एक विशेष स्थान है जैसे फ़ाइल या फ़ाइल सिस्टम में एक निर्देशिका ताकि कोई भी उस विशेष स्थान पर खोज और उस तक पहुंच सके।

तकनीकी रूप से जावा के संदर्भ में, पथ एक इंटरफ़ेस है जो जावा संस्करण 7 के दौरान जावा एनआईओ फ़ाइल पैकेज में पेश किया गया है, और यह विशेष रूप से फ़ाइल सिस्टम में स्थान का प्रतिनिधित्व करता है। पथ इंटरफ़ेस जावा एनआईओ पैकेज में है, इसलिए इसे जावा के रूप में इसका योग्य नाम मिलता है। .nio.file.Path।

एक इकाई के सामान्य पथ में दो प्रकार हो सकते हैं एक पूर्ण मार्ग है और अन्य सापेक्ष पथ है। दोनों रास्तों के नाम से पता चलता है कि निरपेक्ष पथ जड़ से इकाई के लिए स्थान का पता है जहां यह पता लगाता है, जबकि सापेक्ष पथ स्थान का पता है जो किसी अन्य पथ के सापेक्ष है। पैठ अपनी परिभाषा में सीमांकित का उपयोग विंडोज के लिए "\" और यूनिक्स ऑपरेटिंग सिस्टम के लिए "/" के रूप में करता है।

पथ का उदाहरण प्राप्त करने के लिए हम java.nio.file.Paths वर्ग की स्थिर विधि का उपयोग कर सकते हैं get().यह विधि एक पथ स्ट्रिंग, या स्ट्रिंग्स के एक क्रम को परिवर्तित करती है, जो पथ स्ट्रिंग के रूप में जुड़कर एक पथ उदाहरण के रूप में बन जाती है। यह विधि रनटाइम InvalidPathException को भी फेंक देती है यदि तर्कों के पास अवैध वर्ण हैं।

जैसा कि निरपेक्ष पथ के ऊपर उल्लेख किया गया है, मूल तत्व और फ़ाइल को खोजने के लिए आवश्यक पूरी निर्देशिका सूची को पुनः प्राप्त किया जा सकता है। पर्याप्त सापेक्ष पथ को सापेक्ष पथ के साथ आधार पथ के संयोजन द्वारा पुनर्प्राप्त किया जा सकता है। दोनों रास्तों की शिकायत निम्न उदाहरण में चित्रित की जाएगी।

उदाहरण

package com.java.nio;
import java.io.IOException;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.file.FileSystem;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
public class PathDemo {
   public static void main(String[] args) throws IOException {
      Path relative = Paths.get("file2.txt");
      System.out.println("Relative path: " + relative);
      Path absolute = relative.toAbsolutePath();
      System.out.println("Absolute path: " + absolute);
   }
}

अब तक हम जानते हैं कि पथ इंटरफ़ेस क्या है, हमें इसकी आवश्यकता क्यों है और हम इसे कैसे एक्सेस कर सकते हैं। अब हम जानेंगे कि वे कौन से महत्वपूर्ण तरीके हैं जो पथ इंटरफ़ेस हमें प्रदान करते हैं।

पाथ इंटरफेस के महत्वपूर्ण तरीके

getFileName() - इस ऑब्जेक्ट को बनाने वाले फाइल सिस्टम को लौटाता है।
getName() - इस पथ का नाम तत्व पथ ऑब्जेक्ट के रूप में देता है।
getNameCount() - पथ में नाम तत्वों की संख्या लौटाता है।
subpath() - एक रिश्तेदार पथ लौटाता है जो इस पथ के नाम तत्वों का एक बाद है।
getParent() - यदि यह पथ माता-पिता के पास नहीं है, तो मूल पथ लौटा देता है या अशक्त होता है।
getRoot() - इस पथ के रूट घटक को पथ ऑब्जेक्ट के रूप में लौटाता है, या यदि इस पथ में रूट घटक नहीं है, तो अशक्त।
toAbsolutePath() - इस पथ के निरपेक्ष पथ का प्रतिनिधित्व करने वाला पथ ऑब्जेक्ट लौटाता है।
toRealPath() - किसी मौजूदा फ़ाइल का वास्तविक पथ देता है।
toFile() - इस पथ का प्रतिनिधित्व करने वाली एक फ़ाइल ऑब्जेक्ट लौटाता है।
normalize() - एक पथ देता है जो निरर्थक नाम तत्वों के साथ इस पथ को समाप्त कर देता है।
compareTo(Path other) - दो अमूर्त रास्तों की तुलना करता है lexicographically। यह विधि शून्य आती है यदि तर्क इस पथ के बराबर है, शून्य से कम का मान यदि यह पथ तर्क से कम है, या शून्य से अधिक मान है यदि यह पथ तर्क से बड़ा है। ।
endsWith(Path other) - टेस्ट यदि यह पथ दिए गए पथ के साथ समाप्त होता है। यदि दिए गए पथ में N तत्व हैं, और कोई रूट घटक नहीं है, और इस पथ में N या अधिक तत्व हैं, तो यह पथ दिए गए पथ से समाप्त होता है यदि प्रत्येक पथ के अंतिम N तत्व, मूल से दूर तत्व पर शुरू, बराबर हैं।
endsWith(String other) - टेस्ट अगर यह पथ एक पथ के साथ समाप्त होता है, तो दिए गए पथ स्ट्रिंग को परिवर्तित करके, बिल्कुल उसी तरीके से होता है, जो एंडविथ (पथ) विधि द्वारा निर्दिष्ट है।

उदाहरण

उदाहरण के बाद पथ इंटरफ़ेस के विभिन्न तरीकों का वर्णन किया गया है जो ऊपर उल्लिखित हैं -

package com.java.nio;
import java.io.IOException;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.file.FileSystem;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
public class PathDemo {
   public static void main(String[] args) throws IOException {
      Path path = Paths.get("D:/workspace/ContentW/Saurav_CV.docx");
      FileSystem fs =  path.getFileSystem();
      System.out.println(fs.toString());
      System.out.println(path.isAbsolute());
      System.out.println(path.getFileName());
      System.out.println(path.toAbsolutePath().toString());
      System.out.println(path.getRoot());
      System.out.println(path.getParent());
      System.out.println(path.getNameCount());
      System.out.println(path.getName(0));
      System.out.println(path.subpath(0, 2));
      System.out.println(path.toString());
      System.out.println(path.getNameCount());
      Path realPath = path.toRealPath(LinkOption.NOFOLLOW_LINKS);
      System.out.println(realPath.toString());
      String originalPath = "d:\\data\\projects\\a-project\\..\\another-project";
      Path path1 = Paths.get(originalPath);
      Path path2 = path1.normalize();
      System.out.println("path2 = " + path2);
   }
}

जावा एनआईओ पैकेज फाइलों के रूप में नामित एक और उपयोगिता एपीआई प्रदान करता है जो मूल रूप से अपने स्थिर तरीकों का उपयोग करके फ़ाइलों और निर्देशिकाओं में हेरफेर करने के लिए उपयोग किया जाता है जो ज्यादातर पथ ऑब्जेक्ट पर काम करता है।

जैसा कि पथ ट्यूटोरियल में बताया गया है कि फ़ाइल पैकेज में जावा 7 संस्करण के दौरान जावा एनआईओ पैकेज में पथ इंटरफ़ेस पेश किया गया है। इस ट्यूटोरियल के लिए समान फ़ाइल पैकेज है।

इस वर्ग में विशेष रूप से स्थिर विधियाँ शामिल हैं, जो फाइलों, निर्देशिकाओं या अन्य प्रकार की फाइलों पर काम करती हैं। ज्यादातर मामलों में, यहाँ बताए गए तरीके फ़ाइल संचालन करने के लिए संबंधित फाइल सिस्टम प्रदाता को सौंप देंगे।

फ़ाइलें वर्ग में परिभाषित कई विधियां हैं जो जावा डॉक्स से भी पढ़ी जा सकती हैं। इस ट्यूटोरियल में हमने जावा एनआईओ फाइल वर्ग के सभी तरीकों में से कुछ महत्वपूर्ण विधियों को शामिल करने का प्रयास किया।

फ़ाइलें वर्ग के महत्वपूर्ण तरीके।

जावा एनआईओ फ़ाइलें कक्षा में परिभाषित महत्वपूर्ण तरीके निम्नलिखित हैं।

createFile(Path filePath, FileAttribute attrs) - फ़ाइल वर्ग निर्दिष्ट पथ का उपयोग करके फ़ाइल बनाने के लिए यह विधि प्रदान करता है।

उदाहरण

package com.java.nio;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class CreateFile {
   public static void main(String[] args) {
      //initialize Path object
      Path path = Paths.get("D:file.txt");
      //create file
      try {
         Path createdFilePath = Files.createFile(path);
         System.out.println("Created a file at : "+createdFilePath);
      } 
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}

उत्पादन

Created a file at : D:\data\file.txt

copy(InputStream in, Path target, CopyOption… options) - इस विधि का प्रयोग निर्दिष्ट इनपुट स्ट्रीम से निर्दिष्ट लक्ष्य फ़ाइल में सभी बाइट्स को कॉपी करने के लिए किया जाता है और निम्न मानों के साथ इस पैरामीटर के लिए लंबे मूल्य के रूप में पढ़ी या लिखी गई बाइट्स की संख्या देता है -

COPY_ATTRIBUTES - नई फ़ाइल की प्रतिलिपि विशेषताएँ, जैसे अंतिम-संशोधित-समय विशेषता।
REPLACE_EXISTING - यदि मौजूद है तो किसी मौजूदा फ़ाइल को बदलें।
NOFOLLOW_LINKS - यदि कोई फ़ाइल एक प्रतीकात्मक लिंक है, तो लिंक स्वयं, लिंक का लक्ष्य नहीं, कॉपी किया जाता है।

उदाहरण

package com.java.nio;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.List;
public class WriteFile {
   public static void main(String[] args) {
      Path sourceFile = Paths.get("D:file.txt");
      Path targetFile = Paths.get("D:fileCopy.txt");
      try {
         Files.copy(sourceFile, targetFile,
         StandardCopyOption.REPLACE_EXISTING);
      }
      catch (IOException ex) {
         System.err.format("I/O Error when copying file");
      }
      Path wiki_path = Paths.get("D:fileCopy.txt");
      Charset charset = Charset.forName("ISO-8859-1");
      try {
         List<String> lines = Files.readAllLines(wiki_path, charset);
         for (String line : lines) {
            System.out.println(line);
         }
      } 
      catch (IOException e) {
         System.out.println(e);
      }
   }	
}

उत्पादन

To be or not to be?

createDirectories(Path dir, FileAttribute<?>...attrs) - इस विधि का उपयोग सभी noxistent जनक निर्देशिकाओं को बनाकर दिए गए मार्ग का उपयोग करके निर्देशिकाएँ बनाने के लिए किया जाता है।
delete(Path path) - इस विधि का उपयोग निर्दिष्ट पथ से फ़ाइल को हटाने के लिए किया जाता है। यह फ़ाइल NoSuchFileException को फेंकता है यदि फ़ाइल निर्दिष्ट पथ पर मौजूद नहीं है या यदि फ़ाइल निर्देशिका है और यह रिक्त नहीं है और इसे हटाया नहीं जा सकता है।
exists(Path path) - इस पद्धति का उपयोग यह जांचने के लिए किया जाता है कि क्या फ़ाइल निर्दिष्ट पथ पर मौजूद है और यदि फ़ाइल मौजूद है तो यह सही वापस आ जाएगी या अन्यथा यह गलत हो जाएगी।
readAllBytes(Path path) - इस विधि का उपयोग दिए गए पथ पर फ़ाइल से सभी बाइट्स को पढ़ने के लिए किया जाता है और फ़ाइल से पढ़ी गई बाइट्स युक्त बाइट सरणी को वापस करता है।

उदाहरण

package com.java.nio;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
public class ReadFile {
   public static void main(String[] args) {
      Path wiki_path = Paths.get("D:file.txt");
      Charset charset = Charset.forName("ISO-8859-1");
      try {
         List<String> lines = Files.readAllLines(wiki_path, charset);
         for (String line : lines) {
            System.out.println(line);
         }
      } 
      catch (IOException e) {
         System.out.println(e);
      }
   }	
}

उत्पादन

Welcome to file.

size(Path path) - इस विधि का उपयोग बाइट्स में निर्दिष्ट पथ पर फ़ाइल का आकार प्राप्त करने के लिए किया जाता है।
write(Path path, byte[] bytes, OpenOption… options) - इस पद्धति का उपयोग निर्दिष्ट पथ पर किसी फ़ाइल को बाइट्स लिखने के लिए किया जाता है।

उदाहरण

package com.java.nio;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
public class WriteFile {
   public static void main(String[] args) {
      Path path = Paths.get("D:file.txt");
      String question = "To be or not to be?";
      Charset charset = Charset.forName("ISO-8859-1");
      try {
         Files.write(path, question.getBytes());
         List<String> lines = Files.readAllLines(path, charset);
         for (String line : lines) {
            System.out.println(line);
         }
      } 
      catch (IOException e) {
         System.out.println(e);
      }
   }
}

उत्पादन

To be or not to be?

जैसा कि हम जानते हैं कि जावा एनआईओ समवर्ती और मल्टी-थ्रेडिंग का समर्थन करता है जो हमें एक ही समय में अलग-अलग चैनलों से निपटने की अनुमति देता है। जावा एनआईओ पैकेज में इसके लिए जो एपीआई जिम्मेदार है, वह एसिंक्रोनसफाइलसैनेल है जो एनआईओ चैनलों के पैकेज के रूप में परिभाषित किया गया है। AsynchronousFileChannel के लिए है java.nio.channels.AsynchronousFileChannel।

AsynchronousFileChannel NIO की FileChannel के समान है, सिवाय इसके कि यह चैनल सिंक्रोनस I / O ऑपरेशन के विपरीत एसिंक्रोनस रूप से निष्पादित करने के लिए फ़ाइल संचालन को सक्षम करता है जिसमें एक धागा एक कार्रवाई में प्रवेश करता है और अनुरोध पूरा होने तक प्रतीक्षा करता है। यह अतुल्यकालिक चैनल उपयोग के लिए सुरक्षित हैं। कई समवर्ती धागे द्वारा।

एसिंक्रोनस में थ्रेड को ऑपरेटिंग सिस्टम के कर्नेल के पास भेजने के लिए अनुरोध किया जाता है, जबकि धागा किसी अन्य काम को जारी रखता है। फिर भी कर्नेल का काम किया जाता है यह थ्रेड को संकेत देता है फिर थ्रेड संकेत को स्वीकार करता है और वर्तमान जॉब और प्रक्रियाओं को बाधित करता है। मैं / ओ नौकरी आवश्यकतानुसार।

संगामिति प्राप्त करने के लिए यह चैनल दो दृष्टिकोण प्रदान करता है, जिसमें से एक को वापस करना शामिल है java.util.concurrent.Future object और अन्य ऑपरेशन के लिए पास कर रहा है एक प्रकार की वस्तु java.nio.channels.CompletionHandler।

हम एक-एक करके उदाहरणों की मदद से दोनों दृष्टिकोणों को समझेंगे।

Future Object - इसमें फ्यूचर इंटरफेस का एक उदाहरण चैनल से दिया गया है। फ्यूचर इंटरफेस में है get() वह विधि जो संचालन की स्थिति लौटाती है जिसे अतुल्यकालिक रूप से संभाला जाता है जिसके आधार पर अन्य कार्य का निष्पादन तय हो सकता है। हम यह भी जांच सकते हैं कि क्या कार्य पूरा हुआ है या नहीं isDone तरीका।

उदाहरण

निम्न उदाहरण से पता चलता है कि भविष्य की वस्तु का उपयोग कैसे करें और अतुल्यकालिक रूप से कार्य करें।

package com.java.nio;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class FutureObject {
   public static void main(String[] args) throws Exception {
      readFile();
   }
   private static void readFile() throws IOException, InterruptedException, ExecutionException {
      String filePath = "D:fileCopy.txt";
      printFileContents(filePath);
      Path path = Paths.get(filePath);		
      AsynchronousFileChannel channel =AsynchronousFileChannel.open(path, StandardOpenOption.READ);
      ByteBuffer buffer = ByteBuffer.allocate(400);
      Future<Integer> result = channel.read(buffer, 0); // position = 0
      while (! result.isDone()) {
         System.out.println("Task of reading file is in progress asynchronously.");
      }
      System.out.println("Reading done: " + result.isDone());
      System.out.println("Bytes read from file: " + result.get()); 
      buffer.flip();
      System.out.print("Buffer contents: ");
      while (buffer.hasRemaining()) {
         System.out.print((char) buffer.get());                
      }
      System.out.println(" ");
      buffer.clear();
      channel.close();
   }
   private static void printFileContents(String path) throws IOException {
      FileReader fr = new FileReader(path);
      BufferedReader br = new BufferedReader(fr);
      String textRead = br.readLine();
      System.out.println("File contents: ");
      while (textRead != null) {
         System.out.println("     " + textRead);
         textRead = br.readLine();
      }
   fr.close();
   br.close();
   }
}

उत्पादन

File contents: 
   To be or not to be?
   Task of reading file is in progress asynchronously.
   Task of reading file is in progress asynchronously.
   Reading done: true
   Bytes read from file: 19
   Buffer contents: To be or not to be?

Completion Handler -
यह दृष्टिकोण बहुत सरल है क्योंकि इसमें हम कंप्लीशनहैंडलर इंटरफेस का उपयोग करते हैं और इसके दो तरीकों को ओवरराइड करते हैं completed() वह विधि, जो I / O ऑपरेशन के सफलतापूर्वक पूर्ण होने और अन्य होने पर लागू होती है failed() वह विधि जो आई / ओ संचालन विफल होने पर मंगाई जाती है। इसमें एक हैंडलर एक एसिंक्रोनस I / O ऑपरेशन के परिणाम का उपभोग करने के लिए बनाया जाता है क्योंकि एक कार्य पूरा हो जाने के बाद केवल हैंडलर के कार्य होते हैं जिन्हें निष्पादित किया जाता है।

उदाहरण

निम्न उदाहरण दिखाता है कि एसिंक्रोनस रूप से कार्य करने के लिए कंप्लीशनहैंडलर का उपयोग कैसे करें।

package com.java.nio;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class CompletionHandlerDemo {
   public static void main (String [] args) throws Exception {
      writeFile();
   }
   private static void writeFile() throws IOException {
      String input = "Content to be written to the file.";
      System.out.println("Input string: " + input);
      byte [] byteArray = input.getBytes();
      ByteBuffer buffer = ByteBuffer.wrap(byteArray);
      Path path = Paths.get("D:fileCopy.txt");
      AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.WRITE);
      CompletionHandler handler = new CompletionHandler() {
         @Override
         public void completed(Object result, Object attachment) {
            System.out.println(attachment + " completed and " + result + " bytes are written.");
         }
         @Override
         public void failed(Throwable exc, Object attachment) {
            System.out.println(attachment + " failed with exception:");
            exc.printStackTrace();
         }
      };
      channel.write(buffer, 0, "Async Task", handler);
      channel.close();
      printFileContents(path.toString());
   }
   private static void printFileContents(String path) throws IOException {
      FileReader fr = new FileReader(path);
      BufferedReader br = new BufferedReader(fr);
      String textRead = br.readLine();
      System.out.println("File contents: ");
      while (textRead != null) {
         System.out.println("     " + textRead);
         textRead = br.readLine();
      }
      fr.close();
      br.close();
   }
}

उत्पादन

Input string: Content to be written to the file.
Async Task completed and 34 bytes are written.
File contents: 
Content to be written to the file.

हर वर्ण के लिए जावा में एक अच्छी तरह से परिभाषित यूनिकोड कोड इकाइयाँ होती हैं, जिसे JVM.So द्वारा संभाला जाता है। जावा NIO पैकेज में चारसेट नामक एक अमूर्त वर्ग को परिभाषित किया जाता है, जिसका उपयोग मुख्य रूप से एन्सेट और यूनिकोडिटी के डिकोडिंग और डिकोडिंग के लिए किया जाता है।

मानक वर्ण

जावा में समर्थित चारसेट नीचे दिए गए हैं।

US-ASCII - सात बिट ASCII वर्ण।
ISO-8859-1 - आईएसओ लैटिन वर्णमाला।
UTF-8 - यह 8 बिट यूसीएस परिवर्तन प्रारूप है।
UTF-16BE - यह बड़े एंडियन बाइट ऑर्डर के साथ 16 बिट यूसीएस परिवर्तन प्रारूप है।
UTF-16LE - यह छोटे एंडियन बाइट ऑर्डर के साथ 16 बिट यूसीएस ट्रांसफॉर्मेशन है।
UTF-16 - 16 बिट यूसीएस परिवर्तन प्रारूप।

चारसेट क्लास के महत्वपूर्ण तरीके

forName() - यह विधि दिए गए चारसेट नाम के लिए एक चारसेट ऑब्जेक्ट बनाती है। नाम कैनोनिकल या एक उपनाम हो सकता है।
displayName() - यह तरीका दिए गए चारसेट का विहित नाम देता है।
canEncode() - यह विधि जांचती है कि दिए गए चारसेट एन्कोडिंग का समर्थन करते हैं या नहीं।
decode() - यह विधि यूनिकोड चारसेट के charbuffer में दिए गए charset के तार को डिकोड करती है।
encode() - यह विधि दी गईसेट के बाइट बफर में यूनिकोड चार्टसेट के चारबफ़र को एनकोड करती है।

उदाहरण

निम्नलिखित उदाहरण चारसेट क्लास के महत्वपूर्ण तरीकों का वर्णन करते हैं।

package com.java.nio;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
public class CharsetExample {
   public static void main(String[] args) {
      Charset charset = Charset.forName("US-ASCII");
      System.out.println(charset.displayName());
      System.out.println(charset.canEncode());
      String str = "Demo text for conversion.";
      //convert byte buffer in given charset to char buffer in unicode
      ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
      CharBuffer charBuffer = charset.decode(byteBuffer);
      //convert char buffer in unicode to byte buffer in given charset
      ByteBuffer newByteBuffer = charset.encode(charBuffer);
      while(newbb.hasRemaining()){
         char ch = (char) newByteBuffer.get();
         System.out.print(ch);
      }
      newByteBuffer.clear();
   }
}

उत्पादन

US-ASCII
Demo text for conversion.

जैसा कि हम जानते हैं कि जावा NIO कंसिस्टेंसी और मल्टी थ्रेडिंग का समर्थन करता है जो इसे एक ही समय में कई फाइलों पर काम करने वाले कई थ्रेड्स से निपटने में सक्षम बनाता है। लेकिन कुछ मामलों में हमें आवश्यकता होती है कि हमारी फाइल किसी भी थ्रेड द्वारा साझा न हो और गैर-सुलभ हो।

ऐसी आवश्यकता के लिए एनआईओ फिर से फाइललॉक के रूप में जाना जाने वाला एक एपीआई प्रदान करता है जिसका उपयोग पूरी फाइल पर या फ़ाइल के एक हिस्से पर लॉक प्रदान करने के लिए किया जाता है, ताकि फ़ाइल या उसके हिस्से को साझा या सुलभ न मिले।

ऐसे लॉक प्रदान करने या लागू करने के लिए हमें FileChannel या AsynchronousFileChannel का उपयोग करना होगा, जो दो तरीके प्रदान करता है lock() तथा tryLock()इस प्रयोजन के लिए। प्रदान किया गया ताला दो प्रकार का हो सकता है -

Exclusive Lock - एक विशेष लॉक अन्य प्रोग्रामों को किसी भी प्रकार के ओवरलैपिंग लॉक प्राप्त करने से रोकता है।
Shared Lock - एक साझा लॉक अन्य समवर्ती-चल रहे कार्यक्रमों को ओवरलैपिंग अनन्य लॉक प्राप्त करने से रोकता है, लेकिन उन्हें ओवरलैपिंग साझा लॉक प्राप्त करने की अनुमति देता है।

फ़ाइल पर लॉक प्राप्त करने के लिए उपयोग की जाने वाली विधियाँ -

lock() - FileChannel या AsynchronousFileChannel की यह विधि दिए गए चैनल से जुड़ी फ़ाइल पर एक अनन्य लॉक प्राप्त करती है। इस विधि का प्रकार FileLock है जो आगे प्राप्त लॉक की निगरानी के लिए उपयोग किया जाता है।
lock(long position, long size, boolean shared) - यह विधि फिर से लॉक विधि का अतिभारित तरीका है और इसका उपयोग किसी फ़ाइल के किसी विशेष भाग को लॉक करने के लिए किया जाता है।
tryLock() - यह विधि एक FileLock या एक नल लौटाता है अगर लॉक हासिल नहीं किया जा सकता है और यह इस चैनल की फ़ाइल पर स्पष्ट रूप से अनन्य लॉक प्राप्त करने का प्रयास करता है।
tryLock(long position, long size, boolean shared) - यह विधि इस चैनल की फ़ाइल के दिए गए क्षेत्र पर एक लॉक प्राप्त करने का प्रयास करती है जो एक विशेष या साझा प्रकार का हो सकता है।

FileLock क्लास के तरीके

acquiredBy() - यह विधि उस चैनल को लौटा देती है, जिसकी फाइल लॉक का अधिग्रहण किया गया था।
position() - यह विधि लॉक किए गए क्षेत्र की पहली बाइट की फ़ाइल के भीतर स्थिति लौटाती है। बंद क्षेत्र को वास्तविक अंतर्निहित फ़ाइल के भीतर या ओवरलैप होने की आवश्यकता नहीं होती है, इसलिए इस विधि द्वारा लौटाया गया मान फ़ाइल के वर्तमान आकार से अधिक हो सकता है।
size() - यह विधि बाइट्स में बंद क्षेत्र का आकार लौटाती है। लॉक किए गए क्षेत्र को वास्तविक अंतर्निहित फ़ाइल के भीतर, या यहां तक कि ओवरलैप होने की आवश्यकता नहीं है, इसलिए इस विधि द्वारा लौटाया गया मान फ़ाइल के वर्तमान आकार से अधिक हो सकता है।
isShared() - इस विधि का उपयोग यह निर्धारित करने के लिए किया जाता है कि लॉक साझा किया गया है या नहीं।
overlaps(long position,long size) - यह विधि बताती है कि यह लॉक दिए गए लॉक रेंज को ओवरलैप करता है या नहीं।
isValid() - यह विधि बताती है कि प्राप्त लॉक वैध है या नहीं। लॉक ऑब्जेक्ट तब तक वैध रहता है जब तक कि इसे जारी नहीं किया जाता है या संबंधित फाइल चैनल बंद नहीं किया जाता है, जो भी पहले आता है।
release()- प्राप्त लॉक को मुक्त करता है। यदि लॉक ऑब्जेक्ट वैध है तो इस विधि को लागू करने से लॉक रिलीज़ हो जाता है और ऑब्जेक्ट को अमान्य बना देता है। यदि यह लॉक ऑब्जेक्ट अमान्य है तो इस विधि को लागू करने से कोई प्रभाव नहीं पड़ता है।
close()- यह विधि रिलीज़ () विधि को आमंत्रित करती है। इसे वर्ग में जोड़ा गया था ताकि इसका उपयोग स्वचालित संसाधन प्रबंधन ब्लॉक के निर्माण के साथ किया जा सके।

फ़ाइल लॉक प्रदर्शित करने के लिए उदाहरण।

उदाहरण के बाद फ़ाइल पर लॉक बनाएं और उस पर सामग्री लिखें

package com.java.nio;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
public class FileLockExample {
   public static void main(String[] args) throws IOException {
      String input = "Demo text to be written in locked mode.";  
      System.out.println("Input string to the test file is: " + input);  
      ByteBuffer buf = ByteBuffer.wrap(input.getBytes());  
      String fp = "D:file.txt";  
      Path pt = Paths.get(fp);  
      FileChannel channel = FileChannel.open(pt, StandardOpenOption.WRITE,StandardOpenOption.APPEND);  
      channel.position(channel.size() - 1); // position of a cursor at the end of file       
      FileLock lock = channel.lock();   
      System.out.println("The Lock is shared: " + lock.isShared());  
      channel.write(buf);  
      channel.close(); // Releases the Lock  
      System.out.println("Content Writing is complete. Therefore close the channel and release the lock.");  
      PrintFileCreated.print(fp);  
   }  
}

package com.java.nio;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class PrintFileCreated {
   public static void print(String path) throws IOException {  
      FileReader filereader = new FileReader(path);  
      BufferedReader bufferedreader = new BufferedReader(filereader);  
      String tr = bufferedreader.readLine();    
      System.out.println("The Content of testout.txt file is: ");  
      while (tr != null) {      
         System.out.println("    " + tr);  
         tr = bufferedreader.readLine();  
      }  
   filereader.close();  
   bufferedreader.close();  
   }  
}

उत्पादन

Input string to the test file is: Demo text to be written in locked mode.
The Lock is shared: false
Content Writing is complete. Therefore close the channel and release the lock.
The Content of testout.txt file is: 
To be or not to be?Demo text to be written in locked mode.