java复习总结5

java编码
  当你的字节序列是某种编码时，这个时候想把字节序列变成
  字符串，也需要用这种编码方式，否则会出现乱码
  文本文件就是字节序列
  可以是任意编码的序列，如果在中文机器上直接创建文本文件，那么该文本文件
  只认识ANSI编码

  案例：

  public class Bianma {
        public static void main(String[] args) throws Exception {
			String s = "你好世界！";
			byte[] bytes1 = s.getBytes();
			for (byte b : bytes1) {
				System.out.println(Integer.toHexString(b & 0xff) + " ");
			}
			System.out.println();
			byte[] bytes2 = s.getBytes("utf-8");
			for (byte b : bytes2) {
				System.out.println(Integer.toHexString(b & 0xff) + " ");
			}
			System.out.println();
			byte[] bytes3 = s.getBytes("gbk");
			for (byte b : bytes3) {
				System.out.println(Integer.toHexString(b & 0xff) + " ");
			}
		}
}

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

public class FileName {
      public static void main(String[] args) {
		File file = new File("E:\\javaio");
//		System.out.println(file.exists());
		if(!file.exists()){
			file.mkdir();
		}else{
			file.delete();
		}
		//是否是一个目录
		System.out.println(file.isDirectory());
        //是否是一个文件
		System.out.println(file.isFile());
		
		File file2 = new File("E:\\javaio\\riji.txt");
		if(!file2.exists()){
			try {
				file2.createNewFile();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}else{
			file.delete();
		}
		System.out.println(file);
		System.out.println(file.getAbsolutePath());
        System.out.println(file.getName());
        System.out.println(file2.getName());
        System.out.println(file.getParent());
        System.out.println();
      }
}

File的一些常用操作

 public class FileUtils {
       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();
    	   for (String string : filenames) {
			System.out.println(dir + "\\:" + string);
		}
       }
}

public class FileUtilsTest1 {
     public static void main(String[] args) throws IOException {
		FileUtils.listDirectory(new File("E:\\HN"));
	}
}

RandomAccessFile java提供的对文件内容的访问，即可以读文件，也可以写文件。
RandomAccessFile支持随机访问的文件，可以访问文件的任意位置


1)java文件模型
     在硬盘上的文件是byte byte byte存储的，是数据的集合
2)打开文件
           有两种模式"rw"(读写) "r"(只读)
RandomAccessFile raf = new RandomeAccessFile(file,"rw")
文件指针，打开文件时指针在开头pointer = 0;
3)写方法
  raf.write(int)--->只写一个字节（后八位），同时指针指向下一个位置，准备再次写入
4）读方法
int b = raf.read()--->读一个字节
5）文件读写完成后一定要关闭
案例：

public class RafDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws IOException{
        File demo = new File("E:\\demo");
        if(!demo.exists())
        	demo.mkdir();
       File file = new File(demo,"raf.dat");
       if(!file.exists())
    	   file.createNewFile();
       
       RandomAccessFile raf = new RandomAccessFile(file, "rw");
       raf.write('A');
       raf.write('A');
       System.out.println(raf.getFilePointer());//指针的位置
       
       int i = 0x7fffffff;
       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));
      
//      String s1 = new String(buf);
//      System.out.println(s1);
      for (byte b : buf) {
		System.out.println(Integer.toHexString(b & 0xff) + " ");
	}
      raf.close();
	}

}

IO流（输入流、输出流）
字节流、字符流
1 字节流
1）InputStream,OutputStream
InputStream抽象了应用程序读取数据的方式
OutputStream抽象了应用程序写出数据的方式
2）EOF = End 读到-1就读到结尾
3）输入流基本方法
int b = in.read();读取一个字节无符号填充到int低八位，-1是EOF
in.read(byte[] buf)
in.read(byte[] buf,int start,int size)
4）输出流基本方法
out.write(int b)写出一个byte到流，b的低八位
out.write(byte[] buf)将buf字节数组都写入到流
out.write(byte[] buf,int start,int size)
5)FileInputStream(在文件上读取数据)
单字节读取不适合大文件
批量读取，对大文件而言效率高，也是我们最常用读文件的方式
案例：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;


