精华内容
下载资源
问答
  • java 输入和输出 代码示例

    千次阅读 2014-06-19 23:44:50
    java 输入和输出 代码示例

    此处省略介绍,




    package org.rui.io.inout;
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    /**
     * 缓冲输入文件
     * @author lenovo
     *
     */
    public class BufferedInputFile {
    	public static String read(String filename) throws Exception
    	{
    		BufferedReader br=new BufferedReader(
    				new FileReader(filename)
    				);
    		String s;
    		StringBuilder sb=new StringBuilder();
    		while((s=br.readLine())!=null)
    			sb.append(s+"\n");
    		br.close();
    	//	getClass();
    		  
    		return sb.toString();
    	}
    	
    	public static void main(String[] args) throws Exception {
    		//String path=BufferedInputFile.class.getResource(".").getFile().toString();
    		//System.out.println(read(path+"BufferedInputFile.java"));
    		String path="D:/Users/liangrui/workspace/thinking/src/org/rui/io/inout/";
    		System.out.println(read(path+"BufferedInputFile.java"));
    	}
    
    }
    
    /**
    output: 
    同 上
     */

    package org.rui.io.inout;
    
    import java.io.*;
    
    /**
     * 从内存输入
     * @author lenovo
     *
     */
    public class MemoryInput {
    	public static void main(String[] args) throws Exception {
    		String path="D:/Users/liangrui/workspace/thinking/src/org/rui/io/inout/";
    		//		BufferedInputFile.read(path+"MemoryInput.java")
    		StringReader in=new StringReader(BufferedInputFile.read(path+"MemoryInput.java"));
    		int c = 0;
    		while((c=in.read())!=-1)
    			System.out.print((char)c);
    	}
    
    }
    /**
    output: 
    同 上
     */
    

    package org.rui.io.inout;
    
    import java.io.ByteArrayInputStream;
    import java.io.DataInputStream;
    
    /**
     * 格试化的内存输入
     * @author lenovo
     *
     */
    public class FormattedMemoryInput {
    
    
    	public static void main(String[] args) 
    	{
    	try {
    		 String path="D:\\Users\\liangrui\\workspace\\thinking\\src\\org\\rui\\io\\inout/";
    		 DataInputStream in=new DataInputStream(
    				 new ByteArrayInputStream(
    				BufferedInputFile.read(path+"FormattedMemoryInput.java").getBytes()
    				));
    		
    		while(true)
    			System.out.print((char)in.readByte());//返回值不能检测输入的是否结束
    		
    		} catch (Exception e) {
    			System.out.println("end of stream");
    		}
    	}
    }
    

    package org.rui.io.inout;
    
    import java.io.BufferedInputStream;
    import java.io.ByteArrayInputStream;
    import java.io.DataInputStream;
    import java.io.FileInputStream;
    
    /**
     * 下面演示了怎样一次一个字节地的读取文件
     * @author lenovo
     *
     */
    public class TestEOF {
    
    
    	public static void main(String[] args) throws Exception 
    	{
    	
    		 String path="D:\\Users\\liangrui\\workspace\\thinking\\src\\org\\rui\\io\\inout/";
    		 DataInputStream in=new DataInputStream(
    				 new BufferedInputStream(
    				new FileInputStream(path+"TestEOF.java")
    				));
    		//注意 会随着所读的媒介类型的不同而有所不同,字面的意思就是  在没有阻塞的情况下所能读取的字节数
    		 //对于文件 这意味着整个文件,但是对于不同类型的流,可能就不是这样的,因此要谨慎使用
    		while(in.available()!=0)
    			System.out.print((char)in.readByte());
    		
    		
    	}
    }
    

    package org.rui.io.inout;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.ByteArrayInputStream;
    import java.io.DataInputStream;
    import java.io.FileInputStream;
    import java.io.FileWriter;
    import java.io.PrintWriter;
    import java.io.StringReader;
    
    /**
     * 基本的文件输出
     * @author lenovo
     *
     */
    public class BasicFileOutput {
    
    
    	public static void main(String[] args) throws Exception 
    	{
    	   String file="D:/BasicFileOutput.out";
    	   String path="D:\\Users\\liangrui\\workspace\\thinking\\src\\org\\rui\\io\\inout/";
    		
    	   //读文件
    	   BufferedReader in =new BufferedReader(
    			   new StringReader(
    					   BufferedInputFile.read(path+"BasicFileOutput.java")
    					   )
    			   );
    	   
    	   //写
    	   PrintWriter pw=new PrintWriter(
    			   new BufferedWriter(new FileWriter(file))
    			   );
    	   
    	   
    	   int linecount=1;
    	   String s;
    	   while((s=in.readLine())!=null)
    		   pw.println(linecount+++s);
    	   pw.close();
    	   
    	   //读已写入的文件
    	   System.out.println(BufferedInputFile.read(file));
    		
    	}
    }
    

    package org.rui.io.inout;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.PrintWriter;
    import java.io.StringReader;
    /**
     * 文本文件输出的快揵方式
     * @author lenovo
     *
     */
    public class FileOutputShortcut {
    	public static void main(String[] args) throws Exception 
    	{
    	   String file="D:/BasicFileOutput.out";
    	   String path="D:\\Users\\liangrui\\workspace\\thinking\\src\\org\\rui\\io\\inout/";
    		
    	   //读文件
    	   BufferedReader in =new BufferedReader(
    			   new StringReader(
    					   BufferedInputFile.read(path+"BasicFileOutput.java")
    					   )
    			   );
    	   
    	   //写  java se5在printWriter中添加 了一个辅助构造器
    	   PrintWriter pw=new PrintWriter(file);
    	   
    	   
    	   int linecount=1;
    	   String s;
    	   while((s=in.readLine())!=null)
    		   pw.println(linecount+++s);
    	   pw.close();
    	   
    	   //读已写入的文件
    	   System.out.println(BufferedInputFile.read(file));
    		
    	}
    }

    package org.rui.io.inout;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.ByteArrayInputStream;
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    /**
     * 存储和恢复数据
     * 如果我们使用了dataoutputstream写入数据,java保证我们可以使用datainputstream准确地读取数据,
     * 无论读和写数据平台多么不同
     * utf-8是一种多字节格式,其编码长度根据实际使用的字符集会有所变化,如果我们的只是ASCII只占7位
     * 浪费空间和带宽,所以utf-8将ASCII字符编码成单一字节的形式,而非ASCII字符则编码成两到三个字节的形式
     * @author lenovo
     *
     */
    public class StoringAndRecoveringData {
    	public static void main(String[] args) throws Exception 
    	{
    		String path="d:/data.txt";
    		//输出
    		DataOutputStream out=new DataOutputStream(
    				new BufferedOutputStream(
    						new FileOutputStream(path)
    						)
    				);
    		out.writeDouble(5.55);
    		out.writeUTF("hello world");
    		out.writeDouble(6.66);
    		out.writeUTF("你好  世界");
    		out.close();
    		//读取
    		DataInputStream in=new DataInputStream(
    				new BufferedInputStream(
    						new FileInputStream(path)
    						)
    				);
    		
    		//
    		System.out.println(in.readDouble());
    		System.out.println(in.readUTF());
    		System.out.println(in.readDouble());
    		System.out.println(in.readUTF());
    	
    	}
    }
    /**output:
    5.55
    hello world
    6.66
    你好  世界
    */

    package org.rui.io.inout;
    
    import java.io.BufferedInputStream;
    import java.io.ByteArrayInputStream;
    import java.io.DataInputStream;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.RandomAccessFile;
    
    /**
     * 读写随机访问文件
     * 
     * 使用RandomAccessFile时,你必须知道文件排版,这样才能正确地操作它
     * 拥有读取基本类型和utf-8字符串的各种具体方法,下面示例
     * 
     * 你可能会考虑 使用 内存映射文件 来贷替randomaccessfile
     * @author lenovo
     *
     */
    public class UsingRandomAccessFile {
    	static String file="rtest.dat";
    	static void display() throws Exception
    	{
    		RandomAccessFile rf=new RandomAccessFile(file,"r");
    		for(int i=0;i<7;i++)
    			System.out.println(
    					"value "+i+" : "+rf.readDouble());
    			System.out.println(rf.readUTF());
    			rf.close();		
    	}
    	public static void main(String[] args) throws Exception 
    	{
    		RandomAccessFile rf=new RandomAccessFile(file,"rw");
    		//写
    		for(int i=0;i<7;i++)
    			rf.writeDouble(i*1.414);
    		    rf.writeUTF(" the end of the file");
    			rf.close();		
    			
    		    //打印
    			display();
    		//写  打开并修改
    		rf=new RandomAccessFile(file,"rw");
    		rf.seek(5*8);
    		rf.writeDouble(47.0001);
    		rf.close();
    		  //打印
    		display();
    	}
    }
    /**output:
    value 0 : 0.0
    value 1 : 1.414
    value 2 : 2.828
    value 3 : 4.242
    value 4 : 5.656
    value 5 : 7.069999999999999
    value 6 : 8.484
     the end of the file
    value 0 : 0.0
    value 1 : 1.414
    value 2 : 2.828
    value 3 : 4.242
    value 4 : 5.656
    value 5 : 47.0001
    value 6 : 8.484
     the end of the file
    */


    展开全文
  • Java使用System.out来表示标准输出设备,而用System.in来表示标准输入设备。默认情况下,输出设备是显示器,而输入设备是键盘。当程序通过System.in获取输入时,是从键盘获取输入;而通过System.out输出时,输出到...

    Java使用System.out来表示标准输出设备,而用System.in来表示标准输入设备。默认情况下,输出设备是显示器,而输入设备是键盘。当程序通过System.in获取输入时,是从键盘获取输入;而通过System.out输出时,输出到屏幕上。

    看下面的代码↓:

    import java.util.Scanner;
    
    public class Test {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Scanner input = new Scanner(System.in);
    		System.out.print("enter an intenger:(the input ends if it is 0)");
    		int data = input.nextInt();
    		int sum = 0;
    		while (data != 0) {
    			sum += data;
    			System.out.print("enter an intenger(the input ends if it is 0):");
    			data = input.nextInt();
    		}
    		System.out.println("the sum is " + sum);
    		input.close();
    	}
    }

    这段代码是计算从键盘输入的数字之和,直到读到的数字为0停止循环,但是如果需要输入大量数值,那么从键盘上输入是十分麻烦的;因此,可以将需要输入的数据保存在一个名为input.txt的文本文件中;

    程序从文件input.txt中读取输入,而不是让用户在运行时从键盘输入数据,假设一个名为input.txt文件的内容是:2 3 4 5 6 0,那么程序得到的Sum值将为20;

    下面说明怎样在命令行实现:

    (1)使用记事本创建java源代码,保存在特定目录,例如我的目录为G:\data\eclipse data\demo\demo>,文件的保存类型为.java。

      (2)  在此目录下建一个文本文件input.txt,存放数据;

    (3)打开命令行,定位到该目录,使用命令编译源码,编译成功会在目录下生成一个class文件

    javac Testinput.java
     (4)使用输入重定向从文件读取数据

    java Testinput < input.txt


    可以看到程序通过文件而不是键盘输入读取数据;类似地,还有输出重定向语句,输出重定向语句将输出发送给文件,而不是将其显示在控制台上,输出重定向的语句为:

    java Testinput > output.txt

    可以在同一命令行同时使用输入和输出重定向。例如,下面的命令从Input.txt获取输入,并将输出发送给文件output.txt:

    java Testinput <input.txt> output.txt





    展开全文
  • 初学java输入和输出

    千次阅读 2010-02-21 22:53:00
    和输出流( Output Stream )两类,但这种划分并不是绝对的。比如一个文件,当向其中写数据时,它就是一个输出流;当从其中读取数据时,它就是一个输入流。当然,键盘只是一个数人流,而屏幕则只是一个输出流。 ...

    第一节 数据流的基本概念
    Ø     理解数据流
    流一般分为输入流(Input Stream)和输出流(Output Stream)两类,但这种划分并不是绝对的。比如一个文件,当向其中写数据时,它就是一个输出流;当从其中读取数据时,它就是一个输入流。当然,键盘只是一个数人流,而屏幕则只是一个输出流。
    Ø     Java的标准数据流
    标准输入输出指在字符方式下(如DOS),程序与系统进行交互的方式,分为三种:
    标准输入studin,对象是键盘。
    标准输出stdout,对象是屏幕。
    标准错误输出stderr,对象也是屏幕。
    8.1 从键盘输入字符。
    本例用System.in.read(buffer)从键盘输入一行字符,存储在缓冲区buffer中,count保存实际读入的字节个数,再以整数和字符两种方式输出buffer中的值。Read方法在java.io包中,而且要抛出IOException异常。程序如下:
    import java.io.*;
    public class Input1
    {
    public static void main(String args[]) throws IOException
    {
    System.out.println("Input: ");
    byte buffer[] = new byte[512]; //
    输入缓冲区
    int count = System.in.read(buffer); //
    读取标准输入流
    System.out.println("Output: ");
    for (int i=0;i<COUNT;I++)
    输出buffer元素值
    {
    System.out.print(" "+buffer[i]);
    }
    System.out.println();
    for (int i=0;i<COUNT;I++)
    按字符方式输出buffer
    {
    System.out.print((char) buffer[i]);
    }
    System.out.println("count = "+ count); //buffer
    实际长度
    }
    }
    程序中,main方法采用throws子句抛出IOException异常交由系统处理。
    Ø     Java.io包中的数据流及文件类
    字节流:
      从InputStreamOutputStream派生出来的一系列类。这类流以字节(byte)为基本处理单位。
    l     InputStreamOutputStream
    l      FileInputStreamFileOutputStream
    l      PipedInputStreamPipedOutputStream
    l      ByteArrayInputStreamByteArrayOutputStream
    l      FilterInputStreamFilterOutputStream
    l      DataInputStreamDataOutputStream
    l      BufferedInputStreamBufferedOutputStream
    字符流:
      从ReaderWriter派生出的一系列类,这类流以16位的Unicode码表示的字符为基本处理单位
    Ø     ReaderWriter
    Ø      InputStreamReaderOutputStreamWriter
    Ø      FileReaderFileWriter
    Ø      CharArrayReaderCharArrayWriter
    Ø      PipedReaderPipedWriter
    Ø      FilterReaderFilterWriter
    Ø      BufferedReaderBufferedWriter
    Ø      StringReaderStringWriter

    第二节 字节流初步
    InputStream
    OutputStream
    l     read():从流中读入数据
    l     skip():跳过流中若干字节数
    l     available():返回流中可用字节数
    l     mark():在流中标记一个位置
    l     reset():返回标记过得位置
    l     markSupport():是否支持标记和复位操作
    l     close():关闭流
    l     int read()
    从输入流中读一个字节,形成一个0255之间的整数返回(是一个抽象方法)。
    l     int read(byte b[])
    读多个字节到数组中。
    l     int read(byte b[], int off, int len)
    l     write(int b)
    将一个整数输出到流中(只输出低位字节,抽象)
    l     write(byte b[])
    将字节数组中的数据输出到流中
    l     write(byte b[], int off, int len)
    将数组b中从off指定的位置开始,长度为len的数据输出到流中
    l     flush():刷空输出流,并将缓冲区中的数据强制送出
    l     close():关闭流
    从输入流中读取长度为len的数据,写入数组b中从索引off开始的位置,并返回读取得字节数。
    进行I/O操作时可能会产生I/O例外,属于非运行时例外,应该在程序中处理。如:型FileNotFoundException, EOFException, IOException
    8.2 打开文件。
    本例以FileInputStreamread(buffer)方法,每次从源程序文件OpenFile.java中读取512个字节,存储在缓冲区buffer中,再将以buffer中的值构造的字符串new String(buffer)显示在屏幕上。程序如下:
    import java.io.*;
    public class OpenFile
    {
    public static void main(String args[]) throws IOException
    {
    try
    { //
    创建文件输入流对象
    FileInputStream rf = new FileInputStream("OpenFile.java");
    int n=512;
    byte buffer[] = new byte[n];
    while ((rf.read(buffer,0,n)!=-1) && (n>0)) //
    读取输入流
    {
    System.out.print(new String(buffer));
    }
    System.out.println();
    rf.close(); //
    关闭输入流
    }
    catch (IOException ioe)
    {
    System.out.println(ioe);
    }
    catch (Exception e)
    {
    System.out.println(e);
    }
    }
    }
    8.3 写入文件。
    本例用System.in.read(buffer)从键盘输入一行字符,存储在缓冲区buffer中,再以FileOutStreamwrite(buffer)方法,将buffer中内容写入文件Write1.txt中,程序如下:
    import java.io.*;
    public class Write1
    {
    public static void main(String args[])
    {
    try
    {
    System.out.print("Input: ");
    int count,n=512;
    byte buffer[] = new byte[n];
    count = System.in.read(buffer); //
    读取标准输入流
    FileOutputStream wf = new FileOutputStream("Write1.txt");
    //
    创建文件输出流对象
    wf.write(buffer,0,count); //
    写入输出流
    wf.close(); //
    关闭输出流
    System.out.println("Save to Write1.txt!");
    }
    catch (IOException ioe)
    {
    System.out.println(ioe);
    }
    catch (Exception e)
    {
    System.out.println(e);
    }
    }
    }

    第三节 文件操作
    Ø     File
    File
    类声明如下:
    public class File ectends Object implements Serializable,Comparable
    构造方法:
    public File(String pathname)
    public File(File patent,String chile)
    public File(String patent,String child)
    文件名的处理
    Ø     String getName( ) //得到一个文件的名称(不包括路径)
    Ø     String getPath( ) //得到一个文件的路径名
    Ø     String getAbsolutePath( )//得到一个文件的绝对路径名
    Ø     String getParent( ) //得到一个文件的上一级目录名
    Ø     String renameTo(File newName); //将当前文件名更名为给定文件的完整路径
    文件属性测试
    Ø     boolean exists( ) //测试当前File对象所指示的文件是否存在
    Ø     boolean canWrite( )//测试当前文件是否可写
    Ø     boolean canRead( )//测试当前文件是否可读
    Ø     boolean isFile( ) //测试当前文件是否是文件(不是目录)
    Ø     boolean isDirectory( ) //测试当前文件是否是目录
    普通文件信息和工具
    Ø     long lastModified( );//得到文件最近一次修改的时间
    Ø     long length( ); //得到文件的长度,以字节为单位
    Ø     boolean delete( ); //删除当前文件
    目录操作
    v     boolean mkdir( ); //根据当前对象生成一个由该对象指定的路径
    v     String list( ); //列出当前目录下的文件
    8.4 自动更新文件。
    本例使用File类对象对指定文件进行自动更新的操作。程序如下:
    import java.io.*;
    import java.util.Date;
    import java.text.SimpleDateFormat;
    public class UpdateFile
    {
    public static void main(String args[]) throws IOException
    {
    String fname = "Write1.txt"; //
    待复制的文件名
    String childdir = "backup"; //
    子目录名
    new UpdateFile().update(fname,childdir);
    }
    public void update(String fname,String childdir) throws IOException
    {
    File f1,f2,child;
    f1 = new File(fname); //
    当前目录中创建文件对象f1
    child = new File(childdir); //
    当前目录中创建文件对象child
    if (f1.exists())
    {
    if (!child.exists()) //child
    不存在时创建子目录
    child.mkdir();
    f2 = new File(child,fname); //
    在子目录child中创建文件f2
    if (!f2.exists() || //f2
    不存在时或存在但日期较早时
    f2.exists()&&(f1.lastModified() > f2.lastModified()))
    copy(f1,f2); //
    复制
    getinfo(f1);
    getinfo(child);
    }
    else
    System.out.println(f1.getName()+" file not found!");
    }
    public void copy(File f1,File f2) throws IOException
    { //
    创建文件输入流对象
    FileInputStream rf = new FileInputStream(f1);
    FileOutputStream wf = new FileOutputStream(f2);
    //
    创建文件输出流对象
    int count,n=512;
    byte buffer[] = new byte[n];
    count = rf.read(buffer,0,n); //
    读取输入流
    while (count != -1)
    {
    wf.write(buffer,0,count); //
    写入输出流
    count = rf.read(buffer,0,n);
    }
    System.out.println("CopyFile "+f2.getName()+" !");
    rf.close(); //
    关闭输入流
    wf.close(); //
    关闭输出流
    }
    public static void getinfo(File f1) throws IOException
    {
    SimpleDateFormat sdf;
    sdf= new SimpleDateFormat("yyyy
    MMddhhmm");
    if (f1.isFile())
    System.out.println("<FILE>/t"+f1.getAbsolutePath()+"/t"+
    f1.length()+"/t"+sdf.format(new Date(f1.lastModified())));
    else
    {
    System.out.println("

    /t"+f1.getAbsolutePath());
    File[] files = f1.listFiles();
    for (int i=0;i<FILES.LENGTH;I++)
    getinfo(files[i]);
    }
    }
    }
    f1.lastModified()
    返回一个表示日期的长整型,值为从197011日零时开始计算的毫秒数,并以此长整型构造一个日期对象,再按指定格式输出日期。程序运行结果如下:<FILE>     D:/myjava/Write1.txt          6     200212110218

         D:/myjava/backup<FILE>     D:/myjava/backup/Write1.txt     6     200212310513
    Ø     文件过滤器
    FilterInputStreamFilterOutputStream分别对其他输入/输出流进行特殊处理,它们在读/写数据的同时可以对数据进行特殊处理。另外还提供了同步机制,使得某一时刻只有一个线程可以访问一个输入/输出流
    FilterInputStreamFilterOutputStream分别重写了父类InputStreamOutputStream的所有方法,同时,它们的子类也应该重写它们的方法以满足特定的需要
    •     
    要使用过滤流,首先必须把它连接到某个输入/输出流上,通常在构造方法的参数中指定所要连接的流:
    –     FilterInputStream(InputStream in);
    –     FilterOutputStream(OutputStream out);
    这两个类是抽象类,构造方法也是保护方法
    BufferedInputStreamBufferedOutputStream实现了带缓冲的过滤流,它提供了缓冲机制,把任意的I/O捆绑到缓冲流上,可以提高读写效率
    •     
    在初始化时,除了要指定所连接的I/O流之外,还可以指定缓冲区的大小。缺省大小的缓冲区适合于通常的情形;最优的缓冲区大小常依赖于主机操作系统、可使用的内存空间以及机器的配置等;一般缓冲区的大小为内存页或磁盘块等地整数倍,如8912字节或更小。
    –     BufferedInputStream(InputStream in[, int size])
    –     BufferedOutputStream(OutputStream out[, int size])
    8.5 列出当前目录中带过滤器的文件名清单。
    本例实现FilenameFilter接口中的accept方法,在当前目录中列出带过滤器的文件名。
    程序如下:
    import java.io.*;
    public class DirFilter implements FilenameFilter
    {
    private String prefix="",suffix=""; //
    文件名的前缀、后缀
    public DirFilter(String filterstr)
    {
    filterstr = filterstr.toLowerCase();
    int i = filterstr.indexOf('*');
    int j = filterstr.indexOf('.');
    if (i>0)
    prefix = filterstr.substring(0,i);
    if (j>0)
    suffix = filterstr.substring(j+1);
    }
    public static void main(String args[])
    { //
    创建带通配符的文件名过滤器对象
    FilenameFilter filter = new DirFilter("w*abc.txt");
    File f1 = new File("");
    File curdir = new File(f1.getAbsolutePath(),""); //
    当前目录
    System.out.println(curdir.getAbsolutePath());
    String[] str = curdir.list(filter); //
    列出带过滤器的文件名清单
    for (int i=0;i<STR.LENGTH;I++)
    System.out.println("/t"+str[i]);
    }
    public boolean accept(File dir, String filename)
    {
    boolean yes = true;
    try
    {
    filename = filename.toLowerCase();
    yes = (filename.startsWith(prefix)) &
    (filename.endsWith(suffix));
    }
    catch(NullPointerException e)
    {
    }
    return yes;
    }
    }
    程序运行时,列出当前目录中符合过滤条件“w*.txt“的文件名清单。结果如下:
    D:/myjava
         Write1.txt
         Write2.txt
    Ø     文件对话框
    Ø     随机文件操作
    InputStream OutputStream 来说,它们的实例都是顺序访问流,也就是说,只能对文件进行顺序地读/写。随机访问文件则允许对文件内容进行随机读/写。在java中,类RandomAccessFile 提供了随机访问文件的方法。类RandomAccessFile的声明为:
    public class RandomAccessFile extends Object implements DataInput, DataOutput
         File
    :以文件路径名的形式代表一个文件
         FileDescriptor
    :代表一个打开文件的文件描述
         FileFilter & FilenameFilter
    :用于列出满足条件的文件
         File.list(FilenameFilter fnf)
         File.listFiles(FileFilter ff)
         FileDialog.setFilenameFilter(FilenameFilter fnf)
    •     FileInputStream & FileReader
    :顺序读文件
    •     FileOutputStream & FileWriter
    :顺序写文件
    •     RandomAccessFile
    :提供对文件的随机访问支持
    RandomAccessFile则允许对文件内容同时完成读和写操作,它直接继承Object,并且同时实现了接口DataInputDataOutput,提供了支持随机文件操作的方法
    Ø     DataInputDataOutput中的方法
    •     readInt(), writeDouble()…
    Ø     int skipBytes(int n):将指针乡下移动若干字节
    Ø     length():返回文件长度
    Ø     long getFilePointer():返回指针当前位置
    Ø     void seek(long pos):将指针调到所需位置
    Ø     void setLength(long newLength):设定文件长度
    构造方法:
    RandomAccessFile(File file, String mode)
         RandomAccessFile(String name, String mode)
    mode
    的取值
    –     “r”
    只读. 任何写操作都将抛出IOException
    –     “rw”
    读写. 文件不存在时会创建该文件,文件存在时,原文件内容不变,通过写操作改变文件内容。
    –     “rws”
    同步读写. 等同于读写,但是任何协操作的内容都被直接写入物理文件,包括文件内容和文件属性。
    –     “rwd”
    数据同步读写. 等同于读写,但任何内容写操作都直接写到物理文件,对文件属性内容的修改不是这样。
    8.6 随机文件操作。
    本例对一个二进制整数文件实现访问操作当以可读写方式“rw“打开一个文件”prinmes.bin“时,如果文件不存在,将创建一个新文件。先将2作为最小素数写入文件,再依次测试100以内的奇数,将每次产生一个素数写入文件尾。
    程序如下:
    import java.io.*;
    public class PrimesFile
    {
    RandomAccessFile raf;
    public static void main(String args[]) throws IOException
    {
    (new PrimesFile()). createprime(100);
    }
    public void createprime(int max) throws IOException
    {
    raf=new RandomAccessFile("primes.bin","rw");//
    创建文件对象
    raf.seek(0); //
    文件指针为0
    raf.writeInt(2); //
    写入整型
    int k=3;
    while (k<=max)
    {
    if (isPrime(k))
    raf.writeInt(k);
    k = k+2;
    }
    output(max);
    raf.close(); //
    关闭文件
    }
    public boolean isPrime(int k) throws IOException
    {
    int i=0,j;
    boolean yes = true;
    try
    {
    raf.seek(0);
    int count = (int)(raf.length()/4); //
    返回文件字节长度
    while ((i<=count) && yes)
    {
    if (k % raf.readInt()==0) //
    读取整型
    yes = false;
    else
    i++;
    raf.seek(i*4); //
    移动文件指针
    }
    } catch(EOFException e) { } //
    捕获到达文件尾异常
    return yes;
    }
    public void output(int max) throws IOException
    {
    try
    {
    raf.seek(0);
    System.out.println("[2.."+max+"]
    中有 "+
    (raf.length()/4)+"
    个素数:");
    for (int i=0;i<(int)(raf.length()/4);i++)
    {
    raf.seek(i*4);
    System.out.print(raf.readInt()+" ");
    if ((i+1)%10==0) System.out.println();
    }
    } catch(EOFException e) { }
    System.out.println();
    }
    }
    程序运行时创建文件“primes.bin“,并将素数写入其中,结果如下:
    [2..100]
    中有 25 个素数:
    2 3 5 7 11 13 17 19 23 29
    31 37 41 43 47 53 59 61 67 71
    73 79 83 89 97

    第四节 字符流
    Reader
    类和Writer
    前面说过,在JDK1.1之前,java.io包中的流只有普通的字节流(以byte为基本处理单位的流),这种流对于以16位的Unicode码表示的字符流处理很不方便。从JDK1.1开始, java.io包中加入了专门用于字符流处理的类,它们是以ReaderWriter为基础派生的一系列类
    同类InputStreamOutputStream一样,ReaderWriter也是抽象类,只提供了一系列用于字符流处理的接口。它们的方法与类InputStreamOutputStream类似,只不过其中的参数换成字符或字符数组
    Reader

    •     void close()
    •     void mark(int readAheadLimit)
    •     boolean markSupported()

    •     int read()
    •     int read(char[] cbuf)
    •     int read(char[] cbuf, int off, int len)
    •     boolean ready()
    •     void reset()
    •     long skip(long n)
    Writer

    •     void close()
    •     void flush()
    •     void write(char[] cbuf)
    •     void write(char[] cbuf, int off, int len)
    •     void write(int c)
    •     void write(String str)
    •     void write(String str, int off, int len)
    8.7 文件编辑器。
    本例实现文件编辑器中的打开、保存文件功能。程序如下:
    import java.awt.*;
    import java.awt.event.*;
    import java.io.*;
    public class EditFile1 extends WindowAdapter
    implements ActionListener,TextListener
    {
    Frame f;
    TextArea ta1;
    Panel p1;
    TextField tf1;
    Button b1,b2,b3;
    FileDialog fd;
    File file1 = null;
    public static void main(String args[])
    {
    (new EditFile1()).display();
    }
    public void display()
    {
    f = new Frame("EditFile");
    f.setSize(680,400);
    f.setLocation(200,140);
    f.setBackground(Color.lightGray);
    f.addWindowListener(this);
    tf1 = new TextField();
    tf1.setEnabled(false);
    tf1.setFont(new Font("Dialog",0,20)); //
    设置文本行的初始字体
    f.add(tf1,"North");
    ta1 = new TextArea();
    ta1.setFont(new Font("Dialog",0,20)); //
    设置文本区的初始字体
    f.add(ta1);
    ta1.addTextListener(this); //
    注册文本区的事件监听程序
    p1 = new Panel();
    p1.setLayout(new FlowLayout(FlowLayout.LEFT));
    b1 = new Button("Open");
    b2 = new Button("Save");
    b3 = new Button("Save As");
    p1.add(b1);
    p1.add(b2);
    p1.add(b3);
    b2.setEnabled(false);
    b3.setEnabled(false);
    b1.addActionListener(this); //
    注册按钮的事件监听程序
    b2.addActionListener(this);
    b3.addActionListener(this);
    f.add(p1,"South");
    f.setVisible(true);
    }
    public void textValueChanged(TextEvent e)
    { //
    实现TextListener接口中的方法,对文本区操作时触发
    b2.setEnabled(true);
    b3.setEnabled(true);
    }
    public void actionPerformed(ActionEvent e)
    {
    if (e.getSource()==b1) //
    单击[打开]按钮时
    {
    fd = new FileDialog(f,"Open",FileDialog.LOAD);
    fd.setVisible(true); //
    创建并显示打开文件对话框
    if ((fd.getDirectory()!=null) && (fd.getFile()!=null))
    {
    tf1.setText(fd.getDirectory()+fd.getFile());
    try //
    以缓冲区方式读取文件内容
    {
    file1 = new File(fd.getDirectory(),fd.getFile());
    FileReader fr = new FileReader(file1);
    BufferedReader br = new BufferedReader(fr);
    String aline;
    while ((aline=br.readLine()) != null)//
    按行读取文本
    ta1.append(aline+"/r/n");
    fr.close();
    br.close();
    }
    catch (IOException ioe)
    {
    System.out.println(ioe);
    }
    }
    }
    if ((e.getSource()==b2) || (e.getSource()==b3))
    { //
    单击[保存]按钮时
    if ((e.getSource()==b3) ||(e.getSource()==b2)&&(file1==null))
    { //
    单击[SaveAs]按钮时,或单击[Save]按钮且文件对象为空时
    fd = new FileDialog(f,"Save",FileDialog.SAVE);
    if (file1==null)
    fd.setFile("Edit1.txt");
    else
    fd.setFile(file1.getName());
    fd.setVisible(true); //
    创建并显示保存文件对话框

    if ((fd.getDirectory()!=null) && (fd.getFile()!=null))
    {
    tf1.setText(fd.getDirectory()+fd.getFile());
    file1 = new File(fd.getDirectory(),fd.getFile());
    save(file1);
    }
    }
    else
    save(file1);
    }
    }
    public void save(File file1)
    {
    try //
    将文本区内容写入字符输出流
    {
    FileWriter fw = new FileWriter(file1);
    fw.write(ta1.getText());
    fw.close();
    b2.setEnabled(false);
    b3.setEnabled(false);
    }
    catch (IOException ioe)
    {
    System.out.println(ioe);
    }
    }
    public void windowClosing(WindowEvent e)
    {
    System.exit(0);
    }
    }
    第五节 字节流的高级应用
    Ø     管道流
    管道用来把一个程序、线程和代码块的输出连接到另一个程序、线程和代码块的输入。java.io中提供了类PipedInputStreamPipedOutputStream作为管道的输入/输出流
    管道输入流作为一个通信管道的接收端,管道输出流则作为发送端。管道流必须是输入输出并用,即在使用管道前,两者必须进行连接
    管道输入/输出流可以用两种方式进行连接:
    –     
    在构造方法中进行连接
    •     PipedInputStream(PipedOutputStream pos);
    •     PipedOutputStream(PipedInputStream pis);
    –     
    通过各自的connect()方法连接
    •     
    在类PipedInputStream中,connect(PipedOutputStream pos)
         
    •     
    在类PipedOutputStream中,connect(PipedInputStream pis)
    8.8 管道流。
    本例例管道流的使用方法。设输入管道in与输出管道out已连接,Send线程向输出管道out发送数据,Receive线程从输入管道in中接收数据。程序如下:
    import java.io.*;
    public class Pipedstream
    {
    public static void main (String args[])
    {
    PipedInputStream in = new PipedInputStream();
    PipedOutputStream out = new PipedOutputStream();
    try
    {
    in.connect(out);
    }
    catch(IOException ioe) { }
    Send s1 = new Send(out,1);
    Send s2 = new Send(out,2);
    Receive r1 = new Receive(in);
    Receive r2 = new Receive(in);
    s1.start();
    s2.start();
    r1.start();
    r2.start();
    }
    }
    class Send extends Thread //
    发送线程
    {
    PipedOutputStream out;
    static int count=0; //
    记录线程个数
    int k=0;
    public Send(PipedOutputStream out,int k)
    {
    this.out= out;
    this.k= k;
    this.count++; //
    线程个数加1
    }
    public void run( )
    {
    System.out.print("/r/nSend"+this.k+": "+this.getName()+" ");
    int i=k;
    try
    {
    while (i<10)
    {
    out.write(i);
    i+=2;
    sleep(1);
    }
    if (Send.count==1) //
    只剩一个线程时
    {
    out.close(); //
    关闭输入管道流
    System.out.println(" out closed!");
    }
    else
    this.count--; //
    线程个数减1
    }
    catch(InterruptedException e) { }
    catch(IOException e) { }
    }
    }
    class Receive extends Thread //
    接收线程
    {
    PipedInputStream in;
    public Receive(PipedInputStream in)
    {
    this.in = in;
    }
    public void run( )
    {
    System.out.print("/r/nReceive: "+this.getName()+" ");
    try
    {
    int i = in.read();
    while (i!=-1) //
    输入流未结束时
    {
    System.out.print(i+" ");
    i = in.read();
    sleep(1);
    }
    in.close(); //
    关闭输入管道流
    }
    catch(InterruptedException e) { }
    catch(IOException e)
    {
    System.out.println(e);
    }
    }
    }
    程序运行结果如下:
    Send1: Thread-0
    Send2: Thread-1
    Receive: Thread-2 1
    Receive: Thread-3 2 3 4 5 7 out closed!
    6 8 9 java.io.IOException: Pipe closed!
    Ø     数据流
    DataInputStream
    DataOutputStream
    Ø     在提供了字节流的读写手段的同时,
    Ø     以统一的通用的形式向输入流中写入booleanintlongdouble等基本数据类型,并可以在次把基本数据类型的值读取回来。
    Ø     提供了字符串读写的手段。
    Ø     分别实现了DataInputDataOutput接口
    声明类:
    Public class DataInputStream extends filterInputStream implements DataInput
    8.9 数据流。
    本例演示数据流的使用方法。
    程序如下:
    import java.io.*;
    public class Datastream
    {
    public static void main(String arg[])
    {
    String fname = "student1.dat";
    new Student1("Wang").save(fname);
    new Student1("Li").save(fname);
    Student1.display(fname);
    }
    }
    class Student1
    {
    static int count=0;
    int number=1;
    String name;
    Student1(String n1)
    {
    this.count++; //
    编号自动加1
    this.number = this.count;
    this.name = n1;
    }
    Student1()
    {
    this("");
    }
    void save(String fname)
    {
    try
    { //
    添加方式创建文件输出流
    FileOutputStream fout = new FileOutputStream(fname,true);
    DataOutputStream dout = new DataOutputStream(fout);
    dout.writeInt(this.number);
    dout.writeChars(this.name+"/n");
    dout.close();
    }
    catch (IOException ioe){}
    }
    static void display(String fname)
    {
    try
    {
    FileInputStream fin = new FileInputStream(fname);
    DataInputStream din = new DataInputStream(fin);
    int i = din.readInt();
    while (i!=-1) //
    输入流未结束时
    {
    System.out.print(i+" ");
    char ch ;
    while ((ch=din.readChar())!='/n') //
    字符串未结束时
    System.out.print(ch);
    System.out.println();
    i = din.readInt();
    }
    din.close();
    }
    catch (IOException ioe){}
    }
    }
    程序运行结果如下:
    1 Wang
    2 Li
    Ø     对象流
    •     
    对象的持续性(Persistence
    –     
    能够纪录自己的状态一边将来再生的能力,叫对象的持续性
    •     
    对象的串行化(Serialization
    –     
    对象通过写出描述自己状态的的数值来记录自己的过程叫串行化。串行化的主要任务是写出对象实例变量的数值,如果变量是另一个对象的引用,则引用的对象也要串行化。这个过程是递归的
    •     
    对象流
    –     
    能够输入输出对象的流称为对象流。
    –     
    可以将对象串行化后通过对象输入输出流写入文件或传送到其它地方
    java中,允许可串行化的对象在通过对象流进行传输。只有实现Serializable接口的类才能被串行化, Serializable接口中没有任何方法,当一个类声明实现Serializable接口时,只是表明该类加入对象串行化协议
    要串行化一个对象,必须与一定的对象输出/输入流联系起来,通过对象输出流将对象状态保存下来(将对象保存到文件中,或者通过网络传送到其他地方) ,再通过对象输入流将对象状态恢复
    ObjectOutputStreamObjectInputStream分别继承了接口ObjectOutputObjectInput,将数据流功能扩展到可以读写对象,前者用writeObject()方法可以直接将对象保存到输出流中,而后者用readObject()方法可以直接从输入流中读取一个对象
    8.10 对象流。
    本例声明Student2为序列化的类。Save方法中,创建对象输出流out,并以添加方式向文件中直接写入当前对象out.writeObject(this);display方法中,创建对象输入流in,从文件中直接读取一个对象in.readObject(),获得该对象的类名、接口名等属性,并显示其中的成员变量。程序如下:
    import java.io.*;
    public class Student2 implements Serializable //
    序列化
    {
    int number=1;
    String name;
    Student2(int number,String n1)
    {
    this.number = number;
    this.name = n1;
    }
    Student2()
    {
    this(0,"");
    }
    void save(String fname)
    {
    try
    {
    FileOutputStream fout = new FileOutputStream(fname);
    ObjectOutputStream out = new ObjectOutputStream(fout);
    out.writeObject(this); //
    写入对象
    out.close();
    }
    catch (FileNotFoundException fe){}
    catch (IOException ioe){}
    }
    void display(String fname)
    {
    try
    {
    FileInputStream fin = new FileInputStream(fname);
    ObjectInputStream in = new ObjectInputStream(fin);
    Student2 u1 = (Student2)in.readObject(); //
    读取对象
    System.out.println(u1.getClass().getName()+" "+
    u1.getClass().getInterfaces()[0]);
    System.out.println(" "+u1.number+" "+u1.name);
    in.close();
    }
    catch (FileNotFoundException fe){}
    catch (IOException ioe){}
    catch (ClassNotFoundException ioe) {}
    }
    public static void main(String arg[])
    {
    String fname = "student2.obj";
    Student2 s1 = new Student2(1,"Wang");
    s1.save(fname);
    s1.display(fname);
    }
    }
    程序运行结果如下:
    Student2 interface java.io.Serializable
    1 Wang

     

     

    展开全文
  • Java文件和输入和输出

    千次阅读 2019-05-08 19:14:00
    Java文件和输入和输出 一.流:可以定义为数据序列。分为两种: Inputstream-用于从源读取数据 Outputstream-用于将数据写入目标 字节流 Java字节流用于8位字节输入和输出。由InputStream和OutputStream作为基...

    Java文件和输入和输出

    一.流:可以定义为数据序列。分为两种:

          Inputstream-用于从源读取数据

           Outputstream-用于将数据写入目标

    1. 字节流

    Java字节流用于8位字节输入和输出。由InputStream和OutputStream作为基 类。

    1. 字符流

    用于执行16位unicode的输入和输出。由 Reader和 Writer作为基类。

    二.标准流

    1. 标准输入 - 用于将数据提供给用户程序,通常键盘用作标准输入流并表示为System.in。
    2. 标准输出 - 用于输出用户程序生成的数据,通常计算机屏幕用于标准输出流并表示为System.out。
    3. 标准错误 - 用于输出用户程序生成的错误数据,通常计算机屏幕用于标准错误流并表示为System.err。

    三.转换流

    InputStreamReader将字节输入流转换成字符输入流;

    OutputStreamWriter将字 节输出流转换成字符输出流;

    使用InputStreamReader来读取标准输入流,直到用户键入:q 便会停止输入输出。

    public class FileDemo {

           public static void main(String[] args) throws IOException {

           InputStreamReadercin = null;

        try {

           tin= new InputStreamReader (System.in);

           System.out.println("Enter characters, 'f' to quit>");

           char q;

           do {

              q = (char) tin.read();

              System.out.print(q);

           } while(q != 'f');

        } catch (IOException e) {

                  // TODO Auto-generated catch block

                  e.printStackTrace();

           }finally {

           if (tin!= null) {

              tin.close();

           }

        }

    }

    代码运行结果:

    四.目录操作

    目录是一个文件,它可以包含其他文件和目录的列表。 使用File对象创建目录,列出目录中可用的文件。

    1. 创建目录

    两种File类的方法,可用于创建目录 -

    • mkdir()方法创建一个目录,创建成功时返回true,失败时返回false。 失败表示File对象中指定的路径已存在,或者由于整个路径尚不存在或权限问题而无法创建目录。
    • mkdirs()方法创建目录和目录的所有上级目录。

    2.列出目录

    可以使用File对象的list()方法列出目录中可用的所有文件和目录

    展开全文
  • Java中的输入和输出重定向

    万次阅读 2017-07-28 14:17:31
    可以将这些数据用空格隔开,保存在一个名为input.txt的文本文件中,然后使用Java输入和输出重定向。例如需要循环求和计算,新建一个input.txt的文本文件(数据以0结尾,因为下面的求和运算程序是以0作为程序终止求和...
  • Java输入输出

    万次阅读 多人点赞 2018-05-12 15:27:45
    特此写下这篇博客,一是为了总结输入输出,二是为了大家分享。如果大家觉得写得好,就请高抬贵手点个赞呗!!! 1.输入格式,输出格式控制 1.1输入处理 java输入,我们用到Scanner类,可以用它创建一个对象 ...
  • Java输入/输出

    千次阅读 2021-01-01 19:21:49
    Java输入/输出流 一、流的概念 输入流只能读不能写,输出流只能写不能读。按照流中数据的处理单位不同,可将流分为字节流字符流。在字节流中,数据的组织操作的基本单位是字节;在字符流中,数据的组织操作的...
  • java 输入输出

    千次阅读 2015-07-24 17:53:11
    1.输入与输出 ...每种界面都可以有输入和输出2.文本界面使用Scanner类(JDK1.5开始才有),Sanner类在java.util包中,所以使用Scanner类需要写 import java.util.Scanner。 Scanner类的方法有 ne
  • java输入输出

    2016-10-25 17:17:54
    java把不同来源和目标的数据称为抽象为数据流。在java输入输出的功能很强大,提供了很庞大的类库,涉及到的领域很广... 输入和输出流 按数据传输单位分类: 字节流和字符流 按功能分类: 节点流:用于直接操作
  • Java新手 输入和输出

    2018-08-23 04:01:21
    System是一个类,为啥不像scanner一样要创建一个对象才可以用,直接就System.out.println() ? 还有new Scanner(System.in) 这个括号里可以填System.in以外的东西吗 ,不然为什么要设计这么一大串?...
  • java输入和输出重定向

    千次阅读 2016-03-24 22:26:58
    java小程序中,从键盘上输入大量的数值很麻烦,这时候,就可以用到java中的输入输出重定向。
  • Java 输入输出和异常

    千次阅读 2018-08-09 09:03:41
    Java的控制台输入由System.in完成。为了获得一个绑定到控制台的字符流,可以把System.in包装在一个BufferedReader 对象中来创建一个字符流。 下面是创建BufferedReader的基本语法: public class IOtest { ...
  • Java输入输出数据

    千次阅读 2018-04-29 23:50:59
    一、输入基本类型数据按照课本的描述下面的代码,可以看出Java输入类似于c语言的输入。package 输入输出;public class Example3 { public static void main (String args[]) { System.out.println("请输入...
  • JAVA基础知识常用算法合集: https://blog.csdn.net/GD_ONE/article/details/104061907 目录 1.主类的命名必须是Main 2.输入输出: 2.1输入: (1)使用Scanner类进行输入 (2) hasNext()方法 2.2输出 3快速...
  • Java快速输入输出

    千次阅读 2019-01-21 13:26:51
    Java的输出和输出真实太慢了!!! 如果需要输入105数量级的数据并输出同样数量级的数据,使用Scanner和System.out耗时将很可能超过1s。为了避免这种输入输出过慢的情况,这里引入Java中比较快的一种输入输出方式。 ...
  • java的标准输入输出为键盘和显示器,通过System.in 和System.out实现,可以使用重定向的方式改变程序的输入和输出流,以下实例为重定向输出到文件和重定向从文件输入,具体的讲解穿插在代码中。 重定向输出 //...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,322
精华内容 14,528
关键字:

java输入和输出

java 订阅