Ⅰ java 如何通过 字符流或者字节流 将一个txt文档 倒叙 输出 到另一个文档
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.StringReader;
import java.io.StringWriter;
public class ReverseText {
public static void main(String[] args) throws Exception {
String from="c:/1.txt"; //源文件
String to="c:/2.txt"; //反转后的新文件
FileReader reader = new FileReader(from);
FileWriter writer = new FileWriter(to);
StringWriter sWriter = new StringWriter();
int readed = reader.read();
while(readed!=-1){
//writer.write(readed);
sWriter.write(readed);
readed = reader.read();
}
StringBuffer buffer = sWriter.getBuffer();
for(int i= buffer.length()-1;i>=0;i--){
writer.write(buffer.charAt(i));
}
writer.close();
sWriter.close();
reader.close();
}
}
Ⅱ java中如何将流转换成文件类型
我查了一下，File的api 这个File的构造方法的介绍。。。
File(File parent, String child)
根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
File(String pathname)
通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。
File(String parent, String child)
根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
File(URI uri)
通过将给定的 file: URI 转换成一个抽象路径名来创建一个新的 File 实例。
也就意味着，如果，file这种类型，就必须有一个路径。
那，能不能在内存中虚拟一个File file呢？
File f = new File("/1.txt");
假如这样，那么，一旦，你开始往这个file里面开流写内容。只有两种情况可能发生，一种是找不到文件，抛异常。另外一种可能是，直接create了一个文件出来，并且写进去这个文件~~
所以，如果是这样的情况，就很郁闷。
那么，在user对象中，如果非要放File文件类型格式，那么，就写到一个临时文件里吧。等用完之后删除。
如果该成byte[] 或者别的内容，如果你要用数据，其实会更加方便，不用开流从文件里面读取，而是直接从这个数组里面读就是了。
所以，建议把这个User里面的文件变成byte[] 。
一点浅见~~
另祝节日愉快~~
Ⅲ java 字节流，字符流，字符串之间怎样转换
这个问题要分2个部分
字节流和字符流之间的转换
字节流转换成字符流可以用InputSteamReader/OutputStreamWriter相互转换
2.怎么把字符串转为流.
下面的慧猜散程序可以理解把字符串line
转为流前氏输出到兆唯aaa.txt中去
FileOutputStream
fos
=
null;
fos
=
new
FileOutputStream("C:\\aaa.txt");
String
line="This
is
1
line";
fos.write(line.getBytes());
fos.close();
从你提的问题我感觉你对流的理解比较模糊,提的问题也模棱两可的,建议你系统的理解下IO的概念.
Ⅳ java的几种IO流读取文件方式
一、超类：
字节流： InputStream（读入流） OutputStream(写出流）
字符流： Reader（字符 读入流） Writer （字符写出流）
二、文件操作流
字节流： FileInputStream ，FileOutputStream
字符流： FileReader, FileWriter(用法与字节流基本相同，不写）
//1.指定要读 的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileInputStream fis =new FileInputStream(file);
//3.定义结束标志,可用字节数组读取
int i =0 ;
while((i = fis.read())!=-1){
//i 就是从文件中读取的字节，读完后返回-1
}
//4.关闭流
fis.close();
//5.处理异常
//1.指定要写到的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileOutputStream fos =new FileOutputStream(file);
//3.定义结束标志
fos.write(要写出的字节或者字节数组);
//4.刷新和关闭流
fos.flush();
fos.close();
//5.处理异常
三、缓冲流：
字节缓冲流： BufferedInputStream,BufferedOutputStream
字符缓冲流：BufferedReader ,BufferedWriter
缓冲流是对流的操作的功能的加强，提高了数据的读写效率。既然缓冲流是对流的功能和读写效率的加强和提高，所以在创建缓冲流的对象时应该要传入要加强的流对象。
//1.指定要读 的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileInputStream fis =new FileInputStream(file);
//3.创建缓冲流对象加强fis功能
BufferedInputStream bis =new BufferedInputStream(fis);
//4.定义结束标志,可用字节数组读取
int i =0 ;
while((i = bis.read())!=-1){
//i 就是从文件中读取的字节，读完后返回-1
}
//5.关闭流
bis.close();
//6.处理异常
//1.指定要写到的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileOutputStream fos =new FileOutputStream(file);
//3.创建缓冲流对象加强fos功能
BufferedOutputStream bos=new BufferedOutputStream(fos);
//4.向流中写入数据
bos.write(要写出的字节或者字节数组);
//5.刷新和关闭流
bos.flush();
bos.close();
//6.处理异常
四、对象流
ObjectInputStream ,ObjectOutputStream
不同于以上两种类型的流这里只能用字节对对象进行操作原因可以看上篇的编码表比照原理
ObjectOutputStream对象的序列化：
将java程序中的对象写到本地磁盘里用ObjectOutputStream
eg：将Person类的对象序列化到磁盘
创建Person类
注1：此类要实现Serializable接口，此接口为标志性接口
注2：此类要有无参的构造函数
注3：一旦序列化此类不能再修改
class Person implements Serializable{
public Person(){}
}
2.创建对象流对象
注：要增强功能可以将传入文件缓冲流
ObjectOutputStream oos =new ObjectOutputStream(
new FileOutputStream(new File("文件路径")));
3.写入对象 ，一般会将对象用集合存储起来然后直接将集合写入文件
List<Person> list =new ArrayList<>();
list.add(new Person());
...(可以添加多个）
oos.writeObject(list);
4.关闭流，处理异常
oos.flush();
oos.close();
五、转换流：
这类流是用于将字符转换为字节输入输出，用于操作字符文件，属于字符流的子类，所以后缀为reader，writer；前缀inputstream，outputstream；
注 ：要传入字节流作为参赛
InputStreamReader: 字符转换输出流
OutputStreamWriter：字符转换输入流
//1.获取键盘输入的字节流对象
inInputStream in =Stream.in;
/*2.用转换流将字节流对象转换为字符流对象，方便调用字符缓冲流的readeLine()方法*/
InputStreamReader isr =new InputStreamReader(in);
/*5.创建字符转换输出流对象osw，方便把输入的字符流转换为字节输出到本地文件。*/
OutputStreamWriter osw =new OutputStreamWriter(new
FileOutputStream(new File("文件名")));
/*3.现在isr是字符流，可以作为参数传入字符缓冲流中*/
BufferedReader br =new BufferedReader(isr);
/*4.可以调用字符缓冲流br的readLine()方法度一行输入文本*/
String line =null;
while((line =br.readLine()){
osw.write(line);//osw是字符流对象，可以直接操作字符串
}
注：InputStreamReader isr =new InputStreamReader(new "各种类型的字节输入流都行即是：后缀为InputStream就行");
OutputStreamWriter osw =new OutputStreamWriter(new
"后缀为OutputStream就行");
六、区别记忆
1.对象流是可以读写几乎所有类型的只要是对象就行，而字节字符流，只能读写单个字节字符或者字节字符数组，以上没有读写字节字符数组的；注意对象流只有字节流！
2.字符和字节循环读入的结束条件int i=0; (i =fis.read())!=-1
用字符数组复制文件(fr 读入流 ，fw写出流）,字节流也是相同的用法
int i = 0; char[] c = new char[1024];
while((i = fr.reade()) !=-1)）{
fw.write(c,0,i);
}
123456
3.对象流里面套缓冲流的情景：
new ObjectInputStream(new BufferedInputStream(new FileInputStream(new File(“文件路径”))));
4.记忆流及其功能的方法：
前缀表示功能，后缀表示流的类型；
比如说FileInputStream 前缀：File,表示操作的磁盘，后缀：intputstream,表示是字节输入流。
同理 FileReader：表示操作文件的字符流
ObjectInputStream ：操作对象的字节输入流
5.拓展：获取键盘输入的字符的缓冲流的写法：
new BufferedReader(new InputStreamReader(System.in)));
将字节以字符形式输出到控制台的字符缓冲流的写法：
new BufferedWriter（ new OutputStreamWriter（System.out))
Ⅳ java中字节流转成字符流再转为字节流保存成二进制文件会有什么后果。
1. InputStream 和OutputStream,两个是为字复节制流设计的,主要用来处理字节或二进制对象,
2. Reader和 Writer.两个是为字符流（一个字符占两个字节）设计的,主要用来处理字符或字符串.
字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点
所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列
1,字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串
Ⅵ 用java分别以字节流和文本流方式实现文件的读写操作（先向test1.txt文件中写“各位同学：
java创建TXT文件并进绝中肢行读、写、修改操作 import java.io.*;
/** *//**
*
* 功能描述：创建TXT文件并进行读、写、修改并世操作
*
* @author <a href="mailto:[email protected]">KenZhang</a>
* @version 1.0
* Creation date: 2007-12-18 - 下午06:48:45
*/
public class ReadWriteFile {
public static BufferedReader bufread;
//指定培或文件路径和名称
private static String path = "D:/suncity.txt";
private static File filename = new File(path);
private static String readStr ="";
/** *//**
* 创建文本文件.
* @throws IOException
*
*/
public static void creatTxtFile() throws IOException{
if (!filename.exists()) {
filename.createNewFile();
System.err.println(filename + "已创建！");
}
}
/** *//**
* 读取文本文件.
*
*/
public static String readTxtFile(){
String read;
FileReader fileread;
try {
fileread = new FileReader(filename);
bufread = new BufferedReader(fileread);
try {
while ((read = bufread.readLine()) != null) {
readStr = readStr + read+ "\r\n";
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("文件内容是:"+ "\r\n" + readStr);
return readStr;
}
/** *//**
* 写文件.
*
*/
public static void writeTxtFile(String newStr) throws IOException{
//先读取原有文件内容，然后进行写入操作
String filein = newStr + "\r\n" + readStr + "\r\n";
RandomAccessFile mm = null;
try {
mm = new RandomAccessFile(filename, "rw");
mm.writeBytes(filein);
} catch (IOException e1) {
// TODO 自动生成 catch 块
e1.printStackTrace();
} finally {
if (mm != null) {
try {
mm.close();
} catch (IOException e2) {
// TODO 自动生成 catch 块
e2.printStackTrace();
}
}
}
}
/** *//**
* 将文件中指定内容的第一行替换为其它内容.
*
* @param oldStr
* 查找内容
* @param replaceStr
* 替换内容
*/
public static void replaceTxtByStr(String oldStr,String replaceStr) {
String temp = "";
try {
File file = new File(path);
FileInputStream fis = new FileInputStream(file);
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
StringBuffer buf = new StringBuffer();
// 保存该行前面的内容
for (int j = 1; (temp = br.readLine()) != null
&& !temp.equals(oldStr); j++) {
buf = buf.append(temp);
buf = buf.append(System.getProperty("line.separator"));
}
// 将内容插入
buf = buf.append(replaceStr);
// 保存该行后面的内容
while ((temp = br.readLine()) != null) {
buf = buf.append(System.getProperty("line.separator"));
buf = buf.append(temp);
}
br.close();
FileOutputStream fos = new FileOutputStream(file);
PrintWriter pw = new PrintWriter(fos);
pw.write(buf.toString().toCharArray());
pw.flush();
pw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/** *//**
* main方法测试
* @param s
* @throws IOException
*/
public static void main(String[] s) throws IOException {
ReadWriteFile.creatTxtFile();
ReadWriteFile.readTxtFile();
ReadWriteFile.writeTxtFile("20080808:12:13");
// ReadWriteFile.replaceTxtByStr("ken", "zhang");
}
Ⅶ java分别以字节流和字符流的两种方式读取文件内容
importjava.io.BufferedReader;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.PrintWriter;
publicclassTest10{
/**
*复制当前的源程序到项目的根目录
*@throwsIOException
*/
publicstaticvoidmain(String[]args)throwsIOException{
/*
*1:读取原文件
*2：项目标文件中写
*3：使用缓冲流按行读写
*/
FileInputStreamfis=newFileInputStream("src"+File.separator+"day01"+File.separator+"Test1.java");
//转化为字符输出流
InputStreamReaderisr=newInputStreamReader(fis);
//按行为单位读取字符串
BufferedReaderbr=newBufferedReader(isr);
//
PrintWriterpw=newPrintWriter("Test1.java");
Stringline=null;
while((line=br.readLine())!=null){
pw.println(line);
}
pw.close();
br.close();
}
}
Ⅷ java 字符串流怎么转成文件
代码如下：
/**
* 将一个字符串转化为输入版流权
*/
public static InputStream getStringStream(String sInputString){
if (sInputString != null && !sInputString.trim().equals("")){
try{
ByteArrayInputStream tInputStringStream = new ByteArrayInputStream(sInputString.getBytes());
return tInputStringStream;
}catch (Exception ex){
ex.printStackTrace();
}
}
return null;
}
Ⅸ 关于java流的问题，字节流与字符流，为什么要用转换流，把字节转换成字符流，为什么不直接用字符流
你好，很高兴为你解答。
正如你所说Java IO分两种流 1）字节流 InputStream OutputStream ；2）字符流 Reader Writer 。
为什么需要用两种流，而且要转换，不直接用字符流。
简单说来，就是字符流不能处理所有的情况，字节流也不能处理所有的情况。所以需要两种转换。
先说一下二者的区别：
1）字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符卖肆数组或字符串，
2）而字节流处理单元为1个字节， 操作字节和字节数组。
字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串； 字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而友配镇字符流就可以。
所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多好粗国语言支持性比较好！
如果是 音频文件、图片、歌曲，就用字节流好点。
如果是关系到中文（文本）的，用字符流好点。
Ⅹ JAVA:已知获取文件的输出流ouputStream,怎么转换为文件
Filefile1=newFile("a.txt");
Filefile2=newFile("b.txt");
FileChannelaChannel=newFileInputStream(file1).getChannel();
FileChannelbChannel=newFileOutputStream(file2).getChannel();
for(longcount=aChannel.size();count>0;){
longtransferred=aChannel.transferTo(aChannel.position(),count,bChannel);
aChannel.position(aChannel.position()+transferred);
count-=transferred;
}通过NIO的方式将a文件拷贝到b文件，已知输出流，就把输出流转通channel，通过开启的channel通道来版相权互转换，冰阔落递一下。