java IO流 之 字节流

        File file=new File("E:\\test\\javaIo");
        
        System.out.println(file.isDirectory());//判断该文件是否是目录（如果该文件不存在也返回false）
        System.out.println(file.isFile());//判断文件是否是具体的文件
        System.out.println(file.exists());//判断文件是否存在
        System.out.println(file.mkdir());//创建目录  返回boolean类型
        System.out.println(file.delete());//删除文件或目录 返回boolean类型
        System.out.println(file.mkdirs());//创建多级目录  返回boolean类型
        
        File fileF=new File("E:\\test\\javaIo","1.txt");
        fileF.createNewFile();//创建文件
        fileF.delete();//删除文件
        
        System.out.println(file.getAbsolutePath());//获取文件的绝对路径   E:\test\javaIo
        System.out.println(file.getName());//获取文件名字     javaIo
        System.out.println(file.getParent());//获取父文件路径   E:\test
        System.out.println(file.getParentFile());//获取父文件对象

/**
     * 列出 指定目录下（包括子目录）的所有文件
     * @param file
     */
    public static void directoryList(File dir){
        if(!dir.exists()){
            throw new IllegalArgumentException("目录"+dir+"不存在");
        }
        if(!dir.isDirectory()){
            throw new IllegalArgumentException(dir+"不是目录");
        }
        //String[] file=dir.list(); //获取该目录下所有目录和文件的名字  （返回字符串数组）  
        File [] files=dir.listFiles();// 获取 该目录下所有目录和文件 的file对象
        if(files!=null && files.length>0){
            for (File file : files) {
                if(file.isDirectory()){
                    //如果是目录就做递归操作
                    directoryList(file);
                }else{
                    System.out.println(file.getName());
                }
            }
        }
    }

public abstract class InputStream implements Closeable {
    private static final int MAX_SKIP_BUFFER_SIZE = 2048;//最大缓冲区大小
　　//读取一个字节的数据，并且返回读到得数据，如果返回-1，则表示读到输入流的末尾
    public abstract int read() throws IOException;
　　//从输入流中读取一定量的字节，并将其存储在字节数组b中，返回实际读取的字节数，如果返回-1，则表示读到输入流的末尾
    public int read(byte b[]) throws IOException {
        return read(b, 0, b.length);
    }
   //将数据读入一个字节数组，同时返回读取的实际字节数，如果返回-1，则表示读到输入流的末尾。off指定在数组b中存放数据的起始偏移位置，len指定读取的最大字节数
    public int read(byte b[], int off, int len) throws IOException {
       
    }
　　//跳过和放弃此输入流中的 n 个数据字节。 
    public long skip(long n) throws IOException {
    
    }
　　//返回此输入流下一个方法调用可以不受阻塞地从此输入流读取或跳过的估计字节数。
    public int available() throws IOException {
        return 0;
    }
　　//关闭此输入流并释放与该流关联的所有系统资源。 
    public void close() throws IOException {}
   //在此输入流中标记当前的位置。 
    public synchronized void mark(int readlimit) {}
   //将此流重新定位到对此输入流最后调用 mark 方法时的位置。
    public synchronized void reset() throws IOException {
        throw new IOException("mark/reset not supported");
    }
　　//测试此输入流是否支持 mark 和 reset 方法。 
    public boolean markSupported() {
        return false;
    }
}

1     public static void bufferedInputStreamTest() throws IOException{
2         BufferedInputStream bis=new BufferedInputStream(new FileInputStream("E:\\javaTest\\5.txt"));
3         byte [] bytes=new byte[1024];
4         int len=0;
5         while((len=bis.read(bytes))!=-1){
6             System.out.println(new String(bytes,0,len));
7         }
8         bis.close();
9     }

　　　　　byte b = dis.readByte();
        short s = dis.readShort();
        int i = dis.readInt();
        long l = dis.readLong();
        float f = dis.readFloat();
        double d = dis.readDouble();
        char c = dis.readChar();
        boolean bb = dis.readBoolean();

public abstract class OutputStream implements Closeable, Flushable {
   //写入一个字节到stream中
    public abstract void write(int b) throws IOException;
    //把字节数组中所有数据写入到输出流中
    public void write(byte b[]) throws IOException {
        write(b, 0, b.length);
    }
    //把字节数据中从offset位置开始，length个字节的数据写入到输出流。
    public void write(byte b[], int off, int len) throws IOException {
       
    }
    //方法将所有写入到OutputStream的数据冲刷到相应的目标媒介中,即使所有数据都写入到了FileOutputStream，这些数据还是有可能保留在内存的缓冲区中。通过调用flush()方法，可以把缓冲区内的数据刷新到磁盘
    public void flush() throws IOException {
    }

    //结束数据写入时，需要关闭OutputStream
    public void close() throws IOException {
    }

}

    public static void bufferOutPutStreamTest() throws IOException{
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("E:\\javaTest\\5.txt"));
        bos.write("中".getBytes());
        bos.flush();
        bos.close();
    }

// 写数据了
        dos.writeByte(10);
        dos.writeShort(100);
        dos.writeInt(1000);
        dos.writeLong(10000);
        dos.writeFloat(12.34F);
        dos.writeDouble(12.56);
        dos.writeChar('a');
        dos.writeBoolean(true);

 1 public  static void readWriter() throws IOException{
 2         String readFileName="D:"+File.separator+"html"+File.separator+"1.txt";
 3         String writerFileName="D:"+File.separator+"html"+File.separator+"2.txt";
 4         InputStream is=new FileInputStream(new File(readFileName));//
 5         OutputStream out=new FileOutputStream(new File(writerFileName));
 6         byte [] b=new byte[1024];
 7         int len=0;
 8         while((len=is.read(b))!=-1){
 9             out.write(b, 0, len);
10         }
11         is.close();
12         out.close();
13     }

 1 public static void BufferFileCopy() throws IOException{
 2         BufferedInputStream bis=new BufferedInputStream(new FileInputStream("E:\\javaTest\\5.txt"));
 3         BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("E:\\javaTest\\6.txt"));
 4         byte[]bytes=new byte[1024];
 5         int len=0;
 6         while((len=bis.read(bytes))!=-1){
 7             bos.write(bytes, 0, len);
 8         }
 9         bos.flush();
10         bos.close();
11         bis.close();
12     }