Съществуват голямо количество (дори прекалено много) класове за реализация на входно-изходните операции. Класовете най-общо могат да се разделят на две групи - класове поддържащи стария подход въведен  Java 1.0, базиран на  потоци от байтове и новия подход въведен от  Java 1.1 базиран  на unicode символи.
 

Класове за четене и запис върху физически носители (ниско ниво)

• int read(), който връща като резултата следващият байт в потока или-1 ако е достигнат края на потока. Информацията се съхранява в младшият байт на полученото цяло число;
• int read(byte[ ] b), който чете от потока най-много  b.length байта, които се поместват в масива  b. Връща реалният брой прочетени байтове или  -1 ако е достигнат края на потока;
• int read(byte[ ] b, int offset, int len), аналогичен на предходния метод с разликата, че съхраняването на прочетения резултата започва от индекс  offset и се прочитат най-много len байта.

методите за записване са:

• void write(int b), който позволява записа на младшият байт на b в потока;
• void write (byte[ ] b), който записва в потока b.length байта от масива;
• void write (byte[ ] b, int offset, int len), записва len байта от b започвайки от индекс  offset.

 Повечето класове които работят с потоци от символи са производни на един от абстрактните класове Reader и Writer. Методите, които могат да се използват върху такива потоци са много подобни на предишните, като само типът на прочетените данни е различен:

• int read(), който връща следващият символ в потока или -1 ако е достигнат края на потока. Символът се съхранява в двата младши байта на връщаното цяло число.
• int read(char[ ] b), който прочита от потока най-много  b.length символа, които се разполагат в масива b. Връща се реалният брой прочетени символи или -1 ако е достигнат края на потока;
• int read(char[ ] b, int offset, int len), подобен на предния, само че символите се поместват от индекс offset и се прочитат не повече от len символа.

Методите за запис са:

• void write(int b), който позволява записа на символът от младшите байтове на b в потока;
• void write (char[ ] b), който записва в потока  b.length символа записани е масива;
• void write (char[ ] b, int offset, int len), записва  len символа от b започвайки от индекс offset.

Класове за четене и запис (високо ниво, филтри)

Филтърът представлява поток, който обвива друг поток. Филтърът обработва данните преди да ги предаде. Той може да ги помести в буфер, да ги кодира ...

Четене от стандартния потоков вход

Четене от стандартния потоков вход (втори начин) - клас Scanner

Класът Scanner се намира в пакета util и осигурява прости средства за четене и преобразуване до примитивни типове данни информация от файл включително и от стандартния вход(System.in) .

Класът анализира и разделя входната информация на единици (tokens), като използва разграничител, който може да се променя но подразбиране е празен интервал.

Някои методи на класа:

Scanner

new Scanner(System.in)  //конструктор

Пример:

