精华内容
下载资源
问答
  • 从外部设备流向中央处理器的数据成为“输入”,反之成为“输出”。 字符和字节的主要区别:  1.字节读取的时候,读到一个字节就返回一个字节;字符使用了字节读到一个或多个字节(中文对应的字节...

    转载:https://www.cnblogs.com/xiohao/p/8997401.html

    流在Java中是指计算中流动的缓冲区。

    从外部设备流向中央处理器的数据流成为“输入流”,反之成为“输出流”。

    字符流和字节流的主要区别:

     1.字节流读取的时候,读到一个字节就返回一个字节;字符流使用了字节流读到一个或多个字节(中文对应的字节数是两个,在UTF-8码表中是3个字节)时。先去查指定的编码表,将查到的字符返回。

     2.字节流可以处理所有类型数据,如:图片,MP3,AVI视频文件,而字符流只能处理字符数据。只要是处理纯文本数据,就要优先考虑使用字符流,除此之外都用字节流。

    1.字节流:

    字节输入流类:FileInputStream、BufferedInputStream和DataInputStream

    FileInputStream:此类用于从本地文件系统中读取文件内容。

    构造方法:

    ·FileInputStream(File file):打开一个到实际文件的连接来创建一个FileInputStream,该文件通过文件系统中的File对象file指定。

    ·FileInputStream(String name):打开一个到实际文件的连接来创建一个FileInputStream,该文件通过文件系统中的路径名name指定。

    常用方法:

    ·int available():返回下一次对此输入流调用的方法不受阻塞地从此输入流读取(或跳过)的估计剩余字节数。

    ·void close():关闭此文件输入流并释放与该流关联的所有系统资源。

    BufferedInputStream:此类本身带有一个缓冲区,在读取数据时,先放到缓冲区中,可以减少对数据源的访问,提高运行的效率。

    构造方法:

    ·BufferedInputStream(InputStream in):创建一个BufferedInputStream并保存其参数,即输入流in,以便将来使用。

    ·BufferedInputStream(InputStream in,int size):创建一个具有指定缓冲区大小的BufferedInputStream并保存其参数,即输入流in,以便将来使用。

    常用方法:

    ·int available():返回下一次对此输入流调用的方法不受阻塞地从此输入流读取(或跳过)的估计剩余字节数。

    ·void close():关闭此输入流并释放与该流关联的所有系统资源。

    ·int read():从输入流中读取数据的下一个字节。

    ·int read(byte[] b,int off,int len):从此字节输入流中给定偏移量处开始将各字节读取到指定的byte数组中。

     DataInputStream:该类提供一些基于多字节读取方法,从而可以读取基本数据类型的数据。

    构造方法:

    ·DataInputStream(InputStream in):使用指定的底层InputStream创建一个DataInputStream。

    常用方法:

    ·int read(byte[] b):从包含的输入流中读取一定数量的字节,并将它们存储到缓冲区数组b中。

    ·int read(byte[] b,int off,int len):从包含的输入流中将最多len个字节读入一个byte数组中。

    字节输出流类:FileOutputStream、BufferedOutputStream和DataOutputStream

    FileOutputStream:此类用于从本地文件系统的文件中写入数据。

    构造方法:

    ·FileOutputStream(File file):创建一个向指定File对象表示的文件中写入数据的文件输出流。

    ·FileOutputStream(String name):创建一个向具有指定名称的文件中写入数据的输出文件流。

    常用方法:

    ·void close():关闭此文件输出流并释放与此流有关的所有系统资源。

    ·FileDescriptor getFD():返回与此流有关的文件描述符。

    ·void write(byte[] b):将b.length个字节从指定byte数组写入此文件输出流中。

    ·void write(byte[] b,int off,int len):将指定byte数组中从偏移量off开始的len个字节写入此文件输出流。

    ·void write(int b):将指定字节写入此文件输出流。

    BufferedOutputStream:此类本身带有一个缓冲区,在写入数据时,先放到缓冲区中,实现缓冲的数据流。

    构造方法:

    ·BufferedOutputStream(OutputStream out):创建一个新的缓冲输出流,来将数据写入指定的底层输入流。

    ·BufferedOutputStream(OutputStream out,int size):创建一个新的缓冲输出流,来将具有指定缓冲区大小的数据写入指定的底层输出流。

    常用方法:

    ·void flush():刷新此缓冲的输出流。

    ·void write(byte[] b,int off,int len):将指定byte数组中从偏移量off开始的len个字节写入此缓冲的输出流。

    ·void write(int b):将指定的字节写入此缓冲的输出流。

    DataOutputStream(OutputStream out):创建一个新的数据输出流,将数据写入指定基础输出流。

    常用方法:

    ·void flush():清空此数据输出流。

    ·int size():返回计数器written的当前值,即到目前为止写入此数据输出流的字节数。

    ·void write(byte[] b,int off,int len):将指定byte数组中从偏移量off开始的len个字节写入基础输出流。

    ·void write(int b):将指定字节(参数b的八个低位)写入基础输出流。

    2.字符流:

    FileReader:用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。

    构造方法:

    ·FileReader(File file):在给定从中读取数据的File的情况下创建一个新的FileReader。

    ·FileReader(String fileName):在给定从中读取数据的文件名的情况下创建一个新的FileReader。

    BufferedReader类是Reader类的子类,为Reader对象添加字符缓冲器,为数据输入分配内存存储空间,存取数据更为有效。

    构造方法:

    ·BufferedReader(Reader in):创建一个使用默认大小输入缓冲区的缓冲字符输入流。

    ·BufferedReader(Reader in,int sz):创建一个使用指定大小输入缓冲区的缓冲字符输入流。

    操作方法:

    ·void close():关闭该流并释放与之关联的所有资源。

    ·void mark(int readAheadLimit):标记流中的当前为止。

    ·boolean markSupported();判断此流是否支持mark()操作。

    ·int read():读取单个字符。

    ·int read(char[] cbuf,int off,int len):将字符读入数组的某一部分。

    ·String readLine():读取一个文本行。

    ·boolean ready():判断此流是否已准备好被读取。

    ·void reset():将流重置到最新的标记。

    ·long skip(long n):跳过字符。

    FileWriter:用来写入字符文件的便捷类,可用于写入字符流。

    构造方法:

    ·FileWriter(File file):根据给定的File对象构造一个FileWriter对象。

    ·FileWriter(String filename):根据给定的文件名构造一个FileWriter对象。

    BufferedWriter:将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。

     

     

    Java输入/输出流体系中常用的流分类(表内容来自java疯狂讲义)

    注:下表中带下划线的是抽象类,不能创建对象。粗体部分是节点流,其他就是常用的处理流。

    流分类 使用分类 字节输入流 字节输出流 字符输入流 字符输出流
      抽象基类 InputStream

    OutputStream

    Reader Writer
    节点流 访问文件 FileInputStream FileOutStream FileReader FileWriter
    访问数值 ByteArrayInputStream ByteArrayOutStream CharArrayReader CharArrayWriter
    访问管道 PipedInputStream PipedOutStream PipedReader PipedWriter
    访问字符串     StringReader StringWriter
    处理流 缓冲流 BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter
    转换流     InputStreamReader OutputStreamWriter
    对象流 ObjectInputStream ObjectOutputStream    
    抽象基类(过滤) FilterInputStream FilterOutputStream FilterReader FilterWriter
    打印流   PrintStream   PrintWriter
    推回输入流 PushbackInputStream   PushbackReader  
    特殊流 DataInputStream DataOutputStream    

     

     

    展开全文
  • 一文搞定Java的输入输出常见流

    千次阅读 多人点赞 2020-04-07 22:32:25
    多种分类方式: 一种方式是:按照的方向进行分类,以内存为参照物,往内存中去叫做输入(Input),或者叫做读(Read).往内存中出来叫做输出(Output),或者叫做写。 第二种:以读取数据方式的不同进行分类...

    前言:“如果你想要从未拥有过的东西,那么你必须做你从未做过的事。”
    你好,我是梦阳辰,感谢遇见,让我们一起学习起来吧!点赞再看,养成习惯,常用流,多看多练准没错!文章较长,建议收藏再看!

    在这里插入图片描述

    1.IO流分析

    • 什么是IO?
    • I:Input
    • O:Output
      通过IO可以完成对硬盘的读和写。
      在这里插入图片描述
    • IO流的分类。
      有多种分类方式:
    • 一种方式是:按照流的方向进行分类,以内存为参照物,往内存中去叫做输入(Input),或者叫做读(Read).往内存中出来叫做输出(Output),或者叫做写。
    • 第二种:以读取数据方式的不同进行分类:
      有的流是按照字节的方式读取数据。一次读取一个字节byte,等同于读取8个二进制。这种流是万能的,什么文件都可以读取,比如:文本,图片,视频…
      有的流是按照字符的方式读取数据的,一次读取一个字符,这种流是为了方便读取普通文本文件而存在的,这种流不能读取:图片,视频等文件,连word文件都不能读取。
      例如:假设文本文件file.txt,采用字符流的话:
      a中国bo张三
      第一次读:‘a’字符('a’字符在win系统中占用1个字节)
      第二次读:’中’字符('中‘字符在win系统中占用2个字节)
      总结列的分类:
      输入流 ,输出流。
      字节流,字符流。
    • Java中char字符占用两个字节,但系统中占一个字节。
      注意:Java中的IO流都已经写好了,我们要会用就可以了。主要研究怎么new流对象,调用哪个对象的哪个方法读,哪个方法写。

    2.常用的IO流

    Java中所有的流在:java.io.*;
    Java IO流的四大家族(都为抽象类):

    • java.io.InputStream 字节输入流
    • java.io.OutputStream 字节输出流
    • java.io.Reader 字符输入流。
    • java.io.Writer 字符输出流。
      Java中以Stream结尾的都是字节流,以Reader/Writer结尾的都是字符流。
    • 所有的流都是可关闭的,都有close()方法,流是一个管道,是内存和硬盘之间的管道,用完后一定要关闭,不然会浪费很多资源。
    • 所有的输出流:都实现了java.io.Flushiable接口,都是可刷新的,都有flush方法,输出流最后输出之后,一定要记得flush(),刷新一下,这个刷新表示将管道中剩余为输出的数据强行输出完(清空管道),刷新就是为了清空管道。如果没有flush()肯能会造成数据丢失。
    • java.io包下我们需要掌握的16个流:
      //文件
      java.io.FileInputStream
      java.io.FileOutputStream
      java.io.FileReader
      java.io.FileWriter
      //转换流:(将字节流转换成字符流)
      java.io.InputStreamReader
      java.io.OutputStreamWriter
      //缓存流
      java.io.BufferedReader
      java.io.BufferedWriter
      java.io.BufferedInputStream
      java.io.BufferedOutputStream
      数据流
      java.io.DataInputStream
      java.io.DataOutputStream
      标准流
      java.io.PrintWriter
      java.io.PrintStream
      对象流
      java.io.ObjectInputStream
      java.io.ObjectOutputStream

    3.FileInputStream

    • 文件字节输入流,万能的,任何类型的文件都可以采用这个流来读。
    • read()方法读取一个字节的数据,到文件末尾返回-1。
    public class FileInputStreamTest1 {
        public static void main(String[] args) {
    
    //创建文件字节输入流对象
            FileInputStream fis = null;
    
            {
                try {
                    fis = new FileInputStream("E:\\A/Cat.txt");//双斜杠代表一个斜杠或用反斜杠
                    while (true) {
                        int readData = fis.read();//读取到字节本身
                            if(readData==-1)
                                break;
                        System.out.println(readData);
                    }
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {//在finally语句块中确保流一定关闭
                    if (fis != null) {//关闭流的前提是,流不是空
                        try {
                            fis.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
    
    • read(byte[] t):一次最多读取t.length个字节,返回读取的数量,注意在数组中第二次读的数据,将第一次读的数据覆盖,第一次没有覆盖的数据还在数组中。如果一个都没有读取到将返回-1。减少内存和硬盘的交互。
      可以利用String类的转换方法,将byte数组转换成String.
    public class FileInputStreamTest2 {
        public static void main(String[] args) {
            FileInputStream fis = null;
            try {
                fis = new FileInputStream("Chapter1\\Team");
    //            准备一个byte数组
                byte[] bytes = new byte[4];
                int readCount =0;
                while ((readCount=fis.read(bytes))!=-1){
                    System.out.println(new String(bytes,0,readCount));//将数组转换成字符串
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(fis!=null){
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
    • IDEA默认的当前路径是工程project的根,不是模块。
    • available()方法:返回流当中剩余的没有读到的字节数。
    • skip()方法:跳过几个字节不读。
    public class FileInputStreamTest3 {
        public static void main(String[] args) {
            FileInputStream pis = null;
            try {
                pis = new FileInputStream("Chapter1\\Team");
               /* int readByte = pis.read();
    //            剩余的字节数量,其作用为...
                System.out.println(pis.available());
    //            作用
                byte[] bytes= new byte[pis.available()];
    //            不需要循环了,因为数组不能太大所以不适合大文件
                int readCount = pis.read(bytes);
                System.out.println(new String(bytes));*/
    //           skip跳过几个字节不读取
                pis.skip(3);
                System.out.println(pis.read());
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(pis != null){
                    try {
                        pis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    

    4.FileOutputStream

    • 文件字节输出流,负责写。
    • 从内存到硬盘
    • write(int b)方法。
    • write(byte[] b)方法。
    • write(byte[] b,int off,int len)方法。
    public class FileOutputStreamTest1 {
        public static void main(String[] args) {
            FileOutputStream fos = null;
            try {
    //            文件不存在会新建,将源文件清空再写入
    //            fos=new FileOutputStream("Chapter1\\Team");
    //            以追加的方式写入
                fos = new FileOutputStream("Chapter1\\Team",true);
                byte[] bytes = {97,98,99};
                String s ="我是一个中国人";
                byte[] aa= s.getBytes();//将字符串转换成byte[]数组
                fos.write(aa);
                fos.write(bytes);
    //            写部分
                fos.write(bytes,0,1);
    //            注意写完后要刷新
    
                fos.flush();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(fos!=null){
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    }
    

    5.通过Stream类实现文件复制

    使用FileInputStream+ FileOutputStream完成文件的拷贝。

    • 适用于任何文件。
    • 练习:
    public class Copy1 {
        public static void main(String[] args) {
            FileInputStream fis =null;
            FileOutputStream fos =null;
            try {
                fis = new FileInputStream("F:\\视频\\VID_20190425_125038.mp4");
                fos = new FileOutputStream("D:\\VID_20190425_125038.mp4");
    //            一边读一边写
                byte[] bytes = new byte[1024*1024];//一次最多1M
                int  readCount =0;
    //            读多少写多少
                while ((readCount=fis.read(bytes))!=-1){
                    fos.write(bytes,0,readCount);//写
                }
    //            记得刷新
                fos.flush();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            finally {
                if(fos!=null){
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(fis!=null){
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    

    6.FileReader

    • 文件字符输入流,只能读取普通文本。
    • 读取文本内容时,比较方便,快捷。
    • 操作跟FileInputStream类似,将byte数组,改为char数组即可,也可以用String的方法将其装换成字符串形式。

    7.FileWriter

    • 文件字符输出流,写。
    • 只能输出普通文本。
      例子:
      char[] chars = {’我‘,’是‘,'中’}
    • write(chars)
    • writer(chars,0,2);
    • writer("我是中国人“);
    • 不想被清空再创建输出流对象是,在文件名后面的第二个可填项,添加true)
    public class FileWriterTest1 {
        public static void main(String[] args) {
            FileWriter out = null;
            try {
                out = new FileWriter("file",true);
                out.write("我是中国人" + "哈哈");
            } catch (IOException e) {
                e.printStackTrace();
            }
            finally {
                if(out!=null){
                    try {
                        out.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    }
    
    • 通过Writer实现拷贝普通文件:操作跟Stream一样,只不过将byte数组改为Char数组。

    8.BufferedReader缓冲流

    • 带有缓冲区的字符输入流。
    • 使用这个流的时候不需要自定义char数组,或byte数组,自带缓冲。
    • readLine()方法:读一行。
    public class BufferedReaderTest1 {
        public static void main(String[] args)  {
            FileReader reader = null;
            try {
                reader = new FileReader("file");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            //当一个流的构造方法需要一个流的时候,这个被传进来的流叫做“节点流”。
            //外部负责包装的这个流,叫做:包装流,还有一个名字叫做:处理流
            //当前FileReader是节点流,BufferedReader流叫做包装流
            BufferedReader sc = new BufferedReader(reader);
            //对于包装流来说,只需要关闭外层流就行,里面的节点流会自动关闭
    //        readLine方法
            String s =null;
            while (true) {
                try {
                    if (!((s=sc.readLine())!=null)) break;
                } catch (IOException e) {
                    e.printStackTrace();
                }
                System.out.println(s);
            }
            try {
                sc.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    

    练习二:涉及转换流

    package Day1;
    
    
    import java.io.*;
    
    public class BufferedReaderTest2 {
        public static void main(String[] args) {
    
            FileInputStream in = null;
            BufferedReader ge=null;
            try {
                /*//字节流
                in = new FileInputStream("file");
                //        通过转换流转换,in是节点流,reader是包装流
                InputStreamReader reader = new InputStreamReader(in);
                // 这个构造方法只能传一个字符流,不能传字节流,reader是节点流
                 ge = new BufferedReader(reader);*/
                String line = null;
    //            将以上三个步骤合并
                ge= new BufferedReader(new InputStreamReader(new FileInputStream("file")));
                while((line=ge.readLine())!=null){
                    System.out.println(line);
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(ge!=null){
                    try {
                        ge.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    }
    
    

    9.DataInputStream和DataOutputStream数据流

    • DataOutputStream这个流可以将数据连同数据的类型一并写入文件。
    • 不是普通文档。
    • DateOutputStream写的文件,只能使用DataInputStream去读。并且度的时候需要提前知道写入的顺序。读的顺序要和写的顺序一致,才可以正常取出数量。
    package Day2;
    
    import javax.swing.*;
    import java.io.DataOutputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class DateInputStreamTest1 {
        public static void main(String[] args) {
    
            DataOutputStream dos = null;
    
            {
                try {
                    dos = new DataOutputStream(new FileOutputStream("Team"));
    //            写数据
                    byte b = 0;
                    short s = 300;
                    int i = 322;
                    long c = 455L;
                    double d = 3.4;
                    boolean sex = false;
                    char f = 'a';
    //            写,包括类型
                    dos.writeByte(b);
                    dos.writeShort(s);
                    dos.writeInt(i);
                    dos.writeLong(c);
                    dos.writeDouble(d);
                    dos.writeBoolean(sex);
                    dos.writeChar(f);
    //            刷新
                    dos.flush();
    
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    if (dos != null) {
                        try {
                            dos.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
    
    

    10.标准输出流PrintStream

    • 标准的字节输出流,默认输出流,默认输出到控制台。
    • 标准输出流不需要手动close关闭。
    • 存在节点流,和包装流。
    package Day2;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.PrintStream;
    
    public class PrintStreamTest1 {
        public static void main(String[] args) throws FileNotFoundException {
            System.out.println("Hello World!");
            PrintStream print = System.out;
            print.println("Oh my god!");
    //        可以改变标准输出流的方向
           /* System.gc();
            System.currentTimeMillis();
            PrintStream print  = System.out;
            System.exit(0);
            System.arraycopy()*/
    //       标准输出流指向file文件,不指向控制台
           PrintStream printStream=new PrintStream(new FileOutputStream("file"));
    //         修改输出方向
            System.setOut(printStream);
            System.out.println("Hello SZ");
        }
    }
    
    

    练习2:

    package Day2;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.PrintStream;
    
    public class PrintStreamTest1 {
        public static void main(String[] args) throws FileNotFoundException {
            System.out.println("Hello World!");
            PrintStream print = System.out;
            print.println("Oh my god!");
    //        可以改变标准输出流的方向
           /* System.gc();
            System.currentTimeMillis();
            PrintStream print  = System.out;
            System.exit(0);
            System.arraycopy()*/
    //       标准输出流指向file文件,不指向控制台
           PrintStream printStream=new PrintStream(new FileOutputStream("file"));
    //         修改输出方向
            System.setOut(printStream);
            System.out.println("Hello SZ");
        }
    }
    
    

    练习三(记录日志):

    package Day2;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.PrintStream;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class LogTest1 {
        public static void main(String[] args) {
                logs("成功完成了日志的代码!");
                logs("完成Java的学习!");
                logs("登入系统成功!");
                logs("你向某某支付XXX钱!");
                logs("你收到来着某某的XXXXXXXX人民币!");
        }
    public static void logs (String s){
        //        指向日志文件
        PrintStream log =null;
        try {
            log = new PrintStream(new FileOutputStream("log.txt",true));
    //             改变输出方向
            System.setOut(log);
    //        获取当前时间
            Date nowTime = new Date();
            SimpleDateFormat ss = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
                    String times=ss.format(nowTime);
            System.out.println(times+"  "+s);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        //不需要关闭
    
      }
    }
    
    

    11.File类

    • File类和四大家族没有关系,所以不能完成文件的读取。
      File对象代表什么?
    • 文件和目录路径名的抽象表示形式。
      C:\Drivers 这是一个File对象。
      C:\Drevers\reader.txt 也是一个File对象。
    • File只是一个路径名的表现形式。
      FIle的常用方法:
    • 以下通过练习来说明
    package Day2;
    
    import java.io.File;
    import java.io.IOException;
    
    public class FileTest1 {
        public static void main(String[] args) {
    //        创建一个File对象
            File f1 = new File("D:\\tt.txt");
    //        判断文件是否存在
            System.out.println(f1.exists());
    //        1.如果D:\tt.txt不存在,以文件的形式创建
           /* if(!f1.exists()){
                try {
                    f1.createNewFile();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }*/
    //       2.如果不存在,以目录的形式创建
            /*if(!f1.exists()){
                f1.mkdir();
            }*/
    //        3.以多重目录新建
           /* File f2 =new File("D:\\xi\\c\\z\\a");
                if(!f2.exists()){
                    f2.mkdirs();
                }*/
    //        4.获取文件的父路径
            File f3 = new File("D:\\WeChat\\locales");
            String parentPath = f3.getParent();
            System.out.println(parentPath);
    //        5.获取绝对路径
            File f4 = new File("Team");
            System.out.println(f4.getAbsolutePath());
            
        }
    }
    
    

    练习2:

    package Day2;
    
    import java.io.File;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class FileTest2 {
        public static void main(String[] args) {
            File f1 = new File("D:\\resources");
    //      6.获取文件名
            System.out.println(f1.getName());
    //        7.判断是否时一个目录
            System.out.println(f1.isDirectory());
    //        8.判断是否是一个文件
            System.out.println(f1.isFile());
    //        9.获去文件最后一次修改时间
            long haoMiao = f1.lastModified();
    //        将总毫秒树转换成日期
            Date time  = new Date(haoMiao);
            SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
            System.out.println(sd.format(time));
    //        10.获取文件大小,字节
            System.out.println(f1.length());
    //        11.获取当前目录下所有的子文件
            File[] files = f1.listFiles();
            for(File file :files){
                System.out.println(file);
            }
        }
    }
    
    

    12.拷贝目录练习(重点)

    package Day2;
    
    import java.io.*;
    
    public class CopyContent1 {
        public static void main(String[] args) {
    //        拷贝源
            File srcFile = new File("F:\\QQ");
    //        拷贝目标(放哪里)
            File destFile = new File("D:\\");
    //        调用方法
            copyDir(srcFile,destFile);
        }
    
        private static void copyDir(File srcFile, File destFile) {
            if(srcFile.isFile()){//如果是文件递归结束
                /*是文件就拷贝,一边读,一边写*/
                FileInputStream in = null;
                FileOutputStream out = null;
                try {
                    //读
                    in  = new FileInputStream(srcFile);
                    //写
                    String path = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() : destFile.getAbsolutePath() + "\\" )+srcFile.getAbsolutePath().substring(3);
    
                    out = new FileOutputStream(path);
                    byte[] bytes = new byte[1024*1024];
                    int readCount =0;
                    while((readCount=in.read(bytes))!=-1){
                        out.write(bytes,0,readCount);//读多少写多少
                    }
                    out.flush();
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    if(out!=null){
                        try {
                            out.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    if(in!=null){
                        try {
                            in.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
                return;
            }
    //        获取源的子目录
           File[] files=  srcFile.listFiles();
            for(File file :files){
                if(file.isDirectory()) {
    //            获取所有文件的绝对路径
    //            System.out.println(file.getAbsolutePath());
    //            新建目标,对应的目录,将源目录除根目录外,其余加到目标目录后面
                    String srcDir = file.getAbsolutePath();
                    String destDir = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() : destFile.getAbsolutePath() + "\\" )+ srcDir.substring(3);
                    File newFile = new File(destDir);
                    if (!newFile.exists()) {
                        newFile.mkdirs();
                    }
                }
    //            字目录可能还是目录
                copyDir(file,destFile);
            }
        }
      }
    
    
    

    13.ObjectInputStream和ObjectOutputStream对象流

    • 序列化(Serialize):将内存的对象数据信息存到磁盘中。(拆分对象)
    • 反序列化(DeSerialize):将硬盘的数据重新恢复到内存当中,恢复成java对象。
      在这里插入图片描述
    • 参与序列化和反序列化的对象必须实现Serializalbe接口。
    • Serializalbe接口,只是一个标志性接口,起到标志作用,让JVM参考,JVM会为该类创建一个序列化版本号。
    • 序列化版本号的作用:(区分类)
      第一:Java通过类名进行比对,如果类名不一样,肯定不是同一个类。
      第二:如果类名一样,靠序列化版本号区分。
      就算两个人写了同一个类,jvm但不是同一个类,这个时候序列化版本号可以将他们区分。
    • 十年前写的代码放在硬盘,后面改动源代码,重新编译之后,生成了全新的字节码文件。(自动序列化缺点:代码确定后,不能修改,JVM就会认为不是同一个类)
      ==结论:凡是实现Serializable的类,建议收到将序列化版本号写出来,不建议自动生成。
      private static final long serizlVersionUID =456464656546465465L; 建议全球唯一
      ==
    • IDEA自动生成版本号,先到settings->Inspections(搜索Serializable接口),后面鼠标移动到类名,ALt+回车。
    package Day2;
    
    import java.io.*;
    
    public class ObjectInputStreamTest1 {
        public static void main(String[] args) {
            Student ss = new Student(1111,"zhangsh");
            ObjectOutputStream oss =null;
            try {
                //      序列化
                 oss = new ObjectOutputStream(new FileOutputStream("Students"));
                 //序列化对象
                oss.writeObject(ss);
                 oss.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
            finally {
                if(oss!=null){
                    try {
                        oss.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    class Student implements Serializable{//可序列化接口
        private int no;
        private String name;
    
        public Student() {
        }
    
        public Student(int no, String name) {
            this.no = no;
            this.name = name;
        }
    
        public int getNo() {
            return no;
        }
    
        public void setNo(int no) {
            this.no = no;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "no=" + no +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
    

    反序列化:

    package Day2;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    
    public class ObjectInputStreamTest2 {
        public static void main(String[] args) {
            ObjectInputStream ois =null;
            try {
                ois = new ObjectInputStream(new FileInputStream("Students"));
                //反序列化
                Object obj = ois.readObject();
                System.out.println(obj);
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }finally {
                if(ois!=null){
                    try {
                        ois.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
    }
    
    
    • 将对象放到集合当中,序列化集合,要求对象和集合都要实现Serializalbe接口。
    package Day2;
    
    import java.io.*;
    import java.util.ArrayList;
    import java.util.List;
    
    public class ObjectInputStreamTest1 {
        public static void main(String[] args) {
            ObjectOutputStream oss =null;
            List<Student> list= new ArrayList<>();
            list.add(new Student(33,"adsfsa"));
            list.add(new Student(36,"aa"));
            list.add(new Student(39,"adsa"));
            try {
                //      序列化
                 oss = new ObjectOutputStream(new FileOutputStream("Students"));
                 //序列化对象
                oss.writeObject(list);
                 oss.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
            finally {
                if(oss!=null){
                    try {
                        oss.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    class Student implements Serializable{//可序列化接口
        private int no;
        private String name;
    
        public Student() {
        }
    
        public Student(int no, String name) {
            this.no = no;
            this.name = name;
        }
    
        public int getNo() {
            return no;
        }
    
        public void setNo(int no) {
            this.no = no;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "no=" + no +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
    
    • 集合中的对象反序列化,返回的是list类型,需要强转。
      在这里插入图片描述
    • 如果希望某个属性不参与序列化,可以在属性前加 transient关键字,表示游离的。

    14.IO +Properties联合使用

    IO流:文件的读和写。
    Properties:是一个Map集合,key和value都是String类型。
    在这里插入图片描述
    在这里插入图片描述
    希望能和你一起成长​,一同进步,成为更好的自己,我是梦阳辰,一位在校小白!希望能成为你身边的朋友。

    关注公众号【轻松玩编程】回复关键字激活码即可获取:全家桶通用激活码(激活码支持idea,pycharm,webstorm,phpstorm…激活)定期更新。适用于最新及以下版本。(无需破解和修改hosts,如果破解过请卸载重新安装官方原版,如果修改过hosts,请删除你添加的网址,然后重新激活)

    回复关键字“电子书”,“计算机资源”,“Java从入门到进阶”,”JavaScript教程“,“算法”,“Python学习资源”,“人工智能”等即可获取学习资源。

    在这里插入图片描述

    展开全文
  • 常见加密算法分类

    万次阅读 2015-06-09 12:24:08
    常见的加密算法可以分成三类,对称加密算法,非对称加密算法和Hash算法。 对称加密  指加密和解密使用相同密钥的加密算法。对称加密算法的优点在于加解密的高速度和使用长密钥时的难破解性。假设两个用户需要...

    常见的加密算法可以分成三类,对称加密算法,非对称加密算法和Hash算法。

    对称加密

        指加密和解密使用相同密钥的加密算法。对称加密算法的优点在于加解密的高速度和使用长密钥时的难破解性。假设两个用户需要使用对称加密方法加密然后交换数据,则用户最少需要2个密钥并交换使用,如果企业内用户有n个,则整个企业共需要n×(n-1) 个密钥,密钥的生成和分发将成为企业信息部门的恶梦。对称加密算法的安全性取决于加密密钥的保存情况,但要求企业中每一个持有密钥的人都保守秘密是不可能的,他们通常会有意无意的把密钥泄漏出去——如果一个用户使用的密钥被入侵者所获得,入侵者便可以读取该用户密钥加密的所有文档,如果整个企业共用一个加密密钥,那整个企业文档的保密性便无从谈起。

    常见的对称加密算法:DES、3DES、DESX、Blowfish、IDEA、RC4、RC5、RC6和AES

     

    非对称加密

        指加密和解密使用不同密钥的加密算法,也称为公私钥加密。假设两个用户要加密交换数据,双方交换公钥,使用时一方用对方的公钥加密,另一方即可用自己的私钥解密。如果企业中有n个用户,企业需要生成n对密钥,并分发n个公钥。由于公钥是可以公开的,用户只要保管好自己的私钥即可,因此加密密钥的分发将变得十分简单。同时,由于每个用户的私钥是唯一的,其他用户除了可以可以通过信息发送者的公钥来验证信息的来源是否真实,还可以确保发送者无法否认曾发送过该信息。非对称加密的缺点是加解密速度要远远慢于对称加密,在某些极端情况下,甚至能比非对称加密慢上1000倍。

    常见的非对称加密算法:RSA、ECC(移动设备用)、Diffie-Hellman、El Gamal、DSA(数字签名用)

     

    Hash算法

        Hash算法特别的地方在于它是一种单向算法,用户可以通过Hash算法对目标信息生成一段特定长度的唯一的Hash值,却不能通过这个Hash值重新获得目标信息。因此Hash算法常用在不可还原的密码存储、信息完整性校验等。

    常见的Hash算法:MD2、MD4、MD5、HAVAL、SHA、SHA-1、HMAC、HMAC-MD5、HMAC-SHA1

     

        加密算法的效能通常可以按照算法本身的复杂程度、密钥长度(密钥越长越安全)、加解密速度等来衡量。上述的算法中,除了DES密钥长度不够、MD2速度较慢已逐渐被淘汰外,其他算法仍在目前的加密系统产品中使用。

     

    加密算法的选择

        前面的章节已经介绍了对称解密算法和非对称加密算法,有很多人疑惑:那我们在实际使用的过程中究竟该使用哪一种比较好呢?

        我们应该根据自己的使用特点来确定,由于非对称加密算法的运行速度比对称加密算法的速度慢很多,当我们需要加密大量的数据时,建议采用对称加密算法,提高加解密速度。

    对称加密算法不能实现签名,因此签名只能非对称算法。

    由于对称加密算法的密钥管理是一个复杂的过程,密钥的管理直接决定着他的安全性,因此当数据量很小时,我们可以考虑采用非对称加密算法。

        在实际的操作过程中,我们通常采用的方式是:采用非对称加密算法管理对称算法的密钥,然后用对称加密算法加密数据,这样我们就集成了两类加密算法的优点,既实现了加密速度快的优点,又实现了安全方便管理密钥的优点。

        如果在选定了加密算法后,那采用多少位的密钥呢?一般来说,密钥越长,运行的速度就越慢,应该根据的我们实际需要的安全级别来选择,一般来说,RSA建议采用1024位的数字,ECC建议采用160位,AES采用128为即可。

    展开全文
  • 字节输入: 1.FileInputStream ...详细构造函数与常用方法可参考API文档,网上已经中文版的API了,我是个E文盲,伤不起 这里介绍一个最常见的方法: read(byte[] b, int off, int len)  从此输入中将最

    字节输入输出流

    1.FileInputStream[文件字节输入流]->读取文件内容

    用途:从文件系统中的文件获得输入字节,常用于读取图像、声音等原始字节流,读取字符流可考虑使用FileReader

    构造方法:

    构造方法摘要
    FileInputStream(File file)
              通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的 File 对象file 指定。
    FileInputStream(FileDescriptor fdObj)
              通过使用文件描述符 fdObj 创建一个 FileInputStream,该文件描述符表示到文件系统中某个实际文件的现有连接。
    FileInputStream(String name)
              通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的路径名 name 指定。
    常用方法:

    方法摘要

    available()
              返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取(或跳过)的估计剩余字节数。
      close()
              关闭此文件输入流并释放与此流有关的所有系统资源。

    finalize()
              确保在不再引用文件输入流时调用其 close 方法。
      getChannel()
              返回与此文件输入流有关的唯一 FileChannel 对象。
      getFD()
              返回表示到文件系统中实际文件的连接的 FileDescriptor 对象,该文件系统正被此 FileInputStream 使用。
      read()
              从此输入流中读取一个数据字节。
      read(byte[] b)
              从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
      read(byte[] b, int off, int len)
              从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
      skip(long n)
              从输入流中跳过并丢弃 n 个字节的数据。

    这里介绍一个最常见的方法:

    read(byte[] b, int off, int len)
              从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。

    ->off:b字节数组中的偏移量

    小知识:数组偏移量,比如a[1,2,3,4,5]数组,默认数组第一个应该指向a[0],若偏移量为2,则指向a[1]

    案例:

    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    public class Test {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		try {
    			int b;
    			// 创建输入流
    			FileInputStream readfile = new FileInputStream("E:\\test.txt");
    			byte buffer[] = new byte[2500];// 创建字节数组
    			// 从输入流中读取字节并存入buffer数组中,最长读取2500个字节,返回值b为实际读取的长度
    			b = readfile.read(buffer, 1, 2000);// 1为buffer数组中的起始偏移量
    			String str = new String(buffer, 0, b, "Default");
    			System.out.println(str);
    			System.out.println(b);
    			readfile.close();
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }
    

    2014年8月18日22:14:01

    2.FileOutputStream[文件字节输出流]->向文件写入信息

    用途:可以向图像等原始字节文件中写入信息

    构造函数:

    FileOutputStream(File file)
              创建一个向指定 File 对象表示的文件中写入数据的文件输出流,覆盖原有数据
    FileOutputStream(File file, boolean append)
              创建一个向指定 File 对象表示的文件中写入数据的文件输出流,append为true,保持原有数据,追加至末尾
    FileOutputStream(FileDescriptor fdObj)
              创建一个向指定文件描述符处写入数据的输出文件流,该文件描述符表示一个到文件系统中的某个实际文件的现有连接。
    FileOutputStream(String name)
              创建一个向具有指定名称的文件中写入数据的输出文件流。
    FileOutputStream(String name, boolean append)
              创建一个向具有指定 name 的文件中写入数据的输出文件流,,append为true,保持原有数据,追加至末尾
    常用方法:

    方法摘要

    close()
              关闭此文件输出流并释放与此流有关的所有系统资源。

    finalize()
              清理到文件的连接,并确保在不再引用此文件输出流时调用此流的 close 方法。

    getChannel()
              返回与此文件输出流有关的唯一 FileChannel 对象。

    getFD()
              返回与此流有关的文件描述符。

    write(byte[] b)
              将 b.length 个字节从指定 byte 数组写入此文件输出流中。

    write(byte[] b, int off, int len)
              将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。

    write(int b)
              将指定字节写入此文件输出流。
    案例:

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    public class Test {
    	public static void main(String[] args) {
    		try {
    			int b;
    			File file = new File("E:\\test.txt");
    			// 创建输入流
    			FileInputStream readfile = new FileInputStream(file);
    			byte buffer[] = new byte[2500];// 创建字节数组
    			// 从输入流中读取字节并存入buffer数组中,最长读取2500个字节,返回值b为实际读取的长度
    			b = readfile.read(buffer, 1, 2000);// 1为buffer数组中的起始偏移量
    			String str = new String(buffer, 0, b, "Default");
    			System.out.println(str);
    			readfile.close(); // 关闭流
    			// 创建一个输出流,true表示保留文件原有数据,新数据追加到结尾处
    			FileOutputStream writefile = new FileOutputStream(file, true);
    			writefile.write(buffer, 0, b);
    			writefile.close();
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }
    

    字符输入输出流

    1.FileReader[字符输入流]->以字符为单位读取文件内数据信息

    2.FileWriter[字符输出流]->以字符为单位向输出流中写入信息

    上述两个流操作,构造方法,常用函数均与字节流类似,只不过一个处理字节,一个处理字符,使用方法也很相近,主要是针对文本化的文件进行操作,而字节流主要处理图像,视频,声音等原始字节文件数据,直接贴一个代码吧!

    import java.io.FileReader;
    import java.io.FileWriter;
    
    public class Test {
    	public static void main(String[] args) {
    		try {
    			// 字符输入流,读取文件信息
    			FileReader fileread = new FileReader("F:\\test.txt");
    			char[] cbuf = new char[500];
    			int b = fileread.read(cbuf, 0, 500);
    			System.out.println(String.valueOf(cbuf));
    			fileread.close();
    			// 字符输出流,想输出流中写入信息,并且保留原有数据,追加数据值末尾处
    			FileWriter filewriter = new FileWriter("F:\\test.txt", true);
    			filewriter.write(cbuf);
    			filewriter.close();
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }
    

    2014年8月21日23:31:09

    这篇文章写到这,我突然感觉,我一直忽略了一个很重要的类:File

    文件类File:

    我们首先介绍一下文件,我想,文件这个名词,很抽象,但是缺非常容易理解,小弟不才没法用文字描述出来呢,在这里我介绍一下文件的简单分类吧:

    文件的分类:根据我们程序对文件的访问方式不同,大致的可以分为一下三个类别:

    1.顺序文件(Sequential File):这一类文件一行代表一条数据,按序排列的,每条数据或者记录的长度是不限制的,可长可段,访问文件内容必须追条进行访问。

    2.随机文件(Random Access File):这种类型文件最大的特点就是每条数据或者记录的长度是固定一样的,可以任意次序的对文件中记录进行操作,同时,每一条记录都有一个唯一的记录号(ID)与之对应,也就是说,只要知道记录号就可以对其进行访问的。

    3.二进制文件(Binary File):这个在我们电脑中最常见不过了,它是字节的集合,直接存取的是二进制码,对于二进制文件的访问时通过字节数来定位数据的,没有数据类型。

    介绍了文件的分类,就切入正题吧,File类的一些基本信息

    在Java语言中,访问文件或者目录,我们都可以通过File类来访问,甚至可以访问一个压根不存在的东西,或者说什么都不是也行,我们创建了一个File的实例,也就是File对象之后,如果是一个目录,那么我们可以创建和删除目录,也可以显示这个目录下的文件清单,如果这个对象时文件对象话,这点需要注意,这里我们只可以访问存储的目录信息,文件基本属性,比如文件名和文件类型,修改文件名信息等,是不能够进行文件的复制,读取,也就是说我们是不能够对文件的内容进行操作的,这个就属于流操作了,下面简单介绍一下File的简单构造函数和常用的方法吧!作为一个初学者,这些东西,我都是在API里面看的,我也是E文盲,我只能看大牛们翻译的啦!

    File类基础信息:

    1.构造函数信息:

    构造方法摘要
    File(File parent,String child)
              根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
    File(String pathname)
              通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。----这个方法最常用了,我觉得
    File(String parent,String child)
              根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
    File(URI uri)
              通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。
    2.常用字段介绍

    字段摘要

    pathSeparator
              与系统有关的路径分隔符,为了方便,它被表示为一个字符串。

    pathSeparatorChar
              与系统有关的路径分隔符。

    separator
              与系统有关的默认名称分隔符,为了方便,它被表示为一个字符串。WIN下是"\",Linux下是“/”,这个最常用

    separatorChar
              与系统有关的默认名称分隔符。
    3.常用方法

    方法摘要

    canExecute()
              测试应用程序是否可以执行此抽象路径名表示的文件。
      canRead()
              测试应用程序是否可以读取此抽象路径名表示的文件。

    canWrite()
              测试应用程序是否可以修改此抽象路径名表示的文件。

    compareTo(File pathname)
              按字母顺序比较两个抽象路径名。

    createNewFile()
              当且仅当不存在具有此抽象路径名指定名称的文件时,不可分地创建一个新的空文件。

    createTempFile(String prefix,String suffix)
              在默认临时文件目录中创建一个空文件,使用给定前缀和后缀生成其名称。

    createTempFile(String prefix,String suffix, File directory)
               在指定目录中创建一个新的空文件,使用给定的前缀和后缀字符串生成其名称。

    delete()
              删除此抽象路径名表示的文件或目录。

    deleteOnExit()
              在虚拟机终止时,请求删除此抽象路径名表示的文件或目录。

    equals(Object obj)
              测试此抽象路径名与给定对象是否相等。

    exists()
              测试此抽象路径名表示的文件或目录是否存在。

    getAbsoluteFile()
              返回此抽象路径名的绝对路径名形式。

    getAbsolutePath()
              返回此抽象路径名的绝对路径名字符串。

    getCanonicalFile()
              返回此抽象路径名的规范形式。

    getCanonicalPath()
              返回此抽象路径名的规范路径名字符串。

    getFreeSpace()
              返回此抽象路径名指定的分区中未分配的字节数。

    getName()
              返回由此抽象路径名表示的文件或目录的名称。

    getParent()
              返回此抽象路径名父目录的路径名字符串;如果此路径名没有指定父目录,则返回 null

    getParentFile()
              返回此抽象路径名父目录的抽象路径名;如果此路径名没有指定父目录,则返回 null

    getPath()
              将此抽象路径名转换为一个路径名字符串。

    getTotalSpace()
              返回此抽象路径名指定的分区大小。

    getUsableSpace()
              返回此抽象路径名指定的分区上可用于此虚拟机的字节数。

    hashCode()
              计算此抽象路径名的哈希码。

    isAbsolute()
              测试此抽象路径名是否为绝对路径名。

    isDirectory()
              测试此抽象路径名表示的文件是否是一个目录

    isFile()
              测试此抽象路径名表示的文件是否是一个标准文件

    isHidden()
              测试此抽象路径名指定的文件是否是一个隐藏文件。

    lastModified()
              返回此抽象路径名表示的文件最后一次被修改的时间。这个经常用到,比如我们通过定时修改文件信息,我写过一个关于定时生成Html的文章,这里用到了

    length()
              返回由此抽象路径名表示的文件的长度。

    list()
              返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中的文件和目录

    list(FilenameFilter filter)
              返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。

    listFiles()
              返回一个抽象路径名数组,这些路径名表示此抽象路径名表示的目录中的文件。返回一个File数组

    listFiles(FileFilter filter)
              返回抽象路径名数组,这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

    listFiles(FilenameFilter filter)
              返回抽象路径名数组,这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

    listRoots()
              列出可用的文件系统根。

    mkdir()
              创建此抽象路径名指定的目录。

    mkdirs()
              创建此抽象路径名指定的目录,包括所有必需但不存在的父目录。

    renameTo(File dest)
              重新命名此抽象路径名表示的文件。

    setExecutable(boolean executable)
              设置此抽象路径名所有者执行权限的一个便捷方法。

    setExecutable(boolean executable, boolean ownerOnly)
              设置此抽象路径名的所有者或所有用户的执行权限。

    setLastModified(long time)
              设置此抽象路径名指定的文件或目录的最后一次修改时间。

    setReadable(boolean readable)
              设置此抽象路径名所有者读权限的一个便捷方法。

    setReadable(boolean readable, boolean ownerOnly)
              设置此抽象路径名的所有者或所有用户的读权限。

    setReadOnly()
              标记此抽象路径名指定的文件或目录,从而只能对其进行读操作。

    setWritable(boolean writable)
              设置此抽象路径名所有者写权限的一个便捷方法。

    setWritable(boolean writable, boolean ownerOnly)
              设置此抽象路径名的所有者或所有用户的写权限。

    toString()
              返回此抽象路径名的路径名字符串。

    toURI()
              构造一个表示此抽象路径名的 file: URI。
    看这些没用的,还是要自己动手操作的,下面是我自己写的一个简单案例:

    import java.io.File;
    import java.io.IOException;
    
    public class Test {
    	public static void main(String[] args) throws IOException {
    		// 实例化一个File对象,注意这个目录是不存在的,我们重新创建
    		File mydir = new File("F:\\mydir");
    		if (!mydir.exists()) {
    			mydir.mkdir(); // 创建这个目录
    		} // 那么我们访问以下目录名试试
    		System.out.println(mydir.getName());
    		System.out.println(mydir.getAbsolutePath());
    		System.out.println(mydir.separator);
    		// 我们给这个目录下创建一个文件吧
    		File myfile = new File("F:\\mydir\\file.txt");
    		if (!myfile.exists()) {
    			myfile.createNewFile();
    		}
    		// 我们通过目录来访问目录下的这个文件
    		File files[] = mydir.listFiles();
    		for (int i = 0; i < files.length; i++) {
    			System.out.println(files[i].getName());
    			System.out.println(files[i].lastModified());
    		}
    	}
    }
    
    其实这几天挺迷茫的,前几周实习感觉挺有方向的,这几天没有给我安排具体的任务,突然感觉很空洞,夜深的时候,思考自己,我想要什么,当思考明确了自己的目标的时候,迷茫这个词语在脑海中是不存在的,但是这种迷茫也随这你的生活变化,随时都可能再次出现,所以在这里,我给我自己一句话,再苦再累,自己选的路,当你不想走下去的时候,请回头看看已经老去的爸妈,然后跪着走完这条路!!!

    加油,没有过不去砍,认真学,慢慢学,别着急速度,给自己一个理想化的学习态度和一份真诚踏实的心,一路走下去即可!呵呵

    突然觉得这样的上述的流操作,只能进行单一的读文件或者向文件写入数据,很单一,单向的操作,不用担心,java强大的不可挑剔,RandomAccessFile就可以满足我的这个小小愿望:

    RandomAccessFile[随机存取字节流]->可以任意的存和取数据,按照特定的数据类型进行写入或者读取操作,可以指定字节跳跃流所指向的文件指针位置

    构造函数信息:

    构造方法摘要
    RandomAccessFile(File file, String mode)
              创建从中读取和向其中写入(可选)的随机访问文件流,该文件由 File 参数指定。
    RandomAccessFile(String name, String mode)
              创建从中读取和向其中写入(可选)的随机访问文件流,该文件具有指定名称。
    上述mode取值可以是“r”只读,“w”只写或者“rw”读写
    常用方法:(方法有很多但是都很类似,唯一区别不同就是数据类型不同,也就意味着存取时,流所指向的文件指针跳跃的字节个数不同)

    long getFilePointer()
              返回此文件中的当前偏移量

    long length()
              返回此文件的长度,字节数

    read()
              从此文件中读取一个数据字节

    read(byte[] b)
              将最多 b.length 个数据字节从此文件读入 byte 数组

    read(byte[] b, int off, int len)
              将最多 len 个数据字节从此文件读入 byte 数组,off为数组偏移量

    readChar()
              从此文件读取一个字符,这是一个典型的,还有很多,比如readInt(),readBoolean()等等数据类型

    seek(long pos)
              设置到此文件开头测量到的文件指针偏移量,在该位置发生下一个读取或写入操作

    skipBytes(int n)
              尝试跳过输入的 n 个字节以丢弃跳过的字节

    write(byte[] b)
              将 b.length 个字节从指定 byte 数组写入到此文件,并从当前文件指针开始

    write(byte[] b, int off, int len)
              将 len 个字节从指定 byte 数组写入到此文件,并从偏移量 off 处开始

    writeBoolean(boolean v)
              按单字节值将 boolean 写入该文件,还可以有很多,比如writeInt()等等

    写一个超级简单的例子吧:

    import java.io.IOException;
    import java.io.RandomAccessFile;
    
    public class Test {
    	public static void main(String[] args) throws IOException {
    		// 创建一个RAF流,mode类型为“rw”,可写入可读取
    		RandomAccessFile raf = new RandomAccessFile("F:\\test.txt", "rw");
    		int num[] = { 1, 2, 3, 4, 5 };
    		for (int i = 0; i < num.length; i++) {
    			raf.writeInt(num[i]);// 写入int类型数据
    		}
    		raf.seek(0L);// 重新定位流所指向的文件指针位置
    		for (int i = 0; raf.getFilePointer() < raf.length(); i++) {
    			raf.seek(i * 4);// 这里的int占四个字节,定位值按照字节定位的
    			System.out.println(raf.readInt());
    		}
    		raf.close();
    	}
    }
    

    未完待续,还有很多常用的流操作,以后会一一补充,很晚了,该睡觉了,每天抽一点时间学习学习,慢慢积累,I can do it!!


    展开全文
  • 【IO、文件操作】-常见面试题

    千次阅读 2019-01-16 17:08:49
    5. IO分类?6. 什么叫缓冲区? 什么作用? 1. java中几种类型的?jdk为每种类型的提供了一些抽象类以供继承,请说出他们分别是那些类? 2. 字节流有字符的区别? 字节操作的最基本的单元是...
  • 常见加密算法分类与介绍

    千次阅读 2016-08-30 15:46:57
    常见的加密算法可以分成三类,对称加密算法,非对称加密算法和Hash算法。 对称加密 指加密和解密使用相同密钥的加密算法。对称加密算法的优点在于加解密的高速度和使用长密钥时的难破解性。假设两个用户需要使用...
  • 蓝牙Profile的概念和常见种类

    万次阅读 2010-11-29 09:37:00
    BT Profile的概念和常见种类
  • 常见软件测试类型分类

    万次阅读 2018-09-20 09:48:05
    用例回归是一段时间以后再回头对以前使用的用例在重新进行测试,看看会重新发现问题。错误回归,就是在新版本中,对以前版本中出现并修复的缺陷进行再次验证,并以缺陷为核心,对相关修改的部分进行测试的方法。...
  • 分类常见的类别不平衡问题解决方法

    万次阅读 多人点赞 2017-08-29 11:01:32
    常见的类别不平衡问题解决方法 ...例如二分类问题中998个反例,正例2个,那么学习方法只需返回一个永远将新样本预测为反例的分类器,就能达到99.8%的精度;然而这样的分类器没有价值,我们必须要解决这个问题。
  • Java基础常见笔试题总结

    万次阅读 多人点赞 2018-01-30 21:32:31
    以下是自己总结的一些Java常见的基础知识题,答案仅供参考,如异议请指出。一直保持更新状态。 1.什么是Java虚拟机?为什么Java被称作是“平台无关的编程语言”? Java虚拟机是一个可以执行Java字节码的虚拟机...
  • 常见的平面设计风格哪些?

    千次阅读 2019-05-21 16:34:57
    苏州学码思小编和大家介绍当下流行的平面设计风格,大家如果没灵感,可尝试这些风格来应用到你的作品。 目前常见的平面设计项目,可以归纳为十大类: 网页设计、包装设计、DM广告设计、海报设计、平面媒体广告...
  • 【搞定算法】常见算法题分类总览

    万次阅读 多人点赞 2019-07-26 15:24:05
    由于本人平时刷题比较零散,时候找起来不是很方便,所以统一将题目记录于此。主要的题目来源自:剑指 Offer、LeetCode、左神算法、面试、笔试、面经等等。下面按照分类记录: 说明(个人见解): 一、标注说明 ...
  • 机器学习中常见分类器的应用场景

    万次阅读 多人点赞 2017-06-02 15:22:54
    正好14年的时候人做一个实验[1],比较在不同数据集上(121个),不同的分类器(179个)的实际效果。 论文题为:Do we Need Hundreds of Classifiers to Solve Real World Classification Problems? 实验时间...
  • 文件包含常见方法

    千次阅读 2020-06-15 17:08:00
    文件包含原理 开发人员将相同函数写入单独的文件中,需要使用某个函数直接调用此文件,无需再次编写,这种...include_once: 这个函数跟和include语句类似,唯一区别是如果该文件中已经被包含,则不会再次包含 req
  • 常见咳嗽种类、治疗方法和忌食大全  一、风热咳嗽  症见发热,流涕,咳嗽,喉中痰鸣,咯吐黄痰,日重夜轻,小便黄赤,大便干燥,脉浮数,舌红苔厚腻,指纹红紫。治以疏风清肺,化痰止咳。方用鱼蛤石花汤:生...
  • 常见加密算法分,用途,原理以及比较  密码学简介 据记载,公元前400年,古希腊人发明了置换密码。1881年世界上的第一个电话保密专利出现。在第二次世界大战期间,德国军方启用“恩尼格玛”密码机,...
  • 传统分类算法以及计算分类算法

    千次阅读 2016-11-27 11:18:50
    分类算法作为监督的数据挖掘,需要通过分析数据中数据的特征建立模型从而将未知类标签的数据项对应到相应的类别中从而实现分类的目的。K近邻分类算法、决策树分类算法和贝叶斯分类算法都是一些常用的针对静态...
  • 机器学习中最常见的四种分类模型

    千次阅读 2020-05-23 12:30:00
    点击蓝字关注我,干货领取!作者:Jason Brownlee翻译:候博学前言 机器学习是一个从训练集中学习出算法的研究领域。分类是一项需要使用机器学习算法的任务,该算法学习如何为数据集...
  • 机器学习常见算法分类,算法优缺点汇总

    万次阅读 多人点赞 2017-04-14 12:08:13
    本文为您总结一下常见的机器学习算法,以供您在工作和学习中参考。  机器学习的算法很多。很多时候困惑人们都是,很多算法是一类算法,而有些算法又是从其他算法中延伸出来的。这里,我们从两个方面来给大家...
  • 蓝牙Profile Bluetooth的一个很重要特性,就是所有的Bluetooth产品都无须实现全部 的Bluetooth规范。为了更容易的保持Bluetooth设备之间的兼容,Bluetooth...在所有的Profile中,四种是基本的Profile,这些Profile会
  • 常见的并发问题哪些1.并发测试1.1并发测试的定义1.2并发测试的分类2.常见并发问题2.1事务并发的问题2.2极限值并发的问题2.3压力并发的问题2.4异常数据干扰并发的问题 1.并发测试 最近小屌丝一直在埋头苦练性能的知...
  • 【Java基础-3】吃透Java IO:字节、字符、缓冲

    万次阅读 多人点赞 2020-09-23 20:12:33
    什么是Java-IO?字符和字节的区别与适用场景是什么?缓冲到底实现了什么?如何高效地读写文件? 本文用大量的示例图和实例,带你吃透Java IO。
  • 一般网站哪些常见漏洞?

    千次阅读 2018-09-26 18:13:03
    1.1 Web应用的漏洞分类 1、信息泄露漏洞  信息泄露漏洞是由于Web服务器或应用程序没有正确处理一些特殊请求,泄露Web服务器的一些敏感信息,如用户名、密码、源代码、服务器信息、配置信息等。 造成信息泄露...
  • 防止拟合的几种常见方法

    万次阅读 2018-08-14 17:13:18
    防止拟合的处理方法 何时会发生拟合?    我们都知道,在进行数据挖掘或者机器学习模型建立的时候,因为在统计学习中,假设数据满足独立同分布(i.i.d,independently and identically distributed),即...
  • 两个直接子类:Error & Exception 程序错误一般分为三种: 1.编译错误;2.运行时错误;3.逻辑错误。 (1)编译错误是因为程序没有遵循语法规则,编译程序能够自己发现并且提示我们错误的原因和位置,这个也是...
  • 常见的算法包括:分类及回归树(Classification And Regression Tree, CART), ID3 (Iterative Dichotomiser 3), C4.5, Chi-squared Automatic Interaction Detection(CHAID), Decision Stump, 随机森林(Random...
  • web常见漏洞分析

    千次阅读 2020-11-18 10:32:58
    web常见漏洞
  • @[TOC]Toolbox 重分类 Model Builder 模型构建器(Model Builder)是一个用来创建、编辑和管理模型的应用...模型构建器除了助于构造和执行简单工作外,还能通过创建模型并将其共享为工具来提供扩展 ArcGIS 功能的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 93,908
精华内容 37,563
关键字:

常见的过流种类有