java io流编程

一、java.io.File
1、绝对路径和相对路径
   File类：用来构造文件或文件夹的类,在其构造函数中要求传入一个String类型的参数,用于指示文件所在的路径.这里可以使用绝对路径作为参数,也可以使用相对路径. 使用绝对路径指明了文件的具体路径(如：E:\images\login.gif),java虚拟机（JVM）很容易就能定位到该文件,那么使用的是相对路径jvm又是如何定位文件的呢?
  绝对路径名是完整的路径名，不需要任何其他信息就可以定位自身表示的文件。相反，相对路径名必须使用来自其他路径名的信息进行解释。默认情况下，java.io 包中的类总是根据当前用户目录来分析相对路径名。此目录由系统属性 user.dir 指定，通常是 Java 虚拟机的调用目录。System.getProperty("user.dir")
2、创建文件对象
   创建File对象时必须给出文件或文件夹名（可以是相对路径也可以是绝对路径）：
File file1 = new File("C:\\java\\aaa.bmp");
File file2 = new File("C:\\Temp");
File file3 = new File("./data.txt");//相对路径："./"当前目录，
3、检查文件对象是否存在
boolean exists();                               
4、检查是否为文件
boolean isFile();如果File对象所指的是一个文件，则返回true      
5、 操作文件中的相关方法：
  5.1、查询文件长度
      long length();返回文件长度，文件夹的长度为0
  5.2、查询文件修改日期
      long lastModified();返回文件上次修改的日期时间，返回的是从1970年午夜至今文件最后修改时刻的毫秒数，但可以通过Calendar类表示成相对时间。
  5.3、获得文件名和相对路径的函数：
      String getName();   // getName函数获得文件名，不包含路径
      String getPath();    // getPath函数获得文件所在路径和文件名称
      String getAbsolutePath();   //获得文件的绝对路径
   5.4、重命名/移动文件(本地文件的移动，如果是网络上那么还得通过流的读写)
     boolean renameTo(File dest);
      作用：给文件或文件夹改名，如果dest所指的路径与文件原来的路径不同的话，就会将文件或文件夹移动到目标位置。
   5.5、删除文件/目录
      boolean delete();删除File对象所指向的文件或文件夹。如果是文件夹：文件夹必须是空的，否则无法删除
   5.6、创建文件
      file1.createNewFile();如果文件不存在，则创建一个新文件；如果文件存在， 则不进行任何操作，返回false。
   5.7、同样：检查是否是（文件夹）目录、操作目录相关方法、创建目录、删除目录
      boolean mkdir();创建一个子目录//保证要创建的子目录上级目录已经存在
      boolean mkdirs();创建多个（多层）子目录//如果要创建的子目录的上级目录不存在,则先创建上级目录,再创建子目录  

      列举出文件夹下的所有文件
      file.list();// 当前文件夹下：文件名和文件夹名称
      file.listFiles();// 当前文件夹下文件对象
二、文件过滤器
1、FileFilter：
File[] files = file.listFiles(new FileFilter() {
  @Override
     public boolean accept(File pathname) {
if (pathname.getName().endsWith("jpg")) {// 区分大小写，如何不区分？ FileNameExtensionFilter 文件扩展名过滤器（文件扩展名的比较不区分大小写）
return true;
}
return false;
}
});
2、FilenameFilter
    FilenameFilter filenameFilter = new FilenameFilter() {
      public boolean accept(File dir, String name) {
if (name.endsWith("JPG")) { return true;
}
return false;
}
};
   //文件名过滤和文件对象过滤
String[] filenames = file.list(filenameFilter);
File[] files=file.listFiles(filenameFilter);

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;

public class TestFileFilter {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		File file = new File(
				"E:\\软件");
		File[] files = file.listFiles();
		for (int i = 0; i < files.length; i++) {
			System.out.println("筛选前：" + files[i].getName());
		}
		fileFilter(file);
		filenameFilter(file);
	}

	private static void fileFilter(File file) {
		File[] files = file.listFiles(new FileFilter() {

			@Override
			public boolean accept(File pathname) {

				if (pathname.getName().toLowerCase().endsWith(".txt")) {
					return true;
				} else {
					return false;
				}
			}
		});
		for (int i = 0; i < files.length; i++) {
			System.out.println("fileFilter：" + files[i].getName());
		}
	}

	private static void filenameFilter(File file) {
		File[] files = file.listFiles(new FilenameFilter() {

			@Override
			public boolean accept(File dir, String name) {
				if (name.toLowerCase().endsWith(".ppt")) {
					return true;
				} else {

					return false;
				}
			}
		});
		for (int i = 0; i < files.length; i++) {
			System.out.println("filenameFilter：" + files[i].getName());
		}
	}
}

三、字节流                  
   字节流只能读取字节数据。
   字节流读取中文时，会出乱码。因为一个中文字符占两个字节。
   字节流：用于读取二进制的数据文件，(如声音，图片，视频等)
