Hi! Ang mga aralin at gawain sa Level 3 ay nagturo sa iyo kung paano magpakita ng mga bagay-bagay sa console, at, lumipat sa kabilang direksyon, kung paano magbasa ng data mula sa keyboard.
Natutunan mo ring gamitin ang sumusunod na kumplikadong konstruksyon upang magawa ito:
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
Ngunit may isang tanong na hindi pa namin nasasagot.
Paano ito gumagana sa mundo?
Sa katotohanan, ang mga programa ay bihirang ganap na independyente. Nakikipag-usap sila sa iba pang mga programa, system, Internet, atbp. Sa pamamagitan ng "makipag-usap", pangunahing ibig sabihin namin ay "palitan ng data". Iyon ay, nakakatanggap sila ng ilang panlabas na data at nagpapadala din ng data ng panloob na programa sa isang lugar. Ang mga halimbawa ng mga programa na nagpapalitan ng data ay marami sa pang-araw-araw na buhay. Halimbawa, hinahayaan ka ng maraming website na mag-sign in gamit ang iyong Facebook o Twitter account sa halip na magparehistro. Sa sitwasyong ito, dalawang programa (hal. Twitter at ang website kung saan ka nagsa-sign in) ay nagpapalitan ng kinakailangang data. Ang huling resulta ay matagumpay kang naka-sign in. Ang salitang "stream"ay ginagamit upang ilarawan ang proseso ng pagpapalitan ng data. Saan nagmula ang pangalang ito? Sa iyong karanasan, ang isang "stream" ay maaaring mas nauugnay sa mga ilog at kaysa sa programming. Hindi aksidente iyon :) Ang stream ay, sa esensya, isang gumagalaw na piraso ng data. Sa madaling salita, sa programming, hindi tubig ang dumadaloy — kundi data sa anyo ng mga byte at character. Maaari kaming makatanggap ng mga piraso ng data mula sa isang stream ng data at pagkatapos ay gamitin ang mga ito. Muli, gagamitin namin ang pagkakatulad ng tubig/agos: maaari kang sumalok ng tubig mula sa isang ilog upang gawing sopas, patayin ang apoy, o diligan ang iyong mga bulaklak. Hinahayaan ka ng mga stream na magtrabaho kasama ang anumang data source: sa Internet man, file system ng iyong computer, o iba pa — wala itong pinagkaiba. Ang mga stream ay isang unibersal na tool. Pinapayagan nila ang isang programa na makatanggap ng data mula sa kahit saan (mga stream ng input) at ipadala ito kahit saan (mga stream ng output). Ang kanilang gawain ay pareho: kumuha ng data mula sa isang lugar at ipadala ito sa isa pa. Mayroong dalawang uri ng stream:
Ginagamit ang mga input stream upang makatanggap ng data
Ang mga stream ng output ay para sa pagpapadala ng data.
Sa Java, ang mga stream na ito ay ipinapatupad ng InputStreamat OutputStreammga klase. Ngunit ang mga batis ay maaaring ikategorya sa ibang paraan. Bilang karagdagan sa mga input at output stream, nagsasalita din kami ng mga byte stream at character stream . Ang kahulugan dito ay dapat sapat na malinaw: ang byte stream ay nagpapadala ng impormasyon bilang isang set ng mga byte, habang ang isang character stream ay nagpapadala nito bilang isang set ng mga character. Sa araling ito, tatalakayin natin ang mga input stream. Maglalagay ako ng link na may impormasyon tungkol sa mga output stream sa dulo ng aralin. Mababasa mo ito nang mag-isa :) Ngayon tingnan ang code na ito:
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
Sa pagpunta sa mga aralin, hindi mo ba naisip na ang linyang ito ay medyo nakakatakot? :) Hindi na iyon mangyayari kapag na-explore na natin kung paano ito gumagana. Ayusin natin ang mga bagay-bagay. Magsisimula tayo sa dulo. System.inay isang InputStreambagay, isang halimbawa ng klase na napag-usapan natin nang maaga. Ito ay isang input stream na naka-link sa isang system input device (ang keyboard). Siyanga pala, hindi direktang pamilyar ka sa stream na ito. Pagkatapos ng lahat, madalas mong gamitin ang "katrabaho" nito — System.out! System.outay ang stream ng output ng system . Ito ay ginagamit upang mag-output ng data sa console sa pamamagitan ng iyong paboritong paraan System.out.println(), na palagi mong ginagamit :) System.outay isang stream para sa pagpapadala ng data sa console, habangSystem.inay para sa pagkuha ng data mula sa keyboard. Ang lahat ng ito ay simple :) Higit pa rito, maaari tayong magbasa ng data mula sa keyboard nang walang ganitong malaking construct. Maaari lamang nating isulat: System.in.read();
public class Main {
public static void main(String[] args) throws IOException {
while (true) {
int x = System.in.read();
System.out.println(x);
}
}
}
Ang InputStreamklase (tandaan, System.inay isang InputStreambagay) ay may read()paraan na hinahayaan kang magbasa ng data. May isang problema: nagbabasa ito ng bytes , hindi characters . Nakakatamad gumamit ng mga letrang English lang kaya subukan nating basahin ang Chinese character na "魚" mula sa keyboard (kopyahin lang ang sulat na ito mula rito at i-paste ito sa console gamit ang ctrl + v sa PC o Command + v sa Mac ) . Ang ibig sabihin ng karakter na ito ay 'isang isda'. Output ng console: 魚 233 173 154 10 Ang simbolo na ito at marami pang ibang Chinese ay sumasakop ng 3 byte sa memorya ng computer (hindi tulad ng mga Latin na titik, na sumasakop lamang ng 1 byte). Sa kasong ito, 4 na byte ang binabasa mula sa stream: ang unang tatlo ay kumakatawan sa character na "魚", at ang ibang byte ay kumakatawan sa isang bagong linya (Enter). Alinsunod dito, System.insa kanyang walang palamuti na anyo ay hindi isang opsyon para sa amin. Ang mga tao (na may mga bihirang eksepsiyon!) ay hindi marunong magbasa ng mga byte. Ngunit ang InputStreamReaderklase ay dumating upang iligtas! Tingnan natin kung anong uri ng hayop ito.
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
Dumaan kami System.insa object na InputStreamReader . Nakasaad sa pangalan ng klase! Lumilikha kami ng isang InputStreamReaderbagay at ipinapasa ito ng isang input stream kung saan ito magbabasa ng data mula sa. Sa kasong ito...
new InputStreamReader(System.in)
...sinasabi namin dito, "magbabasa ka ng data mula sa stream ng input ng system (mula sa keyboard)". Ngunit hindi lamang ito ang function nito! Ang InputStreamReaderhindi lamang tumatanggap ng data mula sa stream. Kino-convert din nito ang mga byte stream sa mga stream ng character . Sa madaling salita, hindi mo na kailangang i-convert ang data mula sa "ones and zeros" sa isang "wika na nababasa ng tao." InputStreamreaderginagawa ang lahat para sa iyo. Siyempre, InputStreamReaderhindi limitado sa pagbabasa ng data mula sa console. Maaari rin itong magbasa ng data mula sa ibang mga lugar. Halimbawa, mula sa isang file:
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("C:\\Users\\username\\Desktop\\testFile.txt"));
}
}
Dito kami lumikha ng isang FileInputStream(isang lasa ng InputStream), pumasa sa landas ng file, at ipasa ang stream mismo sa InputStreamReader. Ngayon ay makakapagbasa na ito ng data mula sa file (kung ang isang file ay aktwal na umiiral sa landas, siyempre). Ginagamit din namin ang paraan InputStreamReaderng klase read()upang magbasa ng data (hindi mahalaga ang pinagmulan ng data: ang console, isang file, o saanman). Ano ang pagkakaiba ng System.in.read()at InputStreamReader.read()?\ Subukan nating basahin muli ang karakter na "魚" na may InputStreamReader. Ipinaaalala ko sa iyo kung ano ang aktuwal na binasa ni System.in.read(): 魚 233 173 154 10 At paano InputStreamReaderginagawa ang parehong gawain?
public class Main {
public static void main(String[] args) throws IOException {
InputStreamReader reader = new InputStreamReader(System.in);
while (true) {
int x = reader.read();
System.out.println(x);
}
}
}
Console output: 魚 39770 10 Ang pagkakaiba ay agad na nakikita. Ang huling byte (kumakatawan sa bagong linya) ay nananatiling hindi nagbabago (ang numero 10), ngunit ang karakter na "魚" ay na-convert sa isang solong code na "39770". Ito ang ibig sabihin ng pagbabasa ng mga character! Kung hindi ka naniniwala na ang 39770 ay kumakatawan sa titik na "魚", madaling kumbinsihin ang iyong sarili :)
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
char x = 39770;
System.out.println(x);
}
}
Output ng console: 魚 Ngunit kung InputStreamReadernapakahusay, bakit kailangan din natin BufferedReader? InputStreamReadermarunong magbasa ng data at mag-convert ng mga byte sa mga character. Ano pa ang mahihiling natin? Bakit ibang Reader? :/ Ang sagot ay napaka-simple: para sa higit na pagganap at kaginhawahan . Magsimula tayo sa pagganap. Kapag BufferedReadernagbabasa ng data, gumagamit ito ng isang espesyal na lugar na tinatawag na buffer, kung saan "iniimbak" nito ang mga character na binabasa nito. Sa huli, kapag ang mga character na ito ay kinakailangan sa programa, sila ay kukunin mula sa buffer, hindi direkta mula sa data source (keyboard, file, atbp.). Ito ay nakakatipid ng maraming mapagkukunan. Upang maunawaan kung paano ito gumagana, isipin ang isang courier sa isang malaking kumpanya. Ang courier ay nakaupo sa isang opisina, naghihintay para sa isang tao na magdala ng mga pakete para sa paghahatid. Sa tuwing makakatanggap siya ng isang bagong pakete, maaari siyang agad na tumama sa kalsada. Ngunit maaaring mayroong maraming mga pakete sa araw. Kailangan niyang gumawa ng maraming biyahe sa pagitan ng opisina at ng mga address ng paghahatid. Sa halip, naglalagay ang courier ng isang kahon sa kanyang opisina. Inilalagay ng lahat ang kanilang mga pakete sa kahon. Ngayon ay mahinahon nang kunin ng courier ang kahon at lumipat mula sa address patungo sa address. Ito ay nakakatipid ng maraming oras, dahil hindi niya kailangang bumalik sa opisina sa bawat oras. Sa halimbawang ito, ang kahon ay isang buffer lamang, at ang opisina ay isang data source. Mas madali para sa courier na kumuha ng mga pakete mula sa iisang kahon kapag naghahatid kaysa bumalik sa opisina sa bawat oras. Makakatipid din siya ng gasolina. Katulad nito, sa isang programa, mas hindi gaanong masinsinang mapagkukunan ang pagkuha ng data mula sa isang buffer kaysa sa pag-refer sa pinagmumulan ng data sa bawat pagkakataon. Ang resulta,BufferedReader+ InputStreamReaderay mas mabilis kaysa sa InputStreamReadernag-iisa . Isinaalang-alang namin ang pagganap. Paano naman ang convenience? Ang pangunahing bentahe ay na Bufferedreadermaaaring magbasa ng data hindi lamang ng isang character sa isang pagkakataon (bagaman ito ay maaaring gawin ito sa kanyang read()paraan), ngunit din buong linya sa isang pagkakataon! Ginagawa ito gamit ang readLine()pamamaraan;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String s = reader.readLine();
System.out.println("We read this line from the keyboard:");
System.out.println(s);
}
}
Output ng console: Ang CodeGym ay ang pinakamahusay na website para sa pag-aaral ng Java! Nabasa namin ang linyang ito mula sa keyboard: Ang CodeGym ay ang pinakamahusay na website para sa pag-aaral ng Java! Ito ay lalong kapaki-pakinabang kapag nagbabasa ng malalaking halaga ng data. Ang pagbabasa ng isa o dalawang linya ng text character ayon sa character ay magagawa pa rin. Ngunit ang pagbabasa sa "Digmaan at Kapayapaan" ng isang sulat sa isang pagkakataon ay medyo may problema :)
GO TO FULL VERSION