java文件流

‘壹’ java文件流的缓冲区是怎么

缓冲区其实就是个字节数组
如果一个文件很大，比如1G
如果直接写入内存而此时你的内存不足1G，那么就会内存溢出。当然即使不溢出也不应该把很大的文件直接加载在内存中
这时就用到了buffer，new一个4096长度的字节数组只需要占用4KB的内存，通过循环读写就可以把1G的文件写入目标，这样做不仅节约了内存，而且相对来说高效

‘贰’ Java 文件流操作

利用读取流读取到数据然后输出流输出就可以了

BufferedReader bufr = new BufferedReader(new FileReader("D:\\test.txt"));

PrintWriter pw = new PrintWriter(new FileWriter("D:\\test1.txt",true);

String line = null;
while((line = bufr.readLine)!=null){
pw.println(line);
}

bufr.close;
pw.close;

‘叁’ java文件流系统

FileOutputStream fos= new FileOutputStream("dos.dat");
这一行作用是让一个流接到本地文件dos.dat文件上 准备把 '程序里的数据写到文件里'
BufferedOutputStream bos= new BufferedOutputStream(fos);
这一行的作用是fos对象是个基础节点流但是它的功能不强大 所以要在这个流的基础上套接一个带缓冲区的流BufferedOutputStream bos 它的功能很强大
DataOutputStream dos= new DataOutputStream(bos);
这一行的作用是在那个带缓冲区的流的基础上 再次套接一个流 这个流提供了一些很好的方法，可以writeInt,writeByte,writeLong等。

DataOutputStream这个流一般配合DataInputStream流进行一些二进制文件的读写操作.

‘肆’ 在java 中文件流和数据流的区别

文件流是通过方法可以知道长度，名称等详细信息的数据流。主要用于文件操作，在文件流中有自己的适用于文件操作的数据格式。而数据流是一个统称，所有的流都可以称为数据流。文件流属于数据流的一种。

‘伍’ java中如何做文件字节输入流

首先，我以往经验是写入字节流和输出字节流的方式一定要一致，不然写入的字节流就会出错甚至读取不到，下面是字节流的写入和读取方法：

importjava.io.*;
classTest{
publicstaticvoidmain(Stringargs[]){
FileInputStreamfis=null;
FileOutputStreamfos=null;
byte[]buffer=newbyte[100];
inttemp=0;
try{
fis=newFileInputStream("D:/wenhao/src/from.txt");
fos=newFileOutputStream("D:/wenhao/src/to.txt");
while(true){
temp=fis.read(buffer,0,buffer.length);
if(temp==-1){
break;
}
fos.write(buffer,0,temp);
}
}
catch(Exceptione){
System.out.println(e);
}
finally{
try{
fis.close();
fos.close();
}
catch(Exceptione2){
System.out.println(e2);
}
}
}
}

‘陆’ java 文件读写流

读写是两个不同的分支，通常都是分开单独使用的。
可以通过BufferedReader 流的形式进行流缓存，之后通过readLine方法获取到缓存的内容。
BufferedReader bre = null;
try {
String file = "D:/test/test.txt";
bre = new BufferedReader(new FileReader(file));//此时获取到的bre就是整个文件的缓存流
while ((str = bre.readLine())!= null) // 判断最后一行不存在，为空结束循环
{
System.out.println(str);//原样输出读到的内容
}；
备注： 流用完之后必须close掉，如上面的就应该是：bre.close()，否则bre流会一直存在，直到程序运行结束。
可以通过“FileOutputStream”创建文件实例，之后过“OutputStreamWriter”流的形式进行存储，举例：
OutputStreamWriter pw = null;//定义一个流
pw = new OutputStreamWriter(new FileOutputStream(“D:/test.txt”),"GBK");//确认流的输出文件和编码格式，此过程创建了“test.txt”实例
pw.write("我是要写入到记事本文件的内容");//将要写入文件的内容，可以多次write
pw.close();//关闭流
备注：文件流用完之后必须及时通过close方法关闭，否则会一直处于打开状态，直至程序停止，增加系统负担。

‘柒’ java文件流怎么写

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

private File fileObject;
private String savePath;
FileOutputStream fileOutputStream = new FileOutputStream("savePath");
FileInputStream fileInputStream = new FileInputStream(fileObject);
byte[] buffer = new byte[100];
int len = 0;
while ((len = fileInputStream.read(buffer)) > 0) {
fileOutputStream.write(buffer, 0, len);
}

‘捌’ java中关于文件流的读写(Writer Reader)

你好 我刚刚做了个例子 方便你看
class_writer class 这个例子是从 一个文件中读取数据然后插入了数据库中 你可以只看读取与插入的过程 希望能帮到你.
public class writer {
public boolean writ(String str) {
boolean success=false;
str = str.replaceAll(" ", "").replaceAll("\"", "");
String[] strs = str.split(",");
BaseJDBC base = new BaseJDBC();
String ML = "";
Statement stmt;
Connection conn;
ML = "'"+strs[0].replace(" ", "").trim() + "','"
+ strs[1].replace(" ", "").trim() + "','"
+ strs[2].replace(" ", "").trim() + "','"
+ strs[3].replace(" ", "").trim() + "','"
+ strs[4].replace(" ", "").trim()+ "','"
+ strs[5].replace(" ", "").trim()+"','"
+ strs[6].replace(" ", "").trim()+"'";
String query = "INSERT INTO BANK_INFO VALUES(" + ML + ")";
if (!strs[0].equals("参与者行号")) {
try {
conn=base.genConn();
stmt = conn.createStatement();
int num=stmt.executeUpdate(query);
if(num==1)success=true;
stmt.close();
conn.close();
System.out.println();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println(e.getMessage());
}
}
return success;
}

//class readingclass
public class reading {
public static void readFileByLines(String fileName) {
File file = new File(fileName);
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int line = 1;
while ((tempString = reader.readLine()) != null) {
writer w=new writer();
try {
tempString.getBytes("utf-8");
} catch (UnsupportedEncodingException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
if(!w.writ(tempString)){
System.out.println("第"+line+"行出现异常："+tempString);
}else{
System.out.println("第"+line+"行初始化成功！");
}
line++;
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
//1927
public static void main(String[] args) {
// TODO Auto-generated method stub
String fileName = "D:\\BankInfo_20110714094211.csv";
readFileByLines(fileName);

}

‘玖’ java中的文件流

import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

public class Test implements ActionListener {
String[] list1;

String[] list2;

String file1 = "/home/soft01/1.txt";//1.txt路径

String file2 = "/home/soft01/2.txt";//2.txt路径

JTextField jtf1;

JTextField jtf2;

int num = 3;

private boolean flag = true;

public Test() {
begin();
list1 = fileToString(file1);
list2 = fileToString(file2);
}

public void begin() {
JFrame jf = new JFrame();
jf.setLayout(new GridLayout(3, 2));
JLabel jl1 = new JLabel(" 1");
JLabel jl2 = new JLabel(" 2");
JLabel jl3 = new JLabel(" res");
jtf1 = new JTextField(8);
jtf2 = new JTextField(8);
JTextField jtf3 = new JTextField(8);
jtf3.addActionListener(this);
jf.add(jl1);
jf.add(jtf1);
jf.add(jl2);
jf.add(jtf2);
jf.add(jl3);
jf.add(jtf3);
jf.pack();
jf.setLocation(400, 300);
jf.setVisible(true);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

public String[] fileToString(String filePath) {
String text = "";
try {
String str;
BufferedReader reader = new BufferedReader(new InputStreamReader(
new FileInputStream(filePath)));
while ((str = reader.readLine()) != null) {
text = text + str + " ";
}
} catch (Exception e) {
e.printStackTrace();
}
return text.split(" ");
}

public void actionPerformed(ActionEvent e) {
if (num == list1.length) {
num = 3;
}
if (flag) {
jtf1.setText(list1[num]);
} else {
jtf2.setText(list2[num]);
num++;
}
flag = !flag;
}

public static void main(String[] args) {
new Test();
}
}
希望分数给我，写这个也不容易了。

‘拾’ 关于java文件流的小问题：下面是代码

先开的后关，后开的先关.....
其实这么认识是错误的
这个是DataOutputStream的父类FilterOutputStream的源码
public void close() throws IOException {
try {
flush();
} catch (IOException ignored) {
}
out.close();
}
其中out是传入的ByteArrayOutputStream baos
意思就是在做dos的close时，会做父类FilterOutputStream的close。
然后会做ByteArrayOutputStream baos的close。
实际就是这样的咯。

所以一般只需要做最外层包装流的close，就可以关闭这个流了。
在这个样例中，如果做了baos的close。dos和baos共用的流已经被关闭。
所以baos的close和dos的close的实际效果是一样的。

只是习惯上会用最外层的close。
因为比如缓存流BufferedWriter bw这种，
做bw的close会把缓冲区也关闭掉。
但是用内层的流的close的时候，就不会关闭外层流。

一句话就是外层肯定调用内层，内层肯定不调用外层。