大家好，今天给各位分享深入浅出Java文件传输：IO流技术详解的一些知识，其中也会对进行解释，文章篇幅可能偏长，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在就马上开始吧！
/**
* 由99479于2017年7月11日创建。
*/
公共类EncodeDemo01 {
公共静态无效主（字符串[] args）抛出UnsupportedEncodingException {
String s="普杰ABC";
byte[] bytes=s.getBytes("gbk");//转换为字节序列，使用项目的默认编码
对于（字节b:
字节）{
//以十六进制格式显示字节（转换为int）
System.out.print(Integer.toHexString(b0xff)+"");
}
System.out.println();
对于（字节b:
s.getBytes("utf-8")) {
System.out.print(Integer.toHexString(b0xff)+" ");
}
System.out.println();
/**
* 当你的字节序列是某种编码的时候，如果你想把字节序列变成字符串，也需要使用这种编码方式，否则会出现乱码。
*/
String s1=new String(bytes);//使用项目默认编码
System.out.println(s1); //输出乱码
String s2=new String(字节，"gbk");
System.out.println(s2);
/**
* 文本文件是字节序列
* 可以是任意编码的字节序列
* 如果我们直接在中文机器上创建一个文本文件，该文本文件只识别snsi编码。
*/
}
}输出c6 d1 bd dc 41 42 43
e8 92 b2 e6 9d b0 41 42 43
ABC
普杰ABC
File类的使用##
在Java中，File类用于表示文件或目录。在java.io.File包中。 File类仅用于表示文件（目录）信息（名称、大小等），不能用于访问文件内容。以下示例演示了File 类的基本操作。
范例1，常用API导入java.io.File；
导入java.io.IOException；
/**
* 由99479于2017年7月11日创建。
*/
公共类文件演示{
公共静态无效主（字符串[] args）{
//理解构造函数
文件file=new File("d:"+File.separator+"javaio");
//检查文件是否存在
System.out.println(file.getName()+"是否存在："+file.exists());
//如果不存在则创建文件夹，如果存在则删除文件
if(!file.exists()){
file.mkdir();//创建文件夹
//判断是否是目录
System.out.println(file.getName()+"是否为文件夹：" + file.isDirectory());
//判断是否是文件
System.out.println(file.getName()+"是否为文件：" + file.isFile());
}别的{
boolean isDelete=file.delete();
System.out.println(file.getName()+"是否删除成功："+isDelete);
}
//创建文件对象
文件file1=new File("d:"+File.separator+"diary.txt");
System.out.println(file1.getName() + "文件是否存在：" + file1.exists());
if (!file1.exists()){
尝试{
boolean isCreat=file1.createNewFile();
System.out.println(file1.getName()+"是否创建成功："+ isCreat);
System.out.println(file1.getName()+"是否为文件夹：" + file1.isDirectory());
System.out.println(file1.getName()+"是否为文件：" + file.isFile());
System.out.println(file1.getName()+"绝对路径：" + file1.getAbsolutePath());
System.out.println(file1.getName()+"的父路径：" + file1.getParent());
} catch (IOException e) {
e.printStackTrace();
}
}别的{
boolean isDelete=file1.delete();
System.out.println(file1.getName()+"是否删除成功："+ isDelete);
}
}
输出javaio 存在：true
javaio是否删除成功：true
Journal.txt文件是否存在： false
diary.txt 是否创建成功： true
diary.txt是否为文件夹： false
diary.txt 是一个文件吗： false
diary.txt的绝对路径：d:diary.txt
diary.txt父路径：d:范例2，遍历目录FileUtil.javaimport java.io.File;
导入java.io.IOException；
/**
* 由99479于2017年7月12日创建。
* 列出File的一些常用操作如过滤、遍历等。
*/
公共类FileUtils {
/**
* 列出目录中的所有文件或包含子目录中的所有文件和文件夹
* @参数目录
* @抛出IOException
*/
公共静态无效listDirectory（文件目录）抛出IOException{
if (!dir.exists()){
throw new IllegalArgumentException("目录："+dir+"不存在");
}
if (!dir.isDirectory()){
throw new IllegalArgumentException(dir+"不是目录");
}
String [] 文件名=dir.list();
File[] files=dir.listFiles();
对于（文件file:个文件）{
if (file.isFile()){
System.out.println("文件："+file.getAbsolutePath());
}否则if (file.isDirectory()){
System.out.println("文件夹："+file.getAbsolutePath());
//递归调用
列表目录（文件）；
}
}
}
}FileUtilTest01.java导入java.io.File;
导入java.io.IOException；
/**
* 由99479于2017年7月12日创建。
*/
公共类FileUtilsTest01 {
公共静态无效主（字符串[] args）{
尝试{
FileUtils.listDirectory(new File("D:"+File.separator+"迅雷下载"+File.separator+"杀不死"));
} catch (IOException e) {
e.printStackTrace();
}
}
}输出文件夹：D:Thunder DownloadUnkillabletest
文件：D:Thunder DownloadUnkillabletest .0.txt
文件夹：D:Thunder DownloadUnkillabletest新建文件夹
文件：D:Thunder DownloadUnkillabletest新文件夹tstsbg.txt
文件：D:Thunder DownloadKill Undead[Kill BS] Episode 01_bd.mp4
文件：D:Thunder DownloadKill Undead[Kill BS] Episode 02_bd.mp4
文件：D:Thunder DownloadKill Undead[Kill BS] Episode 03_bd.mp4
文件：D:Thunder DownloadKill Undead[Kill BS] Episode 04_bd.mp4
文件：D:Thunder DownloadKill Undead[Kill BS] Episode 05_bd.mp4
文件：D:Thunder DownloadKill Undead[Kill BS] Episode 06_bd.mp4
文件：D:Thunder DownloadKill Undead[Kill BS] Episode 07_bd.mp4
文件：D:Thunder DownloadKill Undead[Kill BS] Episode 08_bd.mp4
文件：D:Thunder DownloadKill Undead[Kill BS] Episode 09_bd.mp4
文件：D:Thunder DownloadKill Undead[Kill BS] Episode 10_bd.mp4
文件：D:Thunder DownloadKill Undead[Kill BS] Episode 11_bd.mp4
文件：D:Thunder DownloadKill Undead[Kill BS] Episode 12_bd.mp4
RandomAccessFile基本操作
RandomAccessFile 是Java 提供的用于文件内容的访问类。它既可以读取文件，也可以写入文件。 RandomAccessFile支持随机访问文件，可以访问文件中的任意位置
（1）Java的文件模型,
硬盘上的文件是以字节为单位存储的，是数据的集合。
（2）打开文件有两种模式1.“rw”读写。 2.“r”是只读的。
使用RandomAccessFile操作文件时，不仅要传入要操作的文件的路径，还要传入操作文件的方法，例如：RandomAccessFile raf=new RandomAccessFile("file","rw");
由于是随机访问文件，所以包含文件指针，文件打开时指针在开头pointer=0；
（3）、写方法raf.write(int) ---只写入一个字节（最后8位），指针指向下一个位置，准备再次写入。
（4）、读方法int b=raf.read() ---读取一个字节
（5）、文件读写完成后一定要关闭（Oracle官方说明），以防出现意想不到的错误。范例导入java.io.File;
导入java.io.FileNotFoundException;
导入java.io.IOException；
导入java.io.RandomAccessFile;
导入java.util.Arrays；
/**
* 由99479于2017年7月12日创建。
*/
公共类RafDemo {
公共静态无效主（字符串[] args）抛出IOException {
文件演示=new File("演示");
if (!demo.exists()){
演示.mkdir();
}
//以demo为父目录
文件file=new File(demo,"raf.dat");
if (!file.exists()){
尝试{
文件.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println(file.getAbsolutePath());
RandomAccessFile raf=new RandomAccessFile(file,"rw");
//指针的位置
System.out.println("指针位置"+raf.getFilePointer());
System.out.println("开始写入文件.");
raf.write("A");//只写入一个字节
System.out.println("指针位置"+raf.getFilePointer());
raf.write("B");
int i=0x7ffffffff；
//使用write方法一次只能写入一个字节。如果要写i，就得写4次。
raf.write(i24);//高八位
raf.write(i16);
raf.write(i8);
raf.write(i);
System.out.println("指针位置"+raf.getFilePointer());
//直接写int即可
raf.writeInt(i);
//写入一个汉字（先转换为字节）
字符串s="中";
byte[] gbk=s.getBytes("gbk");
raf.write(GBK);
System.out.println("文件长度为："+raf.length());
System.out.println("开始读取文件.");
//要读取文件，指针必须移动到头部
raf.seek(0);
//一口气读取，将文件所有内容读入字节数组
byte [] buf=new byte[(int)(raf.length())];
raf.read(buf);
System.out.println(Arrays.toString(buf));
//关闭文件操作流
raf.close();
}
}输出D:IdeaProjectsTestDemodemoraf.dat
指针位置0
开始写入文件.
指针位置1
指针位置6
文件长度： 12
开始读取文件.
[65, 66, 127, -1, -1, -1, 127, -1, -1, -1, -42, -48] 首先我们要了解流的概念。在Java中，IO流就是输入输出流。又分为字节流、字符流。
字节流##
(1)字节流分为InputStream和OutputStream。抽象类InputStream：抽象应用程序读取数据的方式。
OutputStream：如何抽象应用写出数据。
(2)读取返回值-1表示已读取到末尾。
(3)字节输入流的基本方法：
int b=in.read();读取一个无符号字节并将其填充到int的低八位中。读取以-1结束in.read(byte[] buf) 读取数据并将其填充到字节数组中in.read(byte[] buf, int start, int size) 读取数据并将其填充到字节数组buf 中，从buf 起始位置开始存储size长度的数据。 (4)字节输出流的基本方法：
out.write(int b) 向流中写入一个字节，b的低八位out.write(byte[] buf) 将所有buf字节数据写入流中out.write(byte[] buf, int start, int size) 字节数组buf 从起始位置开始写入size length 的字节流。
了解文件输入流字节流FileInputStream 文件输出流字节流FileOutputStream 数据输入输出流字节流字节缓冲流
字节流之文件输入流FileInputStream
FileInputStream 继承抽象类InputStream。专门实现读取文件上的数据。
范例IOUtil导入java.io.FileInputStream;
导入java.io.IOException；
/**
* 由99479于2017年7月13日创建。
*/
公共类IOUtil {
/**
* 读取指定文件的内容并以十六进制格式输出到控制台
* 并在输出中每10 个字节换行一次
* @param 文件名
*/
公共静态无效printHex(String fileName) 抛出IOException{
//以字节流的形式读取文件
FileInputStream in=new FileInputStream(文件名);
整数b；
整数i=1;
while((b=in.read()) !=-1){
System.out.print(Integer.toHexString(b)+" ");
如果（i++%10==0）{
System.out.println();
}
}
//关闭输入流
附寄（）;
}
公共静态无效printHexByByteArray（字符串文件名）抛出IOException{
FileInputStream in=new FileInputStream(文件名);
byte[] buf=新字节[20*1024];
//从in中批量读取字节放入字节数组buf中。
//从第0个位置开始，最多可以放置buf.length。
//返回读取的字节数
int bytes=in.read(buf,0,buf.length);//一次性读取完毕，说明字节数组足够大
整数j=1;
for (int i=0; i 字节； i++){
如果（buf[i]=0xf）{
System.out.print("0");
}
System.out.print(Integer.toHexString(buf[i])+" ");
如果（j++%10==0）{
System.out.println();
}
}
}
IOUtilTest01导入java.io.IOException;
/**
* 由99479于2017年7月13日创建。
*/
公共类IOUtilTest01 {
公共静态无效主（字符串[] args）{
尝试{
IOUtil.printHex("D:\IdeaProjects\TestDemo\demo\raf.dat");
} catch (IOException e) {
e.printStackTrac
e(); } } }IOUtilTest02import java.io.IOException; /** * Created by 99479 on 2017/7/13. */ public class IOUtilTest02 { public static void main(String[] args) { try { IOUtil.printHexByByteArray("D:\IdeaProjects\TestDemo\demo\raf.dat"); } catch (IOException e) { e.printStackTrace(); } } }字节流之文件输出流FileOutputStream
FileOutputStream实现了向文件中写出byte数据的方法，继承了OutputStream。范例import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException;
字节流之数据输入输出流DataOutputString/DataInputStream
这一组操作类是对“流”的扩展，可以更加方便的读取int，long/字符等类型数据。 DataOutputString中的方法举例：writeInt() 、 writeDouble() 、writeUTF()范例：DataOutputStreamimport java.io.DataOutputStream; import java.io.FileOutputStream; import java.io.IOException; /** * Created by 99479 on 2017/7/19. * 往一个文件里面写数字，或者写普通的数据类型 */ public class DosDemo { public static void main(String[] args) throws IOException{ String file = "demo/dos.dat"; DataOutputStream dos = new DataOutputStream(new FileOutputStream(file)); dos.writeInt(10); dos.writeInt(-10); dos.writeLong(10l); dos.writeDouble(10.5); //采用UTF-8编码写出 dos.writeUTF("中国"); //采用UTF-16BE编码写出 dos.writeChars("中国"); dos.close(); IOUtil.printHex(file); } }输出0 0 0 a ff ff ff f6 0 0 0 0 0 0 0 a 40 25 0 0 0 0 0 0 0 6 e4 b8 ad e5 9b bd 4e 2d 56 fd范例：DataInputStreamimport java.io.DataInputStream; import java.io.FileInputStream; import java.io.IOException; /** * Created by 99479 on 2017/7/19. */ public class DisDemo { public static void main(String[] args) throws IOException{ String file = "demo/dos.dat"; IOUtil.printHex(file); DataInputStream dis = new DataInputStream(new FileInputStream(file)); int i = dis.readInt(); System.out.println(i); i = dis.readInt(); System.out.println(i); long l = dis.readLong(); System.out.println(l); double d = dis.readDouble(); System.out.println(d); String s = dis.readUTF(); System.out.println(s); dis.close(); } }输出0 0 0 a ff ff ff f6 0 0 0 0 0 0 0 a 40 25 0 0 0 0 0 0 0 6 e4 b8 ad e5 9b bd 4e 2d 56 fd 10 -10 10 10.5 中国字节缓冲流
字节缓冲流主要学习了解BufferedInputStream和BuferedOutputStream 这两个流类为IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式主要提高了IO的输入输出性能。 从应用程序中把数据输入放入文件，相当于将一缸水倒入到另一个缸中，其中： FileOutputStream --->write()方法相当于一滴一滴地把水“转移”过去。 DataOutputStream --->writeXxx()方法会方便一些，相当于一瓢一瓢的把水“转移”过去。 BufferedOutputStream --->write()方法更方便，相当于一瓢一瓢先放入桶中，再从桶中倒入到另一个缸中，提高了性能。范例：修改IOUtil.java增加方法：copyFileByBuffer /** * 进行文件的拷贝，使用带缓冲的字节流 * @param srcFile * @param destFile * @throws IOException */ public static void copyFileByBuffer(File srcFile,File destFile)throws IOException{ if (!srcFile.exists()){ throw new IllegalArgumentException("文件不存在"); } if (!srcFile.isFile()){ throw new IllegalArgumentException(srcFile+"不是文件"); } BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile)); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile)); int c ; while((c = bis.read()) != -1){ bos.write(c); bos.flush();//刷新缓冲区 } bis.close(); bos.close(); }范例：IOUtilTest04import java.io.File; import java.io.IOException; /** * Created by 99479 on 2017/7/19. */ public class IOUtilTest04 { public static void main(String[] args) throws IOException { IOUtil.copyFileByBuffer(new File("D:\test.txt"),new File("D:\test\new_test.txt")); } }输出之前的： test.txt 之后的： new_test.txt字符流
字符流操作文本文件，如果是MP3，图片，视频之类的文件都采用字节流。 字符流的基本概念： 编码问题认识文本和文本文件：Java的文本（char）是16位无符号整数，是字符的unicode编码（双字节编码）。文件是byte byte byte...的序列，文本文件是文本（char）序列按照某种编码方案（utf-8、utf-16be、gbk）序列化为byte的存储结构。在Java里面的字符流也有读（Reader抽象类），写（Writer抽象类），字符的处理，一次处理一个字符，字符的底层仍然是基本的字节序列。Java中字符流的基本条件：InputStreamReader完成byte流解析为char流，按照编码解析。OutputStreamWriter提供char流到byte流，按照编码处理。范例：对一个文件进行简单的读操作import java.io.FileInputStream; import java.io.IOException; import java.io.InputStreamReader; /** * Created by 99479 on 2017/7/20. */ public class IsrAndAOswDemo { public static void main(String[] args) throws IOException{ FileInputStream in = new FileInputStream("D:\test.txt"); InputStreamReader isr = new InputStreamReader(in,"utf-8");//项目的默认编码 // int c ; // while((c = isr.read()) != -1){ // System.out.print((char)c); // } char [] buffer = new char[8*1024]; int c; //批量读取，放入buffer这个字符数组，从第0个位置开始方式，最多放buffrt.length个 //返回的是读到的个数 StringBuffer stringBuffer = new StringBuffer(); while ((c = isr.read(buffer,0,buffer.length)) != -1){ stringBuffer.append(buffer,0,buffer.length); } System.out.println(stringBuffer); isr.close();//一定要注意关闭，注意关闭，注意关闭 } }输出客家话和；oh；一； 可不行了就回北京了黑戈壁厉害个i好吧；；iuh ；和哦哦哦回家oh；和 字符流的基本概念： 1. 编码问题 - 认识文本和文本文字符流的另一组操作类： 写文件：FileWriter 写文件：FileReader 刚刚做的字符流的读写操作类（InputStreamReader、OutputStreamReader）使用时嵌套了一个类，如果使用FileWriter、FileReader就很方便了。范例：做读写操作import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; /** * Created by 99479 on 2017/7/20. */ public class FrAndFwDemo { public static void main(String[] args) throws IOException{ FileReader fr = new FileReader("D:\test.txt"); FileWriter fw = new FileWriter("D:\test\new_test.txt"); char [] buffer = new char[1024]; int c; while((c = fr.read(buffer,0,buffer.length)) != -1){ fw.write(buffer,0,buffer.length); fw.flush(); } //注意关闭，注意关闭，注意关闭 fr.close(); fw.close(); } }字符流的过滤器
我们可以对字符流加过滤器，让字符流有更多的功能，常用的有一组： BufferedReader，它最强大的功能有一个是 --->readLine 一次读一行。 BufferedWriter/PrintWriter： --->写一行。范例：import java.io.*; /** * Created by 99479 on 2017/7/20. */ public class BrAndBwOrPwDemo { public static void main(String[] args) throws IOException{ //对文件进行读写操作 BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("D:\test.txt"))); // BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\test\new_test.txt"))); PrintWriter pw = new PrintWriter("D:\test\new_test.txt"); String line; while((line = br.readLine()) != null){//读一行 System.out.println(line);//一次读一行，并不能识别换行 // bw.write(line); // bw.newLine();//换行操作 // bw.flush(); pw.println(line); pw.flush(); } br.close(); // bw.close(); pw.close();关于本次深入浅出Java文件传输：IO流技术详解和的问题分享到这里就结束了，如果解决了您的问题，我们非常高兴。
【深入浅出Java文件传输：IO流技术详解】相关文章：
用户评论
这篇文章终于讲到文件传输了！
有18位网友表示赞同！
Java里面操作文件的知识挺实用的, 马上学习看看这IO流。
有5位网友表示赞同！
想了解怎么利用 Java 来处理文件，这篇笔记就够了!
有7位网友表示赞同！
JAVA的IO流是个重要的知识点啊，需要好好掌握！
有20位网友表示赞同！
对于新手来说，这篇文章能帮助我更加清晰地理解文件传输。
有14位网友表示赞同！
学习完这篇文章，感觉可以自己实现一些文件的读写操作了。
有17位网友表示赞同！
Java的IO流讲解得非常详细，很好的入门指南！
有8位网友表示赞同！
我一直想了解如何使用Java进行文件传输，这篇正好适合我学习！
有16位网友表示赞同！
文件传输基础很重要，这篇文章涵盖的内容很全面。
有14位网友表示赞同！
JAVA IO流的应用非常广泛，需要多加练习。
有18位网友表示赞同！
文章内容清晰易懂，对提高 JAVA 的IO流操作能力很有帮助
有12位网友表示赞同！
终于找到一篇解释 Java IO流的好教程了！
有17位网友表示赞同！
学习Java的过程中遇到的很多文件处理问题，这篇文章能解决我!
有6位网友表示赞同！
对Java开发来说，了解IO流是必不可少的，建议大家好好学习！
有17位网友表示赞同！
这篇博客让我对 Java IO 流有了更深入的理解。
有7位网友表示赞同！
希望以后还有更多关于Java IO流的实践案例分享。
有14位网友表示赞同！
文件传输对于程序开发来说非常重要，这篇文章帮助我很清晰地了解了它的运作原理。
有16位网友表示赞同！