1、字节输入流(InputStream,FileInputStream,BufferedInputStream,DataInputStream)
（1）InputStream 此抽象类是表示字节输入流的所有类的超类,以字节为单位
    常用方法：
      int read()下一个数据字节（0 到 255 范围内的 int 字节值），如果到达流的末尾，则返回 -1
     int read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
      int read(byte[] b, int off, int len) 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
      void close() 关闭此输入流并释放与该流关联的所有系统资源
（2）直接子类：
                   
  FileInputStream ：把文件对象转化成输入流。用于读取诸如图像数据之类的原始字节流。
     构造方法：
FileInputStream(File file)通过File对象创建一个 FileInputStream 
FileInputStream(String name) 通过文件路径创建一个 FileInputStream

  （3）FilterInputStream：过滤流，是一种扩展输入流功能的类（装饰器），它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能

（4）BufferedInputStream：在创建 BufferedInputStream 时，会创建一个内部缓冲区数组，利用缓冲区来提高读数据的效率
   先把一批数据读入到缓冲区，接下来read()方法只需要到缓冲区内获取数据，就能减少物理性读取数据的次数。
   构造方法：
   BufferedInputStream(InputStream in) 通过底层流，创建一个 BufferedInputStream
   BufferedInputStream(InputStream in, int size) 通过底层流，创建具有指定缓冲区大小的 BufferedInputStream

（5）DataInputStream：数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型(类型转换请查看源代码)
   构造方法：
    DataInputStream(InputStream in) 使用指定的底层 InputStream 创建一个 DataInputStream

2、字节输出流
(OutputStream,FileOutputStream,BufferedOutputStream,DataOutputStream)
（1）OutputStream：此抽象类是表示输出字节流的所有类的超类
    void close()关闭此输出流并释放与此流有关的所有系统资源
    void flush() 刷新此输出流并强制写出所有缓冲的输出字节
    void write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流
    void write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流

（2）FileOutputStream：文件输出流是用于将数据写入 File 的输出流
   构造方法摘要
FileOutputStream(File file)创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(String name, boolean append) 创建一个向具有指定 name 的文件中写入数据的输出文件流。
//append表示是否追加到文件末尾，还是覆盖源文件内容
  FilterOutputStream
  直接子类：
         BufferedOutputStream,
         DataOutputStream,
         PrintStream: 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式(自动刷新)
         构造方法:
PrintStream(File file)创建具有指定文件且不带自动行刷新的新打印流。 
PrintStream(OutputStream out) 创建新的打印流。
PrintStream(OutputStream out, boolean autoFlush)创建新的打印流。
PrintStream(OutputStream out, boolean autoFlush, String encoding)创建新的打印流。
PrintStream(String fileName) 创建具有指定文件名称且不带自动行刷新的新打印流。
常用方法：
                  public PrintStream append(char c)；将指定字符添加到此输出流
                  public void println(char x)//换行，插入
                  public void write(int b)   //要写入将根据平台的默认字符编码转换的字符，请使用 print(char) 或 println(char) 方法
         
                  按照平台的默认字节编码将 String.valueOf(int) 生成的字符串转换为字节，并完全以 write(int) 方法的方式写入这些字节

3、文件读写步骤
（1）创建文件对象
File file1 = new File("data.txt");
File file2 = new File("dest.txt");
（2）创建读出/写入操作的对象
文件对象仅仅表示文件本身，对文件进行读/写操作还需要读/写操作对象来完成。
读出文件中的内容采用FileInputStream对象，在文件中写入内容采用FileOutputStream对象。
InputStream inputStream = new FileInputStream(file1);
OutputStream outputStream = new FileOutputStream(file1);
说明：写入和读出操作对象必须和具体的文件对象关联起来，而文件对象又是和具体的文件关联的。
（3）数据文件的读/写操作
inputStream.read();
outputStream.write();
（4）关闭资源
inputStream.close();
outputStream.close();

四、字符流

1、Reader:用于读取字符流的抽象类
         方法：  
         int read() 读取单个字符
         int read(char[] cbuf) 将字符读入数组
         int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分
         void close() 关闭该流并释放与之关联的所有资源
        
（1） FileReader：
       extends InputStreamReader extends Reader用于读取字符流
        构造方法：
FileReader(File file) 在给定从中读取数据的 File 的情况下创建一个新 FileReader
FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader
（2）BufferedReader：
      extends Reader
   从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取，可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大
   通常，Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求
    因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）
    构造方法：
BufferedReader(Reader in)创建一个使用默认大小输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz) 创建一个使用指定大小输入缓冲区的缓冲字符输入流
readLine() 读取一个文本行
2 Writer：
        写入字符流的抽象类
        Writer append(char c) 将指定字符添加到此 writer。
        void close() 关闭此流，但要先刷新它。
