คำอธิบายโดยละเอียดเกี่ยวกับประเภทไฟล์ที่แสดงไฟล์ใน Java

คำนำ

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

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

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

สร้างอินสแตนซ์ไฟล์

ก่อนที่จะแนะนำวิธีการสร้างอินสแตนซ์ไฟล์เราจำเป็นต้องดูที่สมาชิกแอตทริบิวต์ที่สำคัญหลายคน

 ระบบไฟล์สุดท้ายคงที่ FS = DefaultFilesYstem.GetFileSystem ();

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

 เส้นทางสตริงสุดท้ายส่วนตัว;

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

 สาธารณะคงที่ถ่านสุดท้ายตัวแยกถ่าน = fs.getSeparator (); Public Static Final PathseParatorchar = fs.getPathseparator ();

ตัวคั่นหมายถึงตัวคั่นระหว่างไดเรกทอรีและ pathseparatorchar แสดงให้เห็นถึงตัวคั่นภายใต้เส้นทางที่แตกต่างกัน ค่าทั้งสองนี้แตกต่างกันภายใต้แพลตฟอร์มระบบที่แตกต่างกัน ตัวอย่างเช่นค่าของทั้งสองภายใต้ windows คือ: "" และ ";" ซึ่งการห้ามใช้เพื่อแยกเส้นทางที่แตกต่างกันหลายเส้นทาง

คลาสไฟล์มีตัวสร้างสี่ตัวที่แตกต่างกันสำหรับการสร้างอินสแตนซ์วัตถุไฟล์ แต่มีเพียงสามตัวเท่านั้นที่ใช้กันทั่วไป นอกจากนี้เรายังมุ่งเน้นไปที่การเรียนรู้โครงสร้างสามคนแรก

 ไฟล์สาธารณะ (ชื่อพา ธ สตริง)

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

 ไฟล์ไฟล์ = ไฟล์ใหม่ ("c: // ผู้ใช้ // Yanga // เดสก์ท็อป"); ไฟล์ไฟล์ 1 = ไฟล์ใหม่ ("c: //users//yanga//desktop//a.txt"); ไฟล์ file2 = ไฟล์ใหม่ ("a.txt");

แน่นอนคุณสามารถระบุเส้นทางหลักได้อย่างชัดเจน:

 ไฟล์สาธารณะ (String Parent, String Child)

ภายในคอนสตรัคเตอร์โปรแกรมจะแยกเส้นทางไฟล์ที่สมบูรณ์สำหรับเราเช่น:

 ไฟล์ไฟล์ = ไฟล์ใหม่ ("c: // ผู้ใช้ // Yanga // เดสก์ท็อป", "a.txt"); ไฟล์ไฟล์ 1 = ไฟล์ใหม่ ("c: // ผู้ใช้ // Yanga // เดสก์ท็อป", "java");

ตัวสร้างที่สามเป็นหลักเหมือนกับอันที่สองยกเว้นว่าจะเพิ่มกระบวนการห่อหุ้มของอินสแตนซ์ไฟล์พาเรนต์:

 ไฟล์สาธารณะ (ไฟล์ parent, string child)

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

รับข้อมูลที่เกี่ยวข้องกับชื่อไฟล์หรือเส้นทาง

วิธี getName สามารถใช้เพื่อรับชื่อไฟล์:

 สตริงสาธารณะ getName () {int index = path.lastIndexof (separatorchar); if (index <prefixLength) ส่งคืน path.substring (คำนำหน้า); Return Path.SubString (ดัชนี + 1);}

