一、文件的编码
package com.study.io;
public class EncodeDemo {
public static void main(String[] args) throws Exception {
String s="好好学习ABC";
byte[] bytes1=s.getBytes();//这是把字符串转换成字符数组，转换成的字节序列用的是项目默认的编码（这里为UTF-8）
for (byte b : bytes1) {
//把字节（转换成了int）以16进制的方式显示
System.out.print(Integer.toHexString(b & 0xff)+" ");//& 0xff是为了把前面的24个0去掉只留下后八位
}
System.out.println();
byte[] bytes2 = s.getBytes("utf-8");//这里会有异常展示，我们就throw这个异常
for (byte b : bytes2) {
System.out.print(Integer.toHexString(b & 0xff)+" ");
}
System.out.println();
byte[] bytes3 = s.getBytes("gbk");//这里会有异常展示，我们就throw这个异常
for (byte b : bytes3) {
System.out.print(Integer.toHexString(b & 0xff)+" ");
}
System.out.println();
byte[] bytes4 = s.getBytes("utf-16be");//这里会有异常展示，我们就throw这个异常
for (byte b : bytes4) {
System.out.print(Integer.toHexString(b & 0xff)+" ");
}
System.out.println();
String str1=new String(bytes4);//这时会使用项目默认的编码来转换，可能出现乱码
System.out.println(str1);
//要使用字节序列的编码来进行转换
String str2=new String(bytes4,"utf-16be");
System.out.println(str2);
}
}
分析：
* 1. “& 0xff”的解释：
* 0xFF表示的是16进制（十进制是255），表示为二进制就是“11111111”。
* 那么&符表示的是按位数进行与（同为1的时候返回1，否则返回0）
* 2.字节byte与int类型转换：
* Integer.toHexString(b & 0xff)这里先把byte类型的b和0xff进行了运算，然后Integer.toHexString取得了十六进制字符串
* 可以看出b & 0xFF运算后得出的仍然是个int,那么为何要和 0xFF进行与运算呢?直接 Integer.toHexString(b);,将byte强转为int不行吗?答案是不行的.
* 其原因在于:1.byte的大小为8bits而int的大小为32bits；2.java的二进制采用的是补码形式
* Integer.toHexString的参数是int，如果不进行&0xff，那么当一个byte会转换成int时，由于int是32位，而byte只有8位这时会进行补位。。。。。。
* 所以，一个byte跟0xff相与会先将那个byte转化成整形运算，这样，结果中的高的24个比特就总会被清0，于是结果总是我们想要的。
* 3.utf-8编码:中文占用3个字节，英文占用1个字节
* gbk编码:中文占用2个字节，英文占用1个字节
* Java采用双字节编码（就是Java中的一个字符占两个字节）是utf-16be编码。中文占用2个字节，英文占用2个字节
*
* 4.当你的字节序列是某种编码时，这个时候想把字节序列变成字符串，也需要用这种编码方式，否则会出现乱码
* 5.文本文件 就是字节序列。可以是任意编码的字节序列。
* 如果我们在中文机器上直接创建文本文件，那么该文件只认识ANSI编码（例如直接在电脑中创建文本文件）
二、File类的使用
package com.study.io;
import java.io.File;
public class FileDemo {
public static void main(String[] args) {
File file=new File("D:\111");//创建文件对象时指定目录需要用双斜杠，因为“”是转义字符
// File file1=new File("d:"+File.separator);
// System.out.println(file.exists());//exists()判断文件或文件夹是否存在
if(!file.exists()){//如果文件不存在
file.mkdir();//创建文件夹mkdir()，还有mkdirs()创建多级目录
}else{
file.delete();//删除文件或文件夹
}
//判断是否是一个目录isDirectory,如果是目录返回true，如果不是目录或者目录不存在返回false
System.out.println(file.isDirectory());
//判断是否是一个文件isFile
System.out.println(file.isFile());
File file2=new File("D:\222","123.txt");
//常用API：
System.out.println(file);//打印的是file.toString()的内容
System.out.println(file.getAbsolutePath());//获取绝对路径
System.out.println(file.getName());//获取文件名称
System.out.println(file2.getName());
System.out.println(file.getParent());//获取父级绝对路径
System.out.println(file2.getParentFile().getAbsolutePath());
}
}
运行结果：
说明：
java.iO.File类表示文件或目录
File类只用于表示文件或目录的信息（名称，大小等），不能用于文件内容的访问。
常用的API：
1.创建File对象：File file=new File(String path);注意：File.seperater();获取系统分隔符，如：“”.
2.boolean file.exists();是否存在.
3.file.mkdir();或者file.mkdirs();创建目录或多级目录。
4.file.isDirectory()判断是否是目录
file.isFile()判断是否是文件。
5.file.delete();删除文件或目录。
6.file.createNewFile();创建新文件。
7.file.getName()获取文件名称或目录绝对路径。
8.file.getAbsolutePath()获取绝对路径。
9.file.getParent();获取父级绝对路径。
1、遍历目录
package com.study.io;
import java.io.File;
import java.io.IOException;
public class FileUtils {
public static void listDirectory(File dir) throws IOException{
if(!dir.exists()){//exists()方法用于判断文件或目录是否存在
throw new IllegalArgumentException("目录："+dir+"不存在");
}
if(!dir.isDirectory()){//isDirectory()方法用于判断File类的对象是否是目录
throw new IllegalArgumentException(dir+"不是目录");
}
//如果要遍历子目录下的内容就需要构造成File对象做递归操作，File提供了直接返回File对象的API
File[] listFiles = dir.listFiles();//返回的是直接子目录（文件）的抽象
if(listFiles !=null && listFiles.length >0){
for (File file : listFiles) {
if(file.isDirectory()){
//递归
listDirectory(file);
}else{
System.out.println(file);
}
}
}
}
}
测试类：
public class FileUtilsTest {
public static void main(String[] args) throws IOException {
FileUtils.listDirectory(new File("D:\ioStudy"));
}
}
运行结果：
三、RandomAccessFile类的使用
RandomAccessFile：java提供的对文件内容的访问，既可以读文件，也可以写文件。
RandomAccessFile支持随机访问文件，可以访问文件的任意位置。
注意 Java文件的模型：
运行结果：
1
12
[65, 66, 127, -1, -1, -1, 127, -1, -1, -1, -42, -48]
7f
ff
ff
ff
7f
ff
ff
ff
d6
d0
四、字节流（FileInputStream、FileOutputStream）
IO流可分为输入流和输出流。
这里又可分为字节流和字符流。
代码示例：
package com.study.io;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class IOUtil {
public static void printHex(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");
}
//Integer.toHexString(b)将整型b转换为16进制表示的字符串
System.out.print(Integer.toHexString(b)+" ");
if(i++%10==0){
System.out.println();
}
}
in.close();//文件读写完成以后一定要关闭
}
public static void printHexByByteArray(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();
}
}
}
in.close();
}
public static void copyFile(File srcFile, File destFile) throws IOException {
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) {//read(buf,0,buf.length)带参数的read返回的是字节的总长度；当全部读完后返回的是-1；
out.write(buf, 0, b);
out.flush();// 最好加上
}
in.close();
out.close();
}
public static void copyFileByBuffer(File srcFile,File destFile)throws IOException{
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();
}
public static void copyFileByByte(File srcFile,File destFile)throws IOException{
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){//read()不带参数的read返回的是读到的字节内容；当全部读完后返回的都是是-1；
out.write(c);
out.flush();
}
in.close();
out.close();
}
}
测试类：
package com.study.io;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class IOUtilTest {
@Test
public void testPrintHex() {
try {
IOUtil.printHex("D:\Javaio\FileUtils.java");
} catch (IOException e) {
e.printStackTrace();
}
}
@Test
public void testPrintHexByByteArray() {
try {
long start = System.currentTimeMillis();//当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）
//IOUtil.printHexByByteArray("e:\javaio\FileUtils.java");
//IOUtil.printHex("e:\javaio\1.mp3");
IOUtil.printHexByByteArray("e:\javaio\1.mp3");
System.out.println();
long end = System.currentTimeMillis();
System.out.println(end - start);
} catch (IOException e) {
e.printStackTrace();
}
}
@Test
public void testCopyFile(){
try {
IOUtil.copyFile(new File("d:\javaio\1.txt"), new File("d:\javaio\1copy.txt"));
} catch (IOException e) {
e.printStackTrace();
}
}
@Test
public void testCopyFileByBuffer(){
try {
long start = System.currentTimeMillis();
//两万多毫秒
IOUtil.copyFile(new File("e:\javaio\1.mp3"), new File(
"e:\javaio\4.mp3"));//7毫秒
long end = System.currentTimeMillis();
System.out.println(end - start );
} catch (IOException e) {
e.printStackTrace();
}
}
}
五、字符流
package com.study.io;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class IsrAndOswDemo {
public static void main(String[] args)throws IOException {
FileInputStream in = new FileInputStream("e:\javaio\utf8.txt");
InputStreamReader isr = new InputStreamReader(in,"utf-8");//默认项目的编码,操作的时候，要写文件本身的编码格式
FileOutputStream out = new FileOutputStream("e:\javaio\utf81.txt");
OutputStreamWriter osw = new OutputStreamWriter(out,"utf-8");
char[] buffer = new char[8*1024];
int c;
while(( c = isr.read(buffer,0,buffer.length))!=-1){
String s = new String(buffer,0,c);
System.out.print(s);
osw.write(buffer,0,c);
osw.flush();
}
isr.close();
osw.close();
}
}
字符流之文件读写流（FileReader/FileWriter）
字符流的过滤器
六、对象的序列化和反序列化
示例：
注意：
