write()方法每次只写8位，若是该字符串占用所有位则需要写四次，对每一节进行写入；00000000 00000000

                     00000000 00000000

file.exits() 文件是否存在

file.mkdir() 创建文件 一级 多级用mkdirs()

file.delete() 删除文件

RandomAccessFile java提供的对文件内容的访问，既可以读文件，也可以写文件。支持随机访问文件，可以访问文件的任意位置。  java文件模型   在硬盘上的文件时 byte byte byte存储的，是数据的集合 打开文件 两种模式：“rw”（读写），“r”（只读）  RandomAccessFile raf = new RandomAccessFile(File,"rw") 文件指针，打开文件时指针在开头 pointer = 0；  写方法： raf.write(int)--->只写一个字节（后8位），同时指针指向下一个位置，准备再次写入  读方法： int b = raf.read()--->读一个字节  文件读写完成以后一定要关闭 raf.close()

注意write方法每次只能写入一个字节： raf.write('A');//此时指针后移 System.out.println(raf.getFilePointer());此时输出为1 这时只写入了一个字节而不是完整的char，只是因为后八位刚好能够表示A raf.write('B'); 若要写入一个整数i则需要写四次 int i=0x7fffffff; raf.write(i>>>24);//高八位 raf.write(i>>>16); raf.write(i>>>8); raf.write(i);//写入最低的八位 System.out.println(raf.getFilePointer()); 此时打印输出6 可以直接写入一个int raf.writeInt(i); String s="中"; byte[] gbk=s.getBytes("gbk"); raf.write(gbk); System.out.println(raf.length(0); 此时打印输出12（中文占俩字节） 读文件，必须把指针移到头部 raf.seek(); //一次性读取： byte[] buf= new byte[(int)raf.length()]; raf.read(buf); System.out.println(Arrays.toString(buf)); 此时打印输出 [65,66,127,-1,-1,-1,127,-1,-1,-1,-42,-48] 开头的65,66是正确的AB，因为后八位已经能表示AB了 也可按字符串输出 String s1=new String(buf); System.out.println(s1,"gbk"); 打印输出AB????? 因为“中”的前后都有字节，只有定位到中的两个字节，才能读出他

file的length方法的作用：

 如果File表示一个具体文件，则length方法返回这个文件的字节大小； 如果File表示一个目录，则length方法的返回值不确定； 如果File表示的目录或文件不存在，则length方法的返回值为0L。 你要是想获取某个目录下的子文件，是不能用length方法的，要用listFiles方法，用法如下： File[] files = file.listFiles(); listFiles方法返回一个File数组，就是拿到的所有子文件（或目录）。

File的过滤，遍历等操作  列出指定目录下的（包括子目录）的所有文件 

 File file = new File();  exists() 方法用于判断文件或目录是否存在 

 isDirectory()方法判断File类的对象是否是目录  

throw new IllegalArgumentException();抛出异常

  String[] filenames = file.list()  //返回的是字符串数组，列出当前目录下的所有子目录和文件，不包含子目录下的内容

 //递归 for(String string : filenames){//将filenames数组中的值，循环赋值给string,直到filenames为空时，结束循环  System.out.println(string); } 

 //如果要遍历目录下的内容就需要构造成File对象做递归操作，File提供了直接返回File对象的API File[] files = file.listFiles(); //返回的是直接子目录（文件）的抽象  //递归，遍历出该目录下所有文件信息，包括子目录下的文件 for(File f :files){  if(f.isDirectory){   //递归遍历该目录下的子目录的信息   listDirectory(file);  }  else{  System.out.pritln(file);  } }

Java.IO.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();获取父级绝对路径。 10.file.getSize();获取文件大小。 11.file.getFormat();获取文件格式名。

public class FileOutDemo{
public static void main(String []args)throws IOException{
//如果该文件不存在，则直接创建，如果存在，删除后创建
FileOutputStream out=new FileOutputStream("demo/out.dat");
out.write('A');//写出‘A’的低八位
out.write("B");//写出了‘B’的低八位
int a=10;//write只能写八位，那么写一个int需要写4次，每次8位
out.write(a>>>24);
out.write(a>>>16);
out.write(a>>>8);
out.write(a);
byte[] gbk="中国".getBytes("gbk");
out.write(gbk);
out.close();
}}
IOUtil.java
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){
out.write(buf,0,b);
out,flush();//最好加上
}
in.close();
out.close();}