จำสิ่งที่ตัวแยกของเราเป็นตัวแทนได้หรือไม่?

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

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

 ไฟล์ไฟล์ = ไฟล์ใหม่ ("c: //users//yanga//desktop//a.txt"); system.out.println (file.getName ()); ไฟล์ไฟล์ 1 = ไฟล์ใหม่ ("c: // ผู้ใช้ // yanga // desktop"); system.out.println (ไฟล์

ผลลัพธ์จะไม่ทำให้คุณประหลาดใจ:

 a.txtdesktop

วิธี getParent ใช้เพื่อส่งคืนไดเรกทอรีหลักของไฟล์ปัจจุบัน ไม่ว่าคุณจะเป็นไฟล์ธรรมดาหรือไดเรกทอรีในที่สุดคุณจะมีไดเรกทอรีหลักของคุณ (แน่นอนไฟล์ชั่วคราวที่สร้างโดยเครื่องเสมือนไม่แน่นอน)

 สตริงสาธารณะ getParent () {int index = path.lastindexof (ตัวแยก); if (index <prefixLength) {if ((prefixLength> 0) && (path.length ()> prefixLength)) ส่งคืน path.substring (0, prefixLength); คืนค่า null; } return path.substring (0, index);}

การใช้วิธีนี้ง่ายมากดังนั้นฉันจะไม่เข้าไปดูรายละเอียด

วิธี getPath สามารถส่งคืนชื่อไฟล์เต็มของอินสแตนซ์ไฟล์ปัจจุบัน:

 สตริงสาธารณะ getPath () {เส้นทางกลับ;}

ต่อไปนี้เป็นการดำเนินการที่เกี่ยวข้องกับไดเรกทอรีซึ่งค่อนข้างง่ายต่อการใช้งาน นี่คือรายการสั้น ๆ :

• Public Boolean Isabsolute (): มันเป็นเส้นทางที่แน่นอน
• สตริงสาธารณะ getAbsolutePath (): รับเส้นทางสัมบูรณ์ไปยังอินสแตนซ์ไฟล์ปัจจุบัน
• สตริงสาธารณะ getCanonicalPath (): ส่งคืนเส้นทางมาตรฐานไปยังอินสแตนซ์ไฟล์ปัจจุบัน

ที่นี่เราจำเป็นต้องอธิบายคำอธิบายบางอย่างของ getCanonicalPath เส้นทางมาตรฐานคืออะไรและมีความแตกต่างระหว่างเส้นทางที่แน่นอนหรือไม่?

โดยทั่วไปการพูด "../" หมายถึงไดเรกทอรีก่อนหน้าของไดเรกทอรีที่อยู่ที่ไฟล์ต้นฉบับ "../../" หมายถึงไดเรกทอรีก่อนหน้าของไดเรกทอรีที่ไฟล์แหล่งที่มาอยู่และอื่น ๆ วิธีการ getabsolutepath ไม่ได้ดำเนินการแปลงดังกล่าวในขณะที่วิธี getCanonicalPath รับรู้อักขระพิเศษเหล่านี้และใช้ความหมายที่เหมาะสม

ตัวอย่างเช่น:

 ไฟล์ไฟล์ = ไฟล์ใหม่ ("..// a.txt"); system.out.println (file.getabsolutepath ()); system.out.println (file.getCanonicalPath ());

ผลลัพธ์ผลลัพธ์:

C:/ผู้ใช้/Yanga/Desktop/Java/Workspace2017/TestFile /../ A.txt
C: /users/yanga/desktop/java/workspace2017/a.txt

อดีตจะใช้ "../a.txt" เป็นส่วนหนึ่งของชื่อเส้นทางไฟล์ในขณะที่หลังสามารถรับรู้ได้ว่า "../a.txt" หมายความว่า "a.txt" อยู่ในไดเรกทอรีบนของไดเรกทอรีปัจจุบัน นี่คือความแตกต่างที่ใหญ่ที่สุดระหว่างทั้งสองเหมาะสำหรับสถานการณ์ที่แตกต่างกัน

รับข้อมูลแอตทริบิวต์ของไฟล์

การดำเนินการของส่วนนี้ของไฟล์นั้นง่ายมากจริง ๆ ไม่มีอะไรมากไปกว่าคำถามบางอย่างเกี่ยวกับการอนุญาตไฟล์ไม่ว่าจะสามารถอ่านได้ไม่ว่าจะเป็นงานเขียนไม่ว่าจะเป็นไฟล์ที่ซ่อนอยู่ ฯลฯ ลองดูวิธีการเหล่านี้โดยละเอียด:

• บูลีนสาธารณะ canread (): ไฟล์ที่สอดคล้องกับอินสแตนซ์ไฟล์นามธรรมนี้สามารถอ่านได้หรือไม่
• Public Boolean CanWrite (): เป็นไฟล์ที่สอดคล้องกับอินสแตนซ์ไฟล์นามธรรมนี้เขียนได้
• บูลีนสาธารณะมีอยู่ (): ไฟล์ที่สอดคล้องกับอินสแตนซ์ไฟล์นามธรรมนี้มีอยู่จริงหรือไม่
• Public Boolean Isdirectory (): ไฟล์ที่สอดคล้องกับอินสแตนซ์ไฟล์นามธรรมนั้นเป็นไดเรกทอรี
• บูลีนสาธารณะ isfile (): ไฟล์ที่สอดคล้องกับอินสแตนซ์ไฟล์นามธรรมนั้นเป็นไฟล์บริสุทธิ์
• บูลีนสาธารณะ ishidden (): ไฟล์ที่สอดคล้องกับอินสแตนซ์ไฟล์นามธรรมนั้นเป็นไฟล์ที่ซ่อนอยู่
• ความยาวสาธารณะ (): จำนวนไบต์ที่ถูกครอบครองโดยเนื้อหาไฟล์

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

การดำเนินการไฟล์

การทำงานของไฟล์ไม่มีอะไรมากไปกว่า "การเพิ่มการลบการดัดแปลงและการค้นหา" ลองมาดูกัน

• Public Boolean CreateNewFile (): สร้างไฟล์ดิสก์ที่มีอยู่จริงตามวัตถุไฟล์นามธรรม
• บูลีนสาธารณะลบ (): ลบไฟล์ดิสก์ที่สอดคล้องกับวัตถุไฟล์ หากการลบล้มเหลวเท็จจะถูกส่งคืน

แน่นอนเมื่อต้องรับมือกับการสร้างและการลบใหม่สองอย่างข้างต้นข้างต้นการดำเนินการระดับไฟล์ยังให้การดำเนินการ "ค้นหา" ที่เรียกว่าซึ่งเราต้องเรียนรู้อย่างรอบคอบ ตัวอย่างเช่น:

 สตริงสาธารณะ [] รายการ () {SecurityManager Security = System.getSecurityManager (); if (ความปลอดภัย! = null) {security.checkread (พา ธ ); } if (isinvalid ()) {return null; } return fs.list (this);}

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

 ไฟล์ไฟล์ = ไฟล์ใหม่ ("c: // ผู้ใช้ // Yanga // เดสก์ท็อป"); string [] list = file.list (); สำหรับ (String str: list) {system.out.println (str);}

ผลลัพธ์ผลลัพธ์ของโปรแกรมจะพิมพ์ชื่อง่าย ๆ ของไฟล์ทั้งหมดในไดเรกทอรีเดสก์ท็อปคอมพิวเตอร์ของฉันดังนั้นฉันจะไม่แสดงให้คุณเห็น

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

ถัดไปลองดูที่วิธีการดึงไฟล์ไดเรกทอรี:

 สตริงสาธารณะ [] รายการ (ตัวกรอง filenameFilter) {ชื่อสตริง [] = list (); if ((ชื่อ == null) || (filter == null)) {return names; } รายการ <String> v = arrayList ใหม่ <> (); สำหรับ (int i = 0; i <names.length; i ++) {ถ้า (filter.accept (นี่, ชื่อ [i])) {v.add (ชื่อ [i]); }} return v.toarray (สตริงใหม่ [v.size ()]);}

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

แต่คำจำกัดความของอินเทอร์เฟซ FilenameFilter นั้นง่ายมาก:

 filenamefilter อินเตอร์เฟสสาธารณะ {บูลีนยอมรับ (ไฟล์ dir, ชื่อสตริง);}

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

ดังนั้นการเขียนใหม่ของวิธีการยอมรับนี้จะกำหนดไฟล์ที่สามารถผ่านการกรองและไม่สามารถ ลองดูตัวอย่าง:

ไฟล์ในโฟลเดอร์ทดสอบบนเดสก์ท็อปของฉันมีดังนี้:

 ไฟล์ไฟล์ = ไฟล์ใหม่ ("c: // ผู้ใช้ // Yanga // เดสก์ท็อป // ทดสอบ"); String [] list = file.list (ใหม่ filenameFilter () {@Override บูลีนสาธารณะยอมรับ (ไฟล์ dir, ชื่อสตริง) {// วัตถุไฟล์ปัจจุบันที่แสดงโดย DIR // ชื่อเป็นชื่อง่าย ๆ ของรายการไฟล์ในปัจจุบัน สำหรับ (String str: list) {system.out.println (str); -

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

ผลลัพธ์ผลลัพธ์สุดท้ายมีดังนี้:

3.txt
4.txt

แน่นอนว่ายังมีวิธีรายการ "กลายพันธุ์" สองวิธีในคลาสไฟล์เช่น:

• ไฟล์สาธารณะ [] listfiles ()
• ไฟล์สาธารณะ [] listfiles (ตัวกรอง filenamefilter)

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

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

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

สองวิธีถัดไปเกี่ยวข้องกับการสร้างโฟลเดอร์:

• บูลีนสาธารณะ mkdir ()
• บูลีนสาธารณะ mkdirs ()

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

 ไฟล์ไฟล์ = ไฟล์ใหม่ ("c: // ผู้ใช้ // yanga // เดสก์ท็อป // test2"); system.out.println (file.mkdir ()); ไฟล์ไฟล์ 2 = ไฟล์ใหม่ ("c: // ผู้ใช้ // yanga // desktop // test3 // hello"); system.out.out.out.

ในหมู่พวกเขาไม่มีการทดสอบ 2 และ test3 จนกว่าโปรแกรมจะถูกดำเนินการ

ผลลัพธ์ผลลัพธ์มีดังนี้:

จริง
เท็จ

ทำไมหลังถึงไม่สามารถสร้างได้?

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

วิธี MKDIRS ใช้เพื่อแก้สถานการณ์นี้ มันจะสร้างไดเรกทอรีที่ไม่ได้สร้างทั้งหมดบนเส้นทางเป้าหมายดูรหัส:

 ไฟล์ file3 = ไฟล์ใหม่ ("c: // ผู้ใช้ // Yanga // เดสก์ท็อป // test3 // hello // 231"); system.out.println (file3.mkdirs ());

แม้ว่าโฟลเดอร์ Test3 ของเราจะไม่มีอยู่หลังจากทำงานโปรแกรมจะสร้างโฟลเดอร์สามโฟลเดอร์ 3, Hello และ 231

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

ณ จุดนี้เราได้เรียนรู้อย่างคร่าวๆเกี่ยวกับไฟล์ประเภทไฟล์ ฉันเชื่อว่าทุกคนจะรู้สึกมากขึ้นหรือน้อยลงว่าการออกแบบของไฟล์บริสุทธิ์และไดเรกทอรีที่ใช้ประเภทเดียวกันดูเหมือนจะสับสนและไม่มีเหตุผลเล็กน้อย ฉันรู้ว่า JDK1.7 Sun ได้เปิดตัวไฟล์และเส้นทางไปยังไฟล์และไดเรกทอรีแยกต่างหากและเราจะได้เรียนรู้เพิ่มเติมเกี่ยวกับเรื่องนี้ในบทความในอนาคต

รหัสรูปภาพและไฟล์ทั้งหมดในบทความจะถูกเก็บไว้ในคลาวด์บน GitHub ของฉัน:

(https://github.com/singleyam/overview_java)

คุณยังสามารถเลือกที่จะดาวน์โหลดในพื้นที่

สรุป

ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่าเนื้อหาของบทความนี้จะมีค่าอ้างอิงบางอย่างสำหรับการศึกษาหรือที่ทำงานของทุกคน หากคุณมีคำถามใด ๆ คุณสามารถฝากข้อความไว้เพื่อสื่อสาร ขอบคุณสำหรับการสนับสนุน Wulin.com