public class IO {
    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){
    			System.out.print("0");
    		}
    		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[20 * 1024];
//    	int bytes = in.read(buf,0,buf.length);
//    	int j = 0;
//    	for(int i = 0;i < bytes; i++){
//    		if(buf[i] <= 0xf){
//    			System.out.print("0");
//    		}
//    			System.out.print(Integer.toHexString(buf[i]) + " ");
//    	    j++;
//    		if(j == 10){
//    		 j=0;	
//    		 System.out.println();
//    		}
//    	}
    int bytes = 0;
    int j =0;
    while((bytes = in.read(buf,0,buf.length)) != -1){
    	for(int i = 0;i < bytes; i++){
    		System.out.print(Integer.toHexString(buf[i] & 0xff) + " ");
            j++;
    		if(j == 10){
    			j=0;
    			System.out.println();
    		}
    	}
    }
    in.close();
    }
}

测试

public class IOTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
//		try {
//			IO.printHex("E:\\javaio\\123.txt");
//		} catch (IOException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//
//	}
		try {
			IO.printHexByByteArray("E:\\javaio\\123.txt");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

6）FileOutputStream 实现了向文件中写出byte数据的方法


方法：

    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();
    }
   测试：
     try {
			IO.copyFile(new File("E:\\javaio\\123.txt"), new File("E:\\javaio\\234.txt"));
			System.out.println("success");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

7）DataOutputStream/DataInputStream
     对“流”功能的扩展，可以更加方便的读取int,long,字符等类型数据
   DataOutputStream
         writeInt()/writeDouble()/writeUTF()
案例

import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class DosDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	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);
        dos.writeUTF("中国");
        dos.writeChars("中国");
        dos.close();
        IO.printHex(file);
	}

}

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class DisDemo {

	/**
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {
		String file = "demo/dos.dat";
		IO.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();
	}

}

8）BufferedInputStream & BufferedOutputStream
这两个流类位于IO提供了带缓冲区的操作一般打开文件进行写入
或读取操作时，都会加上缓冲，这种流模式提高了IO的性能
   案例：

	public static void copyFileByBuffer(File srcFile, File desFile)
			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(desFile));
       int c;
       while((c = bis.read()) != -1){
    	   bos.write(c);
    	   bos.flush();//刷新缓冲区
    	   
       }
       bis.close();
       bos.close();
	}
	public static void copyFileByByte(File srcFile,File desFile)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(desFile);
		int c;
		while((c = in.read()) != -1){
			out.write(c);
			out.flush();
		}
		in.close();
		out.close();
	}
}

字符流
    1）编码
    2）文本和文本文件
    java的文本（char）是16位无符号整数，是字符的unicode编码（双字节编码）
    文件是byte byte byte ...的数据序列
    文本文件是文本（char）序列按照某种编码方案(utf-8,utf-16be,gbk)序列化为
    byte的存储结构
    3）字符流
    字符的处理，一次处理一个字符
    字符的底层仍然是基本的字节序列
    字符流的基本实现
         InputStreamReader 完成byte流解析为char流，按照编码解析
OutputStreamWriter提供char流到byte流，按照编码处理
案例：

 import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;


public class IsOsDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
      FileInputStream in = new FileInputStream("E:\\javaio\\abc.txt");
      InputStreamReader isr = new InputStreamReader(in);//默认项目的编码
      
      FileOutputStream out = new FileOutputStream("E:\\javaio\\34.jpg");
      OutputStreamWriter osw = new OutputStreamWriter(out,"utf-8");
      
//      int c;
//      while((c = isr.read()) != -1){
//    	  System.out.print((char)c);
//      }
      /*方法二：
       * 
       * */
      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();
	}

}