-----------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>