为了账号安全,请及时绑定邮箱和手机立即绑定

文件传输基础——Java IO流

难度入门
时长 2小时 0分
学习人数
综合评分9.67
669人评价 查看评价
9.9 内容实用
9.6 简洁易懂
9.5 逻辑清晰
  • 文件流字节数组
    查看全部
  • 文件流输入
    查看全部
  • 字节流
    查看全部
  • https://img1.sycdn.imooc.com//5bb86ab000014fdf10810484.jpg

    随即对文件进行操作,但不能对文件内容进行改变。

    查看全部
  • /*
    BufferedOutputStream/BufferedInputStream:
    这两个流类为IO提供了带缓冲区操作,一般打开文件进行写入或读取操作时,都会加上缓冲,这种流模式提高了IO的性能;
    从应用程序中把数据放入文件,相当于把一缸水倒入到另一缸中
    FileOutputStream -->write()方法相当于一滴一滴地把水“转移”过去
    DataOutputStream -->writeXxx()方法方便些,相当于一瓢一瓢的把水“转移”过去
    BufferedOutputStream -->write()方法更方便,相当于一瓢一瓢先放入桶中,再从桶中倒入另一个缸中
     */
    public class IOUtilTest4 {
        public static void main(String[] args) throws IOException {
            try {
                long start = System.currentTimeMillis();
    //            IOUtil.copyFileByByte(new File("D:\\ceshi\\word\\AdminLoginAction.java"),
    //                   new File("D:\\ceshi\\word\\tion1.txt"));//75毫秒
    //            IOUtil.copyFileBuffer(new File("D:\\ceshi\\word\\AdminLoginAction.java"),
    //                    new File("D:\\ceshi\\word\\tion2.txt"));//128毫秒
                IOUtil.copyFile(new File("D:\\ceshi\\word\\AdminLoginAction.java"),
                        new File("D:\\ceshi\\word\\tion3.txt"));//10毫秒
                long end = System.currentTimeMillis();
                System.out.println(end-start);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 利用带缓冲的字节流,进行文件的copy
     */
    public static void copyFileBuffer(File srcFile,File destFile) throws IOException{
        if (!srcFile.exists()){
            throw new IllegalArgumentException("文件"+srcFile+"不存在");
        }
        if (!srcFile.isFile()){
            throw new IllegalArgumentException(srcFile+"不是文件");
        }
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destFile));
        int c;
        while ((c = bis.read())!=-1){
            bos.write(c);
            bos.flush();//刷新缓冲区(必须写)
        }
        bis.close();
        bos.close();
    }
    /*
    单字节,不带缓冲进行文件拷贝
     */
    public static void copyFileByByte(File srcFile,File destFile) throws IOException{
        if (!srcFile.exists()){
            throw new IllegalArgumentException("文件"+srcFile+"不存在");
        }
        if (!srcFile.isFile()){
            throw new IllegalArgumentException(srcFile+"不是文件");
        }
        FileInputStream in = new FileInputStream(srcFile);
        FileOutputStream out = new FileOutputStream(destFile);
        int c;
        while ((c = in.read())!=-1){
            out.write(c);
            out.flush();//刷新缓冲区
        }
        in.close();
        out.close();
    }


    查看全部
    1 采集 收起 来源:字节缓冲流

    2018-09-08

  • 写
    /**
     * 7)DataOutputStream/DataInputStream
     * 对“流”功能的扩展,可以更加方便的读取int,long,字符等类型数据
     * DataOutputStream的常用方法:writeInt()/writeDouble()/writeUTF()
     */
    public class DosDemo {
        public static void main(String[] args) throws IOException {
            String file = "demo/dos.dat";
            DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));
            dos.writeInt(10);
            dos.writeInt(-10);
            dos.writeLong(10l);
            dos.writeDouble(10.5);
            //采用utf-8编码写出
            dos.writeUTF("中国");
            //采用utf-16be编码写出
            dos.close();
            IOUtil.printHex(file);
        }
    }
    读
    public class DisDemo {
        public static void main(String[] args) throws IOException {
            String file = "demo/dos.dat";
            IOUtil.printHex(file);
            DataInputStream dis = new DataInputStream(new FileInputStream(file));
            int i = dis.readInt();
            System.out.println(i);
            i = dis.readInt();
            System.out.println(i);
            long l = dis.readLong();
            System.out.println(l);
            double d = dis.readDouble();
            System.out.println(d);
            String s = dis.readUTF();
            System.out.println(s);
            dis.close();
        }
    }


    查看全部
  • /**
     * FileOutputStream实现了向文件中写出byte数据的方法
     */
    public class FileOutDemo {
        public static void main(String[] args) throws IOException {
            //如果该文件不存在,则直接创建;如果存在,则追加内容
    //        FileOutputStream out = new FileOutputStream("demo/out.dat",true);
            //如果该文件不存在,则直接创建;如果存在,则删除后创建
            FileOutputStream out = new FileOutputStream("demo/out.dat");
            out.write('A');//写出A的低八位
            out.write('B');//写出B的低八位
            int a = 10;//write只能写八位,那么写一个int就需要四次,每次八位
            out.write(a>>>24);
            out.write(a>>>16);
            out.write(a>>>8);
            out.write(a);
            byte[] utf = "中国".getBytes("utf-8");
            out.write(utf);
            out.close();
            //把写入的内容打印出来
            IOUtil.printHex("demo/out.dat");
    
        }
    }
    
    //copy文件
    public class IOUtilTest3 {
        public static void main(String[] args){
            try {
                IOUtil.copyFile(new File("D:\\ceshi\\word\\nihao.txt"),
                        new File("D:\\ceshi\\word\\nihao1.txt"));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public class IOUtil {
        public static void copyFile(File srcFile,File destFile) throws IOException{
            if (!srcFile.exists()){
                throw new IllegalArgumentException("文件"+srcFile+"不存在");
        }
            if (!srcFile.isFile()){
                throw new IllegalArgumentException(srcFile+"不是文件");
        }
            FileInputStream in = new FileInputStream(srcFile);
            FileOutputStream out = new FileOutputStream(destFile);
            byte[] buf = new byte[8*1024];
            int b;
            while ((b = in.read(buf,0,buf.length))!=-1){
                out.write(buf,0,b);
                out.flush();//最好加上
            }
            in.close();
            out.close();
        }
    }

        

    查看全部
  • import java.io.IOException;
    public class IOUtilTest1 {
        public static void main(String[] args){
            try {
                IOUtil.printHex("D:\\ceshi\\word\\AdminLoginAction.java");
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    /**
     * IO流(输入流、输出流)
     * 字节流、字符流
     * 1、字节流
     * 1)InputStream、OutputStream
     * InputStream抽象了应用程序读取数据的方式
     * OutputStream抽象了应用程序写出数据的方式
     * 2)EOF = End 读到-1就读到结尾
     * 3)输入流基本方法:
     * int b = in.read();读取一个字节无符号填充到int的低八位,-1是EOF
     * in.read(byte[] buf)//读取数据填充到字节数组buf
     * in.read(byte[] buf,int start,int size)//读取数据到字节数组buf,从buf的strat位置开始存放size长度的数据
     * 4)输出流基本方法:
     * out.write(int b)//写出一个byte到流,b的低8位
     * out.write(byte[] buf)//将buf字节数组都写入到流
     * out.write(byte[] buf,int start,int size)//字节数组buf从start位置开始写size长度的字节到流
     * 5)FileInputStream(继承了InputStream)-->具体实现了在文件上读取数据
     */
    public class IOUtil {
        /*
        读取指定文件内容,按照16进制输出
        每10个byte换行
         */
        public static void printHex(String fileName) throws IOException {
            //把文件作为字节流进行读操作
            FileInputStream in = new FileInputStream(fileName);
            int b;
            int i = 1;
            while((b = in.read())!=1){
                if (b <= 0xf){
                    //单位数前面补0
                    System.out.println("0");
                }
                //将整形b转换为16进制表示的字符串
                System.out.println(Integer.toHexString(b)+" ");//
                if (i++%10==0){
                    System.out.println();
                }
            }
            //io操作最后一定要关闭
            in.close();
        }
    }


    查看全部
  • /**
     * RandomAccessFile是Java提供的对文件内容的访问既可以读文件也可以写文件;
     * RandomAccessFile支持随机访问文件可以访问文件的任意位置
     * 1Java文件模型在硬盘上的文件上是比byte byte byte存储的是数据的集合
     * 2打开文件有两种模式“rw”读写“r”只读
     * RandomAccessFile raf = new RandomAccessFile(file,"rw");
     * 文件指针打开文件时指针在开头pointer = 0
     * 3写方法raf.write(int)-->只写一个字节后8位同时指针指向下一个位置准备再次写入
     * 4读方法int b = raf.read()-->读一个字节
     * 5文件读写完成以后一定要关闭Oracle官方说明
     */
    public class RafDemo {
        public static void main(String args[]) throws IOException {
            File demo = new File("demo");
            if(!demo.exists())
                demo.mkdir();
            File file = new File(demo,"raf.dat");
            if (!file.exists())
                file.createNewFile();
            RandomAccessFile raf = new RandomAccessFile(file,"rw");
            //指针的位置
            System.out.println(raf.getFilePointer());//0
            raf.write('A');//只写了一个字节(只会写进去A2个字节的后八位)
            System.out.println(raf.getFilePointer());//1
            raf.write('B');
            System.out.println(raf.getFilePointer());//2
            int i = 0x7fffffff;
            //用write方法每次只能写一个字节如果要把i写进去就需要写4次
            raf.write(i>>>24);//高8位
            raf.write(i>>>16);//高8位
            raf.write(i>>>8);//高8位
            raf.write(i);//高8位
            //也可以直接写一个int
            raf.writeInt(i);
            String s = "中";
            byte[] gbk = s.getBytes("gbk");
            raf.write(gbk);
            System.out.println(raf.length());//12
            //读文件必须把指针移到头部
            raf.seek(0);
            //一次性读取把文件中的内容都读到字节数组中
            byte[] buf = new byte[(int)raf.length()];
            raf.read(buf);
            System.out.println(Arrays.toString(buf));//[65, 66, 127, -1, -1, -1, 127, -1, -1, -1, -42, -48]
            String s1 = new String(buf,"gbk");
    //        System.out.println(s1);//AB中(因为中本身是utf-16be的编码除非单独包装否则就会有乱码)
            for (byte b:buf) {
                System.out.print(Integer.toHexString(b & 0xff)+" ");//41 42 7f ff ff ff 7f ff ff ff d6 d0 
            }
        }
    }


    查看全部
  • import java.io.File;
    import java.io.IOException;
    
    public class FileUtilTest1 {
        public static void main(String args[]) throws IOException {
            FileUtil.listDirectory(new File("D:\\360安全浏览器下载\\ceshi"));
        }
    }
    
    //列出File的一些常用操作,比如过滤,遍历
    public class FileUtil {
        /**
         * 列出指定目录下(包括其子目录)的所有文件
         * @param dir
         */
        public static void listDirectory(File dir) throws IOException {
            if (!dir.exists()){
                throw new IllegalArgumentException("目录:"+dir+"不存在");
            }
            if (!dir.isDirectory()){
                throw new IllegalArgumentException(dir+"不是目录");
            }
    /*
            String[] filenames = dir.list();//返回字符串数组
            for (String string : filenames){
                //列出该目录下直接的(第一层)文件和目录的名称
                System.out.println(string);
                //列出该目录下直接的(第一层)文件和目录,包括父路径
                System.out.println(dir+"\\"+string);
            }
    */
            //如果要遍历子目录下的内容就需要构造File对象做递归操作,File提供了直接返回File对象
            File[] files = dir.listFiles();//返回的是直接的子目录(文件)的抽象
           //并不会递归
    //        for (File file : files){
    //            //列出该目录下直接的(第一层)文件和目录,包括父路径
    //            System.out.println(file);
    //        }
    
            //列出该目录下所有的文件
            if (files != null && files.length > 0){
                for (File file : files){
                    if (file.isDirectory()){
                        //递归
                        listDirectory(file);
                    }else {
                        System.out.println(file);
                    }
                }
            }
        }
    }


    查看全部
    1 采集 收起 来源:遍历目录

    2018-09-07

  • public class EncodeDemo {
        public static void main(String args[]) throws Exception{
            String s = "慕课Abc";
            byte[] byte1 = s.getBytes();//转换成字节序列用的是项目默认的编码gbk
            for (byte b:byte1){
                //把字节(转换成int)以16进制的方式显示(& 0xff可以把前面的0去掉)
                System.out.print(Integer.toHexString(b & 0xff)+" ");
            }
            System.out.println();
            //gbk编码中文占两个字节,英文占1个字节
            byte[] byte2 = s.getBytes("gbk");
            for (byte b:byte2){
                //把字节(转换成int)以16进制的方式显示(& 0xff可以把前面的0去掉)
                System.out.print(Integer.toHexString(b & 0xff)+" ");
            }
            System.out.println();
            //utf-8编码中文占3个字节,英文占1个字节
            byte[] byte3 = s.getBytes("utf-8");
            for (byte b:byte3){
                //把字节(转换成int)以16进制的方式显示(& 0xff可以把前面的0去掉)
                System.out.print(Integer.toHexString(b & 0xff)+" ");
            }
            System.out.println();
            //java默认是utf-16be编码,中文占2个字节,英文占2个字节
            byte[] byte4 = s.getBytes("utf-16be");
            for (byte b:byte4){
                //把字节(转换成int)以16进制的方式显示(& 0xff可以把前面的0去掉)
                System.out.print(Integer.toHexString(b & 0xff)+" ");
            }
            System.out.println();
            /*
            当字节序列是某种编码时,这个时候想把字节序列变成字符串,
            也需要这种编码方式,否则会出现乱码
             */
            String str1 = new String(byte4);//会使用项目默认的编码
            System.out.println(str1);
            System.out.println();
            String str2 = new String(byte4,"utf-16be");//会使用项目默认的编码
            System.out.println(str2);
        }
    }


    查看全部
    0 采集 收起 来源:文件的编码

    2018-09-07

  • import java.io.File;
    import java.io.IOException;
    /*
    java.io.用于表示文件(目录)
    File类只用于表示文件(目录)的信息(大小,名称等),不能用于文件内容的访问
     */
    public class FileDemo {
        public static void main(String args[])  {
            //了解构造函数的情况   查帮助
            File file1 = new File("D:\\360安全浏览器下载\\s");
            //File.separator设置分隔符
    //        File file = new File("e:"+File.separator);
    //        System.out.println(f.exists());//判断文件(目录是否存在)
            //判断文件(目录是否存在),不存在则直接创建
            if (!file1.exists())
                //创建目录
                file1.mkdir();
    //        //创建多级目录
    //            file1.mkdirs();
            else
                file1.delete();
            //判断是否是一个文件
            System.out.println(file1.isFile());
            //判断是否是一个目录
            System.out.println(file1.isDirectory());
    //        File file2 = new File("D:\\360安全浏览器下载\\日记1.txt");
            File file2 = new File("D:\\360安全浏览器下载","日记1.txt");
    
            if(!file2.exists()){
                try {
                    file2.createNewFile();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }else
                file2.delete();
    
            //file常用的API
            System.out.println(file2);//输出file2.toString的内容
            System.out.println(file2.getAbsolutePath());//输出路径D:\360安全浏览器下载\日记1.txt
            System.out.println(file2.getName());//日记1.txt
            System.out.println(file2.getParent());//输出父路径D:\360安全浏览器下载
            System.out.println(file2.getParentFile().getAbsolutePath());//输出父路径D:\360安全浏览器下载
        }
    }


    查看全部
  • RandomAccessFile

    查看全部
    1. FIleReader,不能添加编码,所以要用InputStreamReader,

    2. FileWriter 可以选择是否追加,而不是直接清除文本

    查看全部
  • 当父类实现序列化接口时,继承此父类的子类不必再进行序列接口的实现。

    但当父类实现序列化接口时,在主函数内序列化子类并反序列化输出时,父类的构造函数不会被调用。

    查看全部

举报

0/150
提交
取消
课程须知
亲,为了更好的学习本门课程,需要您对二进制的知识有所了解,还要熟悉Java的基本语法和面向对象的知识。
老师告诉你能学到什么?
1、了解文件编码。 2、能够对文件和目录进行管理操作。 3、能够应用字节流和字符流对文件进行读写操作。 4、能够对对象进行序列化和反序列化。

微信扫码,参与3人拼团

意见反馈 帮助中心 APP下载
官方微信
友情提示:

您好,此课程属于迁移课程,您已购买该课程,无需重复购买,感谢您对慕课网的支持!