void flush() 刷新该流的缓冲。
        void write(char[] cbuf) 写入字符数组。
        void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。
        void write(int c) 写入单个字符。
        void write(String str) 写入字符串。
        void write(String str, int off, int len) 写入字符串的某一部分。
       
（1）FileWriter：
构造方法：

FileWriter(File file) 根据给定的 File 对象构造一个 FileWriter 对象。

FileWriter(File file, boolean append) 根据给定的 File 对象构造一个 FileWriter 对象。 
FileWriter(String fileName) 根据给定的文件名构造一个 FileWriter 对象
FileWriter(String fileName, boolean append) 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。

append 表示追加到文件末尾，否则覆盖源文件中的数据
      
（2） BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入
        构造方法：
BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。 BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流
        方法摘要
void close() 关闭此流，但要先刷新它。
void flush()刷新该流的缓冲。
void newLine() 写入一个行分隔符。
void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。
void write(int c) 写入单个字符。
          void write(String s, int off, int len) 写入字符串的某一部分。

五、字节流与字符流
字节流：以Stream结尾的都是字节流,字节流用于读取二进制数据（图片、视频、音乐）
  字符流：结尾都是以Reader/Writer结尾的,字符流用于读取文本数据（txt、jsp、java...）
字节流和字符流转换

InputStreamReader  把字节输入流转换成字符流
OutputStreamWriter 把字符流写到字节流

例子：
  用字节流打开文件，然后转成字符流
FileInputStream fis = new FileInputStream("e:/student.c");
InputStreamReader isr = new InputStreamReader(fis);

六、对象的序列化和反序列化
   序列化：把一个对象的状态写入一个字节流的过程。如果一个对象引用到其它对象，而这些对象又引用另外的对象，那么所有这些对象都会被序列化。
  Serializable接口：
   只有实现Serializable接口的对象才能被序列化工具存储或者恢复。
   声明为transient的变量不被序列化工具存储。
   static变量同样不被存储

七、对象流
ObjectOutputStream：
  构造方法：
public ObjectOutputStream(OutputSteam os) 负责向流写入对象：
public void writeObject(Object obj)//obj 序列化的对象
ObjectInputStream：
  构造方法：
public ObjectInputStream(InputSteam is)负责从流读出对象（反序列化）：
public Object readObject()
ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化

八、配置文件管理
后缀一般为ini或者properties的文件
格式：键 = 值
说明：ini或者properties，多个重复键时，ini只处理第一个，properties处理最后一个。其他差别不明显
Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串
  方法及步骤：
     1）加载文件流：
void load(InputStream inStream) 从输入流中读取属性列表（键和元素对）
void load(Reader reader) 按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）
     2）读取文件信息或者修改文件信息：
String getProperty(String key) 通过键获取值
String getProperty(String key,String defaultValue)通过键获取值。如果未找到键，则此方法返回默认值变量
Object setProperty(String key, String value)调用 Hashtable 的方法 put，通过键修改相应的值 ，如果该键不存在则新增
     3）保存到文件流：    
  void store(OutputStream out, String comments) 以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
   void store(Writer writer, String comments) 以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Date;
import java.util.Properties;

public class TestProperty {
	// 1 创建文件对象
	static File file = new File("./config/config.ini");
	static FileInputStream fileInputStream = null;
	static Properties properties = null;
	static FileOutputStream fileOutputStream = null;

	static {
		if (!file.exists()) {
			try {
				file.createNewFile();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		try {
			// 2 创建输入流
			fileInputStream = new FileInputStream(file);
			// 3 创建Properties
			properties = new Properties();
			// 4 加载输入流
			try {
				properties.load(fileInputStream);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	// 写入到配置文件
	public static void setValue(String key, String value) {
		properties.setProperty(key, value);
		try {
			fileOutputStream = new FileOutputStream(file);
			properties.store(fileOutputStream, "qq config information!");
			fileOutputStream.flush();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			try {
				fileOutputStream.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

	}

	public static String getValue(String key) {
		String value = properties.getProperty(key, "8099");
		try {
			fileInputStream.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return value;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String url = "jdbc:oracle:thin:@127.0.0.1:1521:ORACLE";
		String user = "oracle1105";
		String password = "oracle1105";
		String driver = "oracle.jdbc.driver.OracleDriver";
		String port = "8099";

		//保存配置信息
		TestProperty.setValue("url", url);
		TestProperty.setValue("user", user);
		TestProperty.setValue("password", password);
		TestProperty.setValue("driver", driver);
		TestProperty.setValue("port", port);
		
		//读取配置信息
		System.out.println(TestProperty.getValue("url"));
		System.out.println(TestProperty.getValue("user"));
		System.out.println(TestProperty.getValue("password"));
		System.out.println(TestProperty.getValue("driver"));
		System.out.println(TestProperty.getValue("port"));
		
		
		
	}

}