java जावा धारावाहिक वस्तुओं को एक फ़ाइल में कैसे लिखना और पढ़ना है




लिखने की कला (4)

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

मेरे ऑब्जेक्ट को फ़ाइल में लिखने के लिए मेरा कोड यहां दिया गया है: MyClassList एक सरणीसूची है जिसमें मेरी कक्षा की वस्तुएं शामिल हैं (जिसे फ़ाइल में लिखा जाना चाहिए)।

for (int cnt = 0; cnt < MyClassList.size(); cnt++) {
    FileOutputStream fout = new FileOutputStream("G:\\address.ser", true);
    ObjectOutputStream oos = new ObjectOutputStream(fout);
    oos.writeObject(MyClassList.get(cnt));
}

मैंने आउटपुटस्ट्रीम के निर्माता को "सत्य" जोड़ा, क्योंकि मैं प्रत्येक ऑब्जेक्ट को फ़ाइल के अंत में जोड़ना चाहता हूं। क्या वो सही है?

और फ़ाइल से ऑब्जेक्ट्स को पढ़ने के लिए मेरा कोड यहां दिया गया है:

 try {
     streamIn = new FileInputStream("G:\\address.ser");
     ObjectInputStream objectinputstream = new ObjectInputStream(streamIn);
     MyClass readCase = (MyClass) objectinputstream.readObject();
     recordList.add(readCase);
     System.out.println(recordList.get(i));
 } catch (Exception e) {
     e.printStackTrace();
 }

यह अंततः सिर्फ एक वस्तु मुद्रित करता है। अब, मुझे नहीं पता कि मैं सही ढंग से नहीं लिख रहा हूं या सही तरीके से पढ़ रहा हूं!


Answer #1

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

क्रमबद्धता:

LinkedList<YourObject> listOfObjects = <something>;
try {
    FileOutputStream file = new FileOutputStream(<filePath>);
    ObjectOutputStream writer = new ObjectOutputStream(file);
    for (YourObject obj : listOfObjects) {
        writer.writeObject(obj);
    }
    writer.close();
    file.close();
} catch (Exception ex) {
    System.err.println("failed to write " + filePath + ", "+ ex);
}

डी-क्रमबद्धता:

try {
    FileInputStream file = new FileInputStream(<filePath>);
    ObjectInputStream reader = new ObjectInputStream(file);
    while (true) {
        try { 
            YourObject obj = (YourObject)reader.readObject();
            System.out.println(obj)
        } catch (Exception ex) {
            System.err.println("end of reader file ");
            break;
        }
    }
} catch (Exception ex) {
    System.err.println("failed to read " + filePath + ", "+ ex);
}

Answer #2

जैसा कि अन्य ने सुझाव दिया है, आप पूरी सूची को एक बार में क्रमबद्ध और deserialize कर सकते हैं, जो कि आसान है और आप जो करना चाहते हैं उसके साथ पूरी तरह से पालन करना प्रतीत होता है।

उस मामले में क्रमबद्धता कोड बन जाता है

ObjectOutputStream oos = null;
FileOutputStream fout = null;
try{
    fout = new FileOutputStream("G:\\address.ser", true);
    oos = new ObjectOutputStream(fout);
    oos.writeObject(myClassList);
} catch (Exception ex) {
    ex.printStackTrace();
} finally {
    if(oos != null){
        oos.close();
    } 
}

और deserialization बन जाता है (मानते हुए कि MyClassList एक सूची है और उम्मीद है कि आप जेनेरिक का उपयोग करेंगे):

ObjectInputStream objectinputstream = null;
try {
    FileInputStream streamIn = new FileInputStream("G:\\address.ser");
    objectinputstream = new ObjectInputStream(streamIn);
    List<MyClass> readCase = (List<MyClass>) objectinputstream.readObject();
    recordList.add(readCase);
    System.out.println(recordList.get(i));
} catch (Exception e) {
    e.printStackTrace();
} finally {
    if(objectinputstream != null){
        objectinputstream .close();
    } 
}

आप फ़ाइल से कई ऑब्जेक्ट्स को भी deserialize कर सकते हैं, जैसा कि आप चाहते थे:

ObjectInputStream objectinputstream = null;
try {
    streamIn = new FileInputStream("G:\\address.ser");
    objectinputstream = new ObjectInputStream(streamIn);
    MyClass readCase = null;
    do {
        readCase = (MyClass) objectinputstream.readObject();
        if(readCase != null){
            recordList.add(readCase);
        } 
    } while (readCase != null)        
    System.out.println(recordList.get(i));
} catch (Exception e) {
    e.printStackTrace();
} finally {
    if(objectinputstream != null){
        objectinputstream .close();
    } 
}

कृपया अंत में खंड में स्ट्रीम ऑब्जेक्ट्स को बंद करना न भूलें (नोट: यह अपवाद फेंक सकता है)।

संपादित करें

जैसा कि टिप्पणियों में सुझाव दिया गया है, संसाधनों के साथ प्रयास करने के लिए इसे बेहतर बनाना चाहिए और कोड को काफी सरल होना चाहिए।

सूची क्रमबद्धता यहां दी गई है:

try(
    FileOutputStream fout = new FileOutputStream("G:\\address.ser", true);
    ObjectOutputStream oos = new ObjectOutputStream(fout);
){
    oos.writeObject(myClassList);
} catch (Exception ex) {
    ex.printStackTrace();
}

Answer #3

मुझे लगता है कि आपको प्रत्येक ऑब्जेक्ट को अपनी फाइल पर लिखना होगा या इसे पढ़ने के दौरान आपको इसे विभाजित करना होगा। आप अपनी सूची को क्रमबद्ध करने की कोशिश भी कर सकते हैं और जब इसे deserializing प्राप्त कर सकते हैं।


Answer #4

एक ही समय में पूरी सूची को क्रमबद्ध क्यों नहीं करें?

FileOutputStream fout = new FileOutputStream("G:\\address.ser");
ObjectOutputStream oos = new ObjectOutputStream(fout);
oos.writeObject(MyClassList);

मान लीजिए, कि MyClassList एक ArrayList या LinkedList , या एक और Serializable संग्रह है।

इसे वापस पढ़ने के मामले में, आपके कोड में आप केवल एक आइटम तैयार करते हैं, लिखे गए सभी आइटम को इकट्ठा करने के लिए कोई लूप नहीं है।





serialization