JAVA-IO输入输出流
目录
1.编码问题
2.File类的使用
3.RandomAccessFile的使用
4.字节流的使用
5.字符流的使用
1.编码问题
首先直接创建三个.txt文件夹，分别命名联通，联想，联，然后文件内容和文件名称对应，
创建好以后，点击进入查看内容，会看到除了联想以外，别的是乱码的，那么我们可以去查看一下他们的编码格式。
我们可以看到联想的那个文件编码是ANSI,另外的两个编码格式是UTF-8;这就是编码格式造成的。
在Java中举例
public class Demo2 {
public static void main(String[] args) throws Exception{
//.toHexString()此方法返回的字符串表示的无符号整数参数所表示的值以十六进制(基数为16)
String s = "测试ABC";
System.out.println("gbk编码格式");
byte[] bytes1 = s.getBytes("gbk");
for(byte b : bytes1){
//把字节(装换成了int)以16进制的方式显示，(& 0xff是去除前面的24个0，只留下后八位)
System.out.print(Integer.toHexString(b & 0xff)+" ");
/*
* b2 e2 ca d4 41 42 43 这是输出的值，
* 其中 b2 e2 => 测
* ca d4 => 试
* 41 => A , 42 => B ,43 => C
* 得出结论，gbk编码 汉字占两个字节，英文占一个字节
*/
}
System.out.println("\n"+"utf-8编码格式");
byte[] bytes2 = s.getBytes("utf-8");
for(byte b : bytes2){
//把字节(装换成了int)以16进制的方式显示，(& 0xff是去除前面的24个0，只留下后八位)
System.out.print(Integer.toHexString(b & 0xff)+" ");
/*
* e6 b5 8b e8 af 95 41 42 43 这是输出的值，
* 其中 e6 b5 8b => 测
* e8 af 95 => 试
* 41 => A , 42 => B ,43 => C
* 得出结论，utf-8编码 汉字占三个字节，英文占一个字节
*/
}
//Java是双字节编码，utf-16be
System.out.println("\n"+"utf-16be编码格式");
byte[] bytes3 = s.getBytes("utf-16be");
for(byte b : bytes3){
//把字节(装换成了int)以16进制的方式显示，(& 0xff是去除前面的24个0，只留下后八位)
System.out.print(Integer.toHexString(b & 0xff)+" ");
/*
* 6d 4b 8b d5 0 41 0 42 0 43 这是输出的值，
* 其中 6d 4b => 测
* 8b d5 => 试
* 0 41 => A , 0 42 => B , 0 43 => C
* 得出结论，utf-16be编码 汉字占两个字节，英文占两个字节
*/
}
System.out.println();
/*
* 我们在字节序列式某种编码时，这个时候想把字节序列变成字符串，
* 也需要用这种编码方式，否则会乱码
*/
String str1 = new String(bytes3);
System.out.println(str1);
//输出的东西乱码，mK��
str1 = new String(bytes3,"utf-16be");
System.out.println(str1);//正常显示
/*
* 文本文件，就是字节序列
* 文本文件可以存储任意编码的字节序列
* 如果我们在中文机器上面直接创建文本文件，那么文本文件只认识ansi编码
* 联通，联只是一种巧合，他们正好符合了utf-8的编码规则
*/
}
}
2.File类的使用
1）File类的基本方法
import java.io.File;
import java.io.IOException;
public class Demo3 {
public static void main(String[] args) {
/**
*java.io.File类用于表示文件 （目录）
*File类只用于表示文件（目录）的信息（名称，大小等），不能用于文件内容的访问
*/
File file = new File("d:\\demo");
// .exists() 方法 首先查询目录是不是存在
if(!file.exists()){
//file.mkdir是创建一级目录，file.mkdirs是创建多级目录
file.mkdir();//如果目录不存在我们就创建这个目录
}
// else{
// file.delete();//删除文件/文件夹
// }
//是否是一个目录
System.out.println("file是不是目录"+file.isDirectory());
//是否是一个文件 如果不存在或者不是文件返回false
System.out.println("file是不是文件"+file.isFile());
// File file2 = new File("d:\\demo\\test.txt");
File file2 = new File("d:\\demo","test.txt");
if(!file2.exists()){
//.createNewFile()创建文件
try {
file2.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
// else{
// //删除文件
// file2.delete();
// }
System.out.println(file);//file.toString()的内容
System.out.println("file路径:"+file.getAbsolutePath());
System.out.println("目录名称"+file.getName());
System.out.println("文件名称："+file2.getName());
System.out.println("file.getParent()："+file.getParent());//目录路径
System.out.println("file2.getParent()："+file2.getParent());//文件路径
}
}/**
* 列出File的一些常用操作，比如过滤，遍历操作
* @author Administrator
*
*/
public class FileUtil {
/**
* 列出指定目录下(包括其子目录)的所有文件
* @param dir
* @throws Exception
*/
public static void listDirectory(File dir)throws Exception{
//首先判断是否存在
if(!dir.exists()){
throw new IllegalArgumentException("目录："+dir+"不存在");
}
//是不是目录
if(!dir.isDirectory()){
throw new IllegalArgumentException(dir+"不是目录");
}
System.out.println("这是Stringp[] filenames读取dir.list()");
//返回的是字符串数组，list()方法用于列出当前目录下的子目录和文件,
//不包含子目录下的文件名称
String[] filenames = dir.list();
for(String str1:filenames){
System.out.println(dir+"\\"+str1);
}
System.out.println("File[] files = dir.listFile()读取");
//返回子目录文件的抽象
File[] files = dir.listFiles();
if(files!=null && files.length>0){
for(File file: files){
if(file.isDirectory()){
System.out.println(file);
}
}
}
}
public static void main(String[] args)throws Exception {
FileUtil.listDirectory(new File("D:\\yingxiong\\英雄联盟\\Air"));
}
}
3.RandomAccessFile的使用
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Arrays;
/**
* RandomAccessFile 是java提供的对文件内容的访问，既可以读文件，也可以写文件
* RandomAccessFile 支持随机访问文件，可以访问文件的任意位置
*
*(1)java文件模型
*在硬盘上的文件是byte byte byte 存储的，是数据的集合
*(2)打开文件只有两种模式 "rw"(读写) ， "r"(只读)
*RandomAccessFile raf = new RandomAccessFile(file,"rw");
*文件指针，打开文件时，指针在开头pointer=0;
*(3)写方法
*raf.write(int)---->只写一个字节(后8位),同时指针指向下一个位置，准备再次输入
*(4)读方法
*int b = raf.read()--->读一个字节
*(5)文件读写完后一定要关闭
*
*/
public class DemoRandomAccessFile {
public static void main(String[] args)throws IOException {
File demo = new File("demo");
if(!demo.exists()){
demo.mkdir(); //.mkdirs() 是连子目录都一次创建好
}
File file = new File(demo,"raf.dat");
if(!file.exists()){
file.createNewFile();
}
RandomAccessFile raf = new RandomAccessFile(file,"rw");
//指针的位置
System.out.println(raf.getFilePointer());
raf.write('A');//只写了一个字节
System.out.println(raf.getFilePointer());
raf.write('B');
System.out.println(raf.getFilePointer());
int i = 0x7fffffff;//最大整数
//用write每次只能写一个字节，如果要把i写完要写4次
raf.write(i>>>24);
raf.write(i>>>16);
raf.write(i>>>28);
raf.write(i);
System.out.println(raf.getFilePointer());
raf.writeInt(i);
System.out.println(raf.getFilePointer());
String s = "中";
byte[] utf = s.getBytes("utf-8");
raf.write(utf);//utf-8一个汉字三个字节
System.out.println(raf.getFilePointer());
//读文件，必须把指针移到头部
raf.seek(0);
//一次性读取,把文件的内容都读到字节数组中
byte[] buf = new byte[(int)raf.length()];
raf.read(buf);
System.out.println(Arrays.toString(buf));
//关闭
raf.close();
}
}4.字节流的使用
import java.io.FileInputStream;
import java.io.IOException;
import com.demo.test.IOUtil;
public class Fuxi_IOUtil {
/**
* 读取指定文件内容，按照16进制输出到控制台
* 并且按照10个byte换行
* @param fileName
* @throws IOException
*/
public static void prinHex(String fileName)throws IOException{
FileInputStream in = new FileInputStream(fileName);
int b ;
int i = 1;
while((b = in.read()) != -1){
if(b < 0xf){
//单位数前面补0
System.out.print("0");
}
System.out.print(Integer.toHexString(b)+" ");
if(i++ % 10 == 0){
System.out.println();
}
}
in.close();
}
/**
* 批量读取，对小文件而言效率高
* @param fileName
* @throws Exception
*/
public static void prineHexSmall(String fileName)throws IOException{
FileInputStream in = new FileInputStream(fileName);
byte[] buf = new byte[8*1024];
/*从in中批量读取字节，放入到buf这个字节数组中，
* 从第0个位置开始放，最多放buf.length个
* 返回的是读到的字节的个数
*/
int bytes = in.read(buf,0,buf.length);//一次性读完，说明字节数组足够大
int j = 1;
for(int i = 0; i < bytes;i++){
System.out.print(Integer.toHexString(buf[i] & 0xff)+" ");
if(j++%10==0){
System.out.println();
}
}
in.close();
}
/**
* 批量读取，对大文件而言效率高，也是我们最常用的读文件的方式
* @param fileName
* @throws IOException
*/
public static void prineHexBig(String fileName)throws IOException{
FileInputStream in = new FileInputStream(fileName);
byte[] buf = new byte[8*1024];
int bytes = 0;
int j = 1;
while((bytes = in.read(buf, 0, buf.length)) != -1){
for(int i = 0 ; i < bytes ;i++){
System.out.print(Integer.toHexString(buf[i] & 0xff)+" ");
if(j++%10==0){
System.out.println();
}
}
}
}
public static void main(String[] args) throws IOException {
String fileName="d:\\demo\\text1.txt";
// Fuxi_IOUtil.prinHex(fileName);
// Fuxi_IOUtil.prineHexSmall(fileName);
Fuxi_IOUtil.prineHexBig(fileName);
}
}
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class Fuxi_copyfile {
/**
* 复制文件，字节批量读取
* @param srcFile
* @param destFile
* @throws Exception
*/
public static void copyFile(File srcFile,File destFile)throws Exception{
if(!srcFile.exists()){
throw new IllegalArgumentException("文件:"+srcFile+"不存在");
}
if(!srcFile.isFile()){
throw new IllegalArgumentException(srcFile+"不是文件");
}
FileInputStream in = new FileInputStream(srcFile);
FileOutputStream out = new FileOutputStream(destFile);
byte[] buf = new byte[8*1024];
int b ;
while((b=in.read(buf, 0, buf.length)) != -1){
out.write(buf, 0, b);
out.flush();//最好加上
}
in.close();
out.close();
}
/**
* 进行文件的拷贝，用带缓冲的字节流
* @param args
* @throws Exception
*/
public static void copyFileByBuffer(File srcFile ,File destFile)throws Exception{
if(!srcFile.exists()){
throw new IllegalArgumentException("文件:"+srcFile+"不存在");
}
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();
}
/**
* 单字节，不带缓冲进行文件拷贝
* @param srcFile
* @param destFile
* @throws Exception
*/
public static void copyFileByByte(File srcFile,File destFile)throws Exception{
if(!srcFile.exists()){
throw new IllegalArgumentException("文件:"+srcFile+"不存在");
}
if(!srcFile.isFile()){
throw new IllegalArgumentException(srcFile+"不是文件");
}
FileInputStream in = new FileInputStream(srcFile);
FileOutputStream out = new FileOutputStream(destFile);
int c ;
while((c= in.read()) != -1){
out.write(c);
out.flush();
}
in.close();
out.close();
}
public static void main(String[] args) throws Exception {
// Fuxi_copyfile.copyFile(new File("d:\\demo\\text1.txt"), new File("d:\\demo\\text2.txt"));
// Fuxi_copyfile.copyFileByBuffer(new File("d:\\demo\\text1.txt"), new File("d:\\demo\\text3.txt"));
Fuxi_copyfile.copyFileByByte(new File("d:\\demo\\text1.txt"), new File("d:\\demo\\text4.txt"));
}
}5.字符流的使用
InputStreamReader 完成byte流解析为char流，按照编码解析OutputStreamReader 提供char流到byte流，按照编码出来
public static void main(String[] args)throws Exception{
FileInputStream in = new FileInputStream("D:\\demo\\text1.txt");
InputStreamReader isr = new InputStreamReader(in,"utf-8");
FileOutputStream out = new FileOutputStream("D:\\demo\\text11.txt");
OutputStreamWriter osw = new OutputStreamWriter(out,"utf-8");
//第一种方式
/*int a ;
while((a = isr.read())!=-1){
System.out.print((char)a);
}*/
char[] buffer = new char[8*1024];
int a;
/*批量读取，放入buffer这个字符数组，从第0个位置开始放置，最多放buffer.length个
返回的是读到的字符的个数
*/
while(( a = isr.read(buffer,0,buffer.length))!=-1){
String s = new String(buffer,0,a);
System.out.print(s);
osw.write(buffer,0,a);
osw.flush();
}
isr.close();
osw.close();
}</span>FileReader/FileWriter
public static void main(String[] args)throws Exception {
FileReader fr = new FileReader("d:\\demo\\text1.txt");
FileWriter fw = new FileWriter("d:\\demo\\text12.txt");
//如果参数为true那么重复执行代码的时候，会在我们的文件中重复的写入内容
// FileWriter fw = new FileWriter("d:\\demo\\text12.txt",true);
char[] buffer = new char[1024];
int a ;
while((a = fr.read(buffer, 0, buffer.length)) != -1){
//写
fw.write(buffer,0,a);
fw.flush();
}
fr.close();
fw.close();
}</span>
4060
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
