1. 程序的异常
严重问题:Error 不处理,问题严重,比如内存溢出
问题:Exception:
编译器问题:不是运行期RuntimeException的异常,必须进行处理,不处理将不能通过编译
运行期问题:RuntimeException 这种问题也不处理,程序的严谨性问题
如果程序出现了问题,我们没有处理,虚拟机将默认进行处理:把异常问题,出现的原因输出在控制台,同时结束程序
1.1 try...catch...finally处理格式
try{//可能出现问题的代码,代码量越少越好,虚拟机需要开辟新的问题处理这个问题
}catch(异常名称) {//针对问题的处理
}finally{//释放资源
}//变形格式
try{//可能出现问题的代码,try问题出现以后,将会去catch里面查找,但是不能继续执行try里面的代码
}catch(异常名称) {//异常名称写成Exception可以接收所有的异常,能明确尽量明确,针对问题的处理,需要有处理方式
}
例如:
public static voidmain(String[] args) {int a = 20;int b = 0;try{
System.out.println(a/b);
}catch(ArithmeticException s) {
System.out.println("除数不能为0");
}
System.out.println("over");
}
JDK7异常处理新特性:
public static voidmethod2() {int a = 0;int b = 0;int[] arr = {1, 2, 3};try{
System.out.println(a/b);
System.out.println(arr[3]);
}catch(ArithmeticException |ArrayIndexOutOfBoundsException s){
System.out.println("有问题");
}
System.out.println("over");
注意:异常必须是同级关系,不能够是继承关系,并且所有的异常执行同一种操作
异常的几个常用方法:
public String getMessage():返回异常的消息字符串
public String toString():返回throwable的简短描述,将由一下字符串拼接而成:
此对象的类的名称(全路径名)
": "冒号和一个空格
调用此对象getLocalizedMessage()方法的结果
public String getLocalizedMessage():创建throwable的本地化描述,子类可以重写此方法,以便生成特定语言环境的消息,对于不重写此方法的子类,将默认返回与getMessage()的结果
void printStackTrace():获取异常类名和异常信息,以及异常出现在程序中的位置,返回void
void printStackTrace(PrintStream s):通常用该方法将异常的内容存储到日志文件中,以便日后查看
public static voidmain(String[] args) {
String s= "2014-01";
SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd");try{
Date d=sdf.parse(s);
System.out.println(d);
}catch(ParseException e) {
System.out.println(e.getMessage());
System.out.println(e.toString());
e.printStackTrace();
}
}
finally:finally控制的语句一定会得到执行,但是如果执行finally之前jvm退出,将不能执行
finally主要用于释放资源,在IO流和数据库的操作中会经常遇到,try...finally可以单独使用
final:最终的意思,可以修饰类,成员变量,成员方法
修饰类:类不能够被继承
修饰变量:该变量是常量
修饰方法:方法不能够被重写
finalize:是Object类的一个方法,用于垃圾回收。
1.2 throws处理格式
特点:自身不能处理或者没有权限处理,抛出后是编译器的异常必须要处理,运行期可以不处理
public static voidmain(String[] args) {
System.out.println("今天的天气很好");try{
method();
}catch(ParseException e) {
e.printStackTrace();
}
System.out.println("就是有点热");
}public static void method() throwsParseException {
String s= "2015-11-20";
SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//不能处理或者没有权限处理
Date d =sdf.parse(s);
}
1.3 throw以及与throws的区别
throws:
用在方法声明后面,后面跟的是异常的名称
可以跟多个异常类名称,用逗号隔开
表示抛出异常,由该方法的调用者来处理这个异常
throws表示出现异常的一种可能性,并不一定会发生这些异常
throw:
用在方法体中,跟的是异常的对象名
只能抛出一个异常对象名
表示抛出异常,由方法体内的语句处理
throw则是抛出了异常,执行throw则一定是抛出了某种异常
public static voidmain(String[] args) {
method1();try{
method2();
}catch(Exception e) {
e.printStackTrace();
}
}public static voidmethod1() {int a = 10;int b = 0;if (b == 0) {throw newArithmeticException();
}else{
System.out.println(a/b);
}
}public static void method2() throwsException {int a = 10;int b = 0;if(b == 0) {throw newException();
}else{
System.out.println(a/b);
}
}
throws和try到底应该用哪个:
如果后续程序需要继续运行就执行try
如果后续程序不需要继续运行就执行throws
面试题:如果catch里面由return语句,那么finally里面的代码是否会执行,如果会,请问在return 前还是在return 后:会,前,但是return 的返回路径已经确定,准确的说finally在return 的中间
public static voidmain(String[] args) {
System.out.println(getInt());
}public static intgetInt() {int a = 10;try{
System.out.println(a/ 0);
a= 20;
}catch(ArithmeticException e) {
System.out.println("出错啦");
a= 30;returna;
}finally{
System.out.println("到底在哪里呢");
a= 40;
}returna;
}
程序运行结果:
出错啦
到底在哪里呢30
1.4 自定义异常
public classMyException extends Exception{publicMyException() {
}publicMyException(String message) {
super(message);
}
}public classTeacher {public void check(intscore) throws MyException {if(score > 100 || score < 0) {throw new MyException("分数必须在0到100之间");
}else{
System.out.println("分数没有问题");
}
}
}
异常的注意事项:
1. 子类重写父类方法时,子类的方法必须抛出相同的异常或者父类异常的子类,
2. 如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者它的子类的异常,子类不能够抛出父类没有的异常
3. 如果被重写的方法没有异常抛出,那么子类的方法绝对不能够通过throw抛出异常,如果子类方法有异常发生,那么子类只能用try不能用throw
2. 文件操作
2.1 File类和构造方法
定义:文件或者目录路径名的抽象表现形式,未必真实存在
构造方法:一下三种方式的效果相同,一般采用第一种方法:
public File(String pathname):根据路径得到一个File对象
public File(String parent, String child):根据一个目录和一个子文件得到File对象
public File(File parent, String chile):根据一个父File对象和一个子文件/目录得到File对象
2.2 成员方法
创建功能:
public boolean createNewFile():创建文件,如果存在,就不创建并返回false
public boolean mkdir():创建文件夹,如果存在,不创建并返回false
public boolean mkdirs():创建文件夹,如果父文件夹不存在,也会创建,多层。
注意:创建文件或者文件夹时需要选择正确的方法。
如果没有写盘符文件,默认在项目文件路径下
删除文件:
public boolean delete():删除文件或者文件夹,删除最后一层,Java删除时不走回收站,
删除文件夹时,只有是空文件夹只能删除
重命名功能:
public boolean renameTo(File dest):重命名file文件夹成dest
路径名相同重命名,不同时先剪切在重命名
判断功能:
public boolean isDirectory():判断是否是目录
public boolean isFile():判断是否是文件
public boolean exists():判断是否存在
public boolean canRead():判断是否可读
public boolean isHidden():判断是否隐藏
public static voidmain(String[] args) {
File file1= new File("D:\\Wet_Download\\Xunlei_Download\\wangwangwang");
System.out.println("mkdir:" +file1.mkdir());
System.out.println("mkdir:" +file1.mkdir());
File file2= new File("D:\\Wet_Download\\Xunlei_Download\\xiaojingzi.txt");try{
System.out.println("mkdir:" +file2.createNewFile());
}catch(IOException e) {
e.printStackTrace();
}
File file3= new File("D:\\Wet_Download\\Xunlei_Download\\wyy\\xio.txt");
System.out.println("mkdirs:" +file3.mkdirs());
System.out.println("delete:" +file3.delete());
System.out.println("delete:" +file3.delete());
System.out.println("delete:" +file1.delete());
System.out.println("delete:" +file2.delete());
File file4= new File("D:\\Wet_Download\\Xunlei_Download\\wyy\\hello.txt");
File file5= new File("D:\\Wet_Download\\Xunlei_Download\\wyy\\gulao.txt");
System.out.println(file4.renameTo(file5));
System.out.println("------------");
File file6= new File("D:\\Wet_Download\\Xunlei_Download\\wyy");
System.out.println(file6.isDirectory());
System.out.println(file6.isFile());
System.out.println(file6.exists());
System.out.println(file6.canRead());
System.out.println(file6.canWrite());
System.out.println(file6.isHidden());
}
获取功能:
public String getAbsolutePath():获取绝对路径
public String getPath():获取相对路径
public String getName():获取名称
public long length():获取字节数
public long lastModified():获取最后一次修改时间,毫秒值
public static voidmain(String[] args) {
File file= new File("D:\\Wet_Download\\Xunlei_Download\\wyy");
System.out.println("getAbsolutePath:" +file.getAbsolutePath());
System.out.println("getPath:" +file.getName());
System.out.println("getName:" +file.getName());
System.out.println("length:" +file.length());
System.out.println("lastModified:" +file.lastModified());
Date d= new Date(1533819207190l);
SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s=sdf.format(d);
System.out.println(s);
Date da= new Date(); //获取现在的时间
SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String st=sdf.format(da);
System.out.println(st);
}
插入:时间转字符串以及字符串转时间
//时间转字符串输出:
Date d = new Date(1533819207190l); //毫秒值
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s=sdf.format(d);
System.out.println(s);
Date da= new Date(); //获取现在的时间
SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String st=sdf.format(da);
System.out.println(st);//字符串转时间输出:
String s = "2015-11-20";
SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//不能处理或者没有权限处理
Date d = sdf.parse(s);
高级获取功能:
public String[] list():返回指定文件夹或文件字符串文件名数组
public File[] listFiles():返回指定文件夹或文件的文件类数组
public static voidmain(String[] args) {
File file= new File("D:\\Wet_Download");
String[] st=file.list();
System.out.println(Arrays.toString(st));
File[] fi=file.listFiles();
System.out.println(Arrays.toString(fi));
}
文件名称过滤器:
public String[] list(FilenameFilter filter):根据过滤器返回指定文件夹或文件字符串文件名数组
public File[] listFiles(FilenameFilter filter):根据过滤器返回指定文件夹或文件的文件类数组
public static voidmain(String[] args) {
File file= new File("D:\\Wang_File\\Home_Work\\dynamic_convolution");
String[] strArray= file.list(newFilenameFilter() {public booleanaccept(File dir, String name) {/*File fil = new File(dir, name);
if(fil.isFile()) {
if(name.endsWith(".jpg")) {
return true;
}
}
return false;*/
return new File(dir, name).isFile() && name.endsWith(".jpg");
}
});
System.out.println(Arrays.toString(strArray));
}
3. IO流
3.1 递归
递归:方法内部调用方法本身的现象
注意事项
1. 递归需要有出口,否则就是死递归
2. 递归的次数不能够太多,否则就会导致内存溢出
3. 构造方法不能够递归调用
public static int calc(intn) {if(n == 1) {return 1;
}else{return n * calc(n - 1);
}
}
public static voiddeleteFolder(File srcFolder) {
File[] fileArray=srcFolder.listFiles();for(File file : fileArray) { //删除文件
if(file.isDirectory()) {
deleteFolder(file);
}else{
System.out.println(file.getName()+ "----" +file.delete());
}
}
System.out.println(srcFolder.getName()+ "----" + srcFolder.delete()); //删除文件夹
}
3.2 java IO流的分类:
按照流向:输入流:写数据,输出流:读数据
按照数据类型:字节流:都可以使用字节流来传输
输入字节流:读取数据 InputStream
输出字节流:写出数据 OutputStream
字符流:如果是文本类型的数据,可以使用记事本打开,就可以采用字符流来传输
输入字符流:读取数据 Reader
输出字符流:写出数据 Writer
3.2.1 OutputStream
FileOutputStream的构造方法:
FileOutputStream(File file):
FileOutputStream(String name):调用系统功能创建文件,创建fos对象,把fos对象指向这个文件
FileOutputStream(String name, boolean append):true时追加
FileOutputStream(File file, boolean append):true时追加
close():
A 让流对象变成垃圾,这样就可以被垃圾回收器回收了
B 通知系统去释放文件相关的资源
public void write(int b):
public void write(byte[] b):
public void write(byte[] b, int off, int len):
public static void main(String[] args) throwsIOException {
OutputStream fos= new FileOutputStream("fos.txt");
fos.write("hello,Io".getBytes());
fos.write("xiaojingzi".getBytes());
fos.write(382);
fos.write("xiaojingzi".getBytes(), 2, 3);byte[] bys = {'a', 'b', 'c'};
fos.write(bys);
fos.close();//A 让流对象变成垃圾,这样就可以被垃圾回收器回收了 B 通知系统去释放与该文件有关的资源
}
加入异常处理的字节输出流操作
FileOutputStream fos = null;try{
fos= new FileOutputStream("fos1.txt");
fos.write("wa".getBytes());
}catch(FileNotFoundException e) {
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}finally{if (fos != null) {try{
fos.close();//只有fos不是null才能够调用
} catch(IOException e) {
e.printStackTrace();
}
}
}
3.2.2 OutputStream
构造方法:
FileInputStream(File file):
FileInputStream(FileDescriptor fdObj):
FileInputStream(String name):
public static void main(String[] args) throwsIOException {
FileInputStream fos= new FileInputStream("fos.txt");int by = 0;while((by = fos.read()) != -1) {
System.out.print((char)by);
}
}
文件的复制:可以复制中文,IO流先读再写,没有做任何转换,所以可以做正常显示
public static void main(String[] args) throwsIOException {
FileInputStream file= new FileInputStream("fos.txt");
FileOutputStream fos= new FileOutputStream("b.txt");int by = 0;while((by = file.read()) != -1) {
fos.write(by);
}
fos.close();
file.close();
}
!字节流适用于任意格式的文件
高效率读取:
public static void main(String[] args) throwsIOException {
FileInputStream fis= new FileInputStream("fos.txt");byte[] bys = new byte[5];int len = 0;while((len = fis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));
}
}
最终版:数组的长度一般是1024或者1024的整数倍
public static void main(String[] args) throwsIOException {
FileInputStream fis= new FileInputStream("fos.txt");byte[] bys = new byte[1024];int len = 0;while((len = fis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));
}
}
3.3 字节缓冲流
字节流读写一个数组的速度明显比一次读写一个字节的速度快很多,这是加入了数组这样的缓冲区效果,java在本身设计时考虑到这样的设计思想,提供了字节缓冲区流
字节缓冲输出流:BufferedOutputStream
构造方法:一般使用默认的缓冲器大小即可
BufferedOutputStream(OutputStream out):使用默认输出缓冲区的缓冲字符输出流
BufferedOutputStream(OutputStream out, int size):指定输出缓冲区的缓冲字符输出流
字节缓冲输入流:BufferedInputStream
BufferedInputStream(InputStream out):使用默认输出缓冲区的缓冲字符输出流
BufferedInputStream(InputStream out, int size):指定输出缓冲区的缓冲字符输出流
例:传输视频文件:
public static void main(String[] args) throwsIOException {
BufferedInputStream buf= new BufferedInputStream(new FileInputStream("D:\\Wet_Download\\Baiduyun_Download\\day20\\avi\\20.01_IO流(递归概述和注意事项).avi"));
BufferedOutputStream bof= new BufferedOutputStream(new FileOutputStream("D:\\Wet_Download\\copy.avi"));byte[] bys = new byte[1024];intlen;while((len = buf.read(bys)) != -1) {
bof.write(bys,0, len);
}
}
3.4 转换流
字符流=字节流+编码表
编码表:由现实世界额字符和对应的数值组成的一张表
ASCII码表,最高位为符号位,其余为数值位
ISO-8859-1,拉丁码表,8位表示一个数据
gb2313:中文编码表
gbk:
Unicode:国际标准码,融合了一个文字,所有文字都用两个字节表示,java使用的都是Unicode
Utf-8:最多用三个字节来表示一个字符,使用尽可能少的字节数来表示一个字符
String类中的编码与解码问题:
String(byte[] bytes, String charsetName):通过指定的字符集解码字节数组byte[] getBytes(string charsetName):使用指定的字符集合将字符串编码为字节数组
windows:默认本地系统编码为GBK
public static void main(String[] args) throwsUnsupportedEncodingException {byte[] bys = "你好".getBytes("GBK");
System.out.println(Arrays.toString(bys));//[-60, -29, -70, -61]
String ss = new String(bys, "GBK");
System.out.println(ss);byte[] bts = "你好".getBytes("UTF-8");
System.out.println(Arrays.toString(bts));//[-28, -67, -96, -27, -91, -67]
String bs = new String(bts, "UTF-8");
System.out.println(bs);
}
3.4.1 字符流(转换流)
3.4.1 OutputStreamWriter
构造方法:
OutputStreamWriter(OutputStream out):创建一个使用默认字符编码的OutputStreamWriter
OutputStreamWriter(OutputStream out, Charset cs):创建一个使用给定字符集的OutputStreamWriter
OutputStreamWriter(OutputStream out, CharsetEncoder enc):创建一个使用给定字符集编码器的OutputStreamWriter
OutputStreamWriter(OutputStream out, Striing charsetName):创建一个使用命名字符集的OutputStreamWriter
public static void main(String[] args) throwsIOException {
OutputStreamWriter osv= new OutputStreamWriter(new FileOutputStream("xiaojignzi.txt"), "UTF-8");
osv.write("中国");
osv.close();
}
接口方法:
public void write(int c):写一个字符
public void write(char[] cbuf):写一个字符数组
public void write(char[] cbuf,int off, int len):写一个字符数组的一部分
public void write(Striing str):写一个字符串
public void write(String str, int off, int len):写一个字符串的一部分
public static void main(String[] args) throwsIOException {
OutputStreamWriter osw= new OutputStreamWriter(new FileOutputStream("xiaojignzi.txt"));char[] ch = {'a', 'b', 'c'};
osw.write("小镜子");
osw.write(ch);
osw.write(ch,0, 1);
osw.write("小君子", 0, 1);
osw.flush();
osw.close();//先刷新后关闭
}
3.4.2 InputStreamReader
构造方法:
InputStreamReader(InputStream in):创建一个使用默认字符集的InputStreamReader
InputSteamReader(InputStream in, Charset cs):创建一个使用给定字符集的InputStreamReader
InputStreamReader(InputStream in, CharsetDecoder dec):创建一个使用给定字符集编码器的InputStreamReader
InputStreamReader(InputStream in, String charsetName):创建一个使用命名字符集的InputStreamReader
public static void main(String[] args) throwsIOException {
InputStreamReader isr= new InputStreamReader(new FileInputStream("xiaojignzi.txt"), "GBK");int ch = 0;while((ch = isr.read()) != -1) {
System.out.print((char)ch);
}
isr.close();
}
使用什么编码方式写的数据,则以哪种编码方式写数据
接口方法:
public int read():一次读取一个字符
public read(char[] chs):一次读取一个字符数组
public static void main(String[] args) throwsIOException {
OutputStreamWriter osw= new OutputStreamWriter(new FileOutputStream("xiaojingzi.txt"), "UTF-8");
osw.write("xiaojingzi\r\n微信开发者工具");
osw.close();
InputStreamReader ops= new InputStreamReader(new FileInputStream("xiaojingzi.txt"), "UTF-8");
OutputStreamWriter ors= new OutputStreamWriter(new FileOutputStream("xiaojunzi.txt"), "UTF-8");char[] ch = new char[1024];int len = 0;while((len = ops.read(ch)) != -1) {
ors.write(ch,0, len);
}
ors.close();
ops.close();
}
3.4.3 FileWriter:采用本地的编码方式
OutputStreamWriter的子类
构造方法:
FileWriter(File file):File指定文件名
FileWriter(File file, boolean append):File指定文件名,并确定是否追加
FileWriter(FileDescriptor fd):
FileWriter(String fileName):用String指定文件名
FileWriter(String fileName, boolean append):用String指定文件名,并确定是否追加
3.4.4 FileReader:采用本地的编码方式
InputStreamReader的子类
构造方法:
FileReader(File file):指定的file读取
FileReader(FileDescriptor fd):给定的FileDescriptor读取
FileReader(String fileName):给出读取文件的名称
public static void main(String[] args) throwsIOException {
FileReader fr= new FileReader("D:\\Wet_Download\\Baiduyun_Download\\04.Python3.5 装饰器编程 18课\\源码\\内置方法.py");
FileWriter fw= new FileWriter("D:\\wang.txt");char[] ch = new char[1024];int len = 0;while((len = fr.read(ch)) != -1) {
fw.write(ch,0, len);
}
fw.close();
fr.close();
}
3.4.5 字符缓冲输出流:BufferedWriter,如果是追加写,FileWriter("文件名", true)
构造方法:
BufferedWriter(Writer in):创建使用默认大小的输入缓冲区缓冲区字符输入流
BufferedWriter(Writer in, int sz):创建使用指定大小的输入缓冲区字符输入流
接口方法:
public void newLine():根据系统来产生一个换行符
3.4.6 字符缓冲输入流:BufferedReader
构造方法:
BufferedReader(Reader in):创建使用默认大小的输入缓冲区缓冲区字符输入流
BufferedReader(Reader in, int sz):创建使用指定大小的输入缓冲区字符输入流
接口方法:
public String readLine():一次读取一行数据
不包含换行符,读不到新行放回null
public static void main(String[] args) throwsIOException{
BufferedReader br= new BufferedReader(new FileReader("xiaojingzi.txt"));
BufferedWriter bw= new BufferedWriter(new FileWriter("wanwang.txt"));char[] chs = new char[1024];int len = 0;while((len = br.read(chs)) != -1) {
bw.write(chs,0, len);
}
br.close();
bw.close();
}
按照行复制文件的案例:
public static void main(String[] args) throwsIOException {
BufferedReader br= new BufferedReader(new FileReader("xiaojingzi.txt"));
BufferedWriter bw= new BufferedWriter(new FileWriter("hh.txt"));
String line= null;while((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
}
}
复制多级文件的案例
packagedat_20;importjava.io.BufferedInputStream;importjava.io.BufferedOutputStream;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.IOException;public classMoreFile {public static void main(String[] args) throwsIOException {
File srcFile= new File("D:\\简历");
File destFile= new File("D:\\move");
System.out.println(destFile.mkdir());
copyFolder(srcFile, destFile);
}public static void copyFolder(File srcFile, File destFile) throwsIOException {if(srcFile.isDirectory()) {
File newFolder= newFile(destFile, srcFile.getName());
newFolder.mkdir();
File[] fileArray=srcFile.listFiles();for(File file : fileArray) {
copyFolder(file, newFolder);
}
}else{
File newFile= newFile(destFile, srcFile.getName());
copyFile(srcFile, newFile);
}
}public static void copyFile(File srcFile, File destFile) throwsIOException {
BufferedInputStream bis= new BufferedInputStream(newFileInputStream(srcFile));
BufferedOutputStream bos= new BufferedOutputStream(newFileOutputStream(destFile));byte[] bys = new byte[1024];int len = 0;while((len = bis.read(bys)) != -1) {
bos.write(bys,0, len);
}
bos.close();
bis.close();
}
}
学生类根据总分从分高到低排序:
public static void main(String[] args) throwsIOException{
TreeSet ts = new TreeSet(new Comparator(){
@Overridepublic intcompare(Student o1, Student o2) {int num1 = o2.getSum() -o1.getSum();int num2 = num1 == 0 ? o2.getChinese() -o1.getChinese() : num1;int num3 = num2 == 0 ? o2.getMath() -o1.getMath() : num2;int num4 = num3 == 0 ?o2.getName().compareTo(o1.getName()) : num3;returnnum4;
}
});for(int x = 0; x < 5; x++){
Student st= newStudent();
Scanner sc= newScanner(System.in);
System.out.println("please input student grade" +x);
System.out.println("please input student name");
st.setName(sc.nextLine());
System.out.println("please input chinese grade");
st.setChinese(sc.nextInt());
System.out.println("please input math grade");
st.setMath(sc.nextInt());
System.out.println("please input english grade");
st.setEnglish(sc.nextInt());
ts.add(st);
}
BufferedWriter bw= new BufferedWriter(new FileWriter("Student"));
bw.write("学生成绩如下:");
bw.newLine();
bw.flush();
bw.write("姓名,语文成绩,数学成绩,英语成绩");
bw.newLine();
bw.flush();for(Student s : ts){
StringBuilder sb= newStringBuilder();
sb.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getMath()).append(",").append(s.getEnglish());
bw.write(sb.toString());
bw.newLine();
bw.flush();
}
bw.close();
System.out.println("学生信息存储完毕");
}
模拟BufferedReader 的readLine()功能
public classMyBufferedReader {privateReader r;publicMyBufferedReader(Reader r){this.r =r;
}public String readLine() throwsIOException{
StringBuffer sb= newStringBuffer();int ch = 0;while((ch = r.read()) != -1){if(ch == '\r'){continue;
}else if(ch == '\n'){returnsb.toString();
}else{
sb.append((char)ch);
}
}if(sb.length() > 0){returnsb.toString();
}return null;
}public void close() throwsIOException{this.r.close();
}
}
3.4.7 LineNumberReader(BufferedReader的子类)
int getLineNumber():获取行号
void setLineNumber(int):设置行号
public static void main(String[] args) throwsIOException{
LineNumberReader lnr= new LineNumberReader(new FileReader("s"));
lnr.setLineNumber(10);
String line= null;while((line = lnr.readLine()) != null){
System.out.println(lnr.getLineNumber()+ ":" +line);
}
lnr.close();
}
3.4.8 为了保证文件只创建一次,可以使用静态代码块
private static File file = new File("文件名");static{try{
file.createNewFile();
}catch(IOException e){
System.out.println("创建文件夹失败");
}
}
3.5 操作基本数据类型的流
3.5.1 DataInputStream:数据输出流允许应用程序将适当方式将基本Java数据类型输入流中,应用数据可以使用数据输入流将数据读入
构造方法:DataOutputStream(OutputStream out):创建一个新的数据输入流,将数据写入指定基础输出流
3.5.2 DataOutputStream:数据输出流使应用程序以便携式方式将原始Java数据类型写入输出流。 然后应用程序可以使用数据输入流来读取数据。
构造方法:DataInputStream(InputStream input):创建一个新的数据输出流,将数据读出
public static void main(String[] args) throwsIOException{//write();
read();
}public static void write() throwsIOException{
DataOutputStream dos= new DataOutputStream(new FileOutputStream("dos.txt"));
dos.writeByte(10);
dos.writeShort(100);
dos.writeInt(1000);
dos.writeChar('a');
dos.writeFloat(23.878f);
dos.writeDouble(343.38);
}public static void read() throwsIOException{
DataInputStream dip= new DataInputStream(new FileInputStream("dos.txt"));byte b =dip.readByte();short s =dip.readShort();int i =dip.readInt();char c =dip.readChar();float f =dip.readFloat();double d =dip.readDouble();
dip.close();
System.out.println((int)c);
}
3.6 内存操作流
操作字节数组:
ByteArrayInputStream:包含了一个内部缓冲区,该缓冲器可以从流中读取字节,内部计数器跟踪read方法要提供的下一个字节,关闭ByteArrayInputStream无效,此类中的方法在关闭此流后仍可以被调用,而不会产生任何的IOException.
ByteArrayOutputStream:此类实现了一个输出流,其中的数据被写入一个byte数组,缓冲区会随着数据的不断写入自动增长,可以使用toByteArray()和toString()获取数据
操作字符数组:
CharArrayReader
CharArrayWrite
操作字符串:
StringReader
StringWriter
public static void main(String[] args) throwsIOException{
ByteArrayOutputStream baos= newByteArrayOutputStream();for(int x = 0; x < 20; x++){
baos.write(("hello" +x).getBytes());
}byte[] bys =baos.toByteArray();
System.out.println(Arrays.toString(bys));//不需要释放资源
ByteArrayInputStream bais = newByteArrayInputStream(bys);int by = 0;while((by = bais.read()) != -1){
System.out.print((char)by);
}
}
3.7 打印流:
字节打印流:PrintStream
字符打印流:PrintWriter:
特点:
1. 只能操作目的地,不能操作数据
2. 可以操作任意类型的数据
3. 如果启动了自动刷新,可以自动刷新
4. 可以操作文件的流
public static void main(String[] args) throwsIOException{
PrintWriter pw= new PrintWriter(new FileWriter("pw.txt"), true);//带true实现了自动刷新的功能,但是需要调用println方法才可以
pw.write("hello");
pw.write("world");
pw.write("java");//pw.close();
pw.print(true);
pw.print(100);
pw.print("heool");
pw.print("wangjing");
pw.println("xiaojingzi"); //实现了换行
/*println相当于实现了
*write();
*newLine();
*flush();
*三种方法的操作*/pw.close();
}
使用打印流实现复制文本文件
public static void main(String[] args) throwsIOException{/*BufferedWriter bw = new BufferedWriter(new FileWriter("copy.java"));
BufferedReader br = new BufferedReader(new FileReader("Student"));
String line = null;
while((line = br.readLine()) != null){
bw.write(line);
bw.newLine();
bw.flush();
}
bw.close();
br.close();*/BufferedReader br= new BufferedReader(new FileReader("Student"));
PrintWriter pw= new PrintWriter(new FileWriter("copy.java"), true);
String line= null;while((line = br.readLine()) != null){
pw.println(line);
}
br.close();
pw.close();
}
3.8 标准输入输出流
System类中有两个成员变量:
public static final InputStream in "标准"输入流
public static final PrintStream out "标准"输出流
InputStream is = System.in;
PrintStream ps = System.out;
public static voidmain(String[] args){//本质是把IO流输出到控制台(默认输出设备控制台,输入设备是键盘)
System.out.println("helloworld");
PrintStream ps=System.out;
ps.println("xiaojignzi");//ps.print(); 报错
ps.println();
}
键盘录入数据:
A:main方法的args接收数据
B:Scanner(JDK5以后)
Scanner sc = new Scanner(System.in)
String s = sc.nextLine();
注:Scanner容易出现的小问题
先获取Int再获取字符串时,导致输入一个Int以后便不需要再输入,然后字符串读取的只是回车符。
C:通过字符缓冲流包装标准的输入流实现:BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
public static void main(String[] args) throwsIOException{
BufferedReader br= new BufferedReader(newInputStreamReader(System.in));/*上述的语句等价为
* InputStream is = System.in;
* InputStreamReader isr = new InputStreamReader(is);
* BufferedReader br = new BufferedReader(isr);*/System.out.println("请输入一个字符串");
String line=br.readLine();
System.out.println("您输入的字符串是:" +line);
System.out.println("请输入一个整数");int i =Integer.parseInt(br.readLine());
System.out.println("您输入的整数是:" +i);
}
输出数据到控制台
public static void main(String[] args) throwsIOException{
BufferedWriter bw= new BufferedWriter(newOutputStreamWriter(System.out));/** PrintStream ps = System.out;
* OutputStream os = ps; (OutputStream os = System.out;) 多态
* OutputStreamWriter osw = new OutputStreamWriter(os)
* BufferedWriter bw = new BufferedWriter(osw);*/bw.write("hello");
bw.newLine();
bw.write("world");
bw.newLine();
bw.write("xiaojignzi");
bw.flush();
}
3.9 RandomAccessFile
RandomAccessFile类不属于任何流,是Object类的子类,融合了InputStream和OutputStream的功能,支持对随机访问文件的读取和写入
有四种模式,常用是rw可以同时读写,文件不存在将尝试创建
public static void main(String[] args) throwsIOException {
write();
read();
}public static void read() throwsIOException {
RandomAccessFile raf= new RandomAccessFile("raf.txt", "rw");int i =raf.readInt();
System.out.println(i);
System.out.println("当前文件的指针是:" + raf.getFilePointer()); //4 int 类型数据占四个字节
char ch =raf.readChar();
System.out.println(ch);
System.out.println("当前文件的指针位置是:" + raf.getFilePointer()); //6 char 类型数组占两个字节
String s=raf.readUTF();
System.out.println(s);
System.out.println("当前文件的指针位置是:" + raf.getFilePointer()); //14 先读取两个字节,再读取后面的字节
raf.seek(4);
ch=raf.readChar();
System.out.println(ch);//a
raf.close();
}public static void write() throwsIOException {
RandomAccessFile raf= new RandomAccessFile("raf.txt", "rw");
raf.writeInt(100);
raf.writeChar('a');
raf.writeUTF("小哈");
raf.close();
}
3.10 SequenceInputStream表示其它输入流的逻辑串联,它从输入流的有序集合开始,并从第一个输入流开始读取,直到文件的末尾,接着从第二个输入流读取,依次类推,直到最后一个输入流文件的末尾为止
合并流读取两个文件的内容复制到一个文件中
public static void main(String[] args) throwsIOException{
InputStream is1= new FileInputStream("dos.txt");
InputStream is2= new FileInputStream("pw.txt");
SequenceInputStream sis= newSequenceInputStream(is1, is2);
BufferedOutputStream bos= new BufferedOutputStream(new FileOutputStream("copy"));byte[] bys = new byte[1024];int len = 0;while((len = sis.read(bys)) != -1){
bos.write(bys,0, len);
}
bos.close();
sis.close();
}
合并多个文件:
public static void main(String[] args) throwsIOException{
Vector v = new Vector();
InputStream s1= new FileInputStream("copy");
InputStream s2= new FileInputStream("dos.txt");
InputStream s3= new FileInputStream("copy.java");
v.add(s1);
v.add(s2);
v.add(s3);
Enumeration en =v.elements();
SequenceInputStream sis= newSequenceInputStream(en);
BufferedOutputStream bos= new BufferedOutputStream(new FileOutputStream("xiaojigzi"));byte[] byt = new byte[1024];int len = 0;while((len = sis.read(byt)) != -1){
bos.write(byt,0, len);
}
sis.close();
bos.close();
}
3.11 序列化与反序列化流
序列化流:ObjectOutputStream:将JAVA对象的基本数据类型写入OutputStream,可以使用ObjectInputStream读取(重构对象),可以使用文件来实现对象的持久存储,如果流是网络套接字节流,可以再另一台主机或者另一个进程中重构对象
反序列化流:ObjectInputStream
NotSerializableException:未序列化异常
类通过实现java.io.Serializable 接口以启用序列化功能,未实现此接口无法进行任何的序列化和反序列化。该接口中没有任何的方法需要实现。没有方法的接口被称为标记接口。
private static final long serialVersionUID = 1087170578858793875L;产生序列化
public static void main(String[] args) throwsIOException, ClassNotFoundException{//write();
read();
}public static void write() throwsIOException, IOException{
ObjectOutputStream oos= new ObjectOutputStream(new FileOutputStream("xiao"));
Person p= new Person("wangjing", 20);
oos.writeObject(p);
oos.close();
}public static void read() throwsIOException, ClassNotFoundException{
ObjectInputStream oos= new ObjectInputStream(new FileInputStream("xiao"));
Object obj=oos.readObject();
oos.close();
System.out.println(obj);//多态调用的是子类的方法
}
如何不序列化对象的成员变量:使用transient修饰 private transient int age;
3.12 Properties类:属性集合类,是一个可以和IIO流相结合的集合类
表示一个持久的属性集,Properties可以保存在流中或者从流中加载,属性列表中每个键和对应的值都是一个字符串
Properties作为map集合使用
public static voidmain(String[] args){
Properties prop= newProperties();
prop.put("it001", "hello");
prop.put("it002", "world");
prop.put("it003", "java");
Set set =prop.keySet();for(Object key : set){
Object value=prop.get(key);
System.out.println(key+ "-----" +value);
}
}
Properties的特殊功能使用
public Object setProperty(String key, String value):添加元素
public String getProperty(String key):获取元素
public Set stringPropertyNames():获取所有键的集合
public static voidmain(String[] args){
Properties prop= newProperties();
prop.setProperty("张三", "30");
prop.setProperty("李四", "40");
prop.setProperty("王五", "30");
Set set =prop.stringPropertyNames();for(String key : set){
String value=prop.getProperty(key);
System.out.println(key+ "----" +value);
}
}
Properties与IO流结合使用
public void load(Reader reader):把文件中的数据读取到集合中
public void store(Writer writer, String comments):把集合中的数据存储到文件
public static void main(String[] args) throwsIOException{
myStore();
}public static void myLoad() throwsIOException{
Properties prop= newProperties();
Reader r= new FileReader("prop.txt");
prop.load(r);
r.close();
System.out.println("prop" +prop);
}public static void myStore() throwsIOException{
Properties prop= newProperties();
prop.setProperty("wangjing", "30");
prop.setProperty("ixaoxiao", "10");
prop.setProperty("wang", "30");
Writer w= new FileWriter("wang.txt");
prop.store(w,"heoolworld"); //"heoolworld"是注释
w.close();
}
判断文件中是否有指定的键,如果有就修改值
public static void main(String[] args) throwsIOException{
Properties prop= newProperties();
Reader r= new FileReader("wang.txt");
prop.load(r);
r.close();
Set set =prop.stringPropertyNames();for(String key : set){if("wang".equals(key)){
prop.setProperty(key,"100"); // 替换break;
}
}
Writer w= new FileWriter("wang.txt");
prop.store(w,null);
w.close();
}
3.13 NIO包下的IO流
JDK4出现NIO,新IO和传统的IO有相同的目的,都是用于进行输入输出的额,但新的IO使用了不同的方式来处理输入输出的,采用内存映射文件的方式。将文件或者文件的一段区域映射到内存中,就可以像访问内存一样的来访问文件了,这样的效率比旧的IO要高很多。
Path:路径
Paths:有一个静态方法返回一个路径
public static Path get(URI uri)
Files:提供了静态方法供我们使用
public static long copy(Path source, OutputStream out)
public static Path write(Path path, Iterable extends CharSequence> lines, Charset cs, OpenOption... options)
public static void main(String[] args) throwsIOException, IOException{
Files.copy(Paths.get("prop.txt"), new FileOutputStream("copy.java")); //复制文件
ArrayList array = new ArrayList();
array.add("hello");
array.add("wrold");
array.add("java");
Files.write(Paths.get("array.txt"), array, Charset.forName("GBK"));
}