Java Programozás 9. Ea: Java fájlkezelés. Sztrímtan

Átírás

1 Java Programozás 9. Ea: Java fájlkezelés Sztrímtan 148/1 B ITv: MAN

2 Java fájlkezelés A Java nyelvben a fájlkezelés Stream-eken keresztül valósul meg Stream: adatok sorozata, egyik végén befelé a másik végén kifelé "folynak" az adatok A java.io csomag tartalmazza a szükséges osztályokat Stream jellemzői: szekvenciális írás, olvasás különböző input források és output nyelők egységesen kezelhetők egy csatorna bemenete lehet egy másik csatorna kimenete is azaz szűrő csatorna 148/2

3 Stream Csatornák csoportosítása: 148/3 Irány szerint: bemeneti csatorna kimeneti csatorna Adattípus szerint: byte szervezésű csatorna (bájtfolyam) karakter szervezésű csatorna (karakterfolyam) Feladatuk alapján: forrást illetve nyelőt meghatározó csatorna (pl. file, tömb, stb.) szűrő csatorna: A csatorna adatait módosítják A csatorna funkcionalitását bővíti ki

4 Alap stream osztályok Típus - Irány Bemeneti Kimeneti Bájt InputStream OutputStream Karakter Reader Writer Az ezekből származó osztályok ugyanígy végződnek. A két típus a csatorna által kezelt legkisebb adategység típusában különbözik: Bájt csatorna: 8 bit Karakter csatorna: 16 bit, (Unicode) A két osztálycsalád kezelő metódusainak elnevezése, használata megegyezik! 148/4

5 Byte streams Character streams Object ByteArrayInputStream FileInputStream BufferedReader A java.io csomag (részlete) InputStream FilterInputStream ObjectInputStream CharArrayReader FilterReader File PipedInputStream InputStreamReader FileReader SequenceInputStream PipedReader Reader StringReader RandomAccessFile ByteArrayOutputStream FileOutputStream BufferedWriter CharArrayWriter OutputStream FilterOutputStream FilterWriter ObjectOutputStream OutputStreamWriter FileWriter PipedOutputStream PipedWriter Writer PrintWriter 148/5 Class Abstract Class StringWriter

6 Stream Az OutputStream és az InputStream abstract osztályok, melyek meghatározzák a legalacsonyabb szintű műveleteket az összes bájt szervezésű csatorna számára: strukturálatlan adatok írása, olvasása A Java ezeket az osztályokat implementálja a magasabb szintű tevékenységekhez, pl: fájlok írása, olvasása Mivel az összes bájtfolyam örököli az InputStream vagy a OutputStream struktúráját, a különféle bájtfolyamok felcserélhető módon használhatók. 148/6 Kép forrása: chimera.labs.oreilly.com

7 Stream A streamek rétegezhetők (beágyazhatók az adatfolyamba), azért, hogy olyan funkciókat adjanak az adatfolyamhoz, mint például a pufferelés, a szűrés vagy a magasabb szintű adattípusok kezelése. A Reader és a Writer nagyon hasonlít az InputStream és a OutputStream szolgáltatásokra, kivéve, hogy bájt helyett karakterekkel foglalkoznak. Ezek az osztályok helyesen kezelik a Unicode karaktereket, amelyek kezelése nem történik mindig megfelelően a bájtfolyamok esetében. Az InputStreamReader és a OutputStreamWriter olyan speciális osztályok, amelyek egy definiálható karakterkódolást használnak a karakterek és a bájtok kölcsönös átalakítására. 148/7

8 Stream Szűrőfolyam InputStream in = System.in; InputStreamReader charsin = new InputStreamReader( in ); BufferedReader bufferedcharsin = new BufferedReader( charsin ); String line = bufferedcharsin.readline(); double d = NumberFormat.getInstance().parse(line).doubleValue(); InputStream is = new BufferedInputStream(System.in); double d = is.read(); A BufferedInputStream egy olyan típusú szűrőfolyam, amely előbb olvas és pufferel egy bizonyos mennyiségű adatot, aztán kiolvasáskor a kért magasabb szintű adattípusra alakítja, és így adja ki magából 148/8

9 Stream Szűrőfolyam Kép forrása: chimera.labs.oreilly.com 148/9

10 Stream A csatornaosztályok absztrakt ősei: InputStream byte alapú bemeneti csatorna 148/10 OutputStream byte alapú kimeneti csatorna Reader karakter alapú bemeneti csatorna Writer karakter alapú kimeneti csatorna Egy stream életciklusa: Megnyitás A megfelelő stream osztály példányosításával. (Általában a konstruktornak átadott paraméterek segítségével jelöljük ki az elérni szánt médiát) Írás/olvasás A stream megfelelő metódusai segítségével Bezárás A stream objektum close() metódusával

11 Stream megnyitása, lezárása A Java I/O osztályoknak nincsen külön megnyitó metódusa, a konstruktor hozza létre, és rögtön meg is nyitja a csatornát. A csatorna lezárására a close() metódus szolgál. Kimeneti csatornák esetén a close() végrehajtja a flush() metódust is, azaz lemezre menti a pufferek tartalmát. Ha lezárt csatornára próbálunk meghívni valamilyen író/olvasó műveletet, akkor IOException kivételt kapunk. 148/11

12 Stream kiíró műveletek Byte szervezésű stream (OutputStream) write(int a) throws IOException write(byte b[]) throws IOException write(byte b[], int b, int L) throws IOException b: beginindex, L: length Karakter szervezésű stream (Writer) write(int c) throws IOException write(char c[]) throws IOException write(char c[], int b, int L) throws IOException write(string s) 148/12

13 Stream olvasó műveletek Byte szervezésű stream (InputStream) int read() throws IOException int read(byte c[ ]) throws IOException int read(byte c[ ], int s, int L) throws IOException b: beginindex, L: length Karakter szervezésű stream (Reader) int read() throws IOException int read(char c[ ]) throws IOException int read(char c[], int s, int L) throws IOException A visszatérő érték az adat sorszáma, mérete, vagy kódja, fájl végénél: /13

14 Példakód fájl másolása import java.io.*; public class Copier { public static void main( String[] args ) throws IOException { FileInputStream fis = new FileInputStream("Copier.java"); Copy(fis, System.out); fis.close(); } } public static void Copy(InputStream in, OutputStream out) throws IOException { int b; while( (b=in.read())!= -1 ) out.write(b); out.flush(); } 148/14

15 Példakód fájl másolása FileInputStream: Nevéből következik: fájltartalmat beolvasó bájt csatorna A konstruktorában megadott nevű fájlt nyitja meg olvasásra Copy metódus: int egységenként beolvassa a bemenetet, és kiírja a kimenetre Bemenete a megnyitott fájl Kimenete az alapértelmezett kimenet (monitor) A hibakezelés (nem elegáns módon) tovább lett adva a VM-nek Következzenek további példakódok: 148/15

16 Stream A csatornák végének kezelése: A beolvasó műveletek megkülönböztetik az üres és a véget ért csatornákat. Üres egy csatorna, ha pillanatnyilag nem tartalmaz adatot. Ilyenkor a beolvasó műveletek addig várakoznak, amíg nem érkezik adat. Véget ért egy csatorna, ha a csatorna végét jelző jel érkezik meg rajta (fájl vége, UNIX-ban Ctrl-D, DOS-ban Ctrl-Z billentyű) 148/16

17 Stream Egyéb műveletek public long skip(long n) throws IOException 148/17 n darab adategységet átlép beolvasás nélkül visszaadja a ténylegesen átugrott adategységek számát public boolean ready() throws IOException karakter csatornáknál megadja, hogy van-e beolvasható adat. ha igaz, akkor az egy karaktert beolvasó read() nem blokkolódik public int available() throws IOException bájt csatornák esetén megadja, hogy minimálisan hány bájt áll rendelkezésre a csatornán.

18 Stream Bemeneti- kimeneti csatornák (források, nyelők): 148/18 File: FileInputStream (OutputStream) FileReader (Writer) Tömb: ByteArrayInputStream (OutputStream) CharArrayReader (Writer) String: StringReader (Writer) Cső: PipedInputStream (OutputStream) PipedReader (Writer) Egy hálózati végpont Egy másik csatorna kimenete

