-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
程序出现了不正常的情况称为异常，Throwable类是Java中所有错误或异常的超类，异常的分类如下：
程序的异常：Throwable
严重问题：Error（这种问题一般是很严重的问题，更改代码无法解决。）
普通问题：Exception
编译期异常：非RuntimeException（无法编译，所以此问题必须处理。）
Java中的异常分为两大类：编译时异常和运行时异常，所有的RuntimeException类及其子类的实例被称为运行时异常，其它的被称为编译时异常。当程序出现异常时，jvm会自动做出处理，把异常的情况输出在控制台，并终止程序的运行。但是此处理方法不够好，需要我们自己处理，处理方式如下：运行期异常：RuntimeException（出现这个问题是因为代码不够严谨，是需要修改代码的。）
A: try ... catch ... finally;
基本格式：
try {
可能出现问题的代码;
} catch (异常名 变量) {
针对问题的处理;
} finally {
释放资源;
}
执行过程：
一旦在try里发现问题，jvm会生成一个异常对象，然后抛出，和catch里的异常匹配，匹配成功，则执行catch中的处理，最后结束此try...catch语句，继续执行后面的语句。
注意事项：
try里面的代码越少越好；
catch里面必须有针对内容处理的内容；
catch后的异常名能明确的尽量要明确，明确不了的，可以写其父类异常名；
出现多个异常时，需写多个catch，异常名出现上下级关系时，级别大的必须在后面。
被finally修饰的语句一定会被执行，但是如果再finally之前jvm退出了，就不能执行了。
Jdk7针对异常处理的新特性：
try{
可能出现问题的代码;
} catch (异常名1 | 异常名2 | ... 变量) {
针对问题的处理;
}
注意事项：
此方法针对catch中多个异常的处理方式是一致的；
多个异常的关系必须是平级关系。
B: throws;
在定义功能方法时，需要把出现的问题暴露出来让调用者去处理，就通过throws将异常抛出，所以throws的作用是在方法上声明异常。
格式：
throws 异常类名
注意：
throws的位置在方法的括号后面；
尽量不要在main方法上抛出；
编译期异常抛出后，调用者必须处理，运行期异常抛出后，调用者可以不用处理。
throw的作用：
在功能方法内部出现某种异常，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。
throw和throws的区别：
throws：
throw：用在方法声明后面，跟的是异常类名；
可以跟多个异常类名，用逗号隔开；
表示抛出异常，由该方法的调用者来处理；
throws表示出现异常的一种可能性，并不一定会发生这些异常。
用在方法体内，跟的是异常对象名；
只能抛出一个异常对象名；
表示抛出异常，由方法体内的语句处理；
throw表示抛出了异常，执行throw则一定抛出了某种异常。
异常处理时的原则：
如果该功能内部可以将问题处理，就用try处理，如果处理不了，就使用throws抛出，交由调用者处理。
Throwable类（Java.lang包）
概述：Java中所有错误或异常的超类，它有如下一些成员方法；
public String getMessage();
返回此异常消息的详细消息。
public String toString();
返回此异常的简短描述。
public void printStackTrace();
public void printStackTrace(PrintStream s);获取异常类名和信息，以及此异常出现在程序中的位置。
将此异常信息输出到指定的输出流。
final,finally和finalize的区别：
final：最终的意思，可以修饰类、成员变量和成员方法，
修饰类，类不能被继承，
修饰变量，变量是常量，
finally：是异常处理的一部分，用于释放资源，修饰方法，方法不能被重写，
finalize：是Object类的一个方法，用于垃圾回收。
自定义异常类
在Java开发中，有时候需要根据一些实际情况，自定义异常类，一个类必须继承自Exception或者RuntimeException才能是异常类。
下面是一个自定义异常类的使用，并使用try...catch做处理，
<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">//自定义一个异常类 public class MyException extends Exception{ public MyException() { } public MyException(String Message) { super(Message); } }</span></span></span></span></span></span></span></span></span><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">//判断输入年龄是否正确，年龄不正确就报错，并给出提示 public class Student { public void chack(int age) throws MyException{ if(age<0) { throw new MyException("请输入正确的年龄"); }else { System.out.println("输入年龄成功"); } } }</span></span></span></span></span></span></span></span></span><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">//测试类 import java.util.Scanner; public class StudentDemo { public static void main(String[] args) { Student s = new Student(); Scanner sc = new Scanner(System.in); int age = sc.nextInt(); try { s.chack(age); } catch (MyException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }</span></span></span></span></span></span></span></span></span>
异常使用中的注意事项：
A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子异常；
B:如果父类抛出了多个异常，子类重写父类时，只能抛出相同的异常或者是它的子集，子类不能抛出父类没有的异常；
C:如果被重写的方法没有异常抛出，那么子类的方法绝对不可以抛出异常，如果子类方法内有异常发生，那么子类只能使用try...catch方式，不能使用throws方式。
File类（java.lang包）
概述：文件和目录路径名的抽象表示形式。
构造方法：
public File(String pathname);
根据一个路径创建File对象。
public File(String parent,String child);
根据一个路径和一个子目录或子文件名创建File对象。
public File(File parent,String child);
根据一个File对象和一个子目录或子文件名创建File对象。
成员方法
创建功能：
public boolean createNewFile();
创建文件。(创建文件或者文件夹时，如果没有指定盘符，默认在项目路径下）
public boolean mkdir();
创建文件夹。
public boolean mkdirs();
创建多级文件夹。
删除功能：
public boolean delete();
删除文件或文件夹。（删除文件夹时文件夹内必须为空；且此删除功能不走回收站）
修改功能：
public boolean renameTo(File dest);
重命名文件。（调用方法时，如果两文件路径相同，就是重命名，反之，则为重命名加剪切）
判断功能：
public boolean isDirectory();
判断是否是目录。
public boolean isFile();
判断是否是文件。
public boolean exists();
判断是否存在。
public boolean canRead();
判断是否可读。
public boolean canWrite();
判断是否可写。
public boolean isHidden();
判断是否隐藏。
获取功能：
public String getAbsolutePath();
获取绝对路径。
public String getPath();
获取相对路径。
public String getName();
获取名称。
public long length();
获取长度。（字节数长度）
public long lastModified();
获取最后一次的修改时间的毫秒值。
public String[] list();
获取指定目录下的所有文件或文件夹的名称数组。
public File[] listFiles();
获取指定目录下的所有文件或文件夹的File数组。
public String[] list(FilenameFilter filter);
返回一个满足过滤器过滤要求的文件或目录的字符串数组。
public File[] listFiles(FilenameFilter filter);
返回一个满足过滤器过滤要求的文件或目录的文件数组。
FilenameFilter接口（java.io包）
实现此接口的类实例可用于过滤器文件名。
成员方法：
boolean accept(File dir,String name);
测试指定文件是否应该包含在某一文件列表中。其中dir表示文件所在的目录，name表示文件的名称。
此过滤器的使用：
<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">//使用文件名称过滤器筛选以.umd结尾的文件。 public class FileDemo { public static void main(String[] args) { File file = new File("E:\\Ebook"); File[] fileArray = file.listFiles(new FilenameFilter() { @Override public boolean accept(File dir, String name) { // TODO Auto-generated method stub boolean flag = new File(dir,name).isFile(); boolean flag2 = name.endsWith(".umd"); return flag&&flag2; } }); for(File f : fileArray) { System.out.println(f.getName()); } } }</span></span></span></span></span></span></span></span>
递归
概述：方法定义中调用方法本身的现象。
递归使用中的注意事项：
A:递归一定要有出口，否则就是死递归；
B:递归的次数不能太多，否则就会内存溢出；
C:构造方法不能递归使用。
递归的使用：
<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">//递归删除指定目录下带有文件的文件夹 public class FileDemo2 { public static void main(String[] args) { File srcFile = new File("E:\\Book"); deleteFile(srcFile); } private static void deleteFile(File srcFile) { File[] fileArray = srcFile.listFiles(); if (fileArray != null) { for (File file : fileArray) { if (file.isDirectory()) { deleteFile(file); } else { System.out.println(file.getName() + "---" + file.delete()); } } System.out.println(srcFile.getName() + "---" + srcFile.delete()); } } }</span></span></span></span></span></span></span>
IO流
Java对数据的操作时通过流的方式，用于操作流的对象都在IO包中，IO流是用来处理设备之间的数据传输的。
IO流分类：
按照数据流向：输入流（读入数据），输出流（写出数据）；
按照数据类型：
字节流：
字节输入流(InputStream)
字节输出流(OutputStream
字符流
字符输入流(Reader)
字符输出流(Writer)
InputStream,OutputStream,Reader,Writer类都是抽象类，不能实例化，所以需要使用它们的具体子类。
FileOutputStream类（java.io包）
概述：是OutputStream的具体子类，将数据写入File的输出流。
构造方法：
在创建字节输出流对象时，jvm做了以下几件事情：public FileOutputStream(File file);
创建一个指向File对象的字节输出流。
public FileOutputStream(Stiring name);
创建一个指向指定name文件的字节输出流。
public FileOutputStream(File file, boolean append);
如果第二个参数值为true，则为追加写入。
A:调用系统功能去创建文件；
B:创建对象，并指向这个文件。
成员方法：
public void write(byte[] b);
向文件中写入一个字节数组。
public void write(int b);
写入一个字节。
public void write(byte[] b, int off, int len);
写入字节数组的一部分。
public void close();
关闭并释放与此流有关的所有系统资源，让流对象变成垃圾，使其被垃圾回收器回收。
FileInputStream类（java.io包）
概述：是InputStream的具体子类，用于读取File文件的输入字节流。
构造方法：
public FileInputStream(File file);
创建一个字节输入流对象，指向指定的File文件。
public FileInputStream(String name);
创建一个字节输入流对象，指向name表示的文件。
成员方法：
public int read();
从此输入流中读取一个字节数据。（返回其实际读取的字节数据）
public int read(byte[] b);
从此输入流中读取一个字节数组的数据。（此方法返回的是其实际读取的字节个数）
BufferedOutputStream类 （java.io包）
概述：具有缓冲功能的字节输出流。
构造方法：
public BufferedOutputStream(OutputStream out);
创建一个字符缓冲输出流对象。
BufferedInputStream类（java.io包）
概述：具有缓冲功能的字节输入流。
构造方法：
public BufferedInputStream(InputStream in);
创建一个字符缓冲输入流对象。
使用普通字节流和高效字节流复制文件
<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">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 StreamDemo { public static void main(String[] args) { File file = new File("E:\\烟花.jpg"); try { copy1(file, "F:\\晚会1.jpg"); copy2(file, "F:\\晚会2.jpg"); copy3(file, "F:\\晚会3.jpg"); copy4(file, "F:\\晚会4.jpg"); } catch (IOException e) { e.printStackTrace(); } } // 基本字节流一次读取一个字节 public static void copy1(File srcFile, String copyString) throws IOException { FileInputStream fis = new FileInputStream(srcFile); FileOutputStream fos = new FileOutputStream(copyString); int by = 0; while ((by = fis.read()) != -1) { fos.write(by); } fos.close(); fis.close(); } // 基本字节流一次读取一个字节数组。 public static void copy2(File srcFile, String copyString) throws IOException { FileInputStream fis = new FileInputStream(srcFile); FileOutputStream fos = new FileOutputStream(copyString); byte[] bys = new byte[1024]; int len = 0; while ((len = fis.read(bys)) != -1) { fos.write(bys, 0, len); } fos.close(); fis.close(); } // 高效字节流一次读写一个字节 public static void copy3(File srcFile, String copyString) throws IOException { BufferedInputStream bis = new BufferedInputStream(new FileInputStream( srcFile)); BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream(copyString)); int by = 0; while ((by = bis.read()) != -1) { bos.write(by); } bos.close(); bis.close(); } // 高效字节流一次读写一个字节数组 public static void copy4(File srcFile, String copyString) throws IOException { BufferedInputStream bis = new BufferedInputStream(new FileInputStream( srcFile)); BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream(copyString)); byte[] bys = new byte[1024]; int len = 0; while ((len = bis.read(bys)) != -1) { bos.write(bys, 0, len); } bos.close(); bis.close(); } }</span></span></span></span></span>
转换流（字符流）
由于字节流操作中文不是特别方便，所以就使用转换流来专门操作文字，转换流即字符流，是由字节流和编码表的构成的。编码表是由字符及其对应的数值组成的一张表，简体中文Windows操作系统默认使用GBK编码表，Linux系统默认使用UTF-8编码表。
String类中使用到编码表的方法：
构造方法：
public String(byte[] bytes,String charsetName);
使用指定的编码表解码字节数组，将其转换为字符串。
成员方法：
public byte[] getBytes(String charsetName);
使用指定的编码表将字符串编码，转换为字节数组。
OutputStreamWriter类（java.io包）
概述：字符输出流，是Writer类的具体子类。
构造方法：
public OutputStreamWriter(OutputStream out);
创建一个使用默认字符编码的字符输出流对象。
public OutputStreamWriter(OutputStream out,String charsetName);
创建一个使用指定字符编码的字符输出流对象。
成员方法：（以下方法都是继承自其父类Writer中的）
public void write(int c);
写一个字符。
public void write(String str);
写入字符串。
public void write(String str,int off,int len);
写入字符数组的一部分。
public void write(char[] cbuf);
写一个字符数组。
public void write(char[] cbuf,int off,int len);
写入字符数组的一部分。
public void flush();
刷新该缓冲区。
InputStreamReader类（java.io包）
概述：字符输入流，是Reader类的子类。
构造方法：
public InputStreamReader(InputStream in);
创建一个使用默认字符编码的字符输入流对象。
public InputStreamReader(InputStream in,String charsetName);
创建一个使用指定字符编码的字符输入流对象。
FileWriter类（java.io包）
概述：是写入字符文件的便捷类，继承自OutputStreamWriter类，但该类的构造方法更简便。
构造方法：
public FileWriter(File file);
public FileWriter(String filename);
根据给定的File对象或文件名称创建一个字符输出流对象。
FileReader类（java.io包）
概述：用来读取文件的便捷类，继承自InputStreamreader类，但该类的构造方法更简洁。
构造方法：
public FileReader(File file);
public FileReader(String filename);
根据给定的File对象或文件名称创建一个字符输入流对象。
BufferedWriter类（java.io包）
概述：高效字符输出流，继承自writer类。
构造方法：
成员方法：public BufferedWriter(Writer out);
public void newLine();
写入一个行分割符。
BufferedReader类（java.io包）
概述：高效的字符输入流，继承自Reader类。
构造方法：
public BufferedReader(Reader in);
成员方法：
使用三种字符流复制文本文件：public String readLine();
读取一个文本行。
<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; //使用字符流复制文本文件 public class StreamDemo2 { public static void main(String[] args) { try { copy1("E:\\srcfile.txt", "F:\\copyfile1.txt"); copy2("E:\\srcfile.txt", "F:\\copyfile2.txt"); copy3("E:\\srcfile.txt", "F:\\copyfile3.txt"); copy4("E:\\srcfile.txt", "F:\\copyfile4.txt"); } catch (IOException e) { e.printStackTrace(); } } // 使用字符流复制文本文件（一次一个字符） public static void copy1(String srcname, String copyname) throws IOException { InputStreamReader isr = new InputStreamReader(new FileInputStream( srcname)); OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream( copyname)); int ch = 0; while ((ch = isr.read()) != -1) { osw.write(ch); } osw.close(); isr.close(); } // 使用便捷字符流复制文本文件（一次一个字符数组） public static void copy2(String srcname, String copyname) throws IOException { FileReader fr = new FileReader(srcname); FileWriter fw = new FileWriter(copyname); char[] chs = new char[1024]; int len = 0; while ((len = fr.read(chs)) != -1) { fw.write(chs, 0, len); fw.flush(); } fw.close(); fr.close(); } // 使用高效字符流复制文本文件（一次一个字符数组） public static void copy3(String srcname, String copyname) throws IOException { BufferedReader br = new BufferedReader(new FileReader(srcname)); BufferedWriter bw = new BufferedWriter(new FileWriter(copyname)); char[] chs = new char[1024]; int len = 0; while ((len = br.read(chs)) != -1) { bw.write(chs, 0, len); bw.flush(); } bw.close(); br.close(); } // 使用高效字符流复制文本文件（一次一行） public static void copy4(String srcname, String copyname) throws IOException { BufferedReader br = new BufferedReader(new FileReader(srcname)); BufferedWriter bw = new BufferedWriter(new FileWriter(copyname)); String line = null; while ((line = br.readLine()) != null) { bw.write(line); bw.newLine(); bw.flush(); } bw.close(); br.close(); } }</span></span></span></span></span>
LineNumberReader类（java.io包）
概述：可跟踪行号的缓冲字符输入流，该类有两个方法分别用来获取和设置行号。
public int getLineNumber();
获得当前行号。
public void setLineNumber(int lineNumber);
设置当前行号。
DataOutputStream/DataInputStream数据输入/输出流
可以读写基本数据类型的数据流，它们继承自Out/InputStream类的子类，构造方法如下：
DataOutputStream(OutputStream out);
DataInputStream(InputStream in);
以下方法是写入和读取基本数据类型的方法：
public final void writeByte(int v);
public final void writeShort(int v);
public final void writeInt(int v);
public final void writeLong(long v);
public final void writeFloat(float v);
public final void writeDouble(double v);
public final void writeChar(int v);
public final void writeBoolean(boolean v);
public final byte readByte();
public final short readShort();
public final int readInt();
public final long readLong();
public final float readFloat();
public final double readDouble();
public final char readChar();
public final boolean readBoolean();
内存操作流
用于处理和存储临时信息，程序结束，数据就从内存中消失，它的close()方法无意义。内存操作流分为三种，
操作字节数组：ByteArrayInputStream/ByteArrayOutputStream
操作字符数组：CharArrayReader/CharArrayWriter
操作字符串：StringReader/StringWriter
以操作字节数组举例：
构造方法：
ByteArrayInputStream(byte[] buf);
ByteArrayOutputStream();
其中输出流有如下方法，用来创建一个byte数组，并且缓冲区的有效内容已复制到该数组中。
public byte[] toByteArray();
打印流
PrintStream字节打印流
PrintWriter字符打印流
打印流的特点：
a:只有写数据的，没有读数据的，只能操作目的地，不能操作数据源。
b:可以操作任意类型的数据。
c:启用自动刷新，该流就可以自动刷新（在调用println(),printf(),format()方法的时候）。
d:该流可以直接操作文本文件，也可以操作基本流。
其中字符打印流的构造方法：
public PrintWriter(File file);
public PrintWriter(OutputStream out,boolean autoFlush);
创建一个带自动刷新功能的字符打印流。
public PrintWriter(String fileName);
public PrintWriter(Writer out,boolean autoFlush);
在Scanner类出现之前，通过字符缓冲流可以实现键盘录入数据，
<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">//通过字符缓冲流包装标准输入流实现键盘录入数据 import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class BufferedDemo { public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); System.out.println("请输入字符串"); String line = br.readLine(); System.out.println("你输入的字符串是" + line); System.out.println("请输入整数"); String line2 = br.readLine(); int i = Integer.parseInt(line2); System.out.println("你输入的整数是" + i); } }</span></span></span>
RandomAccessFile随机访问流（java.io包）
概述：随机访问流不属于流，是Object的子类，但它可对文件进行随机读取和写入，其随机读写是依赖指向文件的索引。
构造方法：
public RandomAccessFile(String name,String mode);
创建一个随机访问流对象，第一个参数是文件路径，第二个参数是操作文件的模式，其中"rw"表示此对象即可以写数据，又可以读数据。
成员方法：
public final void writeXxx(xxx x);
向文件中写入xxx类型的数据。
public final xxx readXxx();
从文件中读取一个xxx类型的数据。
public long getFilePointer();
返回此文件中当前的文件指针位置。（以字节为单位）
public void seek(long pos);
设置此文件中指针的偏移量
SequenceInputStream类（合并流）
概述：继承自InputStream，可将多个文件合并写入一个新的文件。
构造方法：
public SequenceInputStream(InputStream s1,InputStream s2);
创建一个合并流对象，该对象读取文件时，先读流s1，再读流s2。
public SequenceInputStream(Enumeration<? extends InputStream>e);
创建一个能读取多个文件的合并流对象，该对象读取文件时，先将文件的输入流对象存放到vector集合中，再通过集合的elements()方法获得Enumeration对象。
将多个文档合并写入新文档：
<span style="font-size:14px;"><span style="font-size:14px;">import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.SequenceInputStream; import java.util.Enumeration; import java.util.Vector; //将多个文档合并写入一个新文档 public class SequenceStreamDemo { public static void main(String[] args) throws IOException{ InputStream is1 = new FileInputStream("E:\\a.txt"); InputStream is2 = new FileInputStream("E:\\b.txt"); InputStream is3 = new FileInputStream("E:\\c.txt"); Vector<InputStream> v = new Vector<InputStream>(); v.add(is1); v.add(is2); v.add(is3); Enumeration<InputStream> e = v.elements(); SequenceInputStream sis = new SequenceInputStream(e); OutputStream os = new FileOutputStream("F:\\copy.txt"); byte[] bys = new byte[1024]; int len = 0; while((len = sis.read(bys)) != -1) { os.write(bys,0,len); } os.close(); sis.close(); } }</span></span>
ObjectOutputStream类（序列化流）
概述：OutputStream的子类，把对象按照流一样的方式存入文本文件或在网络中传输。对应的还有烦序列化流：ObjectInputStream。
构造方法：
public ObjectOutputStream(OutputStream out);
成员方法：
对一个类进行序列化操作时，该类必须实现Serializable接口，才能被序列化，当没有实例化该接口时，会报异常NotSerializableException，并且当实现序列化接口后，还需在该类设置ID值，这样在对该类进行改动后，不影响序列化流对该类的读取操作。public void writeXxx(xxx x);
写入一个基本类型xxx的数据。
public void writeObject(object obj);
将指定对象写入ObjectOutputStream。
transient关键字
当类中的某个成员变量不想被序列化是，可使用该关键字修饰。
Properties类（java.util包）
概述：属性集合类，该类继承自Hashtable，是一个可以和IO流相结合使用的集合类，能保存在流中或从流中加载。
区别于Hashtable的特殊成员方法：
public Object setProperty(Stirng key,String value);
添加集合元素。
public String getProperty(String key);
根据键获取值。
public Set<String> stringPropertyNames();
获取所有键的集合。
该类和IO流结合使用时，可将数据从文件到集合之间相互读写，但文件中的数据必须是键值对形式。
public void load(Reader reader);
把文件中的数据以字符流的形式读取到集合中。（文件中的数据必须是以键值对形式存储的）
public void store(Writer writer,String comments);
把集合中的数据存储到文件。
Properties集合与IO流的结合使用，
<span style="font-size:14px;"><span style="font-size:14px;">import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.Reader; import java.io.Writer; import java.util.Properties; import java.util.Set; //使用属性集合类实现对文件的读写。 public class PropertiesDemo { public static void main(String[] args) { try { myWrite(); myRead(); } catch (IOException e) { e.printStackTrace(); } } //使用Properties集合将数据存储到文件中 public static void myWrite() throws IOException{ Properties p = new Properties(); p.setProperty("章子怡","北京人"); p.setProperty("刘德华","香港人"); p.setProperty("周杰伦","台湾人"); Writer w = new FileWriter("E:\\person.txt"); p.store(w,null); } //使用Properties集合从文件中读取数据并遍历 public static void myRead() throws IOException{ Properties p = new Properties(); Reader r = new FileReader("E:\\person.txt"); p.load(r); Set<String> set = p.stringPropertyNames(); for(String key : set) { String value = p.getProperty(key); System.out.println(key+"=" + value); } } }</span></span>
NIO包
概述：NIO就是新IO，是JDK4出现的，新IO和IO目的相同，但方式不同，它是采用内存映射文件的方式，将文件映射到内存中，然后像访问内存一样访问文件。
以下是JDK7出现的新IO；
Path接口（java.nio.file包）：表示路径。
Paths类（java.nio.file包）
此类提供了一个静态方法能将URI转换为Path路径，
public static Path get(URI uri);
Files类（java.nio.file包）
此类提供了一些静态方法用来操作文件，
public static long copy(Path source,OutputStream out);
复制文件。（第一个参数表示数据源的Path路径，第二个参数表示目的地的输出流）
public static Path write(Path path,Iterable<? extends CharSequence>lines,Charset cs,OpenOption... options);
将一个Iterable类型集合以一种编码方式存储到指定Path路径的文件中。
NIO的使用：
<span style="font-size:14px;">import java.io.FileOutputStream; import java.io.IOException; import java.nio.charset.Charset; import java.nio.file.Files; import java.nio.file.Paths; import java.util.ArrayList; //JDK7的NIO复制文件 public class NIODemo { public static void main(String[] args) throws IOException{ //使用NIO复制文件，将E盘下的a.txt复制到F盘下的copy.txt Files.copy(Paths.get("E:\\a.txt"), new FileOutputStream("F:\\copy.txt")); //使用NIO将一个集合中的数据写入文件中 ArrayList<String> array = new ArrayList<String>(); array.add("Hello"); array.add("World"); Files.write(Paths.get("F:\\copy2.txt"), array, Charset.forName("GBK")); } }</span>
528
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
