อินเทอร์เฟซมาตรฐาน: InputStream, OutputStream

"สวัสดี Amigo ตอนนี้ฉันจะบอกคุณเกี่ยวกับสองอินเทอร์เฟซ: InputStreamและOutputStreamพวกมันถูกประกาศเป็นคลาสนามธรรม แต่ถ้าคุณเจาะลึกลงไปคุณจะเห็นว่าพวกมันเป็นอินเตอร์เฟส โดยพื้นฐานแล้วเมธอดเกือบทั้งหมดเป็นนามธรรมยกเว้น วิธีการเล็กๆ น้อยๆ บางอย่างก็เหมือนกับ " ผู้คุ้มกัน " ที่เราพิจารณาก่อนหน้านี้"

นี่เป็นอินเทอร์เฟซที่น่าสนใจมาก สำหรับตอนนี้ ฉันจะเรียกมันว่าอินเทอร์เฟซเพื่อให้คุณเข้าใจว่าเหตุใดเราจึงต้องการมัน แล้วเราจะพูดถึงว่าทำไมพวกเขาถึงเป็นคลาสนามธรรม

"ตกลง แล้วอินเทอร์เฟซเหล่านี้คืออะไร"

“ฉันจะบอกคุณโดยไม่ต้องกังวลใจอีกต่อไป”

Java มีสิ่งที่น่าสนใจที่เรียกว่า « stream » สตรีมเป็นเอนทิตีที่เรียบง่ายมาก และความเรียบง่ายเป็นกุญแจสำคัญสำหรับวิธีที่มีประสิทธิภาพมากในการแลกเปลี่ยนข้อมูล สตรีมมีสองประเภท: สตรีมสำหรับการอ่านและสตรีมสำหรับการเขียน

ตามที่คุณอาจเดาได้ คุณสามารถเขียนข้อมูลไปยังสตรีมเพื่อเขียน มันมี วิธี การเขียนสำหรับสิ่งนี้ คุณสามารถอ่านข้อมูลจากสตรีมเพื่ออ่าน มี วิธี การอ่าน () สำหรับสิ่งนี้

InputStream  เป็นอินเทอร์เฟซสำหรับสตรีมที่รองรับการอ่าน มันกำหนดความสามารถดังต่อไปนี้: «สามารถอ่านไบต์ได้จากฉัน».

ในทำนองเดียวกันOutputStream , OutputStream เป็นอินเทอร์เฟซสำหรับสตรีมที่สนับสนุนการเขียน มันกำหนดความสามารถดังต่อไปนี้: «สามารถเขียนไบต์ถึงฉัน».

"แค่นั้นแหละ?"

"ค่อนข้างมาก แต่ประเด็นทั้งหมดก็คือ Java มีคลาสมากมายที่สามารถทำงานร่วมกับInputStreamและOutputStreamได้ ตัวอย่างเช่น คุณต้องการอ่านไฟล์จากดิสก์และแสดงเนื้อหาบนหน้าจอ ไม่มีอะไรจะง่ายไปกว่านี้อีกแล้ว"

หากต้องการอ่านข้อมูลจากไฟล์บนดิสก์ เรามี คลาส FileInputStream พิเศษ ซึ่งใช้ อินเทอ ร์เฟซInputStream คุณต้องการเขียนข้อมูลนี้ไปยังไฟล์อื่นหรือไม่? สำหรับสิ่งนี้ เรามี คลาส FileOutputStreamซึ่งใช้อินเทอร์เฟซ OutputStream รหัสต่อไปนี้แสดงสิ่งที่คุณต้องทำเพื่อคัดลอกข้อมูลจากไฟล์หนึ่งไปยังอีกไฟล์หนึ่ง

public static void main(String[] args) throws IOException
{
 InputStream inStream = new FileInputStream("c:/source.txt");
 OutputStream outStream = new FileOutputStream("c:/result.txt");

 while (inStream.available() > 0)
 {
  int data = inStream.read(); //read one byte from the input stream
  outStream.write(data); //write that byte to the other stream.
 }

 inStream.close(); //close the streams
 outStream.close();
}

ลองนึกภาพว่าเราได้เขียนคลาสและเพิ่ม  ความสามารถ InputStream  และ  OutputStreamเข้าไป

หากเราใช้งานอินเทอร์เฟซเหล่านี้อย่างเหมาะสม ตอนนี้อินสแตนซ์ของคลาสของเราสามารถบันทึกหรืออ่านจากไฟล์ได้แล้ว เพียงแค่อ่านเนื้อหาโดยใช้วิธีการอ่าน หรือสามารถโหลดได้จากไฟล์โดยการสร้างวัตถุและใช้วิธีการเขียนเพื่อเขียนเนื้อหาของไฟล์

“ยกตัวอย่างได้ไหม”

"แน่นอน."

class MyClass
{
private ArrayList<Integer> list;
}

ตอนนี้เราจะเพิ่มวิธีการอ่านและเขียนเข้าไป

class MyClass
{
private ArrayList<Integer> list;
public void write(int data)
{
list.add(data);
}
public int read()
{
int first = list.get(0);
list.remove(0);
return first;
}

public int available()
{
return list.size();
}
}

แน่นอนว่านี่ไม่ใช่การนำอินเทอร์เฟซ InputStream และ OutputStream มาใช้ แต่ก็คล้ายกันมาก

"ใช่ ฉันเข้าใจ แล้วคุณจะบันทึกเนื้อหาของวัตถุดังกล่าวลงในไฟล์ได้อย่างไร"

"ผมขอยกตัวอย่าง:"

public static void main(String[] args)
{
 MyClass myObject = new MyClass();
 OutputStream outStream = new FileOutputStream ("c:/my-object-data.txt");

 while (myObject.available() > 0)
 {
  int data = myObject.read(); //read one int from the input stream
  outStream.write(data); //write that int to the other stream.
 }

 outStream.close();
}

public static void main(String[] args)
{
 InputStream inStream = new FileInputStream("c:/my-object-data.txt");
 MyClass myObject = new MyClass();

 while (inStream.available() > 0)
 {
  int data = inStream.read(); //read one int from the input stream
  myObject.write(data); //write that int to the other stream.
 }

 inStream.close(); //close the streams
}

"Holy moly! มันคล้ายกับการทำงานกับ InputStream/OutputStream จริงๆ สตรีมนั้นน่ารัก!"

"แล้วบางส่วน!"