19 Fájl csatornák Ha egy csatornához hozzá akarunk rendelni egy fájlrendszerbeli fájlt, akkor a FileInputStream, FileOutputStream, illetve FileReader vagy FileWriter osztályok egyikét kell használnunk. A konstruktornak át kell adnunk egy hivatkozást a fájlra Stringként, vagy egy File objektumként. Ügyeljünk az elérési út formátumára (rendszerfüggő)! InputStream FileInputStream java.io Byte streams Object OutputStream FileOutputStream Reader InputStreamReader FileReader Character streams 148/19 Writer OutputStreamWriter FileWriter

20 Fájl csatornák A FileInputStream konstruktorai: public FileInputStream(String s) public FileInputStream(File f) public FileInputStream(FileDescriptor fd) FileDescriptor: gépspecifikus egyedi forrás azonosító számsor A FileOutputStream konstruktorai: public FileOutputStream(String s, boolean a) public File Output Stream(File f, boolean a) public File Output Stream(FileDescriptor fd, boolean a) boolean a: ha az érték igaz, hozzáfűzésre nyitja meg a fájlt (Append) 148/20

21 Fájl csatornák Biztonsági ellenőrzés: Minden file művelet során meghívódik a SecurityManager osztály megfelelő jogosultság ellenőrző metódusa (pl. checkread()), amely SecurityException-t dob, ha nincs meg a jog. Az egyes check metódusok meghívásával közvetlenül ellenőrizhetők a jogok. A SecurityException kivétel nem kötelezően lekezelendő. 148/21

22 Példakód FileOutputStream/FileInputStream 1. import java.io.fileinputstream; import java.io.fileoutputstream; import java.io.ioexception; Egyszerű adattípus írása (olvasása) bináris fájlba public class io_bin { public static void main(string[] args) { try { FileOutputStream fstr = new FileOutputStream("binary.dat"); for (int i = 65; i <= 90; i++) { fstr.write(i); } fstr.close(); } catch (IOException ioe) { System.err.println(ioe.getMessage()); } 148/22

23 Példakód FileOutputStream/FileInputStream } } try { FileInputStream fis = new FileInputStream("binary.dat"); int b; while ((b = fis.read())!= -1) { System.out.print(b + " "); } System.out.println(); fis.close(); } catch (IOException ioe) { System.err.println(ioe.getMessage()); } Egyszerű adattípus írása (olvasása) bináris fájlba. 148/23

24 Bájt- és karaktertömbök, Stringek Egy csatornát hozzákapcsolhatunk tömbökhöz, vagy Stringekhez. Ehhez a következő osztályokat használhatjuk: ByteArrayInputStream, ByteArrayOutputStream CharArrayReader, CharArrayWriter StringReader, StringWriter InputStream Byte streams ByteArrayInputStream java.io Object OutputStream Reader ByteArrayOutputStream CharArrayReader Character streams StringReader CharArrayWriter 148/24 Writer StringWriter

25 Példakód StringWriter/StringReader import java.io.*; class StWR { public static void main(string args[]) throws IOException{ StringWriter out = new StringWriter(); for (int i=49; i<100; i++) out.write(i); out.close(); } } 148/25 String s =""; StringReader in = new StringReader(out.toString()); int data = in.read(); while (data!= -1) { s += (char)data; data = in.read(); } in.close(); System.out.println(s);

26 Bájtcsatorna feletti karaktercsatornák Az InputStreamReader és az OutputStreamWriter osztályok összekapcsolják a bájt és karakter csatornákat. Ezek olyan karaktercsatornák, amelyek bájtcsatornák felett vannak definiálva, 16 bites Unicode karaktereket írunk és olvasunk, de azok 8 bites bájtok formájában utaznak a csatornán. A konstruktornak megadhatjuk, hogy milyen szabvány szerint konvertáljon. Reader InputStreamReader Object Character streams Writer OutputStreamWriter 148/26

27 Példakód OutputStreamWriter/InputStreamReader import java.io.*; class ChSet { } public static void main (String args[]) throws IOException { Writer w = new OutputStreamWriter(System.out,"8859_2"); w.write(72); w.write(369); w.write(116); w.write(139); w.write(103); w.write(130); w.write(112); w.flush(); } 148/27

28 Bemeneti csatornák összefűzése A SequenceInputStream osztállyal összefűzhetünk több bemeneti csatornát. import java.io.*; public class FileSeq { public static void main( String[] args ) throws IOException { InputStream in = new SequenceInputStream( (new FileInputStream("b.txt")), (new FileInputStream("c.txt")) ); Copy(in, System.out); in.close(); } } 148/28 public static void Copy(InputStream in, OutputStream out) throws IOException { int b; while((b=in.read())!= -1) out.write(b); out.flush(); } Object InputStream FileInputStream SequenceInputStream

29 Hasznos szűrőosztályok DataInputStream, DataOutputStream: különböző adattípusok kiírásával egészíti az eredeti csatornát PrintStream, PrintWriter: különböző adattípusok szöveges kiírásával egészíti az eredeti csatornát Csatornák bufferelése BufferedInputStream, BufferedOutputStream BufferedReader, BufferedWriter 148/29

30 Hasznos szűrőosztályok InputStream FilterInputStream DataInputStream BufferedInputStream Byte streams DataOutputStream Object OutputStream FilterOutputStream PrintStream Reader Character streams Writer BufferedReader PrintWriter BufferedWriter BufferedOutputStream java.io 148/30

31 Példakód DataOutputStream/DataInputStream import java.io.*; public class DSPrg { public static void main(string[] args) throws IOException { FileOutputStream fos = new FileOutputStream("floatex.dat"); DataOutputStream dos = new DataOutputStream(fos); dos.writefloat(34.865f); dos.close(); } } DataInputStream dis = new DataInputStream( new FileInputStream("floatex.dat")); float f = dis.readfloat(); System.out.println(f); dis.close(); 148/31

32 Példakód PrintWriter/BufferedReader import java.io.*; public class PWPrg { static String filename = "pw.txt"; public static void main( String[] args ) throws IOException { FileWriter fw = new FileWriter(fileName); PrintWriter pw = new PrintWriter(fw); pw.printf("product list\n"); pw.printf("product name is %s and its price is %d $", "iphone", 1500); pw.close(); } } BufferedReader reader = new BufferedReader(new FileReader(fileName)); System.out.println("Data from file:"); String s = reader.readline(); while(s!= null) { System.out.println(s); s = reader.readline(); } 148/32

33 148/33

34 Példakód BufferedWriter/BufferedReader public static void BuWrite (String filename, String data){ BufferedWriter writer = null; try { writer = new BufferedWriter(new FileWriter(fileName)); writer.write(data); System.out.println("Data is written!"); } catch (IOException ioe) { System.err.println (ioe); } } finally { try { writer.close(); } catch (IOException ioe) { System.err.println (ioe); } } String írása (olvasása) szöveges fájlba. 148/34

35 Példakód BufferedWriter/BufferedReader public static void BuWrAppend (String filename, String data){ BufferedWriter writer = null; try { writer=new BufferedWriter(new FileWriter(fileName, true)); writer.newline(); writer.write(data); System.out.println("Data is appended!"); } catch (IOException ioe) { } System.err.println (ioe); } finally { try { writer.close(); } catch (IOException ioe) { System.err.println (ioe); } } String írása (olvasása) szöveges fájlba. 148/35

36 Példakód BufferedWriter/BufferedReader public static void BuRead (String filename){ 1. BufferedReader reader = null; String s = ""; try { 2. reader = new BufferedReader(new FileReader(fileName)); System.out.println("Data from file:"); 3. s = reader.readline(); while(s!= null) { System.out.println(s); 4. s = reader.readline(); String írása (olvasása) } szöveges fájlba. } catch (IOException ioe) { System.err.println (ioe); } finally { try { 5. reader.close(); } catch (IOException ioe) { System.err.println (ioe); } } 148/36 }

37 Példakód BufferedWriter/BufferedReader import java.io.*; public class Fkezel { public static void main(string args[]) { String fnev = "TextFile.txt"; BuWrite(fnev, "Hello Programmer!"); BuWrAppend(fnev, "Good Work!"); BuRead(fnev); } } String írása (olvasása) szöveges fájlba. 148/37

