`

Java对IO的操作

    博客分类：
  • Java
JavaCC++C#DOS 
阅读更多

声明:来自尚学党马老师的教程代码

节点流类型(一根管直接插到下面的类型上,下面的管道指的是线程和线和之间的通讯) 
 

 类型 字符流 字节流
 File FileReader FileInputStream
  FileWriter FileOutputStream
  Memory ArrayCharArrayReaderByteArrayInputStream
 CharArrayWriterByteArrayOutputStream
Memory StringStringReader 
 StringWriter 
Pipe(管道)PipedReaderPipedInputStream
 PipedWriterPipedOutputStream
 

缓冲流要"套接"在相应的节点流之上,对读写的数据提供了缓冲的功能,提高了读写的效
对于输出的缓冲流,写出的数据会先在内存中缓存,使用flush方法将会使内在中的数据立刻写出

 

转换流
InputStreamReader和OutputStreamWriter用与字节数据到字符数据之间的转换
InputStreamReader需要和InputStream"套接"
OutputStreamReader需要和OutputStream"套接"

/**
 * 程序输出的时候会有乱码,原因是因为read()方法读取一个字节,中文字符
 * 是由两个字节构成,取一个字节(字符的一半)就转成一个字符,所以输出就会是乱码
 * @author DaHai
 *
 */
 public class TestFileInputStream{
     public static void main(String args[]){
             int b = 0;
             FileInputStream in = null;
             try{
                 in = new FileInputStream("c:\\TestFileInputStream.java");
             }catch(FileNotFoundException e){
                 System.out.println("找不到指定的文件");
                //终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非零的状态码表示异常终止。 
                System.exit(-1);    
            }
            try{
                long num = 0;
                //只有读到文件的结尾才为-1
                while((b=in.read())!=-1){
                    System.out.print((char)b);
                    num++;    
                }
                in.close();
                System.out.println();
                System.out.println("共读取了"+ num +"个字节");
            }catch(IOException e){
                System.out.println("文件读取错误");
                System.exit(-1);
            }
        }
}



import java.io.*;
 public class TestFileOutputStream{
     public static void main(String args[]){
         int b = 0;
         FileInputStream in = null;
         FileOutputStream out = null;
         try{
             in = new FileInputStream("c:\\TestFileInputStream.java");
             //如果这个时候C盘下面还没有Test.java,那么new FileOutputStream会创建一个空的Test.java文件,但不会创建目录
             out = new FileOutputStream("c:\\Test.java");
            while((b = in.read())!=-1){
                    out.write(b);
            }
            in.close();
            out.close();
        }catch(FileNotFoundException e){
            System.out.println("找不到指定文件");
            System.exit(-1);
        }catch(IOException e){
            System.out.println("文件复制错误");
            System.exit(-1);
        }
        System.out.println("文件已复制");
    }
}


从文件里读取字符数据 
import java.io.*;
 public class TestFileReader{
     public static void main(String args[]){
         FileReader fr = null;
         int c = 0;
         try{
             fr = new FileReader("c:\\TestFileReader.java");
             while((c = fr.read())!=-1){
                 System.out.print((char)c);
            }
        }catch(FileNotFoundException e){
            System.out.println("系统找不到指定的文件");
        }catch(IOException e){
            System.out.println("文件读取错误");
        }
    }
}


向文件里写字符数据 
import java.io.*;
public class TestFileWriter{
    public static void main(String args[]){
        FileWriter fw = null;
        int b = 0;
        try{
            fw = new FileWriter("c:\\Unicode.dat");
            for(int i=0;i);
        }
    }
}


带缓冲区功能的输入流 
import java.io.*;
public class TestBufferStream{
    public static void main(String args[]){
        try{
        	//一个字节的输入流并且不带缓冲区
            FileInputStream fis = new FileInputStream("c:\\TestFileInputStream.java");
            //相当于在上面的fis流上又套了一层管道,实际上读取的是一样的数据,但是它有了带缓冲区的功能
            BufferedInputStream bis = new BufferedInputStream(fis);
            int c = 0;
            System.out.println(bis.read());
            System.out.println(bis.read());
            //mark一个标记,从第100个开始往外读
            bis.mark(100);
            for(int i=0;i<10 && (c=bis.read())!=-1;i++){
                System.out.print((char)c+" ");
            }
            System.out.println();
            //重置到上面的mark处
            bis.reset();
            for(int i=0;i<=10 && (c=bis.read())!=-1;i++){
                System.out.print((char)c+" ");    
            }
            bis.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}



import java.io.*;

public class TestBufferStream {
	public static void main(String args[]) {
		try {
			//在FileWriter写出一个字符外面套层BufferedWriter管道
			BufferedWriter bw = new BufferedWriter(new FileWriter("c:\\write.txt"));
			BufferedReader br = new BufferedReader(new FileReader("c:\\write.txt"));
			String s = null;
			for (int i = 0; i <= 100; i++) {
				s = String.valueOf(Math.random());
				bw.write(s);
				bw.newLine();
			}
			bw.flush();
			// readLine()方法为读一行数据
			while ((s = br.readLine()) != null) {
				System.out.println(s);
			}
			bw.close();
			br.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("读取文件出错");
		}
	}
}



import java.io.*;
public class TestTransForm2{
    public static void main(String args[]){
        //等待从键盘的输入,System.in可以理解为一根管道直接插在了键盘上
    	//System.in字节流输入一个字节,外面套层InputStreamReader转换流
        InputStreamReader isr = new InputStreamReader(System.in);
        //isr转换流的外面又套层缓冲流,为了使用下面的readLine()方法,可以记取一行
        BufferedReader br = new BufferedReader(isr);
        String s = null;
        try{
            s = br.readLine();
            while(s!=null){
                if(s.equalsIgnoreCase("exit")) break;
                System.out.println(s.toUpperCase());
                s = br.readLine();
            }
            br.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}



import java.io.*;
 public class TestDataStream {
   public static void main(String[] args) {
       //在内存中定义了一个空间,同时一根管道插在了上面
    ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
    //DataOutputStream直接写基础数据类型(boolean,double等),而且可以写UTF-8(省空间,网络上常用)
    DataOutputStream dos = new DataOutputStream(baos);
    try {
      dos.writeDouble(Math.random());
      dos.writeBoolean(true);
      ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
      System.out.println(bais.available());
      DataInputStream dis = new DataInputStream(bais);
      //输出按照先入先出的形式输出
      System.out.println(dis.readDouble());
      System.out.println(dis.readBoolean());
      dos.close();  dis.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}



import java.io.*;
public class TestPrintStream1 { 
  public static void main(String[] args) {
    PrintStream ps = null;
    try {
      FileOutputStream fos = new FileOutputStream("d:\\bak\\log.dat");
      ps = new PrintStream(fos);
    } catch (IOException e) {
      e.printStackTrace();
    }
    if(ps != null){
      System.setOut(ps);
    }
    int ln = 0;
    for(char c = 0; c <= 60000; c++){
      System.out.print(c+ " ");
      if(ln++ >=100){ System.out.println(); ln = 0;}
    }
  }
}



import java.io.*;
public class TestPrintStream2 {
  public static void main(String[] args) {
    String filename = args[0];
    if(filename!=null){list(filename,System.out);}
  }
  public static void list(String f,PrintStream fs){
    try {
      BufferedReader br = new BufferedReader(new FileReader(f));
      String s = null; 
      while((s=br.readLine())!=null){
        fs.println(s);            
      }
      br.close();
    } catch (IOException e) {
      fs.println("无法读取文件");
    }
  }
}



import java.util.*; 
import java.io.*;
public class TestPrintStream3 {
   public static void main(String[] args) {
     String s = null;
     BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    try {
      FileWriter fw = new FileWriter("d:\\bak\\logfile.log", true); 
      PrintWriter log = new PrintWriter(fw);
      while ((s = br.readLine())!=null) {
        if(s.equalsIgnoreCase("exit")) break;
        System.out.println(s.toUpperCase());
        log.println("-----");
        log.println(s.toUpperCase()); 
        log.flush();
      }
      log.println("==="+new Date()+"==="); 
      log.flush();
      log.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}



import java.io.*;

public class TestObjectIO {
    public static void main(String args[]) throws Exception {
        T t = new T();
        t.k = 8;
        FileOutputStream fos = new FileOutputStream("d:/share/java/io/testobjectio.dat");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(t);
        oos.flush();
        oos.close();
        
        FileInputStream fis = new FileInputStream("d:/share/java/io/testobjectio.dat");
        ObjectInputStream ois = new ObjectInputStream(fis);
        T tReaded = (T)ois.readObject();
        System.out.println(tReaded.i + " " + tReaded.j + " " + tReaded.d + " " + tReaded.k);
   }
}

/**序列化
 *1.一个Object直接转换成为字节流写到硬盘或网络上去
 *2.标记作用
 *3.里面没有任何方法,给JDK看,JDK看到它就知道可以序列化了
 *4.直接实现这个接口,是JKD帮你控制这个对象
 *5.把一个对象直接写到硬或网络上应当把它序列化成一个字节流必须实现这个接口
 */
class T implements Serializable
{
    int i = 10;
    int j = 9;
    double d = 2.3;
    int k = 15;
    //transient透明的,它修饰的成员变量在序列化的时候不予考虑
    //transient int k = 15;  直行的时候,k为0
}

 

分享到：
| [原]Java对数据库中时间的操作
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java的io操作

    Java的IO操作是Java编程中不可或缺的一部分，它允许程序与外部存储设备进行交互，如读取文件、写入文件、创建文件夹等。在Java中，`java.io`包提供了大量的类和接口来支持这些功能。 首先，我们来看如何创建一个新...

    java的各种io操作

    Java的IO操作是Java编程中的重要组成部分，它允许开发者处理输入和输出，包括读取文件、写入文件、复制文件、创建目录等。在Java中，IO操作主要依赖于`java.io`包中的类和接口。 1. **新建目录**： 在Java中，我们...

    java_IO操作

    以下是对标题和描述中涉及的Java IO操作知识点的详细说明： 1. **读取文件内容**： - **按字节读取**：使用`FileInputStream`类，通过`read()`方法逐个读取字节。适用于二进制文件，如图片、音频或视频。 - **按...

    java的io操作源代码

    Java的IO操作是Java编程中的基础且重要的一部分，它提供了对输入输出流的处理，使得程序可以与外部设备（如硬盘、键盘、显示器）进行数据交互。本代码库包含了Java进行基本IO操作的源代码，涵盖了文件的复制、删除、...

    javaIO操作简单例子

    下面是一个简单的Java IO操作示例，展示如何使用InputStream和FileOutputStream进行文件的复制： ```java import java.io.*; public class SimpleIOTest { public static void main(String[] args) { try { ...

    Java-Io流，练习

    为了提高IO操作的效率，Java提供了缓冲流，如`BufferedInputStream`和`BufferedOutputStream`，以及`BufferedReader`和`BufferedWriter`。这些类在内部维护了一个缓冲区，可以减少实际的物理I/O次数。 五、转换流...

    javaIo操作的基础代码

    Java IO操作是Java编程中的重要组成部分，主要用于处理输入和输出数据。在Java中，IO操作涉及到文件、字节流、字符流以及管道流等多个概念。下面将详细解释这些知识点。 首先，我们来看“文件类”。在Java中，`java...

    java.io.Reader 和 java.io.InputStream 的区别

    在深入探讨`java.io.Reader`与`java.io.InputStream`的具体差异之前，我们首先需要理解这两者在Java I/O操作中的基础角色。`java.io.Reader`和`java.io.InputStream`是Java标准库中处理输入数据的核心类，它们分别...

    java的IO操作常规

    Java的I/O操作是Java编程中非常基础且重要的知识点。它允许程序读取或写入数据，与文件系统和其他输入/输出设备进行交互。...Java的IO操作不仅限于文件，还包括网络通信等更广泛的应用场景，是进行Java开发的必备知识。

    提高Java IO操作的性能

    提高Java IO操作的性能 虽然抱怨Java程序性能不佳的呼声由来已久，但实际上，如果开发者在整个开发周期内都能够关注性能问题，Java程序完全可以和C/C++程序一样快。本文分析了Java IO应用中一些常见的性能问题。

    JAVA基本IO操作.mp4

    JAVA基本IO操作.mp4

    JAVA教程IO流操作

    在Java编程语言中，IO（Input/Output）流是一组用于处理输入和输出操作的类和接口，它们允许我们读取和写入数据到各种类型的源和目标，如文件、网络连接、内存缓冲区等。Java IO流系统分为字节流和字符流两大类。 ...

    java-IO框架图

    例如，javaio.bmp和javaio2.bmp可能是两张展示IO框架图的图片，其中详细描绘了不同类之间的继承关系和使用场景，帮助开发者更好地理解和掌握Java IO系统。 总结一下，Java IO框架是Java平台不可或缺的一部分，它为...

    Java_IO完全总结

    Java IO系统主要包括两个包：`java.io`和`java.nio`（New IO），其中`java.io`提供了一系列基于流的I/O操作接口与实现类，而`java.nio`则提供了更高效的数据访问方式，如通道和缓冲区等。 Java IO系统的设计原则之...

    彻底明白java的io系统

    在这个实例学习中，我们将深入探讨Java IO的各种概念和用法，让你彻底摆脱对IO系统的困扰。 Java的IO库主要包含在java.io包下，提供了大量的类和接口，如InputStream、OutputStream、Reader、Writer、File、...

    Java_IO流详解

    Java 的输入/输出操作是基于数据流（Stream）的，有序的字节或者字符通过一个通信信道从源地址传送到目的地址。Java 支持两个数据流：InputStream 和 OutputStream。这两个数据流又可以分为许多子类来完成 IO 功能...

    Java对IO类File的操作

    以上是对`java.io.File`类的简单介绍和应用示例的推测。在实际项目中，结合`File`类和其他IO流类，开发者可以实现各种复杂的文件操作。对于初学者来说，理解和掌握`File`类的使用是学习Java IO的基础。

Magicbox
Global site tag (gtag.js) - Google Analytics