本文目录一览：
java 文件读写流
首先你要知道java的io流主要分两种，一种是字符流，另一种字节流，还有一种过滤流，这个不常用，暂且可以忽略。
等你这些都掌握了，推荐你用nio包中的管道流。
流的套用可以提升读写效率（这种方式只能是同类流的套用，比如字节流套用字节流），还有一种是字符流与字节流互相转换，转换通过一种叫做“桥转换”的类,比如OutputStreamWriter类。
下面举个最基础的字节流例子：
public void copyFile(String file, String bak) {
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
byte[] bytes = new byte[1024];
bis = new BufferedInputStream(new FileInputStream(file));//BufferedInputStream会构造一个背部缓冲区数组，将FileInputStream中的数据存放在缓冲区中，提升了读取的性能
bos = new BufferedOutputStream(new FileOutputStream(bak));//同理
int length = bis.read(bytes);
while (length != -1) {
System.out.println("length: " + length);
bos.write(bytes, 0, length);
length = bis.read(bytes);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
bis.close();
bos.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
字符流的用法：
FileReader fr = new FileReader("D:\\test.txt");
BufferedReader br = new BufferedReader(fr);
或者PrintWriter pw = new PrintWriter(new FileWriter("D:\\test.txt"));
...
java文件读写
在网上查了很多关于修改文件的方法，不得其要领。自己想了两个取巧的办法，来解决对文件的修改。一：读取一个文件file1（FileReader and BufferedReader），进行操作后写入file2(FileWriter and BufferedWriter)，然后删除file1，更改file2文件名为file1(Rename()方法)。二：创建字符缓冲流（StringBuffer），读取文件内容赋给字符缓冲流，再将字符缓冲流中的内容写入到读取的文件中。例如： test.txt 这里是放在d盘的根目录下，内容如下 able adj 有才干的，能干的 active adj 主动的，活跃的 adaptable adj 适应性强的 adroit adj 灵巧的，机敏的 运行结果生成在同目录的 test1.txt中 able #adj*有才干的，能干的 active #adj*主动的，活跃的 adaptable #adj*适应性强的 adroit #adj*灵巧的，机敏的 代码： public class Test { public static void main(String[] args) throws Exception{ BufferedReader br = new BufferedReader(new FileReader("D:\\test.txt")); StringBuffer sb = new StringBuffer(); String lineContent = null ;while( (lineContent = br.readLine()) != null){ String[] sp = lineContent.split(" ");sp[0] = sp[0].concat(" *");sp[1] = sp[1].concat("# ");for(int i=0;i sb.append(sp[i]);}sb.append("\r\n");}FileWriter fw = new FileWriter("D:\\test2.txt"); fw.write(sb.toString()); br.close(); fw.close(); }}
java缓冲流读写数据
--- 下面都是以字节流方式操作 ---
//读数据：
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("xx.xx"));
byte[] b = new byte[1024];
int len = 0;
while((len=bis.read(b))!-1){
//这样就读取并输出了，如果是别的文件的话乱码，因为二进制文件
System.out.println(new String(b,0,len));
}
bis.close();//关闭流，节省资源
//写数据：
BufferedOutputStream bos = new BufferedOutputStream(new FileOuputStream("xx.xx"));
//使用缓冲区写二进制字节数据
bos.write("xxxxx".getBytes());
bos.close();//关闭流，节省资源
如果字符流的话就是：
BufferedReader //读取
BufferedWriter //写入
Java中对文件进行读写操作的基本类是什么?
Java.io包中包括许多类提供许多有关文件的各个方面操作。
1 输入输出抽象基类InputStream/OutputStream ，实现文件内容操作的基本功能函数read()、 write()、close()、skip()等；一般都是创建出其派生类对象（完成指定的特殊功能）来实现文件读写。在文件读写的编程过程中主要应该注意异常处理的技术。
2 FileInputStream/FileOutputStream：
用于本地文件读写（二进制格式读写并且是顺序读写，读和写要分别创建出不同的文件流对象）；
本地文件读写编程的基本过程为：
① 生成文件流对象（对文件读操作时应该为FileInputStream类，而文件写应该为FileOutputStream类）；
② 调用FileInputStream或FileOutputStream类中的功能函数如read()、write(int b)等）读写文件内容；
③ 关闭文件（close()）。
3 PipedInputStream/PipedOutputStream：
用于管道输入输出（将一个程序或一个线程的输出结果直接连接到另一个程序或一个线程的输入端口，实现两者数据直接传送。操作时需要连结）；
4管道的连接：
方法之一是通过构造函数直接将某一个程序的输出作为另一个程序的输入，在定义对象时指明目标管道对象
PipedInputStream pInput=new PipedInputStream();
PipedOutputStream pOutput= new PipedOutputStream(pInput);
方法之二是利用双方类中的任一个成员函数 connect()相连接
PipedInputStream pInput=new PipedInputStream();
PipedOutputStream pOutput= new PipedOutputStream();
pinput.connect(pOutput);
5 管道的输入与输出：
输出管道对象调用write()成员函数输出数据（即向管道的输入端发送数据）；而输入管道对象调用read()成员函数可以读起数据（即从输出管道中获得数据）。这主要是借助系统所提供的缓冲机制来实现的。
6随机文件读写：
RandomAccessFile类（它直接继承于Object类而非InputStream/OutputStream类），从而可以实现读写文件中任何位置中的数据（只需要改变文件的读写位置的指针）。
随机文件读写编程的基本过程为：
① 生成流对象并且指明读写类型；
② 移动读写位置；
③ 读写文件内容；
④ 关闭文件。
七里河团队答疑助人,希望我的回答对你有所帮助
怎样用Java读写二进制文件
import java.util.*;
import java.io.*;
class SmallFile {
static final int HEADLEN = 24; //头总长度
byte[] fileName = new byte[16]; //列表文件名1: 长度128 想把它读到char[]里 它的编码方式不是Unicode。在不确定编码方式的时候，最好直接用byte[]来存放
int offset; //列表文件地址1: 长度32 想把它读到int里
int length = -1; //列表文件长度1: 长度32 想把它读到int里
byte[] content;
public SmallFile() {
}
public SmallFile(byte[] fn, byte[] content) {
Arrays.fill(fileName, (byte) 0);
if (fn != null) {
if (fn.length = 16) {
System.arraycopy(fn, 0, fileName, 0, fn.length);
}
else {
System.arraycopy(fn, 0, fileName, 0, 16);
}
}
this.content = content;
if (content != null) {
this.length = content.length;
}
else {
this.length = -1;
}
}
}
public class ReadBinary {
static final int HEADLEN = 8; //头总长度
private String filename;
private byte[] filehead = new byte[4]; //文件头: 长度32 想把它读到char[]里 它的编码方式不是Unicode
private int filecount = -1; //列表长度: 长度32 想把它读到int里 假设他是3 就会有3个列表文件名
private ListSmallFile files = null;
public void setFilehead(byte[] fh) {
if (fh == null)
return;
Arrays.fill(filehead, (byte) 0);
if (fh.length = 4) {
System.arraycopy(fh, 0, filehead, 0, fh.length);
}
else {
System.arraycopy(fh, 0, filehead, 0, 4);
}
}
public ReadBinary(String filename) {
try {
readFromFile(filename);
}
catch (Exception ex) {
System.out.println(ex.getMessage());
System.out.println("在载入数据文件时失败，因此视同为新建一个数据文件！");
this.filename = filename;
Arrays.fill(filehead, (byte) 0);
filecount = 0;
files = new ArrayListSmallFile ();
}
}
public void readFromFile(String filename) throws Exception {
BufferedInputStream bin = new BufferedInputStream(new FileInputStream(
filename));
this.filename = filename;
DataInputStream in = new DataInputStream(bin);
in.read(filehead); //文件头: 长度32 想把它读到char[]里 它的编码方式不是Unicode
filecount = in.readInt(); //列表长度: 长度32 想把它读到int里 假设他是3 就会有3个列表文件名
if (files == null) {
files = new ArrayListSmallFile ();
}
else {
files.clear();
}
for (int i = 0; i filecount; i++) {
SmallFile file = new SmallFile();
in.read(file.fileName);
file.offset = in.readInt(); //列表文件地址1: 长度32 想把它读到int里
file.length = in.readInt(); //列表文件长度1: 长度32 想把它读到int里
files.add(file);
}
}
public void writeToFile() throws Exception {
String temp = filename + ".tmp"; //临时文件
boolean exists = false;
RandomAccessFile raf = null;
try {
raf = new RandomAccessFile(filename, "r"); //文件存在则从文件读入
exists = true;
}
catch (Exception ex) {
System.out.println("文件不存在，因此启用内存写入模式");
}
if (filecount != files.size()) {
throw new Exception("怪事，居然不相同？？");
}
DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new
FileOutputStream(temp)));
//1、写总文件头
out.write(filehead);
out.writeInt(filecount);
//2、写列表头
int sumlength = 0;
for (int i = 0; i files.size(); i++) {
SmallFile file = files.get(i);
out.write(file.fileName);
if (file.length 0) {
throw new Exception("怪事，文件长度怎么可能小于0？");
}
else {
out.writeInt(ReadBinary.HEADLEN + SmallFile.HEADLEN * filecount +
sumlength);
sumlength += file.length;
out.writeInt(file.length);
}
}
//3、写文件内容
for (int i = 0; i files.size(); i++) {
SmallFile file = files.get(i);
if (file.content != null (file.length == file.content.length)) {
out.write(file.content);
}
else if (exists) {
raf.seek(file.offset);
byte[] b = new byte[file.length];
raf.read(b);
System.out.println("b:" + new String(b));
out.write(b);
}
else {
throw new Exception("怪事，又不能从内存读，又不能从文件读。这活没法干了!");
}
}
out.close();
if (raf != null) {
raf.close();
raf = null;
}
System.gc();
//把原先的文件删除
File f = new File(filename);
f.delete();
//再把临时文件改名到正式文件
File f2 = new File(temp);
f2.renameTo(f);
}
public void addFile(SmallFile file) {
if (files != null) {
filecount++;
files.add(file);
}
}
public static void test1(){
ReadBinary rb = new ReadBinary("f:\\temp\\rb.dat");
rb.setFilehead("HEAD1234567890122222222222222222".getBytes());
SmallFile f = new SmallFile("第1个文件".getBytes(), "第1个文件的内容".getBytes());
rb.addFile(f);
try {
rb.writeToFile();
}
catch (Exception ex) {
ex.printStackTrace();
}
}
public static void test2(){
ReadBinary rb = new ReadBinary("f:\\temp\\rb.dat");
rb.setFilehead("HEA".getBytes());
SmallFile f = new SmallFile("第2个文件".getBytes(), "第2个文件的内容".getBytes());
rb.addFile(f);
try {
rb.writeToFile();
}
catch (Exception ex) {
ex.printStackTrace();
}
}
public static void main(String[] args) {
//test1();
test2();
}
}
Java读写文件的几种方法
java读取配置文件的几种方法如下：
方式一：采用ServletContext读取，读取配置文件的realpath，然后通过文件流读取出来。因为是用ServletContext读取文件路径，所以配置文件可以放入在web-info的classes目录中，也可以在应用层级及web-info的目录中。文件存放位置具体在eclipse工程中的表现是：可以放在src下面，也可放在web-info及webroot下面等。因为是读取出路径后，用文件流进行读取的，所以可以读取任意的配置文件包括xml和properties。缺点：不能在servlet外面应用读取配置信息。
方式二：采用ResourceBundle类读取配置信息，
优点是：可以以完全限定类名的方式加载资源后，直接的读取出来，且可以在非Web应用中读取资源文件。缺点：只能加载类classes下面的资源文件且只能读取.properties文件。