38 148/38

39 Példakód FileOutputStream/FileInputStream import java.io.serializable; import java.util.date; import java.text.*; class Student implements Serializable{ private String Name; private int Height; private Date Birthday; } 148/39 public Student (String n, int h, Date b) { Name = n; Height = h; Birthday = b; } Felhasználói osztály kialakítása fájlkezelés céljából. public String tostring() { SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd"); String s= sdf.format(birthday); return "Name: "+Name+" Height: "+Height+" B.day: "+s; }

40 Példakód FileOutputStream/FileInputStream public static void Kiir(int x) { try { FileOutputStream fos = new FileOutputStream("Students.dat"); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeint(x); } x=sta.lentgh; Felhasználói osztály írása (olvasása) bináris fájlba. for (int i = 0; i < x; i++) { oos.writeobject(sta[i]); } fos.close(); System.out.println("Data is written to file!"); } catch (IOException ioe) { System.out.println("File write exception: "+ioe); } Student sta[]; 148/40

41 Példakód FileOutputStream/FileInputStream /41 public static void Beolvas() { try { Felhasználói osztály írása FileInputStream fis = (olvasása) bináris fájlba. new FileInputStream("Students.dat"); ObjectInputStream ois = new ObjectInputStream(fis); db = ois.readint(); Object o = null; System.out.println("Data from file:"); for (int i = 0; i < db; i++) { o = ois.readobject(); st = (Student)o; System.out.println(st); } fis.close(); } catch (Exception e) { System.out.println("File write exception: "+e); } } }

