జావా ప్రింట్ స్ట్రీమ్ క్లాస్

హాయ్! ఈ రోజు మనం జావా ప్రింట్‌స్ట్రీమ్ క్లాస్ మరియు అది చేయగల ప్రతిదాని గురించి మాట్లాడుతాము. వాస్తవానికి, మీరు ఇప్పటికే ప్రింట్‌స్ట్రీమ్ క్లాస్ యొక్క రెండు పద్ధతులతో సుపరిచితులు . అవి print() మరియు println() , మీరు బహుశా ప్రతిరోజూ ఉపయోగించేవి :) System.out వేరియబుల్ ప్రింట్‌స్ట్రీమ్ ఆబ్జెక్ట్ అయినందున, మీరు System.out.println() కి కాల్ చేసినప్పుడు మీరు ఈ తరగతి పద్ధతుల్లో ఒకదానికి కాల్ చేస్తున్నారు .  ప్రింట్‌స్ట్రీమ్ క్లాస్ యొక్క సాధారణ ప్రయోజనం కొంత స్ట్రీమ్‌కు సమాచారాన్ని పంపడం. ఈ తరగతి అనేక కన్స్ట్రక్టర్లను కలిగి ఉంది. సాధారణంగా ఉపయోగించే వాటిలో కొన్ని ఇక్కడ ఉన్నాయి:

• ప్రింట్ స్ట్రీమ్(అవుట్‌పుట్ స్ట్రీమ్ అవుట్‌పుట్ స్ట్రీమ్)
• PrintStream(ఫైల్ అవుట్‌పుట్‌ఫైల్) FileNotFoundExceptionని విసిరివేస్తుంది
• PrintStream(String outputFileName) FileNotFoundExceptionని విసిరివేస్తుంది

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

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;

public class Main {

   public static void main(String arr[]) throws FileNotFoundException
   {
       PrintStream filePrintStream = new PrintStream(new File("C:\\Users\\Username\\Desktop\\test.txt"));

       filePrintStream.println(222);
       filePrintStream.println("Hello world");
       filePrintStream.println(false);

   }
}

ఈ కోడ్ డెస్క్‌టాప్‌పై test.txt ఫైల్‌ను సృష్టిస్తుంది (ఇది ఇప్పటికే ఉనికిలో లేకుంటే) మరియు దానికి మా నంబర్, స్ట్రింగ్ మరియు బూలియన్‌ని వరుసగా వ్రాస్తాయి. మేము ప్రోగ్రామ్‌ను అమలు చేసిన తర్వాత ఫైల్ కంటెంట్‌లు ఇక్కడ ఉన్నాయి:

222
Hello world!
false

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

import java.io.FileNotFoundException;
import java.io.PrintStream;

public class Main {

   public static void main(String arr[]) throws FileNotFoundException
   {
       PrintStream filePrintStream = new PrintStream("C:\\Users\\Username\\Desktop\\test.txt");

       filePrintStream.println(222);
       filePrintStream.println("Hello world");
       filePrintStream.println(false);
   }
}

ఈ కోడ్ మునుపటి కోడ్ లాగానే పని చేస్తుంది. మా దృష్టికి విలువైన మరొక ఆసక్తికరమైన పద్ధతి printf() , ఇది ఫార్మాట్ స్ట్రింగ్ ఆధారంగా అవుట్‌పుట్‌ను ఉత్పత్తి చేస్తుంది. "ఫార్మాట్ స్ట్రింగ్" అంటే ఏమిటి? నేను ఒక ఉదాహరణ ఇస్తాను:

import java.io.IOException;
import java.io.PrintStream;

public class Main {

   public static void main(String[] args) throws IOException {

       PrintStream printStream = new PrintStream("C:\\Users\\Steve\\Desktop\\test.txt");

       printStream.println("Hello!");
       printStream.println("I'm a robot!");

       printStream.printf("My name is %s. I am %d!", "Amigo", 18);

       printStream.close();
   }
}

