Input / Output-Streams

Java eine Reihe von Möglichkeiten der dedizierten Eingang / Ausgang definiert, sind in der Verpackung angeordnet java.io

Eingabestrom: abstrakte Klasse: das Inputstream (Eingangsstrom von Bytes), Reader (Zeicheneingabestrom)

Ausgabeströme: abstrakte Klasse: das Outputstream (Ausgangsstrom von Bytes), Writer (Zeichenausgabestrom)

Read (); liest das nächste Byte von Daten aus dem Eingangsstrom. Return int Byte-Werte im Bereich von 0 bis 255, nicht verfügbar Byte Rückgabewert -1
read (byte [] b); Länge des Byte gelesen aus dem Eingangsstrom, und gibt die Anzahl der Bytes in der Form einer ganzen Zahl
mark (int readlimit), eine Markierung an der aktuellen Position des Eingabestroms platzieren, readlimit Dieser Parameter bestimmt die Anzahl von Bytes in dem Eingangsstrom vor dem Ausfall Position teilt ermöglicht das gelesene Tag
RESET (); return pointer den Eingang mit dem auf den aktuellen Markierung gemacht
(Long n) auslassen; n Bytes den Eingabestrom zu überspringen und liefert das aktuelle Bytes übersprungenen
markSupport (); wenn die aktuelle Strom Abstützungen Zeichen () / reset () wird wieder wahr
Close (); schlie Eingangsstrom im Zusammenhang mit dem Stream und gibt alle Systemressourcen
- Alle Methoden Nicht alle nur nützlich für bestimmte Unterklassen Inputinput Klassen definiert, wie skip (), Zeichen (), reset () Methoden unterstützt

Dateityp

File-Klasse java.io Paket ist das einzige Vertreter Plattendatei Objekt selbst
Es gibt drei Konstruktor
- neue Datei (String);
- neue Datei (String Vater, String Kind);
- neue Datei (File f, String Kind);

package IO;

import java.io.File;

