basic i o operations java
I denne videoopplæringen vil vi diskutere Java Input-Output Mechanism som Java User Input, InputStream, Java Printf, Println, etc. med standard I / O-enheter:
I hvert programmeringsspråk må vi ha en mekanisme for å lese inndata og også sende de behandlede dataene, også kjent som Output, til sluttbrukeren.
Som du er klar over, er det mange input- og output-enheter i programvareverdenen som programmerere kan bruke til å lese data fra og skrive eller output data til.
Les gjennom vår Komplett Java-treningsserie for å få mer innsikt i Java-konsepter.
Hva du vil lære:
- Videoopplæring om grunnleggende I / O-operasjoner i Java
- Ytterligere eksempler - Inngangs- / utgangsstrømmer
- Konklusjon
Videoopplæring om grunnleggende I / O-operasjoner i Java
Ved hjelp av et Java-program kan du lese og skrive data fra forskjellige kilder og destinasjoner. Lesing og skriving av datakilder og destinasjoner inkluderer:
- Filer
- Rør
- Nettverkstilkoblinger
- Buffere i minnet ( F.eks .: arrays)
- System.in, System.out, System.error
I denne videoopplæringen vil vi ha innspill som en fil og utforske forskjellige klasser, grensesnitt og metoder som er tilgjengelige for å lese data fra filen.
Grunnleggende IO-operasjoner i Java:
Java-filoperasjoner:
Java I / O (Input-Output) er en standardmekanisme som behandler inngangen og genererer utdataene. Pakken “java.io” inneholder metodene for å utføre alle inngangs- og utgangsoperasjonene.
For å utføre I / O-operasjoner raskere, bruker Java konseptet med strømmer. En strøm kan defineres som en sekvens av data som består av byte.
La oss lære mer om Java I / O-strømmer !!
Standard I / O-strømmer i Java
Java-språk gir tilgang til systemressurser, standard inngangsutgangsenheter osv. Ved hjelp av en 'System' -klasse. Denne klassen implementerer et systemavhengig programmeringsgrensesnitt for å få tilgang til forskjellige ressurser.
Systemklassen tilhører Java-pakken med Java. Bortsett fra å tilby standard I / O-strømmer, gir systemklassen også tilgang til miljøvariabler, eksterne variabler, lasting av filer og biblioteker, og også en verktøymetodematriseKopi for kopiering av en del av en matrise.
Siden denne opplæringen bare er basert på standard I / U, hopper vi over resten av fasilitetene som tilbys av systemklassen her.
Fra Input-Output-synspunkt tilbyr systemklassen følgende strømmer:
# 1) Standard inngangsstrøm (System.in)
Inngangsstrømmen som tilbys av systemklassen System.in brukes til å lese inngangsdataene fra en standard inngangsenhet som et tastatur.
Strømmen forblir åpen og er klar til å lese dataene som leveres av brukeren til standardinngangsenheten.
Eksemplet nedenfor demonstrerer System.in.read-funksjonen for å lese et enkelt heltall.
public class Main { public static void main(String args()) throws java.io.IOException { int ch; System.out.println('Enter the character to be displayed : '); ch = System.in.read(); System.out.println('You entered : ' + (char)ch); } }Produksjon:
# 2) Standard utgangsstrøm (System.out)
System.out-grensesnittet i systemklassen brukes til å skrive programutgangen til standardutdataenheten, som skjermen. I de fleste tilfeller skriver System.out-grensesnittet kommandoutgangen til standardutdataenheten.
Den bruker tre metoder fra 'PrintStream' -klassen som standardutdata kommer fra denne klassen.
Disse metodene er:
- skrive ut
- utskrift
- skrive
Metodene “print” og “println” har samme funksjonalitet bortsett fra en enkelt forskjell at println-metoden legger til et nytt linjetegn ( n) til utgangen.
Skrivemetoden brukes ikke ofte bortsett fra i tilfeller der ikke-ASCII-data skal vises.
Følgende eksempel viser System.out-strømmen.
public class Main { public static void main(String args()) throws java.io.IOException { String stringType = 'Java Tutorial Series'; char() charTypeArray = { 'a', 'e', 'i', 'o', 'u' }; boolean booleanType = true; int integerType = 10; double doubleType = Math.PI; long longType = Long.MAX_VALUE; float floatType = Float.MIN_VALUE; System.out.println('String::' + stringType); System.out.print('Character::'); System.out.println(charTypeArray); System.out.println('Boolean::' + booleanType); System.out.println('Integer::' + integerType); System.out.println('Double::' + doubleType); System.out.println('Long::' + longType); System.out.println('Float::' + floatType); } } Produksjon:
hvordan åpne binære filer i Windows
Ovennevnte program viser funksjonene “print” og “println” som brukes med System.out-grensesnittet. Her har vi definert variabler av forskjellige datatyper og viser hver av dem ved hjelp av System.out-grensesnittet.
# 3) Standard feilstrøm (System.err)
Standardfeilstrømmen, System.err, brukes til å vise eventuelle feil under gjennomføringen av programmet.
I likhet med System.out-strømmen støtter også feilstrømmen de tre metodene i PrintStream-klassen, print, println og wrote.
Metoder for å lese innspill fra konsollen
Bortsett fra inngangsstrømmen beskrevet ovenfor, er det få flere metoder som vi kan lese inngangsdata fra konsollen i Java.
Disse metodene er diskutert nedenfor.
# 1) Class BufferedReader
Klassen BufferedReader ble først introdusert i JDK 1.0 og er den klassiske metoden for å lese inndata fra konsollen.
Inngangsstrømmen (System.in) er pakket inn i klassen InputStreamReader som igjen er pakket inn i BufferedReader.
Følgende program viser bruken av BufferedReader-klassen for å lese inndata fra brukeren.
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class Main { public static void main(String() args) throws IOException { BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); System.out.println('Enter the input string'); String name = reader.readLine(); System.out.println('You entered: ' + name); } } Produksjon:
livssyklusmodell i programvareteknikk
I programmet ovenfor har vi erklært et objekt av BufferedReader-klassen initialisert til System.in stream. Ved hjelp av dette objektet leser vi en hel linje med input.
Som du kan se, kan du lese hele bufret data som gjør denne funksjonaliteten veldig effektiv. Den eneste ulempen er den kryptiske koden som kan være vanskelig å huske hver gang.
# 2) Konsollklasse
Klassen “System.console” kan brukes til å lese innganger fra konsollen. Dette brukes til å lese spesielle tegn som passord fra kommandolinjen.
Metoden for å lese inngangsdata ved hjelp av konsollklassen er for tiden den mest effektive og foretrukne metoden i Java.
Følgende program demonstrerer System.console-klassen.
public class Main { public static void main(String() args) { System.out.println('Enter the input string'); String name = System.console().readLine(); System.out.println('You entered: ' + name); } } Produksjon:
Ved å bruke System.console-klassen kan du lese inngangstegnene uten å ekko karakterene. Derfor er denne metoden mer nyttig for å lese passord. For det andre kan du også bruke formatstrenger til å formatere inngangsdataene, lik de som brukes i System.out.printf ().
Selv om dette er den foretrukne måten å lese inngangsdata på, merk at klassen System.console ikke kan brukes med et interaktivt Java-miljø som IDEer.
# 3) Skanner
Å bruke en skannerklasse til å lese inndata er trolig den raskeste og foretrukne metoden. Skanneren brukes mest til å analysere datatypene, inkludert primitive typer og strenger. Men det kan også brukes til å lese inngangsdataene og analysere dem ved hjelp av tokenisert inngang.
Skannerklassen bruker vanlige uttrykk for dette formålet.
Det følgende programmet leser inndataene fra brukeren ved hjelp av skannerklassen.
import java.util.Scanner; class Main { public static void main(String args()) { Scanner myscan = new Scanner(System.in); System.out.println('Enter the input:'); String mystr = myscan.nextLine(); System.out.println('You entered a string:'+mystr); System.out.println('Enter Next input:'); int num = myscan.nextInt(); System.out.println('You entered an integer:'+num); } } Produksjon:
I programmet ovenfor har vi brukt skannerklassen til å lese streng- og heltalldata.
Formatering av utdata i Java ved hjelp av printf
Vi har allerede sett hvordan du skal vise utdataene i et Java-program. I denne delen vil vi se hvordan du formaterer denne utgangen. Vi bruker printf-funksjonen i 'PrintStream' -klassen sammen med 'System.out' -strømmen til Java for dette formålet.
Printf-funksjonen i Java ligner på printf-funksjonen i C / C ++. I motsetning til funksjonene System.out.print og System.out.println som tar et enkelt argument, tar System.out.printf mer enn ett argument.
Følgende er variantene av printf-funksjonen i Java.
| Ikke | Funksjonsprototype | Beskrivelse |
|---|---|---|
| 1 | System.out.printf (streng); | Skriver ut en streng som er gitt i argumentet uten formatering |
| to | System.out.printf (format, argumenter); | Skriver ut utdata med spesifisert formatstreng ‘format’ og argumenter. |
| 3 | System.out.printf (sted, format, argumenter); | Skriver ut utdata ved hjelp av spesifisert formatstreng ved å bruke språk og argumenter. |
Merk at funksjonen System.out.format () er den samme som System.out.printf ().
Den generelle syntaksen for å spesifisere formatstrengen er som følger:
%specifier => + for right-aligning, - for left-aligning. => to specify leading/trailing zeros and precision => suggests the data type.For eksempel:
System.out.println(“ ‘%05.2f’%n”, 2.28);Vil generere følgende utdata:
’02 .28 ’
Vi vil diskutere printf i Java i detalj i de senere emnene i denne opplæringen.
ofte stilte spørsmål
Q # 1) Hva er standard inngang og standard utgang?
Svar: Standard inngangs- og utgangsstrømmer er forhåndskoblede kanaler for å kommunisere mellom dataprogrammet og omgivelsene når programmet begynner å kjøres. De tre forskjellige standardene I / O-strømmer er standardinngang (stdin), standardutgang (stdout), standardfeil (stderr).
Q # 2) Hva er standard inngang i programmering?
Svar: Standardinngang eller stdin er strømmen som brukes til å lese inngang fra en standard inngangsenhet som et tastatur.
Q # 3) Hva er Input-Output-strømmen?
Svar: En inngang-utgangsstrøm representerer en kilde som du leser inngang fra og destinasjonen du leder utgangen din til.
En strøm representerer generelt mange enheter som brukes som kilde og destinasjoner, nemlig tastatur, diskfil, skjermer osv.
Q # 4) Hva er standardinngang i Java?
Svar: Standardinngangen i Java leveres av systemklassen som en System.in-strøm. Systemklassen er en del av java.lang-pakken.
Q # 5) Hva er standardutgangen i Java?
Svar: Standardutgangen i Java leveres av systemklassen som en System.out-strøm. Systemklassen er en del av java.lang-pakken.
Ytterligere eksempler - Inngangs- / utgangsstrømmer
Strømmer representerer datastrømmen, og at dataene kan være i hvilket som helst format (som byte, tekst, primitiv datatype osv.). For å skrive data inn i en destinasjon brukes utgangsstrømmen, og for å lese dataene brukes inngangsstrømmen.
Ulike formater for lesing og skriving
Inngang / utgang kan leses / skrives som følgende forskjellige formater:
# 1) Lesing av fil som Byte Stream
Her vil dataene bli lest i byteformat. “ FileInputStream ” og “ FileOutputStream “Klasser brukes til å lese innholdet som en byte. På denne måten vil kompilatoren for hver byte sende en forespørsel til operativsystemet.
import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class ByteStreamsDemo { public static void main(String() args) throws IOException { FileInputStream fin =null; FileOutputStream fout =null; try { fin=new FileInputStream('input.txt'); fout=new FileOutputStream('out.txt'); int c; while((c=fin.read() )!= -1) { fout.write(c); } } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { if(fin!=null) { fin.close(); }if(fout!=null) { fout.close(); } } } } 
# 2) Lesing av fil som tegnstrøm
På denne måten vil inngangsstrømmen leses i tegnformat. Så for hvert tegn vil kompilatoren sende en forespørsel til operativsystemet. “ FileReader ” og “ FileWriter ” klasser er nyttige for å lese innholdet som karakteren.
public class CharStreamDemo { public static void main(String() args) throws IOException { FileReader input = null; FileWriter output = null; try { input = new FileReader('input.txt'); output = new FileWriter('out1.txt'); int c; while ((c = input.read()) != -1) { output.write(c); } } finally { if (input != null) { input.close(); } if (output != null) { output.close(); } } } } 
# 3) Buffering av inngangs- / utgangsstrømmen
Når du bruker klassene FileInputStream eller FileReader, vil hver forespørsel bli sendt til OS for hver lese- eller skriveoperasjon. Så dette kan føre til ytelsesproblemer. For å unngå denne BufferedInputStream eller BufferedReader, brukes klasser til å pakke inn ubufrede klasser.
Dette leser inngangsstrømmen når bufferen er tom.
På samme måte, FileOutputStream eller FileWriter, blir klasser pakket med BufferedOutputStream eller BufferedWriter for å skrive utdata når bufferen er full.
public class BufferedStreamDemo { public static void main(String() args) throws IOException { BufferedReader input = null; BufferedWriter output = null; try { input = new BufferedReader(new FileReader('input.txt')); output = new BufferedWriter(new FileWriter('out1.txt')); int c; while ((c = input.read()) != -1) { output.write(c); } } finally { if (input != null) { input.close(); } if (output != null) { output.close(); } } } } 
# 4) Lesing som datastrøm
I denne metoden, DataInputStream eller DataOutputStream, brukes klasser til å lese og skrive innholdet som primitive datatyper som boolsk, char, byte, kort, int, lang, float, double og String. For det meste vil DataInputStream og DataOutputStream brukes sammen.
public class DataInputOutputStreamDemo { public static void main(String() args) { File file = new File('read.bin'); FileOutputStream fos = null; DataOutputStream dos = null; try { fos=new FileOutputStream(file); dos=new DataOutputStream(fos); dos.writeInt(50244); dos.writeDouble(400.253); dos.writeChar('d'); dos.flush(); } catch (IOException e) { e.printStackTrace(); }finally { try { if(fos!=null){ fos.close(); } if(dos!=null){ dos.close(); } } catch (Exception e) { e.printStackTrace(); } } /*Reading operation */ FileInputStream fis = null; DataInputStream dis = null; try { fis = new FileInputStream(file); dis = new DataInputStream(fis); System.out.println(dis.readInt()); System.out.println(dis.readDouble()); System.out.println(dis.readChar()); } catch (IOException e) { e.printStackTrace(); }finally { try { if(fis!=null){ fis.close(); } if(dis!=null){ dis.close(); } } catch (Exception e) { e.printStackTrace(); } } } } 
# 5) Lesing som objektstrøm
ObjectInputStream / ObjectOutputStream, klasser er nyttige for å skrive objekter i en fil og lese objektene fra filen. For å lagre objektet i en fil, skal klassen implementere Serializable-grensesnittet.
public class ObjectStreamDemo implements Serializable { int age ; String name; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } 
Vi skal lage et objekt for denne 'ObjectStreamDemo' -klassen, og vi vil skrive objektet i en fil og lese det samme objektet fra den filen.
public class ObjectStreamDemoTest { public static void main(String() args) { // TODO Auto-generated method stub ObjectStreamDemo obj=new ObjectStreamDemo(); obj.setAge(32); obj.setName('bob'); try { FileOutputStream fos = new FileOutputStream('t.tmp'); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(obj); oos.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } FileInputStream fis; ObjectInputStream ois; try { fis = new FileInputStream('t.tmp'); ois = new ObjectInputStream(fis); ObjectStreamDemo obj1 = (ObjectStreamDemo)ois.readObject(); System.out.println(obj1.name); System.out.println(obj1.age); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch(Exception e) { e.printStackTrace(); } } } 
Fil I / O-operasjoner
Filklasse er nyttig for å utføre filoperasjoner.
Noen av filoperasjonene som utføres ved hjelp av filklassen inkluderer:
- Lag en fil
- Sjekk om filen er eksisterende
- Få banen til filen
- Skriv filen
- Les filen
- Slett en fil og gi nytt navn til filen
- Kontroller filtillatelsene og endre filtillatelsene
- Flytt filen fra en katalog til en annen plassering
Demoprogram for å opprette, lese og skrive filen:
public class CreateFileDemo { public static void main(String() args) throws IOException { File newfile=new File('created.txt'); if(!newfile.exists()) { newfile.createNewFile(); System.out.println('file not exist'); } try { String FILENAME='created.txt'; String content='hi how are u'; FileWriter fwt = new FileWriter(FILENAME); BufferedWriter bwt = new BufferedWriter(fwt); bwt.write(content); System.out.println('writing completed ...'); bwt.close(); } catch (IOException e) { e.printStackTrace(); } } } 
Viktige punkter å merke seg:
- En strøm er en logisk fremstilling av datastrømmen.
- Du kan lese / skrive data i et annet format som byte, karakter, objekt, primitiv datatype.
- Filklasse brukes til å opprette en fil, slette filen og flytte eller kopiere eller gi nytt navn til filen.
- BufferedInputStream eller BufferedOutputStream brukes til å forbedre ytelsen ved å buffere dataene.
Konklusjon
Java har en java.lang-pakke som gir standard inn- og utdatafasiliteter ved bruk av systemklassen.
Bortsett fra strømmer, System.in og System.out som brukes til henholdsvis standard input og output, er det også andre metoder som BufferedReader, konsollklasse og skannerklasse som brukes til å lese input fra brukeren.
System.out stream bruker “PrintStream” klassefunksjon, print og println for å vise utdataene. Dette er funksjonene som brukes til å vise utdata uten formatering. En annen funksjon “printf” som ligner på printf-funksjon i C / C ++ brukes også i Java for formatert utdata.
b + tre vs b tre
Vi vil utforske mer om skannerklasse og printf-funksjon i Java i våre kommende opplæringsprogrammer.
=> Besøk her for den eksklusive opplæringsserien for Java Training.
PREV Opplæring | NESTE veiledning
Anbefalt lesing
- Grunnleggende inngangs- / utgangsoperasjoner i C ++
- Operasjon av filinndata i C ++
- Opplæring i Java Collections Framework (JCF)
- Java-distribusjon: Opprettelse og utføring av Java JAR-fil
- Java Virtual Machine: Hvordan JVM hjelper med å kjøre Java-applikasjoner
- Input-Output og filer i Python (Python Åpne, lese og skrive til fil)
- Få tilgang til modifikatorer i Java - opplæring med eksempler
- Java Reflection Tutorial med eksempler