java文件读取

/**

* 列出指定目录下所有文件及其子文件

* 

*/

public static void listDirectoryTree(File file, int level) {

for(int i = 0; i <= level; i++) {

System.out.print("-");

}

System.out.println(file.getName());

if(file.isDirectory()) {

for (File f : file.listFiles()) {

listDirectoryTree(f, level+1);

}

}

}

public static void printHexByByteArray(String fileName)throws IOException{
FileInputStream in=new FileInputStream(fileName);
byte[] buf=new byte[20*1024];
/**从in中批量读取字节，放入到buf这个字节数组中，
从第0个位置开始放，最多放buf.length个
返回的是读到字节的个数
*/
/**int bytes=in.read(buf,o,buf.length);//一次性读完，说明字节数组足够大
int j=1;
for(int i=0;i<bytes;i++){
if(buf[i]<=0xf){
System.out.print("0");}
System.out.print(Integer.toHexString(buf[i])+" ");
if(j++%10==0){
System.out.println();*/
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)+" ");}}}}}

IO流（输入流，输出流）

字节流，字节流

1. 字节流

   1）InputStream，OutputStream

   InputStream抽象了应用程序读取数据的方式

        OutputStream抽象了应用程序写出数据的方式

        2）EOF=End 读到-1就读到结尾

        3）输入流基本方法

        int b=in.read();读取一个字节无符号填充到int低八位。-1是EOF

in.read(byte[] buf)读取数据填充到字节数组buf

in.read(byte[] buf),int start,int size)读取数据到字节数组buf，从buf的start位置开始存放到size长度的数据

4）输出流基本方法

out.write(int b)写出一个byte到流，b的低8位

out.write(byte[] buf)将buf字节数组都写如到流

out.write(byte[] buf,int start, int size)字节数组buf从start位置开始size长度的字节到流

import java.io.FileInputStream;
import java.io.IOException;
public class IOUtil{
/**读取指定文件内容，按照16进制输出控制台
并且没输出10个byte换行*/
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");}
System.out.print(Integer.toHexString(b)+" ");
if(i++%10==0){
System.out.println();}}
in.close();}}
public class IOUtilTest{
public static void main(String[] args){
try{
IOUtil.printHex("e:\\javaio\\FileUtils.java");
}catch(IOException e){
e.printStackTrace();}}}

InputStream抽象了应用程序读取数据的方式

OutputStream抽象了应用程序写出数据的方式

RandomAccessFile java提供的对文件内容的访问，既可以读文件，也可以写文件

RandomAccessFile支持随机访问文件，可以访问文件的任意位置

java文件模型

在硬盘上的文件是bytebytebyte存储的，是数据的集合

打开文件

有两种模式”rw“（读写） “r”（只读）

RandomAccessFile raf=new RandomAccessFile（file，“rw”）

文件指针，打开文件时指针在开头 pointer=0；

写方法

raf.write(int)---->只能写一个字节（后8位），同时指针指向下一个位置，准备再次写入

读方法

int b=raf.read()--->读一个字节

文件读写完成以后一定要关闭

import java.io.File;
import java.io.IOException;
public class RafDemo{
public static void main(String[]args)throws IOException{
File demo=new File("demo");
if(!demo.exists())
demo.mkdir();
File file=new File(demo,"raf.dat");
if(!file.exists())
file.createNewFile();
RandomAccessFile raf=new RadomAccessFile(file,"rw");
//指针的位置
System.out.println(raf.getFilePointer());
raf.write('A');//只写了一个字节
System.out.println(raf.getFilePointer());
raf.write('B');
int i=0x7ffffff;
//用write方法每次只能写一个字节，如果要把i写进去就得写4次
raf.write(i>>>24);//高8位
raf.write(i>>>16);
raf.write(i>>>8);
raf.write(i);
System.out.println)(raf.getFilePointer());
//可以直接写一个int
raf.writeInt(i);
String s="中";
byte[] gbk=s.getBytes("gbk");
raf.write(gbk);
System.out.println(raf.length());
//读文件，必须把指针移到头部
raf.seek(0);
//一次型读取，把文件中的内容都读到字节数组中
byte[] buf=new byte[(int)raf.length()];
raf.read(buf);
System.out.println(Arrays.toString(buf));
raf.close();
}}