42 Példakód FileOutputStream/FileInputStream import java.io.*; import java.util.date; import java.text.*; public class StudentPrg { private static Student st; private static int db = 3; private static Student[] sta = new Student[10]; static SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd"); static Date d0=null, d1=null, d2=null; public static void main(string[] args) { try { d0 = sdf.parse(" "); d1 = sdf.parse(" "); d2 = sdf.parse(" "); } catch (ParseException pe) {System.out.println("Hiba: "+pe);} sta[0] = new Student("Béla", 188, d0); sta[1] = new Student("Enikő", 166, d1); sta[2] = new Student("Ödön", 179, d2); Kiir(db); 6. Beolvas(); 148/42 }... Felhasználói osztály írása (olvasása) bináris fájlba.

43 Fájlrendszer kezelés 148/43

44 Fájlrendszer kezelés A java.io csomagban vannak nem stream típusú fájlok kezelését szolgáló osztályok is, pl: A File osztály egy fájlt reprezentál a helyi fájlrendszerben, segítségével fájl és könyvtárműveleteket végezhetünk A RandomAccessFile osztály segítségével közvetlenül, direkt módon (nem csak sorosan) hozzáférhetünk egy fájl tartalmához A FilenameFilter osztály segítségével szűrhetjük a megjelenített fájlnevek listáját 148/44

45 File osztály A File osztály egy fájlt (bejegyzést) reprezentál a helyi fájlrendszerben. A fájl lehet könyvtár is, ami egy olyan fájl, amiben bejegyzések és egyéb információk lehetnek! A bejegyzést a rendszer az elérési útvonalával (path) azonosítja Konstruktorok File(String pathname); File(String parent, String child); File(File parent, String child); 148/45

46 File osztály Útvonalak értelmezése Absolute path Current directory Relative path Parent path Child path Name c:\users\bitman\documents\java8\abc.txt Abszolút útvonal: mindig a root elemtől indul, és tartalmazza a könyvtárak listáját, a végén a fájl nevével. Relatív útvonal: mindig kombinálni kell egy másik útvonallal, a fájl eléréséhez. 148/46

47 File osztály A bejegyzés útvonal tulajdonságai : boolean isabsolute() abszolút a fájl útvonala? String getabsolutepath() abszolút útvonal lekérése File getabsolutefile() fájl lekérése abszolút útvonallal String getpath() relatív útvonal lekérése String getparent() szülő útvonal lekérése File getparentfile() szülő fájl lekérése String getname() fájl neve 148/47

48 File osztály A bejegyzés tulajdonságai: boolean isdirectory() könyvtár? boolean isfile() fájl? long length() a fájl mérete long lastmodified() utolsó módosítás időpontja boolean ishidden() rejtett? boolean canread() olvasható? boolean canwrite() írható? boolean exists() fizikailag létező bejegyzés? boolean setreadonly() csak olvasható beállítása boolean setwritable(boolean) írható beállítása boolean setreadable(boolean) olvasható beállítása 148/48

49 File osztály A bejegyzések kezelése: boolean mkdir() könyvtár létrehozása boolean mkdirs() könyvtár létrehozása a nem létező szülőkönyvtárakkal együtt boolean createnewfile() throws IOException üres fájl létrehozása (csak akkor jön létre, ha nem létezik) boolean delete() bejegyzés törlése void deleteonexit() a VM leállásakor törli a fájlt boolean renameto(file dest) bejegyzés átnevezése File[] listfiles() bejegyzésben lévő fájlok listája 148/49

50 Példakód import java.io.*; public class FK1 { public static void main(string args[]) { String CurDirName = System.getProperty("user.dir"); System.out.println("User Directory: "+CurDirName); File CurDir = new File(CurDirName); File CurFile = new File(CurDirName, "a.txt"); System.out.println("Is absolute: "+CurFile.isAbsolute()); System.out.println("Path: "+CurFile.getPath()); System.out.println("Parent: "+CurFile.getParent()); System.out.println("Name: "+CurFile.getName()); System.out.println(""); File[] files = CurDir.listFiles(); System.out.println("Files in "+CurDir); for (File f : files) System.out.println(f); 148/50

51 Példakód System.out.println(""); System.out.println(".txt files in "+CurDir); File[] batfiles = CurDir.listFiles(new FileFilter(){ public boolean accept( File path ){ return path.isfile() && path.getname().endswith(".txt"); } }); for (File f : batfiles) System.out.println(f.getAbsolutePath(). substring(f.getabsolutepath().lastindexof("\\")+1)); System.out.println(""); File af = new File("a.txt"); System.out.println(af+ (af.canwrite()? " is writable" : " is not writable")); System.out.println(af+" file size is: "+af.length()+" bytes"); 148/51

52 Példakód String fs = File.separator; boolean ok = (new File(CurDir+fs+"Prb_dir")).exists(); System.out.println("Prb_dir exists: "+ok); if (!ok) { ok = (new File(CurDir+fs+"Prb_dir")).mkdir(); if (ok) System.out.println("Prb_dir created now!"); } 4. File tf = new File("Prb_dir"+fs+"c.txt"); try { FileInputStream fis = new FileInputStream(af); FileOutputStream fos = new FileOutputStream(tf); int b; while( (b=fis.read())!= -1 ) fos.write(b); fos.flush(); fis.close(); fos.close(); } catch (Exception e) {System.err.println(e);} 148/52

53 Példakód if (tf.exists()) tf.setwritable(false); System.out.println(tf+ (tf.canwrite()? " is writable" : " is not writable")); BufferedWriter writer = null; try { writer=new BufferedWriter(new FileWriter(tf, true)); writer.newline(); writer.write("cccccccccc"); System.out.println("Data is appended!"); } catch (Exception e) {System.err.println("Exception: "+ e.getmessage());} try { if (writer!= null) writer.close(); } catch (Exception e) {System.err.println("Exception: "+ e.getmessage());} if (tf.exists()) tf.setwritable(true); System.out.println(tf+ (tf.canwrite()? " is writable" : " is not writable")); 148/53

54 Példakód File nf = new File("Prb_dir"+fs+"nc.dat"); tf.renameto(nf); System.out.println(tf+" New name is: "+nf); File od = new File("Prb_dir"); File nd = new File("New_dir"); od.renameto(nd); System.out.println(od+" New name is: "+nd); File f = new File("New_dir"+fs+"nc.dat"); ok = f.delete(); if (ok) System.out.println(f+" is deleted!"); File d = new File("New_dir"); ok = d.delete(); if (ok) System.out.println(d+" is deleted!"); } } 148/54

55 java.nio 148/55

56 java.nio csomag Új alternatíva a fájlok kezelésére A Java 7-es verziójában jelent meg Mindent tud, amit az io tudott Újdonságai: Linkek kezelése Metainformációk, jogosultságok kezelési lehetőségeinek bővítése Több, egyszerűbb fájl kezelő parancs 148/56

57 newoutputstream() newinputstream() provider() getfilesystem() java.nio csomag Fontosabb osztályok FileSystems A java.nio csomag (részlete) Files getdefault() FileSystem getfilestores() Iterable<FileStore> getfilestore() FileStore getlast ModifiedTime() getfilesystem() get() FileTime getpath() Path Paths FileSystemProvider newdirectorystream() newinputstream() newoutputstream() newbufferedreader() InputStream OutputStream DirectoryStream BufferedReader 148/57 Class Abstract Class Final Class Interface

58 Fontosabb osztályok Path: File, directory, link név fogalom Paths: Path létrehozás Files: File, directory, link műveletek FileSystems: File rendszer objektum létrehozás FileSystem: File rendszer információk FileSystemProvider: File rendszer adatok betöltése FileStore: Eszközt (kötetet, partíciót) jelképez 148/58

59 Fájlrendszer kezelése Aktuális file rendszer kinyerése: FileSystem fs = FileSystems.getDefault(); Filerendszerben levő partíciók: Iterable<FileStore> part = fs.getfilestores(); Filerendszerben levő gyökér directory-k: Iterable<Path> = fs.getrootdirectories(); 148/59

60 Fájlrendszer műveletek Partíció (FileStore) információk: long gettotalspace() long getusablespace() long getunallocatedspace() String name() String type() String tostring() 148/60

61 Példakód import java.nio.file.filestore; import java.nio.file.filesystem; import java.nio.file.filesystems; import java.nio.file.path; import java.io.ioexception; public class FS { public static void main(string[] args) { FileSystem fs = FileSystems.getDefault(); } 148/61 System.out.println("Read-only file system: "+fs.isreadonly()); System.out.println("File name separator: "+fs.getseparator()); for (FileStore store : fs.getfilestores()) { printdetails(store); } for (Path root : fs.getrootdirectories()) { System.out.println(root); }

62 Példakód } 148/62 } public static void printdetails(filestore store) { try { String name = store.name(); String type = store.type(); double ts = ltod(store.gettotalspace()); double us = ltod(store.getunallocatedspace()); double as = ltod(store.getusablespace()); System.out.println(""); System.out.println("Name: "+ name + " Type: "+ type); System.out.println("Total: " + ts + " GB"); System.out.println("Unallocated: " + us + " GB"); System.out.println("Available: " + as + " GB"); } catch (IOException e) { e.printstacktrace(); } } public static double ltod (long x){ double a = x / Math.pow(1024, 3); a = Math.round(a * 100) / 100d; return a;

63 java.nio File Management API FileSystemProvider java.nio.file.spi FileTypeDetector FileSystems java.nio.file FileSystem Path DirectoryStream FileStore FileRef FileStore AttributeView java.nio.file.attribute FileAttribute View 148/63 AttributeView

64 Path Útvonal (ösvény) Tartalma egy útvonal amellyel egy fájlt, könyvtárat, vagy linket azonosítunk. Az ösvény tartalmazhat egy gyökérelemet, könyvtárak sorát és fájlnevet. Pl: /usr/staff/pisti/aaa.txt c:\pisti\java\aaa.txt Hasonlít a java.io.file objektumra, de az rendszer független módon ábrázolja a fájlnevet, ezért Multi-platform programok esetén használata gondot okozhat. A Path mindig az adott rendszertől függ, pl: unix-ban: /valami/adat.txt windowsban: c:\valami\adat.txt. 148/64

65 Path Útvonal (ösvény) A Path egy interfész a java.nio csomagban, ezért nem példányosítható Közvetlen kapcsolatban áll a java.io.file objektummal: egymásba konvertálhatók: File file = new File("C:\\proba.txt"); Path path = file.topath(); Path path = Paths.get("C:\\proba.txt"); File file = path.tofile(); Kétféle műveletet végezhetünk vele: útvonal műveletek (összehasonlítás, ellenőrzés ) fájl műveletek (másolás, törlés, átnevezés ) 148/65

66 Path Útvonal (ösvény) Path objektum létrehozása: A FileSystem segítségével: FileSystem fs = FileSystems.getDefault(); Path p1 = fs.getpath("c:\\java\\ea6\\prg.java"); A Paths segítségével: Path p2 =Paths.get("C:\\Java\\ea6\\Prg.java"); Path p3 =Paths.get("C:","Java","ea6","Prg.java"); Az io.file segítségével: File file = new File("C:\\Java\\ea6\\Prg.java"); Path p4 = file.topath(); 148/66

67 Path Útvonal (ösvény) Path név részek kinyerése: String tostring() String getfilename() Path getparent() Path getroot() int getnamecount() Path getname(int index) Path subpath(int beginindex, int endindex) Iterator<Path> iterator() 148/67

68 Példakód import java.nio.file.path; import java.nio.file.paths; public class FS2 { public static void main(string[] args) { Path p1 = Paths.get("c:\\Java8\\ea6\\test1.txt"); printdetails(p1); } Path p2 = Paths.get("prbdir", "test1.txt"); printdetails(p2); 148/68

69 Példakód } public static void printdetails(path p) { System.out.println(""); System.out.println("Details for path: " + p); } 148/69 int count = p.getnamecount(); System.out.println("Name count: " +count); for (int i = 0; i < count; i++) { Path name = p.getname(i); System.out.println("Name at index " +i+ " is " +name); } Path parent = p.getparent(); Path root = p.getroot(); Path filename = p.getfilename(); System.out.println("Parent: "+parent+", Root: "+root+ ", File Name: " + filename); System.out.println("Absolute Path: " + p.isabsolute());

70 Path Útvonal (ösvény) Path informálódás, átalakítás: boolean isabsolute() Path normalize() Path toabsolutepath() Path torealpath() Uri touri() Path resolve(path other) Path resolve(string other) Path relativize(path other) 148/70

71 Példakód /71 Path p1 = Paths.get("C:\\Java_8\\..\\\\ea6\\test1.txt"); Path p1n = p1.normalize(); System.out.println(p1 + " normalized to " + p1n); Path p2 = Paths.get("J8\\ea6\\x\\..\\..\\test.txt"); Path p2n = p2.normalize(); System.out.println(p2 + " normalized to " + p2n); Path p3 = Paths.get("C:\\Java8"); Path p4 = Paths.get("ea6\\test1.txt"); System.out.println(p3.resolve(p4)); Path p5 = Paths.get("C:\\test.txt"); System.out.println(p3.resolve(p5)); Path p6 = Paths.get("\\"); System.out.println(p3.resolve(p6)); Path p7 = Paths.get("J8", "ea6", "x2"); Path p8 = Paths.get("J8\\ea6"); System.out.println(p7.relativize(p8)); System.out.println(p8.relativize(p7));

72 Path Útvonal (ösvény) Path egyéb műveletek: FileSystem getfilesystem() boolean startswith(path other) boolean startswith(string other) boolean endswith(path other) boolean endswith(string other) int compareto(path other) boolean equals(object other) 148/72

73 Példakód Path p1 = Paths.get("Talon\\3\\Emp.java"); Path p2 = Paths.get("Talon\\3\\Emp.java"); Path p3 = Paths.get("bitman\\Emp.java"); System.out.println("p1: "+p1); System.out.println("p2: "+p2); System.out.println("p3: "+p3); boolean eqp1p2 = p1.equals(p2); System.out.println("eqp1p2: "+eqp1p2); boolean eqp1p3 = p1.equals(p3); System.out.println("eqp1p3: "+eqp1p3); int cp1p2 = p1.compareto(p2); System.out.println("cp1p2: "+cp1p2); int cp1p3 = p1.compareto(p3); System.out.println("cp1p3: "+cp1p3); 148/73

74 Példakód Path p4 = Paths.get("Talon\\3\\pw.txt"); Path p5 = Paths.get("Emp.java"); Path p6 = Paths.get("java"); System.out.println("p4: "+p4); System.out.println("p5: "+p5); System.out.println("p6: "+p6); boolean swp1p4 = p1.startswith(p4); System.out.println("swp1p4: "+swp1p4); boolean ewp1p5 = p1.endswith(p5); System.out.println("ewp1p5: "+ewp1p5); boolean ewp1p6 = p1.endswith(p6); System.out.println("ewp1p6: "+ewp1p6); boolean isfp1p3 = Files.isSameFile(p1, p3); System.out.println("isfp1p3: "+isfp1p3); 148/74

75 Path - Linkek Hard link: A hard link egy másik név az eredeti fájlra, vagyis a két fájl tartalma azonos, és a létrehozás után nem is lehet megmondani, melyik volt az eredeti fájl és melyik a hard link. Hard link csak ugyanabban a fájlrendszerben hozható létre, mint az eredeti, és a mutatott fájl nem lehet könyvtár. Symbolic link: Olyan fájl, melynek tartalma egy másik fájl elérési útvonala A legtöbb program a symlinket arra használja, hogy eljusson a mögötte levő fájlhoz (indirekt fájlelérés). Fontos: egyik link sem egyezik meg a parancsikonnal! 148/75

76 Példakód import java.nio.file.*; public class FK2 { public static void main(string args[]) throws Exception { Path existingfile = Paths.get("Talon\\3\\Emp.java"); Path link = Paths.get("bitman\\Emp.link"); Files.createLink(link, existingfile); Path symlink = Paths.get("bitman\\Emp.symlink"); Files.createSymbolicLink(symLink, existingfile); System.out.println(symLink); 148/76

77 Példakód } Path link2 = Paths.get("bitman\\Emp.symlink"); System.out.println(Files.isSymbolicLink(link2)); System.out.println(Files.readSymbolicLink(link2)); Path t = Files.readSymbolicLink(link2); System.out.println(t.isAbsolute()); System.out.println(t.toAbsolutePath()); } Fontos: a műveletek végrehajtásához megfelelő jogosultságok szükségesek! Futtassuk rendszergazdaként az alkalmazást! 148/77

78 Path URI Az URI (Uniform Resource Identifier), egységes erőforrás-azonosító, egy rövid karaktersorozat, amelyet egy webes erőforrás azonosítására használunk Az URI az erőforrást kétféleképp azonosíthatja: hely szerint (URL): hol lehet az erőforrást elérni név szerint (URN): egy tulajdonság nevével, és értékével urn:isbn: (egy könyv az isbn alapján) Path pth = Paths.get("Talon\\3\\Emp.java"); java.net.uri pthuripath = pth.touri(); System.out.println("Absolute Path: " + pth.toabsolutepath()); System.out.println("URI Path: " + pthuripath); 148/78

79 Példakód } public static void printdetails(path p) { System.out.println(""); System.out.println("Details for path: " + p); } 148/79 int count = p.getnamecount(); System.out.println("Name count: " +count); for (int i = 0; i < count; i++) { Path name = p.getname(i); System.out.println("Name at index " +i+ " is " +name); } Path parent = p.getparent(); Path root = p.getroot(); Path filename = p.getfilename(); System.out.println("Parent: "+parent+", Root: "+root+ ", File Name: " + filename); System.out.println("Absolute Path: " + p.isabsolute());

