精华内容
下载资源
问答
  • 目录 1、Java Io流的概念,分类,类图 1.1、Java Io流的概念 1.2、Io流的分类 1.2.1、按照的流向分,可以分为输入和输出 1.2.2、按照操作单元...1.3.2、java输入/输出体系中常用的的分类表(重点)...

    目录

    1、Java Io流的概念,分类,类图

    1.1、Java Io流的概念

    1.2、Io流的分类

    1.2.1、按照流的流向分,可以分为输入流和输出流

    1.2.2、按照操作单元划分,可以划分为字节流和字符流

    1.2.3、按照流的角色划分为节点流和处理流

    1.3、流的原理浅析和常用的流的分类表

    1.3.1、流的原理浅析

    1.3.2、java输入/输出流体系中常用的流的分类表(重点)

    2、常用的io流的用法

    2.1、Io体系的基类(InputStream/Reader,OutputStream/Writer)

    2.2、文件流(FileInputStream/FileReader ,FileOutputStream/FileWriter)

    2.2.1、FileInputStream、FileOutputStream

    2.2.2、FileReader、FileWriter

    2.2、缓存流(BufferedInputStream/BufferedOutputStream, BufferedReader/BufferedWriter)

    2.2.1、字节缓存流(BufferedInputStream/BufferedOutputStream)

    2.2.2、字节缓存流(BufferedReader/BufferedWriter)

    2.3、转换流(InputStreamReader、OutputStreamWriter)


    1、Java Io流的概念,分类,类图

    1.1、Java Io流的概念

          java的io是实现输入和输出的基础,可以方便的实现数据的输入和输出操作。在java中把不同的输入/输出源(键盘,文件,网络连接等)抽象表述为“流”(stream)。通过流的形式允许java程序使用相同的方式来访问不同的输入/输出源。stram是从起源(source)到接收的(sink)的有序数据。

    注:java把所有的传统的流类型都放到在java io包下,用于实现输入和输出功能。

    1.2、Io流的分类

    按照不同的分类方式,可以把流分为不同的类型。常用的分类有三种:

    1.2.1、按照流的流向分,可以分为输入流和输出流

            输入流: 只能从中读取数据,而不能向其写入数据。

            输出流:只能向其写入数据,而不能向其读取数据。

          此处的输入,输出涉及一个方向的问题,对于如图15.1所示的数据流向,数据从内存到硬盘,通常称为输出流——也就是说,这里的输入,输出都是从程序运行所在的内存的角度来划分的。

    注:如果从硬盘的角度来考虑,图15.1所示的数据流应该是输入流才对;但划分输入/输出流时是从程序运行所在的内存的角度来考虑的,因此如图15.1所在的流时输出流。而不是输入流。

          对于如图15.2所示的数据流向,数据从服务器通过网络流向客户端,在这种情况下,Server端的内存负责将数据输出到网络里,因此Server端的程序使用输出流;Client端的内存负责从网络中读取数据,因此Client端的程序应该使用输入流。

    这是图片描述

    注:java的输入流主要是InputStream和Reader作为基类,而输出流则是主要由outputStream和Writer作为基类。它们都是  一些抽象基类,无法直接创建实例。


    1.2.2、按照操作单元划分,可以划分为字节流和字符流

        字节流和字符流的用法几乎完成全一样,区别在于字节流和字符流所操作的数据单元不同,字节流操作的单元是数据单元是8位的字节,字符流操作的是数据单元为16位的字符。

    字节流主要是由InputStream和outPutStream作为基类,而字符流则主要有Reader和Writer作为基类。


    1.2.3、按照流的角色划分为节点流和处理流

        可以从/向一个特定的IO设备(如磁盘,网络)读/写数据的流,称为节点流。节点流也被称为低级流。图15.3显示了节点流的示意图。 
        从图15.3中可以看出,当使用节点流进行输入和输出时,程序直接连接到实际的数据源,和实际的输入/输出节点连接。 
    处理流则用于对一个已存在的流进行连接和封装,通过封装后的流来实现数据的读/写功能。处理流也被称为高级流。图15.4显示了处理流的示意图。

    这里写图片描述

          从图15.4可以看出,当使用处理流进行输入/输出时,程序并不会直接连接到实际的数据源,没有和实际的输入和输出节点连接。使用处理流的一个明显的好处是,只要使用相同的处理流,程序就可以采用完全相同的输入/输出代码来访问不同的数据源,随着处理流所包装的节点流的变化,程序实际所访问的数据源也相应的发生变化。

    1.3、流的原理浅析和常用的流的分类表

    1.3.1、流的原理浅析

         java Io流共涉及40多个类,这些类看上去很杂乱,但实际上很有规则,而且彼此之间存在非常紧密的联系, Java Io流的40多个类都是从如下4个抽象类基类中派生出来的。

           InputStream/Reader: 所有的输入流的基类,前者是字节输入流,后者是字符输入流。

          OutputStream/Writer: 所有输出流的基类,前者是字节输出流,后者是字符输出流。

        对于InputStream和Reader而言,它们把输入设备抽象成为一个”水管“,这个水管的每个“水滴”依次排列,如图15.5所示: 
        从图15.5可以看出,字节流和字符流的处理方式其实很相似,只是它们处理的输入/输出单位不同而已。输入流使用隐式的记录指针来表示当前正准备从哪个“水滴”开始读取,每当程序从InputStream或者Reader里面取出一个或者多个“水滴”后,记录指针自定向后移动;除此之外,InputStream和Reader里面都提供了一些方法来控制记录指针的移动。

    这里写图片描述

       对于OutputStream和Writer而言,它们同样把输出设备抽象成一个”水管“,只是这个水管里面没有任何水滴,如图15.6所示:

          正如图15.6所示,当执行输出时,程序相当于依次把“水滴”放入到输出流的水管中,输出流同样采用隐示指针来标识当前水滴即将放入的位置,每当程序向OutputStream或者Writer里面输出一个或者多个水滴后,记录指针自动向后移动。 
          图15.5和图15.6显示了java Io的基本概念模型,除此之外,Java的处理流模型则体现了Java输入和输出流设计的灵活性。处理流的功能主要体现在以下两个方面。

           性能的提高:主要以增加缓冲的方式来提供输入和输出的效率。

          操作的便捷:处理流可能提供了一系列便捷的方法来一次输入和输出大批量的内容,而不是输入/输出一个或者多个“水滴”。

        处理流可以“嫁接”在任何已存在的流的基础之上,这就允许Java应用程序采用相同的代码,透明的方式来访问不同的输入和输出设备的数据流。图15.7显示了处理流的模型。

    这里写图片描述


    1.3.2、java输入/输出流体系中常用的流的分类表(重点

    分类字节输入流字节输出流字符输入流字符输出流
    抽象基类InputStreamOutputStreamReaderWriter
    访问文件FileInputStreamFileOutputStreamFileReaderFileWriter
    访问数组ByteArrayInputStreamByteArrayOutputStreamCharArrayReaderCharArrayWriter
    访问管道PipedInputStreamPipedOutputStreamPipedReaderPipedWriter
    访问字符串  StringReaderStringWriter
    缓冲流BufferedInputStreamBufferedOutputStreamBufferedReaderBufferedWriter
    转换流  InputStreamReaderOutputStreamWriter
    对象流ObjectInputStreamObjectOutputStream  
    打印流 PrintStream PrintWriter
    推回输入流PushbackInputStream PushbackReader 
    特殊流DataInputStreamDataOutputStream  

    注:表中粗体字所标出的类代表节点流,必须直接与指定的物理节点关联;斜体字标出的类代表抽象基类,无法直接创建实例;红色为经常使用的流。

    2、常用的io流的用法

           下面是整理的常用的Io流的特性及使用方法,只有清楚每个Io流的特性和方法。才能在不同的需求面前正确的选择对应的IO流进行开发。

    2.1、Io体系的基类(InputStream/Reader,OutputStream/Writer

    字节流和字符流的操作方式基本一致,只是操作的数据单元不同——字节流的操作单元是字节,字符流的操作单元是字符。所以字节流和字符流就整理在一起了。

           InputStreamReader是所有输入流的抽象基类,本身并不能创建实例来执行输入,但它们将成为所有输入流的模板,所以它们的方法是所有输入流都可使用的方法。 
    InputStream/Reader里面包含如下3个方法:

            int read()/int read(),从输入流中读取单个字节/字符(相当于从图15.5所示的水管中取出一滴水),返回所读取的字节/字符数据(字节/字符数据可直接转换为int类型)。

           int read(byte[] b)/int read(char[] b)从输入流中最多读取b.length个字节/字符的数据,并将其存储在字节/字符数组b中,返回实际读取的字节/字符数。

           int read(byte[] b,int off,int len)/int read(char[] b,int off,int len) 从输入流中最多读取len个字节/字符的数据,并将其存储在数组b中,放入数组b中时,并不是从数组起点开始,而是从off位置开始,返回实际读取的字节/字符数。

           对比InputStream和Reader所提供的方法,就不难发现这两个基类的功能基本是一样的。InputStream和Reader都是将输入数据抽象成如图15.5所示的水管,所以程序即可以通过read()方法每次读取一个”水滴“,也可以通过read(char[] b)或者read(byte[] b)方法来读取多个“水滴”。当使用数组作为read()方法中的参数, 我们可以理解为使用一个“竹筒”到如图15.5所示的水管中取水,如图15.8所示read(char[] b)方法的参数可以理解成一个”竹筒“,程序每次调用输入流read(char[] b)或read(byte[] b)方法,就相当于用“竹筒”从输入流中取出一筒“水滴”,程序得到“竹筒”里面的”水滴“后,转换成相应的数据即可;程序多次重复这个“取水”过程,直到最后。程序如何判断取水取到了最后呢?直到read(char[] b)或者read(byte[] b)方法返回-1,即表明到了输入流的结束点。

    这里写图片描述

    InputStream和Reader提供的一些移动指针的方法:

            void mark(int readAheadLimit); 在记录指针当前位置记录一个标记(mark)。

            boolean markSupported(); 判断此输入流是否支持mark()操作,即是否支持记录标记。

            void reset(); 将此流的记录指针重新定位到上一次记录标记(mark)的位置。

            long skip(long n); 记录指针向前移动n个字节/字符。

    OutputStreamWriter: 
            OutputStreamWriter的用法也非常相似,它们采用如图15.6所示的模型来执行输入,两个流都提供了如下三个方法:

            void write(int c); 将指定的字节/字符输出到输出流中,其中c即可以代表字节,也可以代表字符。

            void write(byte[]/char[] buf); 将字节数组/字符数组中的数据输出到指定输出流中。

            void write(byte[]/char[] buf, int off,int len ); 将字节数组/字符数组中从off位置开始,长度为len的字节/字符输出到输出流中。

            因为字符流直接以字符作为操作单位,所以Writer可以用字符串来代替字符数组,即以String对象作为参数。Writer里面还包含如下两个方法:

            void write(String str); 将str字符串里包含的字符输出到指定输出流中。

            void write (String str, int off, int len); 将str字符串里面从off位置开始,长度为len的字符输出到指定输出流中。

    2.2、文件流(FileInputStream/FileReader ,FileOutputStream/FileWriter)

          前面说过InputStream/OutputStreamReader/Writer都是抽象类,本身不能创建实例,但它们分别有一个用于读取文件的输入流:FileInputStreamFileReader,它们都是节点流——会直接和指定文件关联。下面程序示范使用FileInputStream、FileOutputStreamFileReader、FileWriter。 

    2.2.1、FileInputStream、FileOutputStream

    package byte_stream;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class File_X_Stream_Sample {
    
    	public static void main(String[] args) throws IOException {
    		// TODO Auto-generated method stub
    		FileInputStream fis=null;
            FileOutputStream fos=null;
    
            try {
            	
            	File file = new File("D:\\workspace\\file_calss_test","file_learn.txt");
                if(!file.exists())
                {
                	System.out.println("file is not exist");
                	file.createNewFile();
                }
                
            	File file2 = new File("D:\\workspace\\file_calss_test","file_learn2.txt");
                if(!file2.exists())
                {
                	System.out.println("file2 is not exist");
                	file2.createNewFile();
                }
                		
                //创建字节输入流
                fis=new FileInputStream(file);
                //创建字节输出流
                fos=new FileOutputStream(file2);
    
                byte[] b=new byte[1024];
                int hasRead=0;
    			while((hasRead = fis.read(b,0,10))>0) {
    				System.out.println("hasRead="+hasRead+","+new String(b));//b.tostring
    				fos.write(b,0,hasRead);
    			}
            }finally {
    				fis.close();
            	    fos.close();
    		}
    	}
    }
    

    运行结果:file_learn.txt中的内容被正确读出,写入file_learn2.txt

    2.2.2、FileReader、FileWriter

    package char_stream;
    
    import java.io.File;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.Reader;
    import java.io.Writer;;
    
    public class File_Reader_Writer_Sample {
    
    	static private Reader file_in = null;
    	static private Writer file_out =null;
    	
    	public static void main(String[] args) throws IOException {
    		// TODO Auto-generated method stub
          	File file = new File("D:\\workspace\\file_calss_test","file_learn.txt");
            if(!file.exists())
            {
            	System.out.println("file is not exist");
            	file.createNewFile();
            }
            
        	File file2 = new File("D:\\workspace\\file_calss_test","file_learn2.txt");
            if(!file2.exists())
            {
            	System.out.println("file2 is not exist");
            	file2.createNewFile();
            }
            
            file_in = new FileReader(file);
            file_out = new FileWriter(file2);
            
            char [] temp = new char[1024];
            int hasread=0;
            while((hasread= file_in.read(temp, 0, 10))>0) {
            	System.out.println("hasread="+hasread+","+new String(temp));
            	file_out.write(temp, 0, hasread);
            }
            
            file_in.close();
            file_out.close();
    		
    	}
    
    }
    

    运行结果:file_learn.txt中的内容被正确读出,写入file_learn2.txt

    注意:文件中的汉字不能被字符流正确解析

    2.2、缓存流(BufferedInputStream/BufferedOutputStream, BufferedReader/BufferedWriter)

            缓冲流是处理流的一种,它依赖于原始的输入输出流, 它令输入输出流具有1个缓冲区, 显著减少与外部设备的IO次数, 而且提供一些额外的方法。而我们使用缓冲流无非两个目的:

          1.减少IO次数(提升performance)

          2. 使用一些缓冲流的额外的方法

    2.2.1、字节缓存流(BufferedInputStream/BufferedOutputStream

           如下代码拷贝一个25M的文本文件out.txt:

           1、使用原始文件流FileInputStream/FileOutputStream的read(),wrire(int x)方法拷贝时长为:450s

           2、将原始文件流封装成缓冲流BufferedInputStream/BufferedOutputStream拷贝时长变为 :3s

           3、使用原始文件流FileInputStream/FileOutputStreamread(byte[] b),wrire(byte[] b)方法拷贝时长为:1s,貌似比缓冲流效果还好,切其实原理是一致的一次读取多个字节。

    package byte_stream;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class BufferStreamSample {
    
    	static FileInputStream fileIn=null;
    	static FileOutputStream fileOut=null;
    	static BufferedInputStream bufferFileIn=null; 
    	static BufferedOutputStream bufferFileOut=null; 
        static int gBufferedSize = 512;
    	public static void main(String[] args) throws IOException {
    		// TODO Auto-generated method stub
     
            try {
            	//out.txt = 25M
            	File file = new File("D:\\workspace\\io_stream_test","out.txt");
                if(!file.exists())
                {
                	System.out.println("file is not exist");
                	file.createNewFile();
                }
                
            	File file2 = new File("D:\\workspace\\io_stream_test","out_bk.txt");
                if(!file2.exists())
                {
                	System.out.println("file2 is not exist");
                	file2.createNewFile();
                }
                		
                //创建字节输入流、输出流
                fileIn=new FileInputStream(file);
                fileOut=new FileOutputStream(file2);
                //创建缓存流
                bufferFileIn = new BufferedInputStream(fileIn, gBufferedSize);
                bufferFileOut = new BufferedOutputStream(fileOut, gBufferedSize);
                
                byte[] buffer=new byte[gBufferedSize];
                int hasRead=0;
                
                long startTime = System.currentTimeMillis();
                while((hasRead = fileIn.read(buffer)) != -1) {
                	fileOut.write(buffer);			
    			}
                fileOut.flush();
                long endTime = System.currentTimeMillis();
                System.out.println("copy time:"+(endTime-startTime)/1000+"s");
    			
            }finally {
    				fileIn.close();
            	    fileOut.close();
    		}
    	}
    }
    

    2.2.2、字节缓存流(BufferedReader/BufferedWriter

            相比于原始字符流Reader/Writer新增了文本行的读写方式,具体方法:readLine():读取单行文本不包括换行符'\n';newLine():向文件中写入一个换行符'\n'。

    package char_stream;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.Reader;
    import java.io.Writer;;
    
    public class File_Reader_Writer_Sample {
    
    	static private Reader fileIn = null;
    	static private Writer fileOut =null;
    	static private BufferedReader bufferFileIn = null;
    	static private BufferedWriter bufferFileOut =null;	
    	
    	public static void main(String[] args) throws IOException {
    		// TODO Auto-generated method stub
          	File file = new File("D:\\workspace\\io_stream_test","test.txt");
            if(!file.exists())
            {
            	System.out.println("file is not exist");
            	file.createNewFile();
            }
            
        	File file2 = new File("D:\\workspace\\io_stream_test","test_bk.txt");
            if(!file2.exists())
            {
            	System.out.println("file2 is not exist");
            	file2.createNewFile();
            }
            
            fileIn = new FileReader(file);
            fileOut = new FileWriter(file2);
            
            bufferFileIn = new BufferedReader(fileIn,512);       
            bufferFileOut = new BufferedWriter(fileOut, 512);
            		
            String readBuff =null;
            while((readBuff=bufferFileIn.readLine())!=null) {
            	System.out.print(readBuff);
            	bufferFileOut.write(readBuff);
            	bufferFileOut.newLine();
            }        
            bufferFileOut.flush();
    
            fileIn.close();
            fileOut.close();
    		
    	}
    
    }
    

    运行结果:

           

    2.3、转换流(InputStreamReader、OutputStreamWriter

            在《Java网络编程》中,有这样一段话:
            “Reader和Writer最重要的子类是InputStreamReader和OutputStreamWriter类
             InputStreamReader类包含了一个底层输入流,可以从中读取原始字节。它根据指定的编码方式,将这些字节转换为Unicode字符。
            OutputStreamWriter从运行的程序中接收Unicode字符,然后使用指定的编码方式将这些字符转换为字节,再将这些字节写入底层输出流中。”

            转换流的特点
           1. 其是字符流和字节流之间的桥梁
           2. 可对读取到的字节数据经过指定编码转换成字符
           3. 可对读取到的字符数据经过指定编码转换成字节

           什么时候使用转换流呢?
           1,源或者目的对应的设备是字节流,但是操作的却是文本数据,可以使用转换作为桥梁。提高对文本操作的便捷。 
           2,一旦操作文本涉及到具体的指定编码表时,必须使用转换流。

        
            具体的对象体现:
            1. InputStreamReader:字节到字符的桥梁
            2. OutputStreamWriter:字符到字节的桥梁

    这两个流对象是字符体系中的成员,它们有转换作用,本身又是字符流,所以在构造的时候需要传入字节流对象进来。

    字节流InputStream(System.in)转为字符流Reader:

    package byte_to_char_sample;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.io.Reader;
    import java.io.Writer;
    
    public class IoStream_to_ReadWriterSample {
    
    	static private InputStream pre_is = null;
    	static private OutputStream pre_os= null;
    	
    	static private Reader is = null;
    	static private Writer os = null;
    	public static void main(String[] args) throws IOException {
    		// TODO Auto-generated method stub
            
    		pre_is = System.in;
    		pre_os = new FileOutputStream("D:\\workspace\\file_calss_test\\file_learn2.txt");
    		
    		is = new InputStreamReader(pre_is);
    	    os = new OutputStreamWriter(pre_os);
    		
    		char []temp = new char[100];
    		int read_cnt = 0;
    		//while((read_cnt = is.read(temp))>0) {
    		System.out.println("输入字符串:");
    		read_cnt = is.read(temp);
    		System.out.println("read_cnt="+read_cnt+","+new String(temp));
    		os.write(temp,0,read_cnt);
    		//}
    		
    		is.close();
    		os.close();
    	}
    }
    

     

    展开全文
  • 深入理解Java中的各种IO流

    千次阅读 2019-04-05 12:08:50
    程序语言的设计者来说,创建一个好的输入/输出(I/O)系统是一项艰难的任务 < Thinking in Java >       Java IO概要   为了方便理解与阐述,先引入两张图:     &...

    深入理解Java中的IO

    引言:

        对程序语言的设计者来说,创建一个好的输入/输出(I/O)系统是一项艰难的任务 < Thinking in Java >

     

     

     

    Java IO概要

     

    为了方便理解与阐述,先引入两张图:

           a、Java IO中常用的类


      在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader;一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了

     

    Java I/O主要包括如下几个层次,包含三个部分:

      1.流式部分――IO的主体部分;

      2.非流式部分――主要包含一些辅助流式部分的类,如:File类、RandomAccessFile类和FileDescriptor等类;

      3.其他类--文件读取部分的与安全相关的类,如:SerializablePermission类,以及与本地操作系统相关的文件系统的类,如:FileSystem类和Win32FileSystem类和WinNTFileSystem类。

     

      主要的类如下:

         1. File(文件特征与管理):用于文件或者目录的描述信息,例如生成新目录,修改文件名,删除文件,判断文件所在路径等。

         2. InputStream(二进制格式操作):抽象类,基于字节的输入操作,是所有输入流的父类。定义了所有输入流都具有的共同特征。

         3. OutputStream(二进制格式操作):抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。

         4.Reader(文件格式操作):抽象类,基于字符的输入操作。

         5. Writer(文件格式操作):抽象类,基于字符的输出操作。

         6. RandomAccessFile(随机文件操作):一个独立的类,直接继承至Object.它的功能丰富,可以从文件的任意位置进行存取(输入输出)操作

     

     Java中IO流的体系结构如图:

     

    b、Java流类的类结构图:


    1、流的概念和作用

    流:代表任何有能力产出数据的数据源对象或者是有能力接受数据的接收端对象<Thinking in Java>

    流的本质:数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作。 

    流的作用:为数据源和目的地建立一个输送通道。

     

         Java中将输入输出抽象称为流,就好像水管,将两个容器连接起来。流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为流.

     

    2、Java IO所采用的模型  


         Java的IO模型设计非常优秀,它使用Decorator(装饰者)模式,按功能划分Stream,您可以动态装配这些Stream,以便获得您需要的功能。

           例如,您需要一个具有缓冲的文件输入流,则应当组合使用FileInputStream和BufferedInputStream。 

     

    3、IO流的分类

    ·        根据处理数据类型的不同分为:字符流和字节流

    ·        根据数据流向不同分为:输入流和输出流

    ·        按数据来源(去向)分类:

             1、File(文件): FileInputStream, FileOutputStream, FileReader, FileWriter 
             2、byte[]:ByteArrayInputStream, ByteArrayOutputStream 
             3、Char[]: CharArrayReader,CharArrayWriter 
             4、String:StringBufferInputStream, StringReader, StringWriter 
             5、网络数据流:InputStream,OutputStream, Reader, Writer 

     

    字符流和字节流

    流序列中的数据既可以是未经加工的原始二进制数据,也可以是经一定编码处理后符合某种格式规定的特定数据。因此Java中的流分为两种:


     1)  字节流:数据流中最小的数据单元是字节
     2)  字符流:数据流中最小的数据单元是字符, Java中的字符是Unicode编码,一个字符占用两个字节。

     

    字符流的由来: Java中字符是采用Unicode标准,一个字符是16位,即一个字符使用两个字节来表示。为此,JAVA中引入了处理字符的流。因为数据编码的不同,而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时,去查了指定的码表。

     

    输入流和输出流

    根据数据的输入、输出方向的不同对而将流分为输入流和输出流。

    1) 输入流

         程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…),即是将数据源读入到程序的通信通道

     

        

    2) 输出流

       程序向输出流写入数据。将程序中的数据输出到外界(显示器、打印机、文件、网络…)的通信通道。

        

            

    采用数据流的目的就是使得输出输入独立于设备。

    输入流( Input  Stream )不关心数据源来自何种设备(键盘,文件,网络)。
    输出流( Output Stream )不关心数据的目的是何种设备(键盘,文件,网络)。

    3)特性

      相对于程序来说,输出流是往存储介质或数据通道写入数据,而输入流是从存储介质或数据通道中读取数据,一般来说关于流的特性有下面几点:

    1、先进先出,最先写入输出流的数据最先被输入流读取到。

    2、顺序存取,可以一个接一个地往流中写入一串字节,读出时也将按写入顺序读取一串字节,不能随机访问中间的数据。(RandomAccessFile可以从文件的任意位置进行存取(输入输出)操作

    3、只读或只写,每个流只能是输入流或输出流的一种,不能同时具备两个功能,输入流只能进行读操作,对输出流只能进行写操作。在一个数据传输通道中,如果既要写入数据,又要读取数据,则要分别提供两个流。 

     

    4、Java IO流对象

    1.输入字节流InputStream

     

    IO 中输入字节流的继承图可见上图,可以看出:

    1.    InputStream是所有的输入字节流的父类,它是一个抽象类。

    2.    ByteArrayInputStream、StringBufferInputStream(上图的StreamBufferInputStream)、FileInputStream是三种基本的介质流,它们分别从Byte数组、StringBuffer、和本地文件中读取数据。

    3.    PipedInputStream是从与其它线程共用的管道中读取数据.

    4.    ObjectInputStream和所有FilterInputStream的子类都是装饰流(装饰器模式的主角)。

     

     

     

    InputStream中的三个基本的读方法
          abstract int read() :读取一个字节数据,并返回读到的数据,如果返回-1,表示读到了输入流的末尾。
          intread(byte[]?b) :将数据读入一个字节数组,同时返回实际读取的字节数。如果返回-1,表示读到了输入流的末尾。
          intread(byte[]?b, int?off, int?len) :将数据读入一个字节数组,同时返回实际读取的字节数。如果返回-1,表示读到了输入流的末尾。off指定在数组b中存放数据的起始偏移位置;len指定读取的最大字节数。

    流结束的判断:方法read()的返回值为-1时;readLine()的返回值为null时。

    其它方法
          long skip(long?n):在输入流中跳过n个字节,并返回实际跳过的字节数。
          int available() :返回在不发生阻塞的情况下,可读取的字节数。
          void close() :关闭输入流,释放和这个流相关的系统资源。
          voidmark(int?readlimit) :在输入流的当前位置放置一个标记,如果读取的字节数多于readlimit设置的值,则流忽略这个标记。
          void reset() :返回到上一个标记。
          booleanmarkSupported() :测试当前流是否支持mark和reset方法。如果支持,返回true,否则返回false。

    2.输出字节流OutputStream

     

     

    IO 中输出字节流的继承图可见上图,可以看出:

    1.    OutputStream是所有的输出字节流的父类,它是一个抽象类。

    2.    ByteArrayOutputStream、FileOutputStream是两种基本的介质流,它们分别向Byte数组、和本地文件中写入数据。PipedOutputStream是向与其它线程共用的管道中写入数据。

    3.    ObjectOutputStream和所有FilterOutputStream的子类都是装饰流。

     

     

    outputStream中的三个基本的写方法
       abstract void write(int?b):往输出流中写入一个字节。
         void write(byte[]?b) :往输出流中写入数组b中的所有字节。
         void write(byte[]?b, int?off, int?len) :往输出流中写入数组b中从偏移量off开始的len个字节的数据。


    其它方法
       void flush() :刷新输出流,强制缓冲区中的输出字节被写出。
         void close() :关闭输出流,释放和这个流相关的系统资源。
     

    3.字符输入流Reader

     

    在上面的继承关系图中可以看出:

    1.    Reader是所有的输入字符流的父类,它是一个抽象类。

    2.    CharReader、StringReader是两种基本的介质流,它们分别将Char数组、String中读取数据。PipedReader是从与其它线程共用的管道中读取数据。

    3.    BufferedReader很明显就是一个装饰器,它和其子类负责装饰其它Reader对象。

    4.    FilterReader是所有自定义具体装饰流的父类,其子类PushbackReader对Reader对象进行装饰,会增加一个行号。

    5.    InputStreamReader是一个连接字节流和字符流的桥梁,它将字节流转变为字符流。FileReader可以说是一个达到此功能、常用的工具类,在其源代码中明显使用了将FileInputStream转变为Reader的方法。我们可以从这个类中得到一定的技巧。Reader中各个类的用途和使用方法基本和InputStream中的类使用一致。后面会有Reader与InputStream的对应关系。

     

    主要方法:

         (1) public int read() throws IOException; //读取一个字符,返回值为读取的字符 

         (2) public int read(char cbuf[]) throws IOException; /*读取一系列字符到数组cbuf[]中,返回值为实际读取的字符的数量*/ 
         (3) public abstract int read(char cbuf[],int off,int len) throws IOException; 
    /*读取len个字符,从数组cbuf[]的下标off处开始存放,返回值为实际读取的字符数量,该方法必须由子类实现*/ 

     

    4.字符输出流Writer

     

    在上面的关系图中可以看出:

    1.    Writer是所有的输出字符流的父类,它是一个抽象类。

    2.    CharArrayWriter、StringWriter是两种基本的介质流,它们分别向Char数组、String中写入数据。PipedWriter是向与其它线程共用的管道中写入数据,

    3.    BufferedWriter是一个装饰器为Writer提供缓冲功能。

    4.    PrintWriter和PrintStream极其类似,功能和使用也非常相似。

    5.    OutputStreamWriter是OutputStream到Writer转换的桥梁,它的子类FileWriter其实就是一个实现此功能的具体类(具体可以研究一SourceCode)。功能和使用和OutputStream极其类似.

     

     

     

    主要方法:

    (1)  public void write(int c) throws IOException; //将整型值c的低16位写入输出流 
    (2)  public void write(char cbuf[]) throws IOException; //将字符数组cbuf[]写入输出流 
    (3)  public abstract void write(char cbuf[],int off,int len) throws IOException; //将字符数组cbuf[]中的从索引为off的位置处开始的len个字符写入输出流 
    (4)  public void write(String str) throws IOException; //将字符串str中的字符写入输出流 
    (5)  public void write(String str,int off,int len) throws IOException; //将字符串str 中从索引off开始处的len个字符写入输出流 

     

    5.字节流的输入与输出的对应

     

    图中蓝色的为主要的对应部分,红色的部分就是不对应部分。从上面的图中可以看出JavaIO中的字节流是极其对称的。“存在及合理”我们看看这些字节流中不太对称的几个类吧!

     

    1.    LineNumberInputStream主要完成从流中读取数据时,会得到相应的行号,至于什么时候分行、在哪里分行是由改类主动确定的,并不是在原始中有这样一个行号。在输出部分没有对应的部分,我们完全可以自己建立一个LineNumberOutputStream,在最初写入时会有一个基准的行号,以后每次遇到换行时会在下一行添加一个行号,看起来也是可以的。好像更不入流了。

    2.    PushbackInputStream的功能是查看最后一个字节,不满意就放入缓冲区。主要用在编译器的语法、词法分析部分。输出部分的BufferedOutputStream几乎实现相近的功能。

    3.    StringBufferInputStream已经被Deprecated,本身就不应该出现在InputStream部分,主要因为String应该属于字符流的范围。已经被废弃了,当然输出部分也没有必要需要它了!还允许它存在只是为了保持版本的向下兼容而已。

    4.    SequenceInputStream可以认为是一个工具类,将两个或者多个输入流当成一个输入流依次读取。完全可以从IO包中去除,还完全不影响IO包的结构,却让其更“纯洁”――纯洁的Decorator模式。

    5.    PrintStream也可以认为是一个辅助工具。主要可以向其他输出流,或者FileInputStream写入数据,本身内部实现还是带缓冲的。本质上是对其它流的综合运用的一个工具而已。一样可以踢出IO包!System.out和System.out就是PrintStream的实例!

     

    字符流的输入与输出的对应

     

    6.字符流与字节流转换

    转换流的特点:

    1.    其是字符流和字节流之间的桥梁

    2.    可对读取到的字节数据经过指定编码转换成字符

    3.    可对读取到的字符数据经过指定编码转换成字节

     

    何时使用转换流?

    1.    当字节和字符之间有转换动作时;

    2.    流操作的数据需要编码或解码时。

     

    具体的对象体现:

    转换流:在IO中还存在一类是转换流,将字节流转换为字符流,同时可以将字符流转化为字节流。

     

    1.    InputStreamReader:字节到字符的桥梁

    2.     OutputStreamWriter:字符到字节的桥梁

     

    OutputStreamWriter(OutStreamout):将字节流以字符流输出。

    InputStreamReader(InputStream in):将字节流以字符流输入。

     

    这两个流对象是字符体系中的成员,它们有转换作用,本身又是字符流,所以在构造的时候需要传入字节流对象进来。

    7.字节流和字符流的区别(重点)

    字节流和字符流的区别:(详细可以参见http://blog.csdn.net/qq_25184739/article/details/51203733)    

     

             节流没有缓冲区,是直接输出的,而字符流是输出到缓冲区的。因此在输出时,字节流不调用colse()方法时,信息已经输出了,而字符流只有在调用close()方法关闭缓冲区时,信息才输出。要想字符流在未关闭时输出信息,则需要手动调用flush()方法。

     

    ·        读写单位不同:字节流以字节(8bit)为单位,字符流以字符为单位,根据码表映射字符,一次可能读多个字节。

    ·        处理对象不同:字节流能处理所有类型的数据(如图片、avi等),而字符流只能处理字符类型的数据。

     

    结论:只要是处理纯文本数据,就优先考虑使用字符流。除此之外都使用字节流。

     

    8.非流式文件类--File类

      从定义看,File类是Object的直接子类,同时它继承了Comparable接口可以进行数组的排序。

    File类的操作包括文件的创建、删除、重命名、得到路径、创建时间等,以下是文件操作常用的函数。

     

     

    File类是对文件系统中文件以及文件夹进行封装的对象,可以通过对象的思想来操作文件和文件夹。File类保存文件或目录的各种元数据信息,包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名,判断指定文件是否存在、获得当前目录中的文件列表,创建、删除文件和目录等方法。 

    File类共提供了三个不同的构造函数,以不同的参数形式灵活地接收文件和目录名信息。

    构造函数:
    1)File (String   pathname)   
         例:File  f1=new File("FileTest1.txt"); //创建文件对象f1,f1所指的文件是在当前目录下创建的FileTest1.txt
    2)File (String  parent  ,  String child)
         例:File f2=new  File(“D:\\dir1","FileTest2.txt") ;//  注意:D:\\dir1目录事先必须存在,否则异常
    3)File (File    parent  , String child)
         例:File  f4=new File("\\dir3");
              File  f5=new File(f4,"FileTest5.txt");  //在如果 \\dir3目录不存在使用f4.mkdir()先创建

            一个对应于某磁盘文件或目录的File对象一经创建, 就可以通过调用它的方法来获得文件或目录的属性。    
           1)public boolean exists( ) 判断文件或目录是否存在
           2)public boolean isFile( ) 判断是文件还是目录 
           3)public boolean isDirectory( ) 判断是文件还是目录
           4)public String getName( ) 返回文件名或目录名
           5)public String getPath( ) 返回文件或目录的路径。
           6)public long length( ) 获取文件的长度 
           7)public String[ ] list ( ) 将目录中所有文件名保存在字符串数组中返回。 
           File类中还定义了一些对文件或目录进行管理、操作的方法,常用的方法有:
           1) public boolean renameTo( File newFile );    重命名文件
           2) public void delete( );   删除文件
           3)  public boolean mkdir( ); 创建目录

    例子:

     

    [java]  view plain  copy
     
    1. 1.  public class FileDemo1 {     
    2. 2.      public static void main(String[] args) {    
    3. 3.          File file = new File("D:" + File.separator + "test.txt");     
    4. 4.          if (file.exists()) {     
    5. 5.              file.delete();    
    6. 6.          } else {     
    7. 7.              try {     
    8. 8.                  file.createNewFile();    
    9. 9.              } catch (IOException e) {    
    10. 10.                 // TODO Auto-generated catch block     
    11. 11.                 e.printStackTrace();    
    12. 12.             }    
    13. 13.         }    
    14. 14.     }    
    15. 15. }    

     

    9.RandomAccessFile类

     

    该对象并不是流体系中的一员,其封装了字节流,同时还封装了一个缓冲区(字符数组),通过内部的指针来操作字符数组中的数据。该对象特点:

     

     

    1.    该对象只能操作文件,所以构造函数接收两种类型的参数:a.字符串文件路径;b.File对象。

    2.    该对象既可以对文件进行读操作,也能进行写操作,在进行对象实例化时可指定操作模式(r,rw)

     

    注意:该对象在实例化时,如果要操作的文件不存在,会自动创建;如果文件存在,写数据未指定位置,会从头开始写,即覆盖原有的内容。 可以用于多线程下载或多个线程同时写数据到文件。

     

    10、System类对IO的支持

     针对一些频繁的设备交互,Java语言系统预定了3个可以直接使用的流对象,分别是:

    ·        System.in(标准输入),通常代表键盘输入。

    ·        System.out(标准输出):通常写往显示器。

    ·        System.err(标准错误输出):通常写往显示器。

     标准I/O
          Java程序可通过命令行参数与外界进行简短的信息交换,同时,也规定了与标准输入、输出设备,如键盘、显示器进行信息交换的方式。而通过文件可以与外界进行任意数据形式的信息交换。


    1. 命令行参数

    [java]  view plain  copy
     
    1. public class TestArgs {    
    2.     public static void main(String[] args) {    
    3.         for (int i = 0; i < args.length; i++) {    
    4.             System.out.println("args[" + i + "] is <" + args[i] + ">");    
    5.         }    
    6.     }    
    7. }    



    运行命令:java Java C VB


    运行结果:

    [java]  view plain  copy
     
    1. args[0] is <Java>  
    2.   
    3.   
    4. args[1] is <C>  
    5.   
    6.   
    7. args[2] is <VB>  


    2. 标准输入,输出数据流

     


    java系统自带的标准数据流:java.lang.System:

    [java]  view plain  copy
     
    1. java.lang.System     
    2. public final class System  extends Object{     
    3.    static  PrintStream  err;//标准错误流(输出)    
    4.    static  InputStream  in;//标准输入(键盘输入流)    
    5.    static  PrintStream  out;//标准输出流(显示器输出流)    
    6. }    


    注意:
    (1)System类不能创建对象,只能直接使用它的三个静态成员。
    (2)每当main方法被执行时,就自动生成上述三个对象。

    1) 标准输出流 System.out

       System.out向标准输出设备输出数据,其数据类型为PrintStream。方法:

          Void print(参数)
          Void println(参数)
    2)标准输入流 System.in

        System.in读取标准输入设备数据(从标准输入获取数据,一般是键盘),其数 据类型为InputStream。方法:

            int read()  //返回ASCII码。若,返回值=-1,说明没有读取到任何字节读取工作结束。
            int read(byte[] b)//读入多个字节到缓冲区b中返回值是读入的字节数
    例如:

    [java]  view plain  copy
     
    1. import java.io.*;    
    2. public class StandardInputOutput {    
    3.     public static void main(String args[]) {    
    4.         int b;    
    5.         try {    
    6.             System.out.println("please Input:");    
    7.             while ((b = System.in.read()) != -1) {    
    8.                 System.out.print((char) b);    
    9.             }    
    10.         } catch (IOException e) {    
    11.             System.out.println(e.toString());    
    12.         }    
    13.     }    
    14. }    

    等待键盘输入,键盘输入什么,就打印出什么:

    3)标准错误流

       System.err输出标准错误,其数据类型为PrintStream。可查阅API获得详细说明。

        标准输出通过System.out调用println方法输出参数并换行,而print方法输出参数但不换行。println或print方法都通 过重载实现了输出基本数据类型的多个方法,包括输出参数类型为boolean、char、int、long、float和double。同时,也重载实现 了输出参数类型为char[]、String和Object的方法。其中,print(Object)和println(Object)方法在运行时将调 用参数Object的toString方法。

    [java]  view plain  copy
     
    1. import java.io.BufferedReader;    
    2. import java.io.IOException;    
    3. import java.io.InputStreamReader;    
    4.     
    5. public class StandardInputOutput {    
    6.     public static void main(String args[]) {    
    7.         String s;    
    8.         // 创建缓冲区阅读器从键盘逐行读入数据    
    9.         InputStreamReader ir = new InputStreamReader(System.in);    
    10.         BufferedReader in = new BufferedReader(ir);    
    11.         System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出"    
    12.                 + "\nWindows系统: ctrl-z 退出");    
    13.         try {    
    14.             // 读一行数据,并标准输出至显示器    
    15.             s = in.readLine();    
    16.             // readLine()方法运行时若发生I/O错误,将抛出IOException异常    
    17.             while (s != null) {    
    18.                 System.out.println("Read: " + s);    
    19.                 s = in.readLine();    
    20.             }    
    21.             // 关闭缓冲阅读器    
    22.             in.close();    
    23.         } catch (IOException e) { // Catch any IO exceptions.    
    24.             e.printStackTrace();    
    25.         }    
    26.     }    
    27. }    

     

     

    在Java语言中使用字节流和字符流的步骤基本相同,以输入流为例,首先创建一个与数据源相关的流对象,然后利用流对象的方法从流输入数据,最后执行close()方法关闭流。


    附加:

     IOException异常类的子类
    1.public class  EOFException :   非正常到达文件尾或输入流尾时,抛出这种类型的异常。    

          2.public class FileNotFoundException:   当文件找不到时,抛出的异常。

          3.public class InterruptedIOException: 当I/O操作被中断时,抛出这种类型的异常。

     

    转载:http://blog.csdn.net/qq_25184739/article/details/51205186

    展开全文
  • Java IO流经典练习题

    万次阅读 多人点赞 2016-09-19 09:10:05
    本文对javaIO流的练习题做了比较详细的解答,其中有比较基础的,也有比较繁琐的,都是可以加深对javaIO流的全面的理解

    Java IO流经典练习题

     

    本文对javaIO流的13道经典的练习题做解答,里面有详细的思路解析,做题时最好养成先写思路在编程的习惯。

     

    一.练习


    (一) 在电脑D盘下创建一个文件为HelloWorld.txt文件,判断他是文件还是目录,在创建一个目
    IOTest,之后将HelloWorld.txt移动到IOTest目录下去;之后遍历IOTest这个目录下的文


    (二) 递归实现输入任意目录,列出文件以及文件夹,效果看图


    (三) 递归实现列出当前工程下所有.java文件


    (四)从磁盘读取一个文件到内存中,再打印到控制台


    (五) 在程序中写一个"HelloJavaWorld你好世界"输出到操作系统文件Hello.txt文件中


    (六) 拷贝一张图片,从一个目录到另外一个目录下(PS:是拷贝是不是移动)


    (七) 统计一个文件calcCharNum.txt(见附件)中字母'A'和'a'出现的总次数


    (八)统计一个文件calcCharNum.txt(见附件)中各个字母出现次数:

    A(8),B(16),C(10)...,a(12),b(10),c(3)....,括号内代表字符出现次数;


    (九)统计一个文件calcCharNum2.txt(见附件)中各个字母出现次数:
    A(8),B(16),C(10)...,a(12),b(10),c(3)....中(5),国(6),括号内代表字符出现次数;


    (十) 使用随机文件流类RandomAccessFile将一个文本文件倒置读出。


    (十一) 编写一个Java应用程序,可以实现Dos中的type命令,并加上行号。

    即将文本文件在控制台上显示出来,并在每一行的前面加上行号。


    (十二)输入两个文件夹名称,将A文件夹内容全部拷贝到B文件夹,要求使用多线程来操作。


    (十三)查看D盘中所有的文件和文件夹名称,并且使用名称升序降序,文件夹在前和文件夹在
    后,文件大小排序等 


    二.详细的解题过程

     


    (一)第一题



    package com.xykj.lesson1;
    
    import java.io.File;
    import java.io.IOException;
    
    
    public class Test1 {
    	/**
    	 * 1. 在电脑D盘下创建一个文件为HelloWorld.txt文件,
    	 * 判断他是文件还是目录,再创建一个目录IOTest,
    	 * 之后将HelloWorld.txt移动到IOTest目录下去;
    	 * 之后遍历IOTest这个目录下的文件
    	 * 
    	 * 程序分析:
    	 * 1、文件创建使用File的createNewFile()方法
    	 * 2、判断是文件用isFile(),判断是目录用isDirectory
    	 * 3、创建目录用:mkdirs()方法
    	 * 4、移动文件用:renameTo
    	 * 5、遍历目录用:list()方法获得存放文件的数组,foreach遍历的方法把文件打印出来
    	 * */
    	public static void main(String[] args) {
    		 //在电脑D盘下创建一个文件为HelloWorld.txt文件
    		File file=new File("D:","HelloWorld.txt");
    		
    		//创建文件,返回一个布尔值
    		boolean isCreate;
    		try {
    			isCreate = file.createNewFile();
    			if (isCreate) {
    				System.out.println("创建文件成功!");
    			}else {
    				System.out.println("创建文件失败!文件已经存在");
    			}
    		} catch (IOException e) {
    			System.out.println("创建文件失败!");
    		}
    		
    		// 判断他是文件还是目录,
    		if (file.isFile()) {
    			System.out.println("这是一个文件");
    		} else {
    			System.out.println("这是一个目录");
    		}
    		
    		//再创建一个目录IOTest
    		File file2=new File("D:/IOTest");
    		file2.mkdirs();
    		
    		//HelloWorld.txt移动到IOTest目录下去?失败?》
    		if (file.renameTo(file2)) {
    			System.out.println("文件移动成功!");
    		} else {
    			System.out.println("文件移动失败");
    		}
    		
    		//遍历IOTest目录下的文件
    		String[] arr=file2.list();
    		for (String string : arr) {
    			System.out.println(string);
    		}
    	}
    }
    

     

    //上面移动文件要指明文件路径和文件名

    上面的file.renameTo(file2)改为:

    file.renameTo(file2.getPath + "/" + file.getName());

    就不会有错了。



    (二)第二题

     

    1.先建一个FileUtile工具类

     

     

    package com.xykj.lesson2;
    
    import java.io.File;
    import java.util.ArrayList;
    import java.util.List;
    	/**
    	 * 这是一个获取目录下所有文件夹内的所有文件的封装类
    	 * 当然前提是你要传进来一个正确路径的文件夹
    	 * */
    public class FileUtils {
    	
    	//获取文件夹下所有的文件
    	public static List
       
         getAllFiles(String dir){
    		
    		//创建一个集合存放遍历到的File
    		List< File >files=new ArrayList
        
         ();
    		
    		File file=new File(dir);
    		//文件夹必须存在                并且要是文件夹
    		if (file.exists()&&file.isDirectory()) {
    			//重点!    这里要本身一直遍历
    			longErgodic(file,files);//把遍历得到的东西存放在files里面
    		}
    		return files;
    	}
    	
    	//重点理解,这是一个递归方法,会不断来回调用本身,但是所有获得的数据都会存放在集合files里面
    	private static void longErgodic(File file, List
         
           files) {
    		
    		//.listFiles()方法的使用
    		//把文件夹的所有文件(包括文件和文件名)都放在一个文件类的数组里面 
    		File[] fillArr=file.listFiles();
    		
    		//如果是一个空的文件夹
    		 if (fillArr==null) {
    			 //后面的不执行,直接返回
    			return;
    		}
    		 
    		//如果文件夹有内容,遍历里面的所有文件(包括文件夹和文件),都添加到集合里面
    		 for (File file2 : fillArr) {
    			 
    			 //如果只是想要里面的文件或者文件夹或者某些固定格式的文件可以判断下再添加
    			 files.add(file2);
    			 
    			 //添加到集合后,在来判断是否是文件夹,再遍历里面的所有文件
    			 //方法的递归
    			 longErgodic(file2, files);
    		}
    	}
    }
    
         
        
       




     

    2.再建一个主方法调用类



    package com.xykj.lesson2;
    
    import java.io.File;
    import java.util.List;
    
    public class Test2 {
    	/**
    	 * 递归实现输入任意目录,列出文件以及文件夹
    	 * 
    	 * 设计:在FileUtils类里面实现了逻辑操作,在另一边调用就可以了
    	 * */
    	public static void main(String[] args) {
    		 //比如输入D盘
    		List
       
        list=FileUtils.getAllFiles("D:");
    		//输出所有的文件和文件夹的名字
    		for (File file : list) {
    			System.out.println(file);
    		}
    
    	}
    
    }
    
       




    (三)第三题



    package com.xykj.lesson3;
    
    import java.io.File;
    import java.util.List;
    
    import com.xykj.lesson2.FileUtils;
    
    public class Test3 {
    	/**
    	 * 递归实现列出当前工程下所有.java文件
    	 * 还是要题目2的遍历文件的工具类来获取所有的文件,再过滤.java文件就可以了
    	 * 当前目录的地址:输入.就可以获取
    	 * */
    	public static void main(String[] args) {
    		 //输入.  获取当前文件的 所有文件
    		List
       
        list=FileUtils.getAllFiles(".");
    		//输出.java后缀的文件的名字
    		for (File file : list) {
    			if (file.toString().endsWith(".java")) {
    				System.out.println(file.getName());
    			}
    		}
    
    	}
    
    }
    
       




    (四)第四题

     

     

    package com.xykj.lesson4;
    
    import java.io.File;
    import java.io.FileInputStream;
    
    public class Tset4 {
    	/**
    	 * 从磁盘读取一个文件到内存中,再打印到控制台
    	 * 
    	 * 程序设计:
    	 * 1、读取文件用到FileinputSteam 
    	 * 2、把读取的内容不断加入到StringBuffer,
    	 * 3、再把StringBuffer打印出来就可以
    	 * */
    	public static void main(String[] args) {
    
    		// 读取D:\notePad\aa.txt里面的内容
    		File file = new File("D:\\notePad\\aa.txt");
    		try {
    			// 创建读取流即输入流
    			FileInputStream fis = new FileInputStream(file);
    			int len = 0;
    			byte[] buf = new byte[1024];
    			StringBuffer sb = new StringBuffer();
    			// 把读取的数据添加到StringBuffer里面
    			while ((len = fis.read(buf)) != -1) {
    				sb.append(new String(buf, 0, len));
    			}
    			// 把StringBuffer里面的内容打印出来
    			System.out.println(sb);
    			fis.close();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    


     


    (五)第五题

     

     

    package com.xykj.lesson5;
    
    import java.io.File;
    import java.io.FileOutputStream;
    
    public class Test5 {
    	/**
    	 * 在程序中写一个"HelloJavaWorld你好世界"输出到操作系统文件Hello.txt文件中
    	 * 
    	 * 程序分析:文件写入,要用到输出流FileOutputStream
    	 * */
    	public static void main(String[] args) {
    		// 向文件D:/Hello.txt,写入内容
    		File file = new File("D:/Hello.txt");
    		try {
    			// 创建输出流
    			FileOutputStream fos = new FileOutputStream(file);
    			//把String类型的字符串转化为byte数组的数据保存在输出流中
    			fos.write("HelloJavaWorld你好世界".getBytes());
    			fos.flush();//刷新输出流
    			fos.close();//关闭输出流
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    

     


     

    (六)第六题

     

     

    package com.xykj.lesson6;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    public class Test6 {
    	/**
    	 * 拷贝一张图片,从一个目录到另外一个目录下(PS:是拷贝是不是移动)
    	 * 
    	 * 程序设计思路:
    	 *  这题不能使用renameTo, 
    	 *  解题步骤:
    	 * 1、在目的地址创建一个图片文件
    	 * 2、读取源地址文件的字节流
    	 * 3、把读取到的字节流写入到目的地址的文件里面 
    	 * 4、刷新输出流,并关闭就可以了
    	 * 
    	 * @throws Exception
    	 * */
    	public static void main(String[] args) {
    		// 本题示范把D盘下的mm.jpg复制到D盘java文件夹里面
    		// 源文件地址
    		File fileFrom = new File("D:/mm.jpg");
    		// 目的文件地址
    		File fileTo = new File("D:/java/mm.jpg");
    
    		// 1、创建目的文件地址
    		try {
    			if (!fileTo.createNewFile()) {
    				System.out.println("创建文件失败!");
    			}
    			// 2、读取源地址文件的字节流
    			FileInputStream fis = new FileInputStream(fileFrom);
    			FileOutputStream fos = new FileOutputStream(fileTo);
    			int len = 0;
    			byte[] buf = new byte[1024];
    			while ((len = fis.read(buf)) != -1) {
    				// 3、把读取到的字节流写入到目的地址的文件里面
    				fos.write(buf, 0, len);
    			}
    			// 刷新下输出流
    			fos.flush();
    			// 关闭输入流和输出流
    			fis.close();
    			fos.close();
    			System.out.println("文件复制成功!");
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    }
    

     



     

    (七)第七题

     

     

    package com.xykj.lesson7;
    
    import java.io.File;
    import java.io.FileInputStream;
    
    public class Test7 {
    	/**
    	 * 统计一个文件calcCharNum.txt(见附件)中字母'A'和'a'出现的总次数
    	 * 
    	 * 程序分析:
    	 * 读取文件用FileInputStream
    	 * 一次只读一个字节(一个字母就是一个字节),当字节内容和A或a相等时,相应的数量加1
    	 * */
    	public static void main(String[] args) {
    		try {
    			//添加文件路径
    			File file = new File("D:/java/calcCharNum.txt");
    			//创建文件读取流
    			FileInputStream fis = new FileInputStream(file);
    			int numA = 0;//字母A的数量
    			int numa = 0;//字母a的数量
    			int len = 0;//每次读取的字节数量
    			while ((len=fis.read())!= -1) {
    				//统计字母a的数量
    				if (new String((char)len+"").equals("a")) {
    					numa++;
    				}
    				//统计字母A的数量
    				if (new String((char)len+"").equals("A")) {
    					numA++;
    				}
    			}
    			//打印出文件内字母的数量
    			System.out.println("a的数量是:"+numa);
    			System.out.println("A的数量是:"+numA);
    			System.out.println("a和A出现的总次数:"+(numA+numa));
    			fis.close();//关闭输入流
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    
    	}
    
    }
    




    (八)第八题

     

    package com.xykj.lesson8;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map.Entry;
    
    public class Test8 {
    	/**
    	 * 统计一个文件calcCharNum.txt(见附件)中各个字母出现次数:
    	 * A(8),B(16),C(10)...,a(12),b(10),c(3)....,括号内代表字符出现次数;
    	 *
    	 * 程序分析:
    	 * 1.这里没中文字符,依然可以只用字节流来读取文件
    	 * 2.不能保存相同的主键值,可以使用HashMap:key-value来实现
    	 * 3.先获得该key的value,如果存在key的话value的值加1 
    	 * */
    	public static void main(String[] args) {
    
    		// 文件路径
    		File file = new File("D:/java/calcCharNum.txt");
    		try {
    
    			// 创建读取文件的输入流
    			FileInputStream fis = new FileInputStream(file);
    			// 创建集合HashMap类存放要保存的key-value
    			HashMap
       
         map = new HashMap<>();
    
    			// 读取文件
    			int len = 0;// 每次读取的文件长度
    			int count = 0;
    			while ((len = fis.read()) != -1) {
    				// 每次获取到的字母
    				char c = (char) len;
    				//这里使用try catch是因为 map.get(c + ""),第一次get不到东西会出现空指针
    				try {
    					// 通过每次的key值获取它的value值,
    					// 但是在它的key值没有时或报空指针错误,所以要try catch处理
    					// 当她有key值,就可以获取到相应的value值
    					count = map.get(c + "");
    				} catch (Exception e) {// 什么都不用输出
    				}
    				// 如果有它的key值对应的value值要加1
    				map.put(c + "", count + 1);
    			}
    			fis.close();
    			
    			// 读完后把结果打印出来
    			//迭代器的使用
    			Iterator
        
         
          > iterator = map.entrySet().iterator();
    			while (iterator.hasNext()) {
    				Entry
          
            entry = iterator.next();
    				System.out.print(entry.getKey() + "(" + entry.getValue()+ ") \t");
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    
          
         
        
       

     

    其实本题也可以直接用字符流来读取的。




    (九)第九题

     

     

    package com.xykj.lesson9;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map.Entry;
    
    public class Test9 {
    	/**
    	 * 统计一个文件calcCharNum2.txt(见附件)中各个字母出现次数:
    	 * A(8),B(16),C(10)...,a(12),b(10),c(3)....中(5),国(6),
    	 * 括号内代表字符出现次数;
    	 * 
    	 * 程序分析:
    	 * 1.这出现中文字符,依然只能用字符流来读取文件
    	 * 2.不能保存相同的主键值,可以使用HashMap:key-value来实现
    	 * 3.先获得该key的value,如果存在key的话value的值加1 
    	 * */
    	public static void main(String[] args) {
    		// 文件路径
    		File file = new File("D:/java/calcCharNum2.txt");
    		// 创建集合HashMap类存放要保存的key-value
    		HashMap
       
         map = new HashMap<>();
    
    		try {
    
    			// 创建字符流
    			FileReader fr = new FileReader(file);
    			// 每次读取的字符长度
    			int len = 0;
    			int count=0;//出现该字符的次数
    			while ((len = fr.read()) != -1) {
    				// 获取对应的字符
    				char c = (char) len;
    				try {
    					// 通过每次的key值获取它的value值,
    					// 但是在它的key值没有时或报空指针错误,所以要try catch处理
    					// 当她有key值,就可以获取到相应的value值
    					count = map.get(c + "");
    				} catch (Exception e) {// 什么都不用输出
    				}
    				// 如果有它的key值对应的value值要加1
    				map.put(c + "", count + 1);
    			}
    			
    			// 读完后把结果打印出来
    			Iterator
        
         
          > iterator = map.entrySet().iterator();
    			
    			//迭代器的使用
    			while (iterator.hasNext()) {				
    				Entry
          
            entry = iterator.next();
    				System.out.print(entry.getKey() + "(" + entry.getValue()+ ") \t");
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    
    	}
    
    }
    
          
         
        
       




    (十)第十题

     

    package com.xykj.lesson10;
    
    import java.io.File;
    import java.io.RandomAccessFile;
    
    public class Test10 {
    	/**
    	 * 使用随机文件流类RandomAccessFile将一个文本文件倒置读出。
    	 * 
    	 * 程序分析:
    	 *  RandomAccessFile的seek方法能把读取文件的光标移动到具体的位置
    	 * 但是还是有地点值得注意的是一个字母或数字是占用一个字节的, 一个汉字是占用两个字节的
    	 * */
    	public static void main(String[] args) {
    		// 要读取的文件的地址
    		File file = new File("D:/java/calcCharNum2.txt");
    		try {
    			RandomAccessFile raf = new RandomAccessFile(file, "r");
    			long length = raf.length();
    			StringBuffer sb = new StringBuffer();
    			while (length > 0) {
    				length--;
    				raf.seek(length);
    				int c = (char) raf.readByte();
    				// 如果asc码<=255,>=0,则判断是个英文字符,添加到字符串中.
    				if (c >= 0 && c <= 255) {
    					sb.append((char) c);
    				} else {
    					// 如果不在asc码范围内,则判断是个汉字字符
    					// 汉字字符是占2个字节的,所以length再退一个字节
    					length--;
    					raf.seek(length);
    					byte[] cc = new byte[2];
    					// cc被复制为文件中连续的两个字节
    					raf.readFully(cc);
    					sb.append(new String(cc));
    				}
    			}
    			System.out.println(sb);
    			raf.close();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    }
    




    (十一)第十一题

     

    package com.xykj.lesson1;
    
    import java.io.File;
    import java.io.IOException;
    
    
    public class Test1 {
    	/**
    	 * 1. 在电脑D盘下创建一个文件为HelloWorld.txt文件,
    	 * 判断他是文件还是目录,再创建一个目录IOTest,
    	 * 之后将HelloWorld.txt移动到IOTest目录下去;
    	 * 之后遍历IOTest这个目录下的文件
    	 * 
    	 * 程序分析:
    	 * 1、文件创建使用File的createNewFile()方法
    	 * 2、判断是文件用isFile(),判断是目录用isDirectory
    	 * 3、创建目录用:mkdirs()方法
    	 * 4、移动文件用:renameTo
    	 * 5、遍历目录用:list()方法获得存放文件的数组,foreach遍历的方法把文件打印出来
    	 * */
    	public static void main(String[] args) {
    		 //在电脑D盘下创建一个文件为HelloWorld.txt文件
    		File file=new File("D:","HelloWorld.txt");
    		
    		//创建文件,返回一个布尔值
    		boolean isCreate;
    		try {
    			isCreate = file.createNewFile();
    			if (isCreate) {
    				System.out.println("创建文件成功!");
    			}else {
    				System.out.println("创建文件失败!文件已经存在");
    			}
    		} catch (IOException e) {
    			System.out.println("创建文件失败!");
    		}
    		
    		// 判断他是文件还是目录,
    		if (file.isFile()) {
    			System.out.println("这是一个文件");
    		} else {
    			System.out.println("这是一个目录");
    		}
    		
    		//再创建一个目录IOTest
    		File file2=new File("D:/IOTest");
    		file2.mkdirs();
    		
    		//HelloWorld.txt移动到IOTest目录下去?失败?》
    		if (file.renameTo(file2)) {
    			System.out.println("文件移动成功!");
    		} else {
    			System.out.println("文件移动失败");
    		}
    		
    		//遍历IOTest目录下的文件
    		String[] arr=file2.list();
    		for (String string : arr) {
    			System.out.println(string);
    		}
    	}
    }
    



     

    (十二)第十二题

     

    package com.xykj.lesson12;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.List;
    import java.util.Scanner;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    import com.xykj.lesson2.FileUtils;
    
    
    public class Test12 {
    	/*
    	 * 输入两个文件夹名称,将A文件夹内容全部拷贝到B文件夹,要求使用多线程来操作。
    	 * 
    	 * 程序分析:
    	 * 1.拷贝文件里面的东西,要分析的东西还是蛮多的,要先建文件夹再拷贝里面的东西,而且要一层层的来搞
    	 * 2.这里也需要文件遍历工具,直接调用第二题的工具类,不再重写
    	 * 3.多线程的使用,可以直接在方法里面直接新建线程
    	 * 4.对整个文件夹进行复制 文件夹分隔符可以用\\或/,其他的都是不对的
    	 * 所有其中还对输入的分割符进行了替换
    	 * 这题看起来比较长,分开看其实也不长
    	 * */
    	public static void main(String[] args) {
    		Scanner scanner=new Scanner(System.in);
    		System.out.println("要复制的文件夹:");
    		String fromDir = scanner.next();// 接收输入
    		System.out.println("要复制到哪里去:");
    		String toDir = scanner.next();// 接收输入
    
    		// 把输入的地址转化为File类型
    		File fromFile = new File(fromDir);
    		File toFile = new File(toDir);
    		
    		//新建线程
    		new Thread(){
    			//里面做实际操作
    			public void run() {
    				// 判断如果要复制的是文件,直接复制就可以了
    				if (fromFile.isFile()) {
    					System.out.println("复制单个文件");
    					copy(fromFile, toFile);
    				} else {
    					// 要复制文件夹
    					// 要防止一种无法进行的复制:比如说,要把复制的文件复制到自己的子文件夹里面
    					// 举个例子:把D:/java/jsp文件夹复制到D:/java/jsp/js文件夹里面,
    					// 这会导致子文件不断增加的同时,而父文件也要不断增加,的一个死循环
    					// 如果反过来,就没事,相当于只是简单的覆盖而已
    					// 具体实现就是看:目的地地址包含复制的文件夹地址,就不允许操作
    					if (toDir.replace("/", "\\").toLowerCase()
    							.startsWith(fromDir.replace("/", "\\").toLowerCase())) {
    						return;
    					}
    
    					// 复制文件(包括文件和文件夹)操作
    
    					// 先获取所有的文件(包括文件和文件夹)
    					List
       
         list = FileUtils.getAllFiles(fromDir);
    
    					// 创建一个线程池,加快复制的速度
    					ExecutorService threadPool = Executors.newFixedThreadPool(20);
    
    					// 需要对每一个文件的路径进行处理
    					for (File file : list) {
    						// 复制文件名
    						String name = file.getAbsolutePath();
    						// 把原来的文件路径换成新的文件路径
    						String toName = name.replace(fromFile.getParent(), toDir + "/");
    						System.out.println(name + "变成了" + toName);
    						// 如果是文件夹,直接创建
    						if (file.isDirectory()) {
    							new File(toName).mkdirs();
    						} else {
    							// 如果是文件,在线程里面复制
    							threadPool.execute(new Runnable() {
    								@Override
    								public void run() {
    									File copyFile = new File(toName);
    									// 先要有父文件夹
    									copyFile.getParentFile().mkdirs();
    
    									// 开始复制文件
    									copy(file, copyFile);
    								}
    							});
    						}
    					}
    
    				}
    				scanner.close();
    			};
    			
    		}.start();//开始线程
    	}
    	
    	//复制文件的操作
    	public static void copy(File fromFile, File toFile) {
    		// 定义一个输入流
    		FileInputStream fis = null;
    		// 定义一个输出流
    		FileOutputStream fos = null;
    
    		try {
    			// 把复制地址的File,封装后赋值给输入流对象
    			fis = new FileInputStream(fromFile);
    			// 把目的地的File,封装后复制给输出流的对象
    			fos = new FileOutputStream(toFile);
    			// 创建一个容量,
    			byte[] buf = new byte[1024];
    			// 每次读取/写入的字节长度
    			int len = 0;
    			// 边读边写
    			while ((len = fis.read(buf)) != -1) {// 判断是否还能读到数据
    				// 把输入放到输出流里面
    				fos.write(buf, 0, len);
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			try {
    				// 关闭输入流和输出流
    				fis.close();
    				fos.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    
    		}
    	}
    
    }
    
       


     


    (十三)第十三题

      

    package com.xykj.lesson13;
    
    import java.io.File;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    import com.xykj.lesson2.FileUtils;
    
    public class Test13 {
    	/**
    	 * 查看D盘中所有的文件和文件夹名称,并且使用名称升序降序,
    	 * 文件夹在前和文件夹在后,文件大小排序等。
    	 * 
    	 * 程序分析:
    	 * 1.查找文件和文件夹,需要例题二里遍历文件的工具类(这里直接调用,不在重写)
    	 * 2.排序需要用到list集合里面的Collections工具类类的sort方法
    	 * 3.这里有三重排序:首先是要按是否是文件夹来排序,然后按名称来排序,最后按大小来排序
    	 *   其实这里还是会有问题的,按照某一个排序还没事,但是三个都排序就不一定有效!
    	   实际应用中也是只按一种排序就可以了的
    	 * */
    	public static void main(String[] args) {
    		 List
       
         list =FileUtils.getAllFiles("D:");
    		 
    		 //按文件夹先显示的顺序:
    		 Collections.sort(list, new Comparator
        
         () {
    			@Override
    			public int compare(File o1, File o2) {
    				return (o2.isDirectory()?1:-1)-(o1.isDirectory()?1:-1);
    			}
    		});
    		
    		 //按文件名称显示的顺序:
    		 Collections.sort(list, new Comparator
         
          () {
    				@Override
    				public int compare(File o1, File o2) {
    					return (o1.getName()).compareTo(o2.getName());
    				}
    			});
    		 
    		 //按文件名称显示的顺序:
    		 Collections.sort(list, new Comparator
          
           () {
    				@Override
    				public int compare(File o1, File o2) {
    					return (int)(o1.length()-o2.length());
    				}
    			});
    			
    		 //遍历集合的文件
    		 for (File file : list) {
    		 //打印排序后的文件或文件夹
    		 System.out.println(file.getName());
    		}
    	}
    }
    
          
         
        
       

     



    以上是这些题目的详细的解题过程,当然很多题目的解决方法不是固定的,

    但是对于基本的解题方式还是要了解的。对于知识点的掌握的话,

    文件的基本操作,读取文件的基本方法,和写文件的基本方法都是要掌握的,

    还有字节流的读取和字符流的读取方式和用处也要会区分。

     

     

     

     

     

    展开全文
  • Java IO流经典练习题详解

    千次阅读 多人点赞 2019-02-20 19:36:44
    Java IO流经典练习题 转载于:https://blog.csdn.net/wenzhi20102321/article/details/52582705 博主对转载的原代码进行了调试,改了一些小问题后,亲测可用。   本文对javaIO流的13道经典的练习题做解答,里面...

                                           Java IO流经典练习题


    转载于:https://blog.csdn.net/wenzhi20102321/article/details/52582705

    博主对转载的原代码进行了调试,改了一些小问题后,亲测可用。

     

    本文对javaIO流的13道经典的练习题做解答,里面有详细的思路解析,做题时最好养成先写思路在编程的习惯。


    (一) 在电脑D盘下创建一个文件为HelloWorld.txt文件,判断他是文件还是目录,在创建

    一个目录IOTest,之后将HelloWorld.txt移动到IOTest目录下去;之后遍历IOTest这个目录下的文件

     

    import java.io.File;
    import java.io.IOException;
    public class Test1 {
        /**
         * 1. 在电脑D盘下创建一个文件为HelloWorld.txt文件,
         * 判断他是文件还是目录,再创建一个目录IOTest,
         * 之后将HelloWorld.txt移动到IOTest目录下去;
         * 之后遍历IOTest这个目录下的文件
         *
         * 程序分析:
         * 1、文件创建使用File的createNewFile()方法
         * 2、判断是文件用isFile(),判断是目录用isDirectory
         * 3、创建目录用:mkdirs()方法
         * 4、移动文件用:renameTo
         * 5、遍历目录用:list()方法获得存放文件的数组,foreach遍历的方法把文件打印出来
         * */
        public static void main(String[] args) {
             //在电脑D盘下创建一个文件为HelloWorld.txt文件
            File file=new File("D:","HelloWorld.txt");
            
            //创建文件,返回一个布尔值
            boolean isCreate;
            try {
                isCreate = file.createNewFile();
                if (isCreate) {
                    System.out.println("创建文件成功!");
                }else {
                    System.out.println("创建文件失败!文件已经存在");
                }
            } catch (IOException e) {
                System.out.println("创建文件失败!");
            }
            
            // 判断他是文件还是目录,
            if (file.isFile()) {
                System.out.println("这是一个文件");
            } else {
                System.out.println("这是一个目录");
            }
            
            //再创建一个目录IOTest
            File file2=new File("D:/IOTest");
            file2.mkdirs();
            
            //HelloWorld.txt移动到IOTest目录下去
           
           //移动文件用:renameTo(File file)里面需要传入一个file类型的对象
    	File file3 = new File(file1.getPath()+"/"+file1.getName()); 
            //File file3 = new File("D:/IOTest/文件名"); //这里的代码加上             
            //file.renameTo(file3)会创建一个文件
    	if(file.renameTo(file3)) {
    		System.out.println("移动成功");
    	}else {
    		System.out.println("移动失败");
    	}
            //遍历IOTest目录下的文件
    	//list() 返回一个字符串数组,命名由此抽象路径名表示的目录中的文件和目录。
    	String[] list = file1.list();
    	for(String str:list) {
    		System.out.println(str);
    	}
     	
      }
    }

     

     

    (二) 递归实现输入任意目录,列出文件以及文件夹,效果看图

    1.先建一个FileUtile工具类

    import java.io.File;
    import java.util.ArrayList;
    import java.util.List;
        /**
         * 这是一个获取目录下所有文件夹内的所有文件的封装类
         * 当然前提是你要传进来一个正确路径的文件夹
         * */
    public class FileUtils {
        
        //获取文件夹下所有的文件
        public static List getAllFiles(String dir){
            
            //创建一个集合存放遍历到的File
            List< File >files=new ArrayList();
            
            File file=new File(dir);
            //文件夹必须存在                并且要是文件夹
            if (file.exists()&&file.isDirectory()) {
                //重点!    这里要本身一直遍历
                longErgodic(file,files);//把遍历得到的东西存放在files里面
            }
            return files;
        }
        
        //重点理解,这是一个递归方法,会不断来回调用本身,但是所有获得的数据都会存放在集合files里面
        private static void longErgodic(File file, List files) {
            
            //.listFiles()方法的使用
            //把文件夹的所有文件(包括文件和文件名)都放在一个文件类的数组里面
            File[] fillArr=file.listFiles();
            
            //如果文件夹有内容,遍历里面的所有文件(包括文件夹和文件),都添加到集合里面
             for (File file2 : fillArr) {
                
                 //如果只是想要里面的文件或者文件夹或者某些固定格式的文件可以判断下再添加
                 files.add(file2);
                
                 //添加到集合后,在来判断是否是文件夹,再遍历里面的所有文件
                 //方法的递归
                 if(file2.isDirectory()) {
    				longErgodic(file2, files);
    			}
                 
            }
        }
    }
    
    

    2.再建一个主方法调用类

    import java.io.File;
    import java.util.List;
     /**
         * 递归实现输入任意目录,列出文件以及文件夹
         *
         * 设计:在FileUtils类里面实现了逻辑操作,在另一边调用就可以了
         * */
    public class Test2 {
    public static void main(String[] args) {
            //比如输入D盘下自己建的测试文件夹
    	List<File> list = FileUtileTest2.getAllFiles("D:/test");
    	//输出所有的文件和文件夹的名字
            for(File file:list) {
    		System.out.println(file);
    		
    	}
    	
    }
    }
    

     

     

    (三) 递归实现列出当前工程下所有.java文件


     

    import java.io.File;
    import java.util.List;
    
    import com.xykj.lesson2.FileUtils;
    
    public class Test3 {
        /**
         * 递归实现列出当前工程下所有.java文件
         * 还是要题目2的遍历文件的工具类来获取所有的文件,再过滤.java文件就可以了
         * 当前目录的地址:输入.就可以获取
         * */
        public static void main(String[] args) {
             //输入.  获取当前文件的 所有文件
            List<File> list=FileUtils.getAllFiles(".");
            //输出.java后缀的文件的名字
            for (File file : list) {
                if (file.toString().endsWith(".java")) {
                    System.out.println(file.getName());
                }
            }
    
        }
    
    }
    
    

     

    (四)从磁盘读取一个文件到内存中,再打印到控制台

     

    
    import java.io.File;
    import java.io.FileInputStream;
    
    public class Tset4 {
        /**
         * 从磁盘读取一个文件到内存中,再打印到控制台
         *
         * 程序设计:
         * 1、读取文件用到FileinputSteam
         * 2、把读取的内容不断加入到StringBuffer,
         * 3、再把StringBuffer打印出来就可以
         * */
        public static void main(String[] args) {
    
            // 读取D:\notePad\aa.txt里面的内容 
            //java7可以对实现了Closable接口的类使用try catch resource
            //不用将close写在finally{}里面了,不用书写
    
            File file = new File("D:\\notePad\\aa.txt");
            // 创建读取流即输入流  
            try( FileInputStream fis = new FileInputStream(file);) {                      
                int len = 0;
                byte[] buf = new byte[1024];
                StringBuffer sb = new StringBuffer();
                // 把读取的数据添加到StringBuffer里面
                while ((len = fis.read(buf)) != -1) {
                    sb.append(new String(buf, 0, len));
                }
                // 把StringBuffer里面的内容打印出来
                System.out.println(sb);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

     

     

    (五) 在程序中写一个"HelloJavaWorld你好世界"输出到操作系统文件Hello.txt文件中
     

     

    import java.io.File;
    import java.io.FileOutputStream;
    
    public class Test5 {
        /**
         * 在程序中写一个"HelloJavaWorld你好世界"输出到操作系统文件Hello.txt文件中
         *
         * 程序分析:文件写入,要用到输出流FileOutputStream
         * */
        public static void main(String[] args) {
            // 向文件D:/Hello.txt,写入内容
            File file = new File("D:/Hello.txt");
            try( FileOutputStream fos = new FileOutputStream(file);) {
                // 创建输出流
                //把String类型的字符串转化为byte数组的数据保存在输出流中
                fos.write("HelloJavaWorld你好世界".getBytes());
                fos.flush();//刷新输出流
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

     


     

    (六) 拷贝一张图片,从一个目录到另外一个目录下(PS:是拷贝是不是移动)

     

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    public class Test6 {
        /**
         * 拷贝一张图片,从一个目录到另外一个目录下(PS:是拷贝是不是移动)
         *
         * 程序设计思路:
         *  这题不能使用renameTo,
         *  解题步骤:
         * 1、在目的地址创建一个图片文件
         * 2、读取源地址文件的字节流
         * 3、把读取到的字节流写入到目的地址的文件里面
         * 4、刷新输出流,并关闭就可以了
         *
         * @throws Exception
         * */
        public static void main(String[] args) {
            // 本题示范把D盘下的mm.jpg复制到D盘java文件夹里面
            // 源文件地址
            File fileFrom = new File("D:/mm.jpg");
            // 目的文件地址
            File fileTo = new File("D:/java/mm.jpg");
    
            // 1、创建目的文件地址
            try {
                if (!fileTo.createNewFile()) {
                    System.out.println("创建文件失败!");
                }
                // 2、读取源地址文件的字节流
                FileInputStream fis = new FileInputStream(fileFrom);
                FileOutputStream fos = new FileOutputStream(fileTo);
                int len = 0;
                byte[] buf = new byte[1024];
                while ((len = fis.read(buf)) != -1) {
                    // 3、把读取到的字节流写入到目的地址的文件里面
                    fos.write(buf, 0, len);
                }
                // 刷新下输出流
                fos.flush();
                // 关闭输入流和输出流
                fis.close();
                fos.close();
                System.out.println("文件复制成功!");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
    }

     

     

    (七) 统计一个文件calcCharNum.txt(见附件)中字母'A'和'a'出现的总次数

     

    import java.io.File;
    import java.io.FileInputStream;
    
    public class Test7 {
        /**
         * 统计一个文件calcCharNum.txt(见附件)中字母'A'和'a'出现的总次数
         *
         * 程序分析:
         * 读取文件用FileInputStream
         * 一次只读一个字节(一个字母就是一个字节),当字节内容和A或a相等时,相应的数量加1
         * */
        public static void main(String[] args) {
            try {
                //添加文件路径
                File file = new File("D:/java/calcCharNum.txt");
                //创建文件读取流
                FileInputStream fis = new FileInputStream(file);
                int numA = 0;//字母A的数量
                int numa = 0;//字母a的数量
                int len = 0;//每次读取的字节数量
                while ((len=fis.read())!= -1) {
                    //统计字母a的数量
                    if (new String((char)len+"").equals("a")) {
                        numa++;
                    }
                    //统计字母A的数量
                    if (new String((char)len+"").equals("A")) {
                        numA++;
                    }
                }
                //打印出文件内字母的数量
                System.out.println("a的数量是:"+numa);
                System.out.println("A的数量是:"+numA);
                System.out.println("a和A出现的总次数:"+(numA+numa));
                fis.close();//关闭输入流
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    
    }


    (八)统计一个文件file.txt中各个字母出现次数:(可复制内容于文件中测试:A(8),B(16),C(10),a(12),b(10),c(3),A(8),B(16),C(10),a(12),b(10),c(3))

    A(8),B(16),C(10)...,a(12),b(10),c(3)....,括号内代表字符出现次数;
     

    import java.io.File;
    import java.io.FileInputStream;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map.Entry;
    
    public class Test8 {
        /**
         * 统计一个文件calcCharNum.txt(见附件)中各个字母出现次数:
         * A(8),B(16),C(10)...,a(12),b(10),c(3)....,括号内代表字符出现次数;
         *
         * 程序分析:
         * 1.这里没中文字符,依然可以只用字节流来读取文件
         * 2.不能保存相同的主键值,可以使用HashMap:key-value来实现
         * 3.先获得该key的value,如果存在key的话value的值加1
         * */
        public static void main(String[] args) {
     
            // 文件路径
            File file = new File("file.txt");
            try {
     
                // 创建读取文件的输入流
                FileInputStream fis = new FileInputStream(file);
                // 创建集合HashMap类存放要保存的key-value
                HashMap map = new HashMap<>();
     
                // 读取文件
                int len = 0;// 每次读取的文件长度
                int count = 0;
                while ((len = fis.read()) != -1) {
                    // 每次获取到的字母
                    char c = (char) len;
                    //这里使用try catch是因为 map.get(c + ""),第一次get不到东西会出现空指针
                    try {
                        // 通过每次的key值获取它的value值,
                        // 但是在它的key值没有时或报空指针错误,所以要try catch处理
                        // 当她有key值,就可以获取到相应的value值
                        count = (int) map.get(c + "");
                    } catch (Exception e) {// 什么都不用输出
                    }
                    // 如果有它的key值对应的value值要加1
                    map.put(c + "", count + 1);
                }
                fis.close();
                
                // 读完后把结果打印出来
                //迭代器的使用
                Iterator iterator = map.entrySet().iterator();
                while (iterator.hasNext()) {
                    Entry entry = (Entry) iterator.next();
                    System.out.println(entry.getKey() + "{" + entry.getValue()+ "} \t");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

     

    其实本题也可以直接用字符流来读取的。

     

    (九)统计一个文件calcCharNum2.txt中各个字母出现次数:(复制下面进行测试)
    A(8),B(16),C(10),a(12),b(10),c(3),中(5),国(6),括号内代表字符出现次数;

     

    import java.io.File;
    import java.io.FileReader;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map.Entry;
    
    public class Test9 {
        /**
         * 统计一个文件calcCharNum2.txt(见附件)中各个字母出现次数:
         * A(8),B(16),C(10)...,a(12),b(10),c(3)....中(5),国(6),
         * 括号内代表字符出现次数;
         *
         * 程序分析:
         * 1.这出现中文字符,依然只能用字符流来读取文件
         * 2.不能保存相同的主键值,可以使用HashMap:key-value来实现
         * 3.先获得该key的value,如果存在key的话value的值加1
         * */
        public static void main(String[] args) {
            // 文件路径
            File file = new File("D:/java/calcCharNum2.txt");
            // 创建集合HashMap类存放要保存的key-value
            HashMap map = new HashMap<>();
    
            try {
    
                // 创建字符流
                FileReader fr = new FileReader(file);
                // 每次读取的字符长度
                int len = 0;
                int count=0;//出现该字符的次数
                while ((len = fr.read()) != -1) {
                    // 获取对应的字符
                    char c = (char) len;
                    try {
                        // 通过每次的key值获取它的value值,
                        // 但是在它的key值没有时或报空指针错误,所以要try catch处理
                        // 当她有key值,就可以获取到相应的value值
                        count = (int) map.get(c + "");
                    } catch (Exception e) {// 什么都不用输出
                    }
                    // 如果有它的key值对应的value值要加1
                    map.put(c + "", count + 1);
                }
                
                // 读完后把结果打印出来
                Iterator iterator = map.entrySet().iterator();
                
                //迭代器的使用
                while (iterator.hasNext()) {                
                    Entry entry = (Entry) iterator.next();
                    System.out.print(entry.getKey() + "(" + entry.getValue()+ ") \t");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    
    }	

     


    (十) 使用随机文件流类RandomAccessFile将一个文本文件倒置读出。
     

     

    import java.io.File;
    import java.io.RandomAccessFile;
    
    public class Test10 {
        /**
         * 使用随机文件流类RandomAccessFile将一个文本文件倒置读出。
         *
         * 程序分析:
         *  RandomAccessFile的seek方法能把读取文件的光标移动到具体的位置
         * 但是还是有地点值得注意的是一个字母或数字是占用一个字节的, 一个汉字是占用两个字节的
         * */
        public static void main(String[] args) {
            // 要读取的文件的地址
            File file = new File("D:/java/calcCharNum2.txt");
            try {
                RandomAccessFile raf = new RandomAccessFile(file, "r");
                long length = raf.length();
                StringBuffer sb = new StringBuffer();
                while (length > 0) {
                    length--;
                    raf.seek(length);
                    int c = (char) raf.readByte();
                    // 如果asc码<=255,>=0,则判断是个英文字符,添加到字符串中.
                    if (c >= 0 && c <= 255) {
                        sb.append((char) c);
                    } else {
                        // 如果不在asc码范围内,则判断是个汉字字符
                        // 汉字字符是占2个字节的,所以length再退一个字节
                        length--;
                        raf.seek(length);
                        byte[] cc = new byte[2];
                        // cc被复制为文件中连续的两个字节
                        raf.readFully(cc);
                        sb.append(new String(cc));
                    }
                }
                System.out.println(sb);
                raf.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
    }

     

     

    (十一) 编写一个Java应用程序,可以实现Dos中的type命令,并加上行号。

    即将文本文件在控制台上显示出来,并在每一行的前面加上行号。

     

    import java.io.File;
    import java.io.IOException;
    
    
    public class Test1 {
        /**
         * 1. 在电脑D盘下创建一个文件为HelloWorld.txt文件,
         * 判断他是文件还是目录,再创建一个目录IOTest,
         * 之后将HelloWorld.txt移动到IOTest目录下去;
         * 之后遍历IOTest这个目录下的文件
         *
         * 程序分析:
         * 1、文件创建使用File的createNewFile()方法
         * 2、判断是文件用isFile(),判断是目录用isDirectory
         * 3、创建目录用:mkdirs()方法
         * 4、移动文件用:renameTo
         * 5、遍历目录用:list()方法获得存放文件的数组,foreach遍历的方法把文件打印出来
         * */
        public static void main(String[] args) {
             //在电脑D盘下创建一个文件为HelloWorld.txt文件
            File file=new File("D:","HelloWorld.txt");
            
            //创建文件,返回一个布尔值
            boolean isCreate;
            try {
                isCreate = file.createNewFile();
                if (isCreate) {
                    System.out.println("创建文件成功!");
                }else {
                    System.out.println("创建文件失败!文件已经存在");
                }
            } catch (IOException e) {
                System.out.println("创建文件失败!");
            }
            
            // 判断他是文件还是目录,
            if (file.isFile()) {
                System.out.println("这是一个文件");
            } else {
                System.out.println("这是一个目录");
            }
            
            //再创建一个目录IOTest
            File file2=new File("D:/IOTest");
            file2.mkdirs();
            
            //HelloWorld.txt移动到IOTest目录下去?失败?》
            if (file.renameTo(file2)) {
                System.out.println("文件移动成功!");
            } else {
                System.out.println("文件移动失败");
            }
            
            //遍历IOTest目录下的文件
            String[] arr=file2.list();
            for (String string : arr) {
                System.out.println(string);
            }
        }
    }

     


     


    (十二)输入两个文件夹名称,将A文件夹内容全部拷贝到B文件夹,要求使用多线程来操作。


     

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.List;
    import java.util.Scanner;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    import com.xykj.lesson2.FileUtils;
    
    
    public class Test12 {
        /*
         * 输入两个文件夹名称,将A文件夹内容全部拷贝到B文件夹,要求使用多线程来操作。
         *
         * 程序分析:
         * 1.拷贝文件里面的东西,要分析的东西还是蛮多的,要先建文件夹再拷贝里面的东西,而且要一层层的来搞
         * 2.这里也需要文件遍历工具,直接调用第二题的工具类,不再重写
         * 3.多线程的使用,可以直接在方法里面直接新建线程
         * 4.对整个文件夹进行复制 文件夹分隔符可以用\\或/,其他的都是不对的
         * 所有其中还对输入的分割符进行了替换
         * 这题看起来比较长,分开看其实也不长
         * */
        public static void main(String[] args) {
            Scanner scanner=new Scanner(System.in);
            System.out.println("要复制的文件夹:");
            String fromDir = scanner.next();// 接收输入
            System.out.println("要复制到哪里去:");
            String toDir = scanner.next();// 接收输入
    
            // 把输入的地址转化为File类型
            File fromFile = new File(fromDir);
            File toFile = new File(toDir);
            
            //新建线程
            new Thread(){
                //里面做实际操作
                public void run() {
                    // 判断如果要复制的是文件,直接复制就可以了
                    if (fromFile.isFile()) {
                        System.out.println("复制单个文件");
                        copy(fromFile, toFile);
                    } else {
                        // 要复制文件夹
                        // 要防止一种无法进行的复制:比如说,要把复制的文件复制到自己的子文件夹里面
                        // 举个例子:把D:/java/jsp文件夹复制到D:/java/jsp/js文件夹里面,
                        // 这会导致子文件不断增加的同时,而父文件也要不断增加,的一个死循环
                        // 如果反过来,就没事,相当于只是简单的覆盖而已
                        // 具体实现就是看:目的地地址包含复制的文件夹地址,就不允许操作
                        if (toDir.replace("/", "\\").toLowerCase()
                                .startsWith(fromDir.replace("/", "\\").toLowerCase())) {
                            return;
                        }
    
                        // 复制文件(包括文件和文件夹)操作
    
                        // 先获取所有的文件(包括文件和文件夹)
                        List list = FileUtils.getAllFiles(fromDir);
    
                        // 创建一个线程池,加快复制的速度
                        ExecutorService threadPool = Executors.newFixedThreadPool(20);
    
                        // 需要对每一个文件的路径进行处理
                        for (File file : list) {
                            // 复制文件名
                            String name = file.getAbsolutePath();
                            // 把原来的文件路径换成新的文件路径
                            String toName = name.replace(fromFile.getParent(), toDir + "/");
                            System.out.println(name + "变成了" + toName);
                            // 如果是文件夹,直接创建
                            if (file.isDirectory()) {
                                new File(toName).mkdirs();
                            } else {
                                // 如果是文件,在线程里面复制
                                threadPool.execute(new Runnable() {
                                    @Override
                                    public void run() {
                                        File copyFile = new File(toName);
                                        // 先要有父文件夹
                                        copyFile.getParentFile().mkdirs();
    
                                        // 开始复制文件
                                        copy(file, copyFile);
                                    }
                                });
                            }
                        }
    
                    }
                    scanner.close();
                };
                
            }.start();//开始线程
        }
        
        //复制文件的操作
        public static void copy(File fromFile, File toFile) {
            // 定义一个输入流
            FileInputStream fis = null;
            // 定义一个输出流
            FileOutputStream fos = null;
    
            try {
                // 把复制地址的File,封装后赋值给输入流对象
                fis = new FileInputStream(fromFile);
                // 把目的地的File,封装后复制给输出流的对象
                fos = new FileOutputStream(toFile);
                // 创建一个容量,
                byte[] buf = new byte[1024];
                // 每次读取/写入的字节长度
                int len = 0;
                // 边读边写
                while ((len = fis.read(buf)) != -1) {// 判断是否还能读到数据
                    // 把输入放到输出流里面
                    fos.write(buf, 0, len);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    // 关闭输入流和输出流
                    fis.close();
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
            }
        }
    
    }

     

     


    (十三)查看D盘中所有的文件和文件夹名称,并且使用名称升序降序,文件夹在前和文件夹在
    后,文件大小排序等。

     

    import java.io.File;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    import com.xykj.lesson2.FileUtils;
    
    public class Test13 {
        /**
         * 查看D盘中所有的文件和文件夹名称,并且使用名称升序降序,
         * 文件夹在前和文件夹在后,文件大小排序等。
         *
         * 程序分析:
         * 1.查找文件和文件夹,需要例题二里遍历文件的工具类(这里直接调用,不在重写)
         * 2.排序需要用到list集合里面的Collections工具类类的sort方法
         * 3.这里有三重排序:首先是要按是否是文件夹来排序,然后按名称来排序,最后按大小来排序
         *   其实这里还是会有问题的,按照某一个排序还没事,但是三个都排序就不一定有效!
           实际应用中也是只按一种排序就可以了的
         * */
        public static void main(String[] args) {
             List list =FileUtils.getAllFiles("D:");
            
             //按文件夹先显示的顺序:
             Collections.sort(list, new Comparator() {
                @Override
                public int compare(File o1, File o2) {
                    return (o2.isDirectory()?1:-1)-(o1.isDirectory()?1:-1);
                }
            });
            
             //按文件名称显示的顺序:
             Collections.sort(list, new Comparator() {
                    @Override
                    public int compare(File o1, File o2) {
                        return (o1.getName()).compareTo(o2.getName());
                    }
                });
            
             //按文件名称显示的顺序:
             Collections.sort(list, new Comparator() {
                    @Override
                    public int compare(File o1, File o2) {
                        return (int)(o1.length()-o2.length());
                    }
                });
                
             //遍历集合的文件
             for (File file : list) {
             //打印排序后的文件或文件夹
             System.out.println(file.getName());
            }
        }
    }

     

     

    以上是这些题目的详细的解题过程,当然很多题目的解决方法不是固定的,

    但是对于基本的解题方式还是要了解的。对于知识点的掌握的话,

    文件的基本操作,读取文件的基本方法,和写文件的基本方法都是要掌握的,

    还有字节流的读取和字符流的读取方式和用处也要会区分。

     

     

     

     


     

    展开全文
  • Java IO流经典练习题(转载)

    千次阅读 2018-10-20 14:38:03
    Java IO流经典练习题 本文对javaIO流的13道经典的练习题做解答,里面有详细的思路解析,做题时最好养成先写思路在编程的习惯。 一.练习的题目 (一)在电脑D盘下创建一个文件为HelloWorld.txt文件,判断他...
  • java io流练习题经典

    千次阅读 2019-05-08 22:46:56
    java io流练习,建议可以跟着敲敲,这些在面试中常会遇到,希望对大家有帮助... Java IO流经典练习题 本文对javaIO流的13道经典的练习题做解答,里面有详细的思路解析,做题时最好养成先写思路在编程的习惯。 ...
  • 一、效果展示 1、最初可以看到data/data目录下该项目只有一个cache文件夹和lib文件 第一次运行程序,用户名和密码皆为空。 ... ...二、设计知识点 javaIO流 checkbox单选框 三、实现步骤 1、编...
  • Java程序设计

    千次阅读 2021-02-28 21:30:14
    JAVA程序设计第一章:从0开始学习java先下载JDK二级目录三级目录 第一章:从0开始学习java java是一种可以编写跨平台应用程序的面向对象程序设计语言。 本章我们要学习的内容有: 1.了解java语言的发展和运行机制 ...
  • Java IO流

    万次阅读 2018-10-14 01:09:56
    Java IO流中各种的介绍和实现图片的读写
  • 史上最全面Java面试汇总(面试题+答案)

    万次阅读 多人点赞 2018-07-06 14:09:25
    JAVA面试精选【Java基础第一部分】 JAVA面试精选【Java基础第二部分】 JAVA面试精选【Java基础第三部分】 JAVA面试精选【Java算法与编程一】 JAVA面试精选【Java算法与编程二】 Java高级工程师—面试(1) ...
  • 深入理解Java中的IO

    万次阅读 多人点赞 2016-04-21 01:15:20
    深入理解Java中的IO,个人学习总结。
  • JAVA面试笔记

    千次阅读 多人点赞 2019-03-07 17:52:40
    JAVA面试笔记Java基础面试1、HashMap源码?5、Set的实现?6、讲解线程execute?8、讲解Runable和Callnable的区别?9、使用泛型的好处?10、JDK动态代理和Cglib的区别?Spring面试题Spirng基础面试1、什么是Spring?2...
  • Java IO完全总结(转载) --- 重点在源码分析

    万次阅读 多人点赞 2018-04-04 11:58:32
    转载自https://blog.csdn.net/baobeisimple/article/details/1713797个人认为前面对于输入...Java 8:活好水多——Java 的新IO (nio) inputStream 的read方法是 abstract 因为不同的 输入 对于 来源的解读方式...
  • Java网络编程(三) java 流io和块io

    千次阅读 2016-07-03 12:01:23
    这就意味着,Java 程序往往拖得很长,其运行速率大大低于本地编译代码,因而对操作系统I/O 子系统的要求并不太高。 如今在运行时优化方面,JVM 已然前进了一大步。现在 JVM 运行字节码的速率已经接近本地编译代码...
  • Java IO用法详解

    千次阅读 多人点赞 2018-03-19 10:10:36
    一、java io 概述1.1 相关概念Java IOJava IOJava 输入输出系统。不管我们编写何种应用,都难免和各种输入输出相关的媒介打交道,其实和媒介进行IO的过程是十分复杂的,这要考虑的因素特别多,比如我们要考虑和哪...
  • [JDK1.8] Java-I/O使用概述

    千次阅读 2018-06-14 15:58:45
    概述 Java I/O分为两大类: ...java IO选择的原则及其与IO流相关类的关系 IO流输入输出,字符字节 深入了解JDK1.8 从Package java.io开始 Java IO JAVA的节点和处理 IO、文件、NIO
  • 1、什么是面向对象技术 ?...2、 面积对象的程序设计和面向过程的程序设计有什么区别? 面向过程语言编程模式是: 程序=数据结构 +算法 编程时需要考虑和内容是的程序什么、怎么做、重点考虑每个实现的
  • 04748JAVA语言程序设计实践考试复习

    千次阅读 热门讨论 2018-11-04 15:14:21
    还是呢句话实践考试考试学校很重要,java语言程序设计实践是在北邮考,北邮有考试指导 文档下载: https://download.csdn.net/download/grandaunt/10762461 据我估计考题应该是补充重点代码型的,至于真实情况,我考...
  • Java网络IO演进之路

    千次阅读 多人点赞 2020-04-22 00:45:44
    你对网络IO了解多少?别被面试官打败到一个被问烂了的知识点上面!
  • JavaSE实战——IO流

    千次阅读 2015-07-25 22:32:33
    本文重点记录了JavaIO基础操作的心得。首先从File类入手,简述了基本的文件操作。接着先介绍了字节输入输出FileXxxputStream及BufferedXxxStream缓冲区的读写优势。简单介绍编码表相关知识。接着讲述转换...
  • Java IO

    2018-07-30 10:58:47
    一、java io 概述 1.1 相关概念 Java IO Java IOJava 输入输出系统。不管我们编写何种应用,都难免和各种输入输出相关的媒介打交道,其实和媒介进行IO的过程是十分复杂的...Java类库的设计者通过设计大量的类来...
  • Java Language——IO 机制

    千次阅读 多人点赞 2016-05-21 12:43:26
    JavaIO 使用了一种装饰器设计模式,它将 IO 分为底层节点和上层处理。本篇重点在如何访问文件与目录、如何以二进制格式和文本格式来读写数据、对象序列化机制、还有 Java7 的 "NIO.2"。
  • 理解Java中的IO

    千次阅读 2016-04-21 15:26:22
     对程序语言的设计者来说,创建一个好的输入/输出(I/O)系统是一项艰难的任务   本文的目录视图如下: Java IO概要  a.Java IO中常用的类  b.Java流类的类结构图 1.的概念和作用 2.Java IO所采用的模型 : 3....
  • 详细介绍了Java 中常见的四种IO模型BIO、NIO、IO多路复用、AIO,以及select、poll、epoll系统函数。
  • IO流缓冲等高级

    千次阅读 2019-12-07 10:10:16
    IO流缓冲等高级 回顾 1 File类 表示硬盘中一个文件或文件夹(目录) 文件: //1.1创建对象 File file=new File("d:\\123.txt"); //1.2判断文件是否存在 if(!file.exists()){ file.createNewFile(); }...
  • Java核心技术卷】I/O详析

    千次阅读 多人点赞 2019-09-09 08:34:27
    文章目录概述Java io基本概念关于流流的分类Java io框架一、以字节为单位的输出的框架图(1)框架图图示(2)OutputStream详解(3)OutputStream子类(4)引申:打印二、以字节为单位的输入的框架图(1)框架...
  • 小甲鱼零基础入门学习python笔记

    万次阅读 多人点赞 2019-08-14 11:06:30
    以简单的方式快速完成某些复杂的事情通常是创造脚本语言的重要原则,基于这项原则,使得脚本语言通常比 C 语言、C++语言 或 Java 之类的系统编程语言要简单容易。也让脚本语言另有一些属于脚本语言的特性: • 语法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,447
精华内容 16,578
关键字:

java程序设计io流的重点

java 订阅