ఇక్కడ, స్ట్రింగ్‌లో మా రోబోట్ పేరు మరియు వయస్సును స్పష్టంగా పేర్కొనడానికి బదులుగా, మేము ఈ సమాచారం కోసం ప్లేస్‌హోల్డర్‌లను ఉంచాము, %s మరియు %d ద్వారా ప్రాతినిధ్యం వహిస్తాము . మరియు మేము వాటిని భర్తీ చేసే డేటాను వాదనలుగా పాస్ చేస్తాము. మా విషయంలో, ఇది స్ట్రింగ్ " అమిగో " మరియు సంఖ్య 18. మేము మరొక ప్లేస్‌హోల్డర్‌ని సృష్టించి, %b అని చెప్పవచ్చు మరియు మరొక ఆర్గ్యుమెంట్‌ని పాస్ చేయవచ్చు. మనకు ఇది ఎందుకు అవసరం? అన్నింటికంటే, ఎక్కువ సౌలభ్యం కోసం. మీ ప్రోగ్రామ్‌కు మీరు తరచుగా స్వాగత సందేశాన్ని ప్రదర్శించాల్సిన అవసరం ఉన్నట్లయితే, మీరు ప్రతి కొత్త రోబోట్‌కు అవసరమైన వచనాన్ని మాన్యువల్‌గా టైప్ చేయాలి. ప్రతి ఒక్కరికి వేర్వేరు పేర్లు మరియు వయస్సు ఉన్నందున మీరు ఈ వచనాన్ని స్థిరంగా కూడా చేయలేరు! కానీ ఈ కొత్త పద్ధతిని ఉపయోగించి, మీరు గ్రీటింగ్‌ను స్థిరంగా వేరు చేయవచ్చు మరియు అవసరమైతే, printf () పద్ధతికి పంపబడిన వాదనలను మార్చవచ్చు.

import java.io.IOException;
import java.io.PrintStream;

public class Main {

   private static final String GREETINGS_MESSAGE = "My name is %s. I am %d!";

   public static void main(String[] args) throws IOException {

       PrintStream printStream = new PrintStream("C:\\Users\\Steve\\Desktop\\test.txt");

       printStream.println("Hello!");
       printStream.println("We are robots!");


       printStream.printf(GREETINGS_MESSAGE, "Amigo", 18);
       printStream.printf(GREETINGS_MESSAGE, "R2-D2", 35);
       printStream.printf(GREETINGS_MESSAGE, "C-3PO", 35);

       printStream.close();
   }
}

System.inని భర్తీ చేస్తోంది

ఈ పాఠంలో, మేము "సిస్టమ్‌తో పోరాడుతాము" మరియు సిస్టమ్ అవుట్‌పుట్‌ను మనకు కావలసిన చోటికి మళ్లించడానికి System.in వేరియబుల్‌ను ఎలా భర్తీ చేయాలో నేర్చుకుంటాము. System.in అంటే ఏమిటో మీరు మరచిపోవచ్చు , కానీ ఏ CodeGym విద్యార్థి ఈ నిర్మాణాన్ని మరచిపోలేరు:

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

System.in ( System.out  లాగానే ) అనేది సిస్టమ్ క్లాస్ యొక్క స్టాటిక్ వేరియబుల్ . కానీ System.out కాకుండా , ఇది మరొక తరగతిని సూచిస్తుంది, అవి InputStream . డిఫాల్ట్‌గా, System.in అనేది సిస్టమ్ పరికరం నుండి డేటాను చదివే స్ట్రీమ్ - కీబోర్డ్. అయినప్పటికీ, System.out మాదిరిగానే , మేము కీబోర్డ్‌ను డేటా మూలంగా భర్తీ చేయవచ్చు. మనకు కావలసిన చోట నుండి డేటాను చదువుకోవచ్చు! ఒక ఉదాహరణ చూద్దాం:

import java.io.*;

public class Main {