public class FileTest {
    public static void main(String[] args) {
        //使用路径创建File对象
        //File file = new File(String pathname)
//        File file = new File("D:\\word.txt");
        File file = new File("word.txt");

        //使用父路径、子路径创建
        //File file = new File(String father, String child)
//        String fatherPath = "D:\\";
//        String childPath = "word2.txt";
//        File file2 = new File(fatherPath, childPath);

        //使用父路径对象、子路径创建
        //File file = new File(File f, String child)
//        childPath = "word3.txt";
//        File file = new File(file2.getParent(), childPath);
        if (!file.exists()) {
//            file.delete();  //删除文件
//            System.out.println("文件已删除");
        } else {
            try {
                file.createNewFile();  //创建文件
                System.out.println("文件已创建");
                String name = file.getName();  //获取文件名称
                long length = file.length();  //获取文件长度
                boolean hidden = file.isHidden(); //判断是否是隐藏文件
                System.out.println("文件名称：" + name);
                System.out.println("文件长度：" + length);
                System.out.println("是否是隐藏文件：" + hidden);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

Datei-Eingabe / Ausgabe-Streams

Fileinputstream und Outputstream-Klasse
- Mangel: nur diese zwei Klassen liefert ein Verfahren zum Lesen oder Byte-Array. Da die Zeichen zwei Bytes in der Datei zu besetzen, einen Byte-Strom verwenden, um schlecht verstümmelt, diesmal mit einem Zeichenstrom zu lesen kann dieses Phänomen vermeiden
Filereader und Filewriter Klasse

//FileInputStream与FileOutputStream类
package IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileInputStreamFileOutputStream {
    public static void main(String[] agrs) {
        File file = new File("word.txt");

        //没有文件就创建
        if (file.exists()) {
            System.out.println("存在文件" + file.getPath());
        } else {
            try {
                file.createNewFile();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        //写入字节流
        try {
            //创建FileOutputStream对象
            FileOutputStream outputStream = new FileOutputStream(file);
            //创建byte数组
            byte[] buy = "我有一只小毛驴，我从来也不骑。".getBytes();
            outputStream.write(buy);  //将数组中的信息写入到文件中
            outputStream.close();  //将流关闭
        } catch (Exception e) {
            e.printStackTrace();
        }

        //读出字节流
        try {
            //创建FileInputStream对象
            FileInputStream fileInputStream = new FileInputStream(file);
            byte[] byt = new byte[1024];  //创建数组
            int len = fileInputStream.read(byt);
            //将文件中的信息输出
            System.out.println("文件中的信息是：" + new String(byt, 0, len));
            fileInputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Ungepufferte Eingangs- / Ausgangsströme

flush () Methode auch den Inhalt der Pufferzone im Fall der obligatorischen an die Peripheriepuffern geschrieben verwendet wird, nicht voll ist, wird der Prozess übliche refresh, flush () -Methode aufgerufen ist nur eine Unterklasse von Output Klasse den Cache verwendet wenn sie aktiv sind, rufen Sie close () -Methode, bevor das System heruntergefahren Strom wird auch die Informationen im Cache auf der Festplatte Datei aktualisieren

BufferedInputStream 和 BufferedOutputStream 类
- Puffer kann mit allen Input Klasse zu erreichen, um eine optimale Leistung des verpackt werden
- constructor
- BufferedInputStream (Inputstream in, int size); Größe 32-Byte-Standard
- BufferedOutputStream (Inputstream in, int size); Größe 32-Byte-Standard
BufferedReader 和 BufferedWriter 类
- Reader und Writer-Klassen sind vererbten Klasse
- gemeinsame Methode
- BufferedReader
  - Read (), ein einzelnes Zeichen gelesen
  - die readline (), eine Linie von Textzeichenfolge zu lesen, wird zurückgegeben. Keine Daten lesen return null
- BufferedWriter
  - write (String s, int off, int len); geschrieben Teil der Zeichenfolge
  - flush (); Cache-Räum-Stream
  - newLine (), eine Leitungstrennschreib

package IO;

import java.io.*;

public class students {
    public static void main(String[] agrs) {
        String[] contents = {"好久不见", "最近好吗", "常联系"};

        //写数据
        File file = new File("students.txt");  //创建File对象
        try {
            FileWriter fw = new FileWriter(file);  //创建FileWriter对象
            BufferedWriter bufw = new BufferedWriter(fw);
            for (int i = 0; i < contents.length; i++) {
                bufw.write(contents[i]);
                bufw.newLine();
            }
            bufw.close();
            fw.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

        //读数据
        try {
            FileReader fr = new FileReader(file);  //创建FileReader对象
            BufferedReader bufw = new BufferedReader(fr);
            String s = null;  //创建字符串对象
            int i = 0;
            //如果文件的文本行数不为null则进入循环
            while ((s = bufw.readLine()) != null) {
                i++;
                System.out.println("第" + i + "行：" + s);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

Dateneingabe- / Datenausgabeströme

Dataoutputstream Datainputstream-Klasse und Klassen, die eine maschinenunabhängige Art und Weise im wesentlichen des Java-Datentyp gelesen von dem darunterliegenden Eingabestrom ermöglichen
constructor
- Datainputstream (Inputstream in); Erstellt einen Datainputstream aus dem festgelegten Basiswert Input
- Dataoutputstream (OUTSTREAM out), um einen neuen Datenausgabestrom zu erzeugen, die Ausgangsstrom von Daten in die spezifizierten Basis
  - writebytes (String s); Da die Java-Unicode-Zeichencodierung Zwei-Byte ist, werden nur die niederwertigen Bytes Byte-Schreib
  - writeChars (String s), zwei Bytes geschrieben
  - writeUTF (String s), als die Länge in Bytes des codierten utf geschrieben

package IO;

import java.io.*;

public class Example {
    public static void main(String[] args) {
        File file = new File("hi.txt");
        try {
            FileOutputStream fs = new FileOutputStream(file);
            DataOutputStream ds = new DataOutputStream(fs);
            ds.writeUTF("使用writeUTF()方法写入数据");  //使用这个写，可以读出来
            ds.writeBytes("使用writeBytes()方法写入数据");
            ds.writeChars("使用writeChars()方法写入数据");
            ds.close();  //关闭流

            FileInputStream fis = new FileInputStream(file);
            DataInputStream dis = new DataInputStream(fis);
            System.out.println(dis.readUTF());
            dis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }


    }
}

ZIP Kompression Eingangs- / Ausgangsströme

Java-Klassen gebaut bieten eine sehr einfache Klasse zu verwenden, Kompression und ZipInputStream Klasse ZipOutputStream erreichen Dateien java.util.zip Verpackung / Dekompression

ZipOutputStream Klasse, kann die Datei in eine ZIP-Datei komprimiert
- Konstruktoren ZipOutputStream (Output out);
ZipInputStream Klasse lesen ZIP komprimierte Dateiformate, einschließlich komprimiert und unkomprimiert Eintrag Eintrag
- Konstruktoren ZipInputStream (Inputstream in);

//压缩文件
package IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class MyZip {
    private void zip(String zipFileName, File inputFile) throws Exception {
        //创建ZipOutputStream对象
        ZipOutputStream out = new ZipOutputStream(new FileOutputStream(zipFileName));
        zip(out, inputFile, "");  //调用方法
        System.out.println("Ziping...");  //输出信息
        out.close();  //关闭流
    }

    private void zip(ZipOutputStream out, File f, String base) throws Exception {
        if (f.isDirectory()) {
            File[] fl = f.listFiles();
//            if (base.length() != 0) {
//                out.putNextEntry(new ZipEntry(base + "\\")); //写入此目录的entry??
//            }
            for (int i = 0; i < fl.length; i++) {
                zip(out, fl[i], base + fl[i]);
            }
        } else {
            out.putNextEntry(new ZipEntry(base));  //创建新的进入点
            FileInputStream in = new FileInputStream(f);
            int b;
            System.out.println(base);
            while ((b = in.read()) != -1) {  //如果没有达到流的尾部
                out.write(b);                 //将自己写入当前ZIP条目
            }
            in.close();
        }
    }

    public static void main(String[] args) {
        MyZip book = new MyZip();
        try {
            book.zip("D:\\zi.zip", new File("src\\number"));
            System.out.println("done.");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

//解压缩
package IO;

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;

public class MyZip2 {
    public static void main(String[] args) {
        File file = new File("D:\\zi.zip");  //当前压缩文件
        try {
            ZipFile zipFile = new ZipFile(file);  //创建压缩文件对象
            ZipInputStream zin = new ZipInputStream(new FileInputStream(file)); //创建ZipInputStream对象
            ZipEntry entry = zin.getNextEntry();  //跳过根目录，获取下一个ZipEntry
            while (((entry = zin.getNextEntry()) != null)
                    && !entry.isDirectory()) {  //entry不为空，并不在同一目录下
                File tmp = new File("D:\\" + entry.getName());  //解压出的文件路径
                if (!tmp.exists()) {
                    tmp.getParentFile().mkdirs();  //创建文件父类文件夹路径
                    OutputStream os = new FileOutputStream(tmp);  //将文件目录中的文件放入输出流
                    InputStream in = zipFile.getInputStream(entry);  //用输入流读取压缩文件中制定目录中的文件
                    int count = 0;
                    while ((count = in.read()) != -1) {  //如果有输入流可以读取到数值
                        os.write(count);                 //输入流写入
                    }
                    os.close();  //关闭输出流
                    in.close();  //关闭输入流
                }
                zin.closeEntry();  //关闭当前entry
                System.out.println(entry.getName() + " unzip successfully.");
            }
            zin.close();  //关闭流

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Bingmous

Veröffentlicht 46 Originalarbeiten · erntete Lob 0 · Aufrufe 1021

Privatbrief Bedenken

Java vom Eintritt in das Master-Kapitel 15 I / O (Eingabe / Ausgabe)