80 A java.nio.files osztály fájl műveletei Fájl (dir, link) ellenőrzés: boolean exists(path path, LinkOption... options) az options értéke lehet: LinkOption.NOFOLLOW_LINKS értéke: igaz, ha létezik, és hamis ha nem létezik vagy nem megállapítható (nincs jog) boolean notexists(path path, LinkOption... options) értéke: igaz, ha nem létezik és hamis ha létezik vagy nem megállapítható 148/80

81 A java.nio.files osztály fájl műveletei Fájl (dir, link) ellenőrzés: boolean isdirectory(path path, LinkOption... options) boolean isregularfile(path path, LinkOption... options) boolean issymboliclink(path path) boolean isexecutable(path path) boolean isreadable(path path) boolean iswritable(path path) 148/81

82 A java.nio.files osztály fájl műveletei Fájl (dir, link) másolás Path copy(path source, Path target, CopyOption... options) Az options tartalmazhatja: REPLACE_EXISTING: felülír, ha a cél létezik COPY_ATTRIBUTES: másolja az attribútumokat is (rendszerfüggő) NOFOLLOW_LINKS: link esetén csak a linket másolja. Pl: fájl (source) másolása ugyanazon a néven egy másik könyvtárba (target): Path source = Paths.get("Talon\\3\\Emp.java"); Path target = Paths.get("bitman"); 148/82 Path t; t = target.resolve(source.getfilename()); Files.copy(source, t);

83 A java.nio.files osztály fájl műveletei Fájl (dir, link) mozgatás (áthelyezés) Path move(path source, Path target, CopyOption... options) Az options tartalmazhat: REPLACE_EXISTING: felülír, ha a cél létezik ATOMIC_MOVE: atomi műveletként mozgat, ha az opr. nem támogatja akkor kivételt dob. Ha a forrás nem létezik: NoSuchFileException Ha a cél már létezik: FileAlreadyExistsException Ha nincs jogosultságunk: AccessDeniedException Path source = Paths.get("Talon\\3\\a.txt"); Path target = Paths.get("bitman"); 148/83 Path t; t = target.resolve(source.getfilename()); Files.move(source, t);

84 A java.nio.files osztály fájl műveletei Fájl (dir, link) törlés void delete(path path) ha a path egy link, akkor csak a link törlődik ha a path egy dir, akkor csak ha üres boolean deleteifexists(path path) ha a path nem létező, akkor nem kivételt dob, hanem hamisat ad Path delfile = Paths.get("bitman\\a.txt"); Files.delete(delFile); 148/84

85 A java.nio.files osztály fájl műveletei Fájl létrehozása Path createfile(path path, FileAttribute<?>... attrs) Üres file-t hoz létre Ha a file már létezik, akkor kivételt dob Ha az útvonalban megadott valamelyik elem nem létezik, kivételt dob Atomi műveletként hozza létre a file-t és állítja be a megadott attribútumokat (attribútumokról később) Lehet létrehozni file-okat a már tanult csatornák írásával is (pl: FileOutputStream, FileWriter ) Path newfile = Paths.get("bitman\\a.txt"); Files.createFile(newFile); 148/85

86 A java.nio.files osztály fájl műveletei Könyvtár létrehozása Path createdirectory(path dir, FileAttribute<?>... attrs) Létrehoz egy üres könyvtárat Ha már létezik a könyvtár, vagy az útvonalban megadott valamelyik elem nem létezik, kivételt dob Atomi művelet Path createdirectories(path dir, FileAttribute<?>... attrs) Létrehozza a könyvtárat, ha a szülők nem léteznek azokat is létrehozza Nem atomi művelt, azaz lehetséges, hogy a szülő létrejött, de a gyermek már nem 148/86 Path newdir = Paths.get("X56"); Files.createDirectory(newDir); Files.createDirectories(Paths.get("A\\B\\C"));

87 A java.nio.files osztály fájl műveletei Link létrehozása: Szimbolikus link (soft link): Path createsymboliclink(path link, Path target, FileAttribute<?>... attrs) Ha az operációs rendszer nem támogatja a soft linket, akkor kivételt dob Hard link: Path createlink(path link, Path existing) Path existingfile = Paths.get("Talon\\3\\Emp.java"); Path link = Paths.get("bitman\\Emp.link"); Files.createLink(link, existingfile); Path symlink = Paths.get("bitman\\Emp.symlink"); Files.createSymbolicLink(symLink, existingfile); 148/87

88 A java.nio.files osztály fájl műveletei Temp file, directory létrehozás Path createtempfile(path dir, String prefix, String suffix, FileAttribute<?>... attrs) Létrehoz egy temporary file-t a megadott directory-ban, legenerálva a nevet, a megadott névkezdettel, véletlen számokból álló folytatással, a megadott kiterjesztéssel, és a megadott attribútumokkal a prefix és a suffix lehet null ha a suffix null, akkor.tmp a kiterjesztés Path tmpd = Paths.get("C:\\temp"); Files.createTempFile(tmpd, "bitm", ".txt"); 148/88