•  с малък файл (например http://ff.tu-sofia.bg/JavaAv/io/bback.gif )
•  с голям файл (например http://ff.tu-sofia.bg/media/rd14.jpg )
                           

exemple

import java.io.*;    public class ByteCopy {       public static void main(String arg[]) {          int bt;          try {             System.out.print("file to be copied:");             BufferedReader stdin = new BufferedReader(new  InputStreamReader(System.in));             String s =stdin.readLine();             System.out.print("new file: ");                        String sn= stdin.readLine();                          System.out.println("copy the file "+s+" in the file "+sn);                          FileInputStream fi = new FileInputStream(s);             FileOutputStream fo = new FileOutputStream(sn);             while((bt= fi.read())!=-1)fo.write(bt);             stdin.close();             fi.close();             fo.close();             System.out.println("created");          }          catch(IOException e) {          System.out.println("Error:"+e);;       }    } }

Забележка: FileNotFoundException наследява IOException

Забележки:

Класът "BufferedReader"  използва буфер за четене и позволява използването на "readLine()" 

Класът File

Информация за параметрите на файл
 

Пример

При стартиране с: java FileInfo FileInfo.java

import java.io.*; import java.util.*; /**print  the file charcteristics */ public class FileInfo{    public static void main(String args[]) {       if(args.length == 0){          System.out.println(                 "Usage FileInfo <FilePath> ");          return;       }       File f = new File(args[0]);       System.out.println(             " Abs path: " + f.getAbsolutePath() +             "\n write: " + f.canWrite() +             "\n read: " + f.canRead() +             "\n Name: " + f.getName() +             "\n Length: " + f.length() +             "\n Parent " + f.getParent() +             "\n Path: " + f.getPath() +             "\n Modif: " +                              new Date(f.lastModified()));       if(f.isFile())             System.out.println("fichier");       else if(f.isDirectory())             System.out.println("repertoire");    } }

Abs path: E:\My_Documents\JAVA\CoursJava(my)\io\FileInfo.java  write: true  read: true  Name: FileInfo.java  Length: 855  Parent null  Path: FileInfo.java  Modif: Tue May 14 10:30:44 GMT+03:00 2002 fichier

 

Създаване, преименуване и изтриване на файлове

Устойчивост (Persistence) на обектите. Сериализация на обекти

Сериализация - запис на обекти в даден поток 

Сериализацията се използва за запазване на обектите (persist) във файл, база от данни, мрежа, друг процес или друга система. Сериализацията преобразува обектите в подреден, последователен поток от байтове ( "flattening") .  Този поток може да бъде прочетен по-късно за реконструиране на оригиналния обект (deserialization).

Сериализацият не се извършва за  transient или static полета. Маркирането на полето   transient не позволява записването му в потока и възстановяването му при десериализация.  Използва се за маркиране на временни променливи или променливи съдъжащи локална информация като времеви данни или идентификатори на процеси.

Само обекти които наследяват  java.io.Serializable  интерфейс могат дъдат сериализирани.

• Интерфейсът Serializable не притежава методи или полета (Marker Interface)

Класът ObjectOutputStream
        клас от пакетът java.io - съдържа методи за "сериализация" на обекти,масиви и базови типове.
        важни методи:
             writeObject()                    //записва обектите
             defaultWriteObject()        //викан от writeObject() за запис на компоненти

Класът ObjectInputStream
        клас от пакетът java.io - съдържа методи за "де-сериализация" на обекти,масиви и базови типове.
        важни методи:
             readObject()                    //чете обектите
             defaultReadObject()        //викан от readObject() за четене на компоненти

Всички методи могат да предизвикат IOException
 
 Информация запазвана при сериализацията - необходимата за реконструиране на състоянието на обекта
    - Запазват се само не-статичните данни
    - Методите не са част от тази информация
    - Запазва се информация за класа
    - Не се интересува от видимостта на компонентите

ObjectInputStream ois = new ObjectInputStream (new FileInputStream ("save.ser"));
ObjectOutputStream oos =  new ObjectOutputStream (new FileOutputStream ("save.ser"));

Пример 

import java.io.*;

public class StudRd {
         public static void main(String[] arg)throws
                       IOException,ClassNotFoundException{

                ObjectInputStream ois = null;
                StudentSr s;
                int n=0, nf=0;
                try{
                      ois = new ObjectInputStream (new FileInputStream ("save.ser"));

                      for(;;){
                            s= (StudentSr)ois.readObject();
                            n++;
                            if(average(s)>=4){
                                   System.out.print(""+s);
                                   System.out.println("\thas average "+ average(s));
                                   nf++;
                            }
                      }
                }
                catch(EOFException ex){
                      System.out.println("printed "+nf+" students, found total "+n+" students");
                }
                finally{
                      ois.close();
                }
         }
         public static double average(StudentSr s){
                double sum;
                int i;
                for(sum=i=0;i<s.notes.length;i++){
                      sum+=s.notes[i];
                }
                return sum/s.notes.length;
         }
}

Резултат:

NIO2, канали,  файлове с директен достъп

 Въведен в Java 7  за да замести клса File. Различен за различни операционни системи. Не е задължително пътят реално да съществува.

Създаване:

Path path = Paths.get("Test.txt");                         // в текущата директория
Path path = Paths.get("D:\\data\\Test.txt");            // Windows
Path path = Paths.get("/home/data/Test.txt");            //  Unix

Синттаксически операции - Пример 

• позиция - мястото където се чете или пише
  public final int position( )
  public final Buffer position(int newPosition)
  
• капацитет - максимален брой елементи
  public final int capacity( )
  
• граница - последната възможна позиция 
  public final int limit( )
  public final Buffer limit(int newLimit)
  
• маркер - за запомняне на дадена позиция
  public final Buffer mark( )  - запомняне на текуща позиция
  public final Buffer reset( ) - текущата позиция става равна на  маркера

import java.io.*;
import java.nio.*;
import java.nio.channels.SeekableByteChannel;
import java.nio.charset.Charset;
import java.nio.file.*;
import java.util.EnumSet;

public class RafRead {
    public static void main(String[] args) {
        int bufLen=5;
        Path path = Paths.get("Test.txt");
        ByteBuffer buf = ByteBuffer.allocate(bufLen);
        String encoding = System.getProperty("file.encoding");
        try (SeekableByteChannel sbc = (Files.newByteChannel(
                path, EnumSet.of(StandardOpenOption.READ)))) {
            System.out.println("the size of the file is "+sbc.size());
            sbc.position(0);
            System.out.println("\nReading "+bufLen+" character from position: "
                    + sbc.position());
            do{
                sbc.read(buf);
            }while(buf.hasRemaining());
            buf.flip();
            System.out.print(Charset.forName(encoding).decode(buf));
            buf.rewind();
            // позициониране в средата
            sbc.position(sbc.size() / 2);
            System.out.println("\nReading "+bufLen+" character from position: "
                    + sbc.position());
            do{
                sbc.read(buf);
            }while(buf.hasRemaining());
            buf.flip();
            System.out.print(Charset.forName(encoding).decode(buf));
            buf.rewind();
            // позициониране в края
            sbc.position(sbc.size() - bufLen);
            System.out.println("\nReading "+bufLen+" character from position: "
                    + sbc.position());
            do{
                sbc.read(buf);
            }while(buf.hasRemaining());
            buf.flip();
            System.out.print(Charset.forName(encoding).decode(buf));
            buf.clear();
        } catch (IOException ex) {
            System.err.println(ex);
        }
    }
}

Примера чете първите 10 байта от файла  Test.txt и ги записва в края на файла.

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SeekableByteChannel;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.EnumSet;
public class RafRW {
    public static void main(String[] args) {
        Path path = Paths.get("Test.txt");
        ByteBuffer bf = ByteBuffer.allocate(10);  
        try (SeekableByteChannel sbc = (Files.newByteChannel(path,
                EnumSet.of(StandardOpenOption.READ, StandardOpenOption.WRITE)))) {
          
            sbc.position(0);
            do {
                sbc.read(bf);
            } while (bf.hasRemaining());
            bf.flip();
            sbc.position(sbc.size());
            while (bf.hasRemaining()) {
                sbc.write(bf);
            }
            bf.clear();
        } catch (IOException ex) {
            System.err.println(ex);
        }
    }
}