import java.io.IOExpection;
import java.io.File;
//列出File的一些常用操作比如过滤，遍历等操作
public class FileUtiles{
/**列出指定目录下（包括其子目录）的所有文件
public static void listDirectory(File dir)throws IOException{
if(!dir.exists()){
throw new IllegalArgumentException("目录："+dir+"不存在。");
}
if(!dir.isDirectory()){
throw new IllegalArgumentException(dir+"不是目录");
}
/**String []filenames=dir.list();//返回的是字符串数组，返回直接子的名称，不包含子目录下的内容，list（）方法用于列出当前目录下的子目录和文件
for(String string:filenames){
System.out.println(dir+"\\"+string);}*/
File [] files=dir.listFiles();//返回的是直接子目录（文件）的抽象
if(files!=null&&files.length>0){
for(File file:files){
if(file.isDirectory()){
//递归
listDirectory(file);
}else{
System.out.println(file);}}}
}}
public class FileUtilTest1{
public static void main(Stirng []args) throws IOException {
FileUtils.listDirectory(new File("e:\example"));}}

java.io.File类用于表示文件（目录）

File类只用于表示文件（目录）得信息（名称，大小等），不能用于文件内容得访问

import java.ioFile
public class FileDemo{
public static void main(String[] args){
//了解构造函数得情况 查帮助
File file=new File("e:\\javaio");
//判断文件或目录是否存在
System.out.println(file.exists());
//.mkdir创建一级目录，.mkdirs创建多级目录，.isDirectory判断是否是一个目录（是目录返回true，如果不是目录or目录不存在返回false），.isFlie判断是否是一个文件
//.delete删除目录，.createNewFile()创建文件
//Flie.separator设置分隔符
File file2=new File("e:\\javaio","日记1.txt");
if(!file2.exists())
try{
file2.createNewFile();
}catch(IOException e){
e.printStackTrace();}
else file2.delete();
//常用File对象的API
System.out.println(file);//file.toString()的内容，打印路径
System.out.println(file.getAbsoltePath());//打印路径
System.out.println(file.getName());//打印文件的名字
System.out.println(file.getParent());//得到父目录的路径
}}

public class EncodeDemo{
publilc static void main(String []args)throws Exception{
String s="慕课网ABC";
byte[] bytes1=s.getBytes();//转化成字节序列用得是默认得编码gbk
for(byte b:bytes1){
//把字节（转化成了int）以16进制得方式显示
System.out..println(Integer.toHexString(b & 0xff)+" ");}
System.out.println();
byte[] bytes2=s.getBytes("gbk");
//gbk编码中文占用2个字节，英文占用1个字节
for(byte b:bytes2){
System.out.println(Integer.toHexString(b & 0xff)+" ");}
System.out.println();
byte []bytes3=s.getBytes("utf-8");
//utf-8编码中文占用3个字节，英文占用1个字节
for(byte b:bytes3){
System.out.println(Integer.toHexString(b & 0xff)+" ");}
//java是双字节编码utf-16be
byte[] bytes4=s.getBytes("utf-16be");
//utf-16be中文占用2个字节，英文占用2个字节
for(byte b:bytes4){
System.out.print(Integer.toHexString(b &0xff)+" ");}
/**当你得字节序列是某种编码时，这个时候想把字节序列变成
字符串，也需要用这种编码方式，否则会出现乱码*/
Stirng str1=new String(bytes4);//用项目默认得编码
System.out.println(str1);
String str2=new String(bytes4,"utf-16be");
System.out.println(str2);
/**文本文件 就是字节序列
可以是任意编码得字节序列
如果我们在中文机器是直接创建文本文件，那么该文本文件只认识ansi编码
*/
}}