89 A java.nio.files osztály fájl műveletei Temp file, directory létrehozás Path createtempfile(string prefix, String suffix, FileAttribute<?>... attrs) A fájl az alapértelmezett temp könyvtárban jön létre Path createtempdirectory(path dir, String prefix, FileAttribute<?>... attrs) Létrehoz egy temporary directory-t a megadott directoryban, legenerálva a nevét a megadott kezdettel, valamint a megadott attribútumokkal. Path createtempdirectory(string prefix, FileAttribute<?>... attrs) A direktory az alapértelmezett temp directory-ban jön létre Files.createTempDirectory(Paths.get("C:\\temp"), 148/89 "Bitm");

90 A java.nio.files osztály fájl műveletei File olvasás, írás: Stream kinyerés: InputStream newinputstream(path path, OpenOption... options) megnyitja olvasásra a megadott file-t és visszaad egy stream-t amivel olvashatjuk, az options egyenlőre csak READ lehet. BufferedReader newbufferedreader(path path, Charset cs) létrehoz egy BufferedReader stream-et, amivel olvashatjuk a megadott file-t bufferelten a megadott dekódolással. 148/90

91 A java.nio.files osztály fájl műveletei File olvasás, írás: Stream kinyerés: OutputStream newoutputstream(path path, OpenOption... options) 148/91 Megnyitja (létrehozza) írásra a megadott file-t és visszaad egy stream-et,a mivel írhatjuk Az options lehetséges tagjai (nem teljes): CREATE: megnyitja ha létezik, létrehozza ha nem CREATE_NEW: létrehozza, ha már létezik akkor kivételt dob APPEND: megnyitja ha létezik különben kivételt dob, végére ír TRUNCATE_EXISTING: ha létezik üressé teszi CREATE,APPEND: a kettő kombinációja CREATE,TRUNCATE_EXISTING: a kettő kombinációja - ha nem adok meg options-t, akkor CREATE,TRUNCATE_EXISTING

92 A java.nio.files osztály fájl műveletei File olvasás, írás: Stream kinyerés: BufferedWriter newbufferedwriter(path path, Charset cs, OpenOption... options) Mint az előző csak bufferelt karakter alapú stream-et kapunk, ami a megadott Charset szerinti kódolással ír. 148/92

93 A java.nio.files osztály fájl műveletei File olvasás, írás: Channel kinyerés: SeekableByteChannel newbytechannel(path path, Set<? extends OpenOption> options, FileAttribute<?>... attrs) Megnyitja vagy létrehozza a file-t és visszaad egy FileChannel-t, amivel tetszőleges pozícióba írhatok vagy olvashatok. Az attrs, akkor számít, ha új file-t hozok létre. Ezek lesznek az attribútumai. Mivel csak az utolsó paraméter lehet -s, ezért a megnyitási opciókat halmazban lehet megadni. Pl. WritableByteChannel wbc = Files.newByteChannel(path, EnumSet.of(CREATE,APPEND)); 148/93

94 A java.nio.files osztály fájl műveletei File olvasás, írás: Channel kinyerés: SeekableByteChannel newbytechannel(path path, OpenOption... options) ua. mint előző, csak nem lehet megadni attribútumokat az esetleg létrejövő file-nak, ezért a nyitási opciókat újra a szokott módon lehet megadni 148/94

