`

JAVA范例 七)输入/输出流---字符流

 
阅读更多

      字符流

  实例140 按顺序创建文件 

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterTest {
	public static void main(String[] args) {
		FileWriter fw;
		try {
			fw = new FileWriter("E:/TestApplet.java");				// 创建字符输出流对象
			BufferedWriter bf = new BufferedWriter(fw);	// 创建缓冲字符输出流对象
			for (int i = 0; i < 10; i++) {					// 将字符串写入文件
				bf.write("Line" + i);
			}
			bf.close();								// 关闭缓冲字符输出流
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

 

  实例141 按顺序读取文件

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderTest {
	public static void main(String[] args) {
		FileReader fr;
		try {
			fr = new FileReader("E:/TestApplet.java");				// 创建文件字符输出流对象
			BufferedReader br = new BufferedReader(fr);	// 创建缓冲字符输出流对象
			String str;
			while((str=br.readLine())!=null){
				System.out.println(str);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

 

  实例142 追加文件内容   

package Chapter07.Characters;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;

public class CharactersDemo_03 {
	// 使用RandomAccessFile实现文件的追加,其中:fileName表示文件名;content表示要追加的内容
	public static void appendMethod_one(String fileName, String content) {
		try {
			// 按读写方式创建一个随机访问文件流
			RandomAccessFile raf = new RandomAccessFile(fileName, "rw");
			long fileLength = raf.length();// 获取文件的长度即字节数
			// 将写文件指针移到文件尾。
			raf.seek(fileLength);
			// 按字节的形式将内容写到随机访问文件流中
			raf.writeBytes(content);
			// 关闭流
			raf.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	// 使用FileWriter实现文件的追加,其中:fileName表示文件名;content表示要追加的内容
	public static void appendMethod_two(String fileName, String content) {
		try {
			// 创建一个FileWriter对象,其中boolean型参数则表示是否以追加形式写文件
			FileWriter fw = new FileWriter(fileName, true);
			// 追加内容
			fw.write(content);
			// 关闭文件输出流
			fw.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	public static void showFileContent(String fileName) {
		File file = new File(fileName);
		BufferedReader reader = null;
		try {
			System.out.println("以行为单位读取文件内容,一次读一整行:");
			reader = new BufferedReader(new FileReader(file));
			String tempString = null;
			int line = 1;
			// 一次读入一行,直到读入null为文件结束
			while ((tempString = reader.readLine()) != null) {
				// 显示行号
				System.out.println(line + ": " + tempString);
				line++;
			}
			reader.close();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (reader != null) {
				try {
					reader.close();
				} catch (IOException e1) {
				}
			}
		}
	}
	public static void main(String[] args) {
		String fileName = "D:/temp/append.txt";
		String content = "Successful operation!";
		System.out.println(fileName + "文件的内容如下:");
		CharactersDemo_03.showFileContent(fileName); // 显示文件内容
		// 按RandomAccessFile的形式追加文件
		System.out.println("\n按RandomAccessFile的形式追加文件后的内容如下:");
		CharactersDemo_03.appendMethod_one(fileName, content);
		CharactersDemo_03.appendMethod_one(fileName, "\n Game is Over! \n");
		CharactersDemo_03.showFileContent(fileName); // 显示文件内容
		// 按FileWriter的形式追加文件
		System.out.println("\n按FileWriter的形式追加文件后的内容如下:");
		CharactersDemo_03.appendMethod_two(fileName, content);
		CharactersDemo_03.appendMethod_two(fileName, "\n Game is Over! \n");
		CharactersDemo_03.showFileContent(fileName); // 显示文件内容
	}
}

 

      实例143 只显示文件中指定的字符

import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class StringTest {
	public static void main(String[] args) throws IOException {
		try {
			RandomAccessFile rf = new RandomAccessFile("D:\\test.txt", "r");
			// 创建一个RandomAccessFile类对象
			long count = Long.valueOf(args[0]).longValue();
			// 由命令行参数传入一个数字count,表示显示文件中最后的count个字符
			long pos = rf.length();// 返回文件的长度
			pos -= count;
			if (pos < 0)
				pos = 0;
			rf.seek(pos);// 将指针移动到文件尾
			while (true) {
				try {
					byte b = rf.readByte();// 读取一个字节
					System.out.print((char) b);// 将读取的字节转换成字符输出
				} catch (EOFException e) {
					break;
				}
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
	}
}

 

  实例144 读取jar包文件

package Chapter07.Characters;

import java.awt.geom.Area;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;

public class CharactersDemo_05 {
	// javaClass表示类文件;filepath表示文件的相对路径
	public static void readJar_URL(Class javaClass, String filepath) {
		URL url = javaClass.getResource(filepath);// 获取定位资源URL对象
		System.out.println("资源的URL: " + url);
		try {
			InputStream stream = url.openStream();// 打开fileURL对应的文件流
			BufferedReader bufferedreader = new BufferedReader(// 创建一个缓冲字符输入流
					new InputStreamReader(stream));
			String str;
			while ((str = bufferedreader.readLine()) != null) {// 从缓冲字符输入流中按行读取信息
				System.out.println(str);
			}
			stream.close();// 关闭流
		} catch (IOException ioexception) {
			ioexception.printStackTrace();
		}
	}
	// 读Jar包中的资源信息,其中:javaClass表示类文件;filepath表示文件的相对路径
	public static void readJar_stream(Class javaClass, String filepath) {
		InputStream stream = javaClass.getResourceAsStream(filepath);// 获取该资源输入流的引用
		if (stream != null) {
			// 创建一个缓冲字符输入流
			BufferedReader bufferedreader = new BufferedReader(
					new InputStreamReader(stream));
			String str;
			try {
				// 从缓冲字符输入流中按行读取信息
				while ((str = bufferedreader.readLine()) != null) {
					System.out.println(str);
				}
				stream.close();
			} catch (IOException ioexception) {
				ioexception.printStackTrace();
			}
		}
	}
	public static void main(String[] args) {
		System.out.println("以该class文件的位置为准,以URL的方式读取Jar包信息的内容如下:");
		Class javaClass = aa.class;//在该文件的目录下要存在aa.class文件
		String filePath = "config0.conf";//filePath的值是要读取的jar包名称
		CharactersDemo_05.readJar_URL(javaClass, filePath);
		System.out.println();
		System.out.println("以该class文件的位置为准,以直接获取资源输入流的引用的方式读取Jar包信息的内容如下:");
		filePath = "bdc/config1.conf";//filePath的值是要读取的jar包名称
		CharactersDemo_05.readJar_stream(javaClass, filePath);
		System.out.println();
		System.out.println("以该jar文件的位置为准,以URL的方式读取Jar包信息的内容如下::");
		filePath = "/jarTest/abc/bdc/config1.conf";//filePath的值是要读取的jar包名称
		CharactersDemo_05.readJar_URL(javaClass, filePath);
	}
}

 

  实例145 文件的加密/解密操作   

package Chapter07.Characters;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.RandomAccessFile;

public class CharactersDemo_06 {
	private File file; // 存储文件对象信息
	byte[] buf; // 缓冲区,存储文件中的所有数据
	RandomAccessFile raf;
	public CharactersDemo_06(String filename) {
		file = new File(filename);
		buf = new byte[(int) file.length()];
	}
	// 按照读写方式打开文件
	public void open() throws FileNotFoundException {
		raf = new RandomAccessFile(file, "rw");
	}
	// 关闭文件
	public void close() throws IOException {
		raf.close();
	}
	// 对文件进行加密或解密
	public void password() throws IOException {
		raf.read(buf);// 将文件内容读入到缓冲区中
		for (int i = 0; i < buf.length; i++)
			buf[i] = (byte) (~buf[i]);// 将缓冲区中的内容按位取反
		raf.seek(0);// 将文件指针定位到文件头部
		raf.write(buf);// 将缓冲区中的内容写入到文件中
	}
	// 显示文件的内容
	public static void showFileContent(String fileName) {
		File file = new File(fileName);
		BufferedReader reader = null;
		try {
			reader = new BufferedReader(new FileReader(file));
			String tempString = null;
			// 一次读入一行,直到读入null为文件结束
			while ((tempString = reader.readLine()) != null) {
				// 显示行号
				System.out.println(tempString);
			}
			reader.close();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (reader != null) {
				try {
					reader.close();
				} catch (IOException e1) {
				}
			}
		}
	}
	public static void main(String argv[]) {
		CharactersDemo_06 oa;
		if (argv.length < 1) {
			System.out.println("你需要指定待加密的文件名称!");
			return;
		}
		// 下面利用encrypt对象oa对由命令行参数指定的文件进行加密处理
		oa = new CharactersDemo_06(argv[0]);
		try {
			oa.open();// 打开文件
			oa.password();// 先对指定的文件加密
			System.out.println("文件加密成功!加密后的文件内容如下:");
			CharactersDemo_06.showFileContent(argv[0]);// 显示加密后文件的内容
			oa.password();// 再对已经加密的文件解密
			oa.close();// 关闭文件
			System.out.println("\n文件解密成功!解密后的文件内容如下:");
			CharactersDemo_06.showFileContent(argv[0]);// 显示解密后文件的内容
		} catch (FileNotFoundException e) {
			System.out.println("打不开指定文件:" + argv[0]);
		} catch (IOException e) {
			System.out.println("文件读写出错:" + argv[0]);
		}
	}
}

 

      实例146 复制图片 

package Chapter07.Characters;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class StreamDemo extends JFrame {
	private JPanel j;
	private BorderLayout bl = new BorderLayout();
	// 添加组件
	private JPanel j1 = new JPanel();
	private JScrollPane js = new JScrollPane();
	private JTextArea jta = new JTextArea();
	private JLabel jl1 = new JLabel();
	private JLabel jl2 = new JLabel();
	private JButton jb = new JButton();
	private GridLayout gl = new GridLayout();
	private JTextField jtf1 = new JTextField();
	private JTextField jtf2 = new JTextField();
	// 定义文件输入输出流
	File f = null;
	File ff = null;
	FileInputStream fis = null;
	FileOutputStream fos = null;
	DataInputStream dis = null;
	DataOutputStream dos = null;
	private void jbInit() {
		// 设置各组件及窗口属性,窗口的布局,并在窗口中添加各组件
		j = (JPanel) this.getContentPane();
		j.setLayout(bl);
		this.setSize(new Dimension(395, 195));
		this.setTitle("复制图片操作");
		jb.setText("开始");
		jb.addActionListener(new ActionListener() {// 添加事件监听器
					public void actionPerformed(ActionEvent e) {
						try {
							jb_actionPerformed(e);
						} catch (Exception e1) {
							e1.printStackTrace();
						}
					}
				});
		jl1.setMaximumSize(new Dimension(50, 18));
		jl1.setText("源文件:");
		jl2.setText("目标文件");
		j1.setLayout(gl);
		gl.setColumns(2);
		gl.setRows(2);
		j.add(j1, BorderLayout.NORTH);
		j1.add(jl1, null);
		j1.add(jtf1, null);
		j1.add(jl2, null);
		j1.add(jtf2, null);
		j.add(js, BorderLayout.CENTER);
		js.getViewport().add(jta, null);
		j.add(jb, BorderLayout.SOUTH);
		this.setVisible(true);
	}
	void jb_actionPerformed(ActionEvent e) throws Exception {
		final int BufferSize = 1024;// 定义缓冲区大小
		byte[] b = new byte[BufferSize];// 创建缓冲区
		f = new File(this.jtf1.getText());
		ff = new File(this.jtf2.getText());
		if (!ff.exists())
			try {
				ff.createNewFile();
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		// 打开文件的输入输出流
		fis = new FileInputStream(f);
		fos = new FileOutputStream(ff);
		// 将数据输入输出流与文件输入输出流链接
		dis = new DataInputStream(fis);
		dos = new DataOutputStream(fos);
		// 清空,并显示源文件和目标文件信息
		this.jta.setText("");
		this.jta.append("读取文件:" + f.getAbsolutePath() + "\n");
		this.jta.append("写入文件:" + ff.getAbsolutePath() + "\n");
		// 利用缓冲区读写文件
		int bytes;
		while ((bytes = dis.read(b, 0, BufferSize)) != -1) {
			dos.write(b, 0, bytes);
			this.jta.append("读取 " + bytes + "B" + " 写入 " + bytes + "B" + "\n");
		}
		// 显示读写完成
		this.jta.append("完成");
		// 关闭流
		dis.close();
		dos.close();
	}
	public static void main(String[] args) {
		new StreamDemo().jbInit();
	}
}

 

  实例147 随机读写Java类文件 

package Chapter07.Characters;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class CharactersDemo_07 {
	public static void RandomToWrite(File file) {
		Student[] students = new Student[4]; // 创建Student数组
		// 初始化Student数组
		students[0] = new Student("优秀", "90");
		students[1] = new Student("优良", "80");
		students[2] = new Student("良好", "70");
		students[3] = new Student("及格", "60");
		RandomAccessFile randomAccessFile = null; // 创建RandomAccessFile对象
		try {
			randomAccessFile = new RandomAccessFile(file, "rw"); // 创建一个可以支持读写状态的RandomAccessFile对象
		} catch (FileNotFoundException e1) { // 捕获异常
			System.out.println("文件没有找到" + e1.getMessage()); // 输出异常信息
		}
		try {
			for (int i = 0; i < students.length; i++) // for遍历students数组
			{
				randomAccessFile.writeChars(students[i].getLevel()); // 向文件中写入评分等级
				randomAccessFile.writeChars(students[i].getScore()); // 向文件中写入分数
			}
			randomAccessFile.close(); // 关闭randomAccessFile
		} catch (IOException e1) { // 捕获异常
			e1.printStackTrace(); // 输出异常信息
		}
	}
	private static String readName(RandomAccessFile randomAccessfile)
			throws IOException {
		char[] name = new char[5]; // 创建char类型数组
		for (int i = 0; i < name.length; i++) {
			name[i] = randomAccessfile.readChar(); // 读取字符
		}
		return new String(name);
	}
	public static Student[] RandomToRead(File file) throws Exception {
		RandomAccessFile randomAccessFile; // 创建RandomAccessFile实例
		randomAccessFile = new RandomAccessFile(file, "r"); // 初始化randomAccessFile对象
		int num = (int) randomAccessFile.length() / Student.size(); // 返回Student类的占用空间大小
		Student[] student = new Student[num]; // 创建Student数组student
		for (int i = 0; i < num; i++) {
			randomAccessFile.seek((i) * Student.size());
			// 使用对应的read方法读出数据。
			student[i] = new Student(readName(randomAccessFile),
					readName(randomAccessFile));
		}
		randomAccessFile.close(); // randomAccessFile关闭
		return student; // 返回数组
	}
	public static void main(String[] args) throws Exception {
		// 创建,并初始文件名称
		String filename = "D:/temp/1.txt";
		File file = new File(filename); // 创建并初始File对象file
		RandomToWrite(file); // 调用RandomWriteFile方法
		Student[] student = RandomToRead(file); // 返回文件中保存的student数组
		// 使用for,遍历student数组
		System.out.println(filename + "的内容如下:");
		for (int i = 0; i < student.length; i++) {
			System.out.println("Level=" + student[i].getLevel() + "|Score="
					+ student[i].getScore());
		}
	}
}
class Student {
	String level; // 评分级别
	String score; // 分数
	final static int SIZE = 8; // 创建,并初始化静态域LEN
	public Student(String level, String score) {
		if (level.length() > SIZE) {
			level = level.substring(0, 8); // 截取字符串的子字符串
		} else {
			while (level.length() < SIZE)
				level = level + "\u0000";
		}
		this.level = level; // 初始化level
		this.score = score; // 初始化score
	}
	// 获取类占用的空间
	public static int size() {
		return 20;// 字符串长度是8,一个字符占用2个字节,一个整型是4个字节
	}
	public String getLevel() {
		return level;
	}
	public void setLevel(String level) {
		this.level = level;
	}
	public String getScore() {
		return score;
	}
	public void setScore(String score) {
		this.score = score;
	}
}

 

分享到:
评论

相关推荐

    Java输入输出流(IO)教程

    覆盖的内容主要包括:1)输入输出流的介绍及分类,如输入流和输出流、字节流和字符流;2)File类的使用;3)具体介绍了字节流、字符流、缓冲流、转换流的应用;4)阐述对象序列化及反序列化的实现方式;5)讨论了...

    《java范例大全》源代码

    源代码中会有读写文件、复制文件、处理标准输入输出的实例,展示如何使用FileInputStream、FileOutputStream、BufferedReader、PrintWriter等类。 8. **数据库操作**:Java通过JDBC(Java Database Connectivity)...

    Java范例开发大全代码

    5. **IO流**:包括文件操作、网络通信,以及不同类型的输入/输出流(如字节流、字符流、缓冲流和对象流)。 6. **多线程**:线程的创建(通过Thread类或实现Runnable接口)、线程同步(synchronized关键字、wait()...

    Java范例开发大全

    《Java范例开发大全》共22章,内容涉及Java开发环境的搭建、Java基础类型与运算符、条件控制语句、异常处理、数组、字符串、输入输出流、面向对象及其四大特征、内部类与接口、Java常用类、集合、多线程编程、Java...

    Java范例开发大全(光盘源码)

    5. **输入/输出流**:Java I/O流系统提供了读写文件、网络通信等功能。书中会介绍如何使用FileInputStream、FileOutputStream、BufferedReader、PrintWriter等类进行文件操作,以及Socket编程的基础知识。 6. **多...

    Java范例程序.rar_Java范例

    - **Reader与Writer**:字符流的基类,用于处理文本数据。 - **BufferedReader与BufferedWriter**:提高读写性能,通过缓冲区进行操作。 6. **多线程**: - **Thread类与Runnable接口**:创建线程的两种方式,...

    java源码包---java 源码 大量 实例

     Java数据压缩与传输实例,可以学习一下实例化套按字、得到文件输入流、压缩输入流、文件输出流、实例化缓冲区、写入数据到文件、关闭输入流、关闭套接字关闭输出流、输出错误信息等Java编程小技巧。 Java数组倒置...

    JAVA语言与其程序设计范例.rar

    范例可能包含文件读写、字符流、字节流、缓冲流的使用。 9. **网络编程**:Java提供了丰富的网络编程API,如Socket和ServerSocket。范例可能展示了如何建立客户端和服务器之间的连接,进行数据传输。 10. **JDBC**...

    Java2范例入门与提高

    本章会讲解文件的读写、字节流与字符流的区别、缓冲区的使用以及对象序列化等重要概念。 5. **Chap05** - 多线程 Java提供了丰富的多线程支持,包括线程的创建、同步、通信等。本章会探讨Thread类和Runnable接口,...

    Java通用范例开发金典[源码]

    - 字符流:掌握Reader和Writer接口,以及BufferedReader和BufferedWriter的用法。 - 对象序列化:理解如何将对象持久化到磁盘,以及反序列化回内存。 4. **多线程** - 线程基础:创建和管理线程,理解线程同步和...

    Java2范例入门与提高(源码)

    5. **Chap05** - 文件和I/O流:这部分可能涉及文件读写,输入输出流,包括字节流和字符流,以及缓冲区的概念。 6. **Chap06** - 多线程:Java支持多线程编程,这部分可能讲解线程的创建、同步机制(如synchronized...

    Java2范例入门与提高.

    5. **输入/输出流**:Java的I/O流系统使得处理文件、网络数据变得简单。我们将学习字节流、字符流、对象序列化以及缓冲流的使用。 6. **多线程编程**:Java支持多线程,我们将讨论如何创建和管理线程,同步机制(如...

    C++大学教程

    1.9 Java、Internet与万维网--------------------------------------------7 1.10 其它高级语言------------------------------------------------------8 1.11 结构化编程-----------------------------------...

    java通用范例经典

    范例会涵盖字节流、字符流、对象流,以及缓冲流、转换流等,帮助开发者掌握数据输入输出的方法。 6. **多线程**:Java提供了强大的并发处理能力,包括Thread类、Runnable接口、同步机制(synchronized关键字、wait/...

    java范例程序 中文版

    I/O流是Java处理输入和输出的重要组件,分为字节流(处理原始字节数据)和字符流(处理字符数据)。Java的IO库包括许多类,如FileInputStream、FileOutputStream、BufferedReader、BufferedWriter等。 多线程是Java...

    Java完美经典-江义华+code+超过100个程式范例

    6. **输入/输出流**:包括文件操作、对象序列化、缓冲流和转换流的使用,以及如何进行网络数据传输。 7. **多线程编程**:讲解线程的概念,如何创建和管理线程,以及同步机制如synchronized关键字和wait/notify方法...

    JAVA培训范例I,初学者入门的经典实例

    I/O流处理是Java的一大特色,Java提供了丰富的类库来处理输入输出,包括文件操作、网络通信等。学会使用InputStream、OutputStream、Reader、Writer等基本流,以及BufferedReader、PrintWriter等缓冲流,可以方便地...

    Java 2范例入门与提高

    输入/输出流是Java中处理数据传输的核心,分为字节流和字符流,还有缓冲流、对象流等高级流的概念。 此外,多线程是Java的一大特色。通过实现Runnable接口或继承Thread类,可以创建并管理多个并发执行的任务,实现...

Global site tag (gtag.js) - Google Analytics