సీరియలైజేషన్. ప్రారంభం.

"ఈ రోజు మనం వస్తువులను సేవ్ చేయడం మరియు వాటిని ఫైల్ నుండి చదవడం గురించి పరిశోధించామని మీకు గుర్తుందా?"

"అవును, మేము ఇప్పుడే అవుట్‌పుట్ స్ట్రీమ్‌కి సేవ్ చేసాము, ఇన్‌పుట్ స్ట్రీమ్ నుండి రీడ్ చేసాము."

"బాగా చేసారు, అమిగో. మీరు ఈ వివరాలను గమనిస్తున్నారని వినడానికి చాలా బాగుంది. మీరు కోడ్‌ను పూర్తి చేయగలరా, తద్వారా అది ఫైల్‌లో సేవ్ చేయబడి చదవబడుతుంది?"

"ఏమిటి పూర్తి చేయాలి?! ఫైల్‌ఇన్‌పుట్‌స్ట్రీమ్ మరియు ఫైల్‌అవుట్‌పుట్‌స్ట్రీమ్‌ని ప్రకటించి, వాటిని సేవ్ మరియు లోడ్ పద్ధతులకు పంపండి. ఇక్కడ గందరగోళానికి గురి కావడానికి ఏమీ లేదు. చాలా సులభం."

"మీ కోసం నేను సంతోషంగా ఉన్నాను. ఇప్పుడు కొత్త అంశం కోసం: సీరియలైజేషన్ ."

సీరియలైజేషన్ మేము ఇప్పుడే చేసిన దానిలాగే ఉంటుంది, కానీ చాలా చల్లగా మరియు జావా మెషీన్‌లోనే నిర్మించబడింది. జావా యంత్రం దాని వస్తువులను నిల్వ చేయవచ్చు మరియు లోడ్ చేయగలదు. దీన్ని చేయడానికి సేవ్ మరియు లోడ్ పద్ధతులు కూడా అవసరం లేదు: అన్ని వస్తువులు జావా మెషీన్‌లో నిల్వ చేయబడతాయి మరియు వాటికి పూర్తి ప్రాప్యత ఉంది."

మేము ఆబ్జెక్ట్‌ని తీసుకొని దానిని స్ట్రీమ్‌లో సేవ్ చేసి స్ట్రీమ్ నుండి చదువుతాము:

public static void main(String[] args) throws Exception
{
 Cat cat = new Cat();

 //Save a cat to file
 FileOutputStream fileOutput = new FileOutputStream("cat.dat");
 ObjectOutputStream outputStream = new ObjectOutputStream(fileOutput);
 outputStream.writeObject(cat);
 fileOutput.close();
 outputStream.close();

 //Load a cat from file
 FileInputStream fiStream = new FileInputStream("cat.dat");
 ObjectInputStream objectStream = new ObjectInputStream(fiStream);
 Object object = objectStream.readObject();
 fiStream.close();
 objectStream.close();

 Cat newCat = (Cat)object;
}

"అంతే?"

"సరిగ్గా. చాలా పెద్ద మరియు సంక్లిష్టమైన సీరియలైజేషన్ మెకానిజం ఉంది, ఇది స్ట్రీమ్‌లో సేవ్ చేయడానికి మరియు దాదాపు ఏదైనా డేటా రకం స్ట్రీమ్ నుండి చదవడానికి అనుమతిస్తుంది."

"దాదాపు ఏదైనా. కాబట్టి ఏదైనా డేటా రకం కాదా?"

"అవును, వాస్తవం ఏమిటంటే, అన్ని ఆబ్జెక్ట్‌లు భద్రపరచబడే స్వాభావిక సామర్థ్యాన్ని కలిగి ఉండవు . కొన్ని వస్తువులు వాటి మొత్తం డేటాను అంతర్గతంగా నిల్వ చేయవు. బదులుగా, అవి కేవలం ఇతర వస్తువులు మరియు/లేదా డేటా మూలాలను సూచిస్తాయి. ఉదాహరణకు, కన్సోల్ (సిస్టమ్. ఇన్), ఇన్‌పుట్ స్ట్రీమ్ (ఇన్‌పుట్ స్ట్రీమ్) మరియు ఇతర విషయాలు."

అందుకే జావా సృష్టికర్తలు ప్రత్యేక సీరియలైజబుల్ ఇంటర్‌ఫేస్ మార్కర్‌తో ముందుకు వచ్చారు . ఇది ఏ డేటా మరియు పద్ధతులను కలిగి లేనందున దీనిని మార్కర్ అంటారు. ఇది "ట్యాగ్" లేదా "మార్క్" తరగతులకు మాత్రమే ఉపయోగించబడుతుంది. మా తరగతి దాని మొత్తం డేటాను అంతర్గతంగా నిల్వ చేస్తుందని మేము విశ్వసిస్తే, మేము దానిని సీరియలైజ్ చేయదగిన సాధనాలతో గుర్తు పెట్టవచ్చు .

సీరియలైజేషన్‌కు మద్దతుతో ఇక్కడ «పిల్లి» ఉదాహరణ:

class Cat implements Serializable
{
 public String name;
 public int age;
 public int weight;
}

మేము ఆబ్జెక్ట్‌ను సీరియలైజ్ చేయడానికి (సేవ్ చేయడానికి) ప్రయత్నించినప్పుడు, జావా మెషీన్ అది సీరియలైజేషన్‌కు మద్దతిస్తుందో లేదో తనిఖీ చేస్తుంది: ఇది సీరియలైజ్ చేయగల ఇంటర్‌ఫేస్‌ను అమలు చేస్తుందా? అలా చేస్తే, అది వస్తువును సేవ్ చేస్తుంది. కాకపోతే, సీరియలైజేషన్ అసాధ్యమని సూచించడానికి ఇది మినహాయింపును విసురుతుంది.
సీరియలైజ్ చేయదగిన వస్తువు తప్పనిసరిగా సీరియలైజ్ చేయదగిన వస్తువులను మాత్రమే కలిగి ఉండాలని ఇక్కడ మీరు అర్థం చేసుకోవాలి.

"సరే, అది అర్ధమే. మీరు దాని భాగాలను సేవ్ చేయకుండా మొత్తం సేవ్ చేయలేరు."

"సరిగ్గా."

"మరియు ints, స్ట్రింగ్స్ మరియు అర్రేలిస్ట్‌ల గురించి ఏమిటి?"

"వీరందరూ సీరియలైజేషన్‌కు మద్దతు ఇస్తున్నారు. ఇది జరిగేలా చూసేందుకు జావా సృష్టికర్తలు ప్రత్యేక శ్రద్ధ తీసుకున్నారు. ఇక్కడ ఎలాంటి సమస్యలు ఉండకూడదు."

అంతేకాకుండా, ఆబ్జెక్ట్ సీరియల్ చేయబడినప్పుడు ఆబ్జెక్ట్ రకం సేవ్ చేయబడుతుంది. ఇప్పుడు మీరు ఆబ్జెక్ట్ వేరియబుల్‌లో క్యాట్ ఆబ్జెక్ట్‌కు సూచనను సేవ్ చేయవచ్చు. ప్రతిదీ సీరియలైజ్ అవుతుంది మరియు డీరియలైజ్ అవుతుంది.

"Deserialize?"

" డీసీరియలైజేషన్ అనేది సీరియలైజేషన్‌ను రివర్స్ చేసే ప్రక్రియ: స్ట్రీమ్/ఫైల్ నుండి వస్తువును చదవడం మరియు పునర్నిర్మించడం."

"ఆహ్, ఇకపై ప్రశ్నలు లేవు."