   public static void main(String[] args) throws IOException {

       String greetings = "Hi! My name is Amigo!\nI'm learning Java on the CodeGym website.\nOne day I will become a cool programmer!\n";
       byte[] bytes = greetings.getBytes();

       InputStream inputStream = new ByteArrayInputStream(bytes);

       System.setIn(inputStream);

       BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

       String str;

       while ((str = reader.readLine())!= null) {

           System.out.println(str);
       }

   }
}

కాబట్టి మనం ఏమి చేసాము? System.in సాధారణంగా కీబోర్డ్‌కు కట్టుబడి ఉంటుంది. కానీ మేము కీబోర్డ్ నుండి డేటాను చదవకూడదనుకుంటున్నాము: డేటాను సాధారణ స్ట్రింగ్ నుండి చదవండి! మేము స్ట్రింగ్‌ను సృష్టించాము మరియు దానిని బైట్ అర్రేగా పొందాము. మనకు బైట్లు ఎందుకు అవసరం? విషయం ఏమిటంటే, ఇన్‌పుట్‌స్ట్రీమ్ ఒక అబ్‌స్ట్రాక్ట్ క్లాస్, కాబట్టి మేము దాని యొక్క ఉదాహరణను నేరుగా సృష్టించలేము. దాని వారసుల్లో ఒకరిని మనం ఎంచుకోవాలి. ఉదాహరణకు, మేము ByteArrayInputStream ఎంచుకోవచ్చు . ఇది చాలా సులభం మరియు దాని పేరు మాత్రమే ఇది ఎలా పని చేస్తుందో మాకు తెలియజేస్తుంది: దాని డేటా మూలం బైట్ శ్రేణి. కాబట్టి మేము బైట్ శ్రేణిని సృష్టించాము మరియు దానిని డేటాను చదివే మా స్ట్రీమ్ యొక్క కన్స్ట్రక్టర్‌కు పంపుతాము . మరియు ఇప్పుడు ప్రతిదీ సిద్ధంగా ఉంది! ఇప్పుడు మనం System.setIn()ని ఉపయోగించాలి.ఇన్ వేరియబుల్ విలువను స్పష్టంగా సెట్ చేసే పద్ధతి . ఔట్ లేకుండా , మీరు గుర్తుంచుకుంటారు, వేరియబుల్ విలువను నేరుగా సెట్ చేయడం కూడా సాధ్యం కాదు: మేము setOut() పద్ధతిని ఉపయోగించాల్సి ఉంటుంది. మేము సిస్టమ్.ఇన్ వేరియబుల్‌కు మా ఇన్‌పుట్‌స్ట్రీమ్‌ను కేటాయించిన తర్వాత , మేము మా ప్రయోజనాన్ని సాధించామో లేదో తనిఖీ చేయాలనుకుంటున్నాము. మా పాత స్నేహితుడు బఫర్డ్ రీడర్ ఇక్కడ మా సహాయానికి వస్తాడు. సాధారణంగా, ఈ కోడ్ IntelliJ IDEAలో కన్సోల్‌ను తెరిచి, ఆపై మీరు కీబోర్డ్ నుండి నమోదు చేసిన డేటాను చదివి ఉంటుంది.

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

       String str;

       while ((str = reader.readLine())!= null) {

           System.out.println(str);
       }

కానీ ఇప్పుడు మీరు దీన్ని అమలు చేసినప్పుడు, మా స్ట్రింగ్ కన్సోల్‌లో ప్రదర్శించబడుతుందని మీరు చూస్తారు. కీబోర్డ్ నుండి చదవడం లేదు. మేము డేటా మూలాన్ని భర్తీ చేసాము. ఇది ఇకపై కీబోర్డ్ కాదు, కానీ మా స్ట్రింగ్! ఇది చాలా సులభం :) నేటి పాఠంలో, మేము కొత్త తరగతిని తెలుసుకున్నాము మరియు I/Oతో పని చేయడానికి ఒక చిన్న కొత్త హ్యాక్‌ను అన్వేషించాము. ఇప్పుడు కోర్సుకు తిరిగి వచ్చి కొన్ని పనులను పూర్తి చేయడానికి సమయం ఆసన్నమైంది :) తదుపరి పాఠంలో కలుద్దాం!