95 A java.nio.files osztály fájl műveletei File olvasás, írás: long copy(inputstream in, Path target, CopyOption... options) A stream tartalmát kiolvassa és menti a megadott file-ba. Pl. (csak részlet) URI u = URI.create(" try(inputstream in = u.tourl().openstream()){ Files.copy(in, path); } 148/95

96 A java.nio.files osztály fájl műveletei File olvasás, írás: long copy(inputstream in, Path target, CopyOption... options) A stream tartalmát kiolvassa és menti a megadott file-ba. Pl. (csak részlet) URI u = URI.create(" try(inputstream in = u.tourl().openstream()){ Files.copy(in, path); } Tibi: 82 long copy(path source, OutputStream out) Másolja a megadott file tartalmát a megadott stream-re 148/96

97 A java.nio.files osztály fájl műveletei File olvasás, írás: byte[] readallbytes(path path) Az összes byte-t kiolvassa a megadott file-ból és visszaadja egy tömbben. Nagy fájloknál nem ajánlott a használata. pl. byte[] arr = Files.readAllBytes(file); List<String> readalllines(path path, Charset cs) Az összes sort kiolvassa a megadott file-ból a megadott dekódolást használva. Nagy fájloknál nem ajánlott Sor elválasztó jelek: \n, \r, \r\n 148/97

98 A java.nio.files osztály fájl műveletei File olvasás, írás: Path write(path path, byte[] bytes, OpenOption... options) A teljes tömb kiírása a file-ba. A megnyitási opciók a szokásosak Path write(path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption... options) Az összes sor kiírása a file-ba a megadott kódolással 148/98

99 java.nio.file.attribute 148/99

100 A java.nio.file.attribute osztály Ez a csomag tartalmazza a fájlok attribútumait kezelő eljárásokat 148/100 A fájlok tulajdonságait, felhasználhatóságát, hatóköreit leíró jelölések az attribútumok. Az, hogy milyen attribútumokat vehetnek fel a fájlok, az adott fájlrendszertől függ. Az attribútumok attribútum csoportokba vannak szervezve: Basic, Dos, FileOwner, Posix, Acl, UserDefined

101 A java.nio.file.attribute osztály A BasicFileAttributeView kezeli az alapvető fájl attribútumokat, például a létrehozási időt, az utolsó hozzáférési időt, az utolsó módosított időt, a méretet, a fájltípust, fájlok, könyvtárak, szimbolikus linkek, és egyéb bejegyzések esetén, és a fájlokat azonosító egyedi hexa kódokat Ez a csomag minden platformon támogatott. A DosFileAttributeView a DOS specifikus fájl tulajdonságokat, pl: rejtett fájl, rendszerfájl, archív fájl és csak olvasható fájl. 148/101 Ez csak a DOS-t támogató rendszereken érhető el, mint a Microsoft Windows.

102 A java.nio.file.attribute osztály A PosixFileAttributeView kezeli a UNIX rendszereken elérhető attribútumokat. Lehetővé teszi a tulajdonosi, a csoporthoz tartozók, és mindenki más jogosultságainak kezelését. A FileOwnerAttributeView kezeli a fájl tulajdonosának jogait. Az AclFileAttributeView kezeli az ACL (Access Control List) fájlt. A UserDefinedFileAttributeView a felhasználó által definiált attribútumokat kezeli. 148/102

103 A java.nio.file.attribute osztály Attribútumok kezelése: Nem minden csoportot támogat minden op. rendszer A Basic csoportot minden op.rendszer támogatja. A többiről tájékozódhatunk a FileStore metódusaival: boolean supportsfileattributeview(string name) boolean supportsfileattributeview(class<? extends FileAttributeView> type) 148/103

104 Példakód import java.nio.file.*; import java.nio.file.attribute.*; Path path = Paths.get("C:"); try { FileStore fs = Files.getFileStore(path); printdetails(fs, BasicFileAttributeView.class); printdetails(fs, DosFileAttributeView.class); printdetails(fs, PosixFileAttributeView.class); printdetails(fs, FileOwnerAttributeView.class); printdetails(fs, AclFileAttributeView.class); printdetails(fs, UserDefinedFileAttributeView.class); } catch (Exception ex) {ex.printstacktrace();} public static void printdetails(filestore fs, Class<? extends FileAttributeView> attribclass) { boolean supported = fs.supportsfileattributeview(attribclass); System.out.format("%s is supported: %s%n", attribclass.getsimplename(), supported); } 148/104

105 A java.nio.file.attribute osztály A legfontosabb interfészek: FileStoreAttributeView FileStoreSpaceAttributeView DosFileAttributeView BasicFileAttributeView PosixFileAttributeView AttributeView FileAttributeView FileOwnerAttributeView AclFileAttributeView java.nio.file.attribute UserDefineAttributeView Interface 148/105

106 A java.nio.file.attribute osztály Attribútumok kezelése: Az attribútumok olvasásához készítettek minden csoporthoz egy interface-t. Pl. BasicFileAttributes, DosFileAttributes, stb. Ennek minden attribútumhoz van egy kiolvasó metódusa Ezt megkaphatom a view readattributes() metódusával, pl: BasicFileAttributes attr = bview.readattributes(); vagy a Files readattributes(..) metódusával, pl: BasicFileAttributes attr = Files.readAttributes(p, BasicFileAttributes.class); 148/106

107 A java.nio.file.attribute osztály Attribútumok kezelése: A Files osztálynak vannak metódusai, amivel közvetlenül, név szerint olvashatom, írhatom bármelyik csoportba tartozó attribútumokat. A név szintaktikája: csoportnév: attrnév. (pl. basic:size) Az olvasás metódusa a getattribute, az írásé a setattribute. A Files osztálynak a leggyakrabban használt attribútum kezelésekre külön metódusa van kényelmi okokból. (pl: van getlastmodifiedtime, setlastmodifiedtime, ) 148/107

108 A java.nio.file.attribute osztály Attribútumok kezelése: olvasás A megfelelő FileAttributes metódusaival (amit persze kétféleképpen kaphatok meg mint láttuk) A Files osztály getattribute metódusával A gyakran használtakat a Files osztály közvetlen metódusaival Attribútumok kezelése: írás A view módosító metódusaival A Files osztály setattribute metódusával A gyakran használtakat a Files osztály közvetlen metódusaival 148/108

109 A java.nio.file.attribute osztály A Basic csoport attribútumai: lastmodifiedtime, lastaccesstime, creationtime, size, isregularfile, isdirectory, issymboliclink, isother, filekey 148/109

110 A java.nio.file.attribute osztály A Basic csoport attribútumai: Az attribútumok lekérdezése név szerint a Files osztály getattribute metódusával. Pl Path p = Paths.get("bitman\\Emp.java"); long a = (Long)Files.getAttribute(p, "basic:size"); System.out.println(p+" file size is: "+a+" bytes"); System.out.println("File last modified time is: "+ Files.getAttribute(p, "basic:lastmodifiedtime")); 148/110

111 A java.nio.file.attribute osztály A Basic csoport attribútumai: Az attribútumok lekérdezhetőek a BasicFileAttributes segítségével: Path p = Paths.get("bitman\\Emp.java"); BasicFileAttributes bfa = Files.readAttributes(p, BasicFileAttributes.class); System.out.format("Creation Time: %s %n", bfa.creationtime()); System.out.format("Last Access Time: %s %n", bfa.lastaccesstime()); 148/111

112 A java.nio.file.attribute osztály A Basic csoport attribútumai: Lekérdezhetjük a teljes Basic attributum csoportot a BasicFileAttributesView segítségével: BasicFileAttributeView bfav = Files.getFileAttributeView(p, BasicFileAttributeView.class); BasicFileAttributes bfa = bfav.readattributes(); System.out.format("Size:%s bytes %n", bfa.size()); System.out.format("Last Modified Time: %s %n", bfa.lastmodifiedtime()); 148/112

113 A java.nio.file.attribute osztály A Basic csoport attribútumai: A legfontosabb attribútumok lekérdezésére rendelkezésre állnak a Files osztály metódusai: long size(path) boolean ishidden(path path) boolean isregularfile(path path, LinkOption... options) boolean isdirectory(path path, LinkOption... options) boolean issymboliclink(path path) FileTime getlastmodifiedtime(path path, LinkOption... options) 148/113 Path p = Paths.get("bitman\\Emp.java"); System.out.println("File size is: "+Files.size(p));

114 A java.nio.file.attribute osztály A Basic csoport attribútumai: Az attribútumok módosíthatók a Files osztály setattribute metódusával. A basic csoportban csak a dátumok módosíthatók: lastmodifiedtime, lastaccesstime, creationtime 1. Path p = Paths.get("bitman\\Emp.java"); FileTime time = FileTime.fromMillis(System.currentTimeMillis()); Files.setAttribute(p, "basic:creationtime", time); A lastmodifiedtime attribútum módosítható a Files osztály setlastmodifiedtime metódusával: 2. Files.setLastModifiedTime(p, time); 148/114

115 A java.nio.file.attribute osztály A Basic csoport attribútumai: Az idő attribútumok együtt módosíthatók a BasicFileAttributesView osztály settimes metódusával import java.nio.file.*; import java.nio.file.attribute.*; import java.time.instant; Path p = Paths.get("bitman\\Emp.java"); BasicFileAttributeView bfav = Files.getFileAttributeView(p, BasicFileAttributeView.class); FileTime newlastmodifiedtime = null; FileTime newlastaccesstime = null; FileTime newcreatetime = FileTime.from(Instant.now()); bfav.settimes(newlastmodifiedtime, newlastaccesstime, newcreatetime); 148/115

116 A java.nio.file.attribute osztály A DOS csoport attribútumai: readonly, hidden, system, archive Lekérdezhetők: A Files osztály getattribute metódusával A DosFileAttributes isreadonly, ishidden, issystem, isarchive metódusaival Módosíthatók: A view setreadonly, sethidden, setarchive, setsystem metódusaival A Files osztály setattribute metódusával 148/116

117 A java.nio.file.attribute osztály Az Owner csoport attribútumai: owner 148/117 Lekérdezhetők: A Files osztály getattribute metódusával UserPrincipal princ = (UserPrincipal)Files.getAttribute(p, "owner:owner"); A FileOwnerAttributeView getowner metódusával A Files osztály getowner metódusával Módosítható: A FileOwnerAttributeView setowner metódusával A Files osztály setowner metódusával A felhasználó UserPrincipal-jának előállításához a FileSystem-től le lehet kérni egy lookup service-t és azzal megkeresni a megadott nevű felhasználót: UserPrincipal user = fs.getuserprincipallookupservice().lookupprincipalbyname("kovacs25");

118 A java.nio.file.attribute osztály A posix csoport attribútumai: group, permissions A basic és a owner view-ek leszármazottja A permissions PosixFilePermission enum elemek halmaza a szokásos rwxrwxrwx-et fejezi ki Lekérdezhető: A Files osztály getattribute metódusával A PosixFileAttributes group, permissions metódusaival A permissions lekérdezhető a Files getposixfilepermissions metódusával 148/118

119 A java.nio.file.attribute osztály A posix csoport: Módosítható: A view setgroup, setpermissions metódusával Pl: a csoport állításához az owner beállításához hasonlóan egy lookup service-el megkerestetjük a kívánt csoportot, majd beállítjuk: GroupPrincipal group = fs.getuserprincipallookupservice().lookupprincipalbygroupname("staff"); Files.getFileAttributeView(p, PosixFileAttributeView.class).setGroup(group); A permissions módosítható a Files osztály setposixfilepermissions metódusával, pl: Set<PosixFilePermission> perms = EnumSet.of(OWNER_READ, OWNER_WRITE, OWNER_EXECUTE, GROUP_READ); 148/119 vagy: Set<PosixFilePermission> perms = PosixFilePermissions.fromString("rwxr-----"); Files.setPosixFilePermissions(p,perms);

120 A java.nio.file.attribute osztály Az acl csoport attribútumai: acl Az acl egy AclEntry típusú lista. Egy AclEntry adatai: type: engedélyezés vagy letíltás (AclEntryType) principal: a felhasználó UserPrincipal-ja permissions: a jogok (Set<AclEntryPermissions>) flags: a bejegyzés öröklődését szabályozó flagek halmaza (Set<AclEntryFlag>) 148/120

121 A java.nio.file.attribute osztály Az acl csoport: Az AclEntry-k létrehozásához builder osztályt lehet használni (építő tervezési minta) Példa: 1. UserPrincipal létrehozása UserPrincipal joe = p.getfilesystem().getuserprincipallookupservice().lookupprincipalbyname("joe"); 2. view létrehozása AclFileAttributeView view = Files.getFileAttributeView(file, AclFileAttributeView.class); 3. Entry felépítése 148/121 AclEntry entry = AclEntry.newBuilder().setType(AclEntryType.ALLOW).setPrincipal(joe).setPermissions(AclEntryPermission.READ_DATA, AclEntryPermission.READ_ATTRIBUTES).build();

122 A java.nio.file.attribute osztály Az acl csoport: 4. Lista lekérdezése, új entry beszúrása (a deny-k elé), lista beállítása List<AclEntry> acl = view.getacl(); acl.add(0, entry); view.setacl(acl); 148/122

123 148/123

124 Teszt 1. Melyik két fogalom hiányzik az alap (ős) stream osztályok táblázatából? Típus - Irány Bemeneti Kimeneti Bájt InputStream OutputStream Karakter?????????? CharReader, CharWriter StringReader, StrigWriter Reader, Writer DataInpuStream, DataOutputStream PrintStream, PrintWriter 148/124

125 Teszt 2. Melyik a Java alapvető I/O csomagja? java.input java.io javax.nio java.inout java.io.file 148/125

126 Teszt 3. Egy stream típusú adatfolyamban áramolhatnak az adatok mindkét irányba? Nem, az adatfolyamban lévő adatok csak egy irányba áramolhatnak Nem, a stream adatfolyam mindig csak a kimenetre szolgál. Igen, egy stream adatfolyam egyszerre írható és olvasható Igen, de egyszerre csak egy irányba 148/126

127 Teszt 4. Mi a puffer? Olyan stream, aminek a bemenete egy bizonyos adattípus, amit átmenetileg tárol, és magasabb rendű adattípussá alakítja Olyan file, ami beállított számú bájtot tud tárolni Olyan stream, ami meghatározott számú bájtot tud tárolni A memória egy része, amely a bemeneti vagy a kimeneti adatok tárolóterületeként szolgál. 148/127

128 Teszt 5. Melyik módszerrel kell megnyitni a létező myfile.txt fájl, úgy, hogy karaktereket tudjunk a végéhez hozzáírni? FileWriter fw = new FileWriter("myFile.txt"); FileWriter fw = new FileWriter("myFile.txt", true); FileWriter fw = new FileWriter("myFile.txt", false); FileWriter fw = new FileWriter("myFile.txt", FileWriter.APPEND); 148/128

129 Teszt 6. Mire szolgál a flush() metódus? Törli az összes adatot a megnyitott fájlból Törli az összes adatot a megadott stream-ből Inicializálja a kimeneti stream-et A puffer teljes tartalmát kiírja a megnyitott kimenetre 148/129

130 Teszt 7. A bemeneti vagy a kimeneti műveletek biztonságosabbak? A bemeneti A kimeneti Egyformán biztonságosak 148/130

131 Teszt 8. Az abc.txt fájlban csak egyetlen szó van, ezt kell beolvasni. Keresse meg, és javítsa ki a programban lévő hibákat! import java.nio.*; public class ABC { public static void main(string[] args) { BufferedReader reader = new Reader(new FileReader("abc.txt")); reader.open(); System.out.println(reader.readLine()); reader.close(); } } /131

132 Teszt 9. A readline() metódus milyen típusú adattal tér vissza? A megnyitott fájl típusától függően lehet char[ ] vagy byte[ ] char[ ] byte[ ] String byte int 148/132

133 Teszt 10. Mi történik, ha olvasáskor a readline() metódus eléri a fájl végét? Kivételt dob: EndOfFileException Visszaad egy üres stringet: "" Visszaad a nulla értéket: 0 Visszaad egy null értéket Mivel nincs több adat, leáll a beolvasó ciklus Kivételt dob: NoMoreDataException 148/133

134 Teszt 11. A FileReader osztály segítségével be lehet olvasni, és a képernyőn megjeleníteni egy Java bájtkódot tartalmazó fájl (.class) tartalmát? Nem, a bájtkód csak végrehajtható, nem olvasható Nem, a bájtkód fájl karakterként nem értelmezhető kódokat tartalmaz Igen, tetszőleges fájl beolvasható a FileReader-rel Csak akkor, ha a fájlt ugyanazzal a virtuális géppel olvassuk, amivel létrehozták 148/134

135 Teszt 12. Melyik módszerrel kell megnyitni a létező mydata.dat fájl, úgy, hogy a létező tartalmát felülírjuk? FileOutputStream fos = new FileOutputStream( "mydata.dat", true ) FileOutputStream fos = new FileOutputStream( "mydata.dat") DataOutputStream dos = new DataOutputStream( "mydata.dat" ) FileOutputStream fos = new FileOutputStream( new BufferedOutputStream( "mydata.dat") ) 148/135

136 Teszt 13. Egy program 10 darab int értéket ír egy fájlba (FileOutputStream). Hány bájt lesz a fájl mérete? A kiírásra kerülő számok értékétől (nagyságától) függ! /136

137 Teszt 14. Melyik metódussal lehet beolvasni egy DataInputStreamből egy int értéket? ReadInt() ReadInteger() readint() read() (int)readdata() 148/137

138 Teszt 15. A bináris fájlok írása és olvasása gyorsabb vagy lassabb a karakter szervezésű fájlokénál? Lassabb, mivel a primitív adatok több memóriát igényelnek a karaktereknél. Lassabb, mivel a primitív adatokat az IO műveletek végrehajtásakor karakterekké kell alakítani. Gyorsabb, mivel a bináris adatok nem használnak puffert. Gyorsabb, mivel a bináris adatok rövidebbek, mint a karakteresek, és nem igényelnek semmiféle átalakítást. 148/138

139 Teszt 16. Lehetséges a Java nyelv segítségével úgy lemásolni egy fájlt, hogy nem tudjuk a benne lévő adatok formátumát? Nem, a másoláshoz muszáj ismernünk a fájlban lévő bájtok formátumát. Nem, muszáj legalább a fájl fejlécében lévő adatokat ismerni a másoláshoz. Igen, de csak akkor működik a másolás helyesen, ha az első adat formátuma megegyezik az összes többi adat formátumával. Igen, a bájtról bájtra végrehajtott másolás működik tetszőleges típusú fájlra. 148/139

140 Teszt 17. Melyik csomagban van a File osztály? java.util.io java.io java.io.file javax.nio java.nio 148/140

141 Teszt 18. A Java könyvtárban állva, szeretnénk fizikailag létrehozni az aaa.txt fájlt. A kódot megírtuk, de hibás. Javítsa ki a hibákat! c:\program\java\aaa\bbb\aaa.txt import java.util.io.*; public class FKP { public static void main(string args[]) throw Exception{ File nf = new File("\aaa\bbb", "aaa.txt"); nf.create(); } } /141

142 Teszt 19. Melyik metódus segítségével tudjuk megállapítani, hogy egy file létezik-e? isfile() isdirectory() exists() list() created() 148/142

143 Teszt 20. Melyik metódussal készítünk egy új könyvtárat? mkdir() mkdirectory() makedirectory() Directory.new() Directory.make() 148/143

144 Teszt 21. Melyik metódussal tudunk letörölni egy fájlt a fájlrendszerből? remove() delete() erase() terminate() drop() 148/144

145 Teszt 22. Melyik módszerrel alakítható át egy File objektum Path objektummá? File file = new File("C:\\proba.txt"); Path path; path = file; path = file.topath(); path = file.tofile(); path = new Path(file.getFile()); path = file.tostring(); 148/145

146 Teszt 23. Melyik módszer helyes az aaa.txt nevű path objektum létrehozására, mely az aktuális könyvtár alatti, aaa nevű könyvtárba kerül? FileSystem fs = FileSystems.getDefault(); Path path = fs.getpath("aaa\\aaa.txt"); Path path = Paths.get("aaa\\aaa.txt"); Path path = Paths.get("aaa", "aaa.txt"); File f = new File("aaa\\aaa.txt"); Path path4 = f.topath(); 148/146

147 Teszt 24. Adott az alábbi fájl. Milyen típusú eredményt, és milyen értéket ad vissza a getname(1) metódus?? Path path = Paths.get("c:/aaa/bbb/abc.txt");??? = path.getname(1); Eredmény típusa: String char[ ] Path boolean Eredmény értéke: aaa c:\aaa bbb c:\aaa\bbb.txt 148/147

148 Teszt 25. Hogyan lehet meghatározni egy fájlrendszerbeli fájl méretét? Path p = Paths.get("aaa\\abc.txt"); p.size(); p.getsize(); p.length(); File(p).size(); Files.size(p); 148/148

149 VÉGE VÉGE 148/149