IO流：
IO流是用来处理设备之间的数据传输的。
java对数据的操作是通过流的方式。
java用于操作流的对象都在IO包中。
流按操作的数据分为两种：字符流和字节流。
字符流的由来：字符流其实就是字节流读取文字字节数据后，不直接操作而是先查指定的编码表， 获取对应的文字。再对这个文字进行操作。
简单说，就是字符流=字节流+编码表。
字节流的抽象基类(就是顶层父类)：InputStream,OutputStream
字符流的抽象基类：Reader,Writer
这些体系的子类都以父类名作为后缀，而子类名的前缀就是该对象的功能。
就从熟悉的文字开始学习，也就是字符流：
//需求：将一些文字存入到硬盘中。（记住：如果要操作文字，优先考虑字符流，而且要将文字存到硬盘上，要用输出流——writer）
// 硬盘的数据基本体现是文件。所以就找到了FileWriter.
package day20;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo {
public static void main(String[] args) throws IOException {
/*创建一个可以往文件中写入字符数据的字符输出流对象。
* 既然是往一个文件中写入文字数据，那么在创建对象时就必须明确该文件（用于存储数据的目的地）
* 如果文件不存在就会自动创建。如果存在就会被覆盖。
* */
FileWriter fw=new FileWriter("demo.txt");
/*
* 调用Writer对象中的write(String)方法写入数据。
* 这样做后数据就写入到了临时存储缓冲区中。
* */
fw.write("abcde");
/*
* 要将数据存储到目的地，还需要进行刷新操作。
* */
fw.flush();
/*
* 关闭流，关闭资源。在关闭前会调用flush刷新缓冲区的数据到达目的地。
* */
fw.close();
//fw.write("haha"); //这句话就会抛出异常，流都关闭了，不能再往进写了。
/* flush与close区别：
* flush可以刷新多次，close只能一次
* flush相当于文件写入新数据保存后，文件没关闭，刷新一下，就会看到新的内容，然后还可以继续写，可以反复这样做，重复多次。
* close会自动调用flush就相当于你关闭文件时，系统会提示你文件未保存是否要保存一样，点了保存，但是如果要查看，就必须再次打开文件，这就相当于重新打开了一个流。所以说close只能刷新一次。
* */
/* 两个小问题：
* 1.换行：
* 如果要在文件中第一行写abcd 第二行写haha 怎么操作呢？
* 方法一：windows系统的换行\r\n
* \n是不行的，记事本是windows操作软件，不认识这个。
* fw.write("abcde\r\nhaha");
* 方法二：unix系统的换行。先要声明LINE_SEPARATOR
* private static final String LINE_SEPARATOR = System.getProperty("line.separator");
* fw.write("abcde"+LINE_SEPARATOR+"haha");
* 2.续写：
* 如果写好了数据之后，又想要添加新的内容，还不想覆盖原来的，怎么操作？
* 看下API里FileWriter的构造函数，可以知道在创建对象时，加上true就行了。
* FileWriter fw=new FileWriter("demo.txt"，true);
* */
}
}
IO异常的处理方式：
package day20;
import java.io.FileWriter;
import java.io.IOException;
/*
* IO异常处理：
* 1.在try外面创建对象，里面初始化。
* 2.close放在finally中，而且记得要判断对象是否为空。
* 如果创建的文件地址不存在，就不需要close。
* */
public class IOExceptionDemo {
public static void main(String[] args) {
FileWriter fw=null;
try {
fw=new FileWriter("demo.txt");
fw.write("abcde");
}catch (Exception e) {
System.out.println(e.toString());
}finally{
if(fw!=null)
try {
fw.close(); //fw对象在try代码块中创建的，所以这样会异常。
} catch (IOException e) {
throw new RuntimeException("关闭失败");
}
}
}
}
//需求：读取一个文本文件，将读取到的字符打印。和上面Writer类似，找到了FileReader。
package day20;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo {
public static void main(String[] args) throws IOException {
/*
* 创建读取字符数据的流对象。
* 在创建读取流对象时，必须明确被读取的文件，一定要确定该文件是存在的。
* 用一个读取流关联一个已存在的文件。
* */
FileReader fr=new FileReader("demo.txt");
//用read方法读取文件中的内容。返回的是int
int ch=0;
while((ch=fr.read())!=-1){
System.out.println((char)ch);
}
/*
* int ch=fr.read();
* System.out.println(ch);
* int ch1=fr.read();
* System.out.println(ch1);
* fr.close(); //如果文件读完了，就返回-1.不过这样写太麻烦了。
* */
/* 使用read(char[])读取文本文件数据。
* char[] buf=new char[3];
* int len=0;
* while((len=fr.read(buf))!=-1){
* System.out.println(new String(buf,0,len));
* }
* */
}
}
了解几个类：
System类:
System类中的方法都是静态的。
常用方法：
currentTimeMillis();获取当前时间的毫秒值。两个一减就能算出程序运行的时间。
getProperty(); 确定当前的系统属性。
properties集合是map的子集，其中存储的都是String类型的键和值。键是固定的，不同机器属性不同，所以键对应的值就不同。
最好使用它自己的存储和取出的方法来完成元素的操作。比如换行操作：通常我们知道的是unix系统中的\n，windows系统就是\r\n，其他系统可能还不一样，java最牛的就是跨平台性，怎么解决呢？
其实系统属性中就有换行的操作，所以只需要调用getProperty()方法中的line.separator键，就可获取他的值，就是换行操作。
例如：System.out.println("hello"+System.getProperty("line.separator")+"world");
这句代码在任何系统都可以获取该系统的回车符，从而实现换行操作。很常用,通常会把他定义成常量来使用。
private static final String LINE_SEPARATOR = System.getProperty("line.separator");
System.out.println("hello"+LINE_SEPARATOR+"world");
setProperty("key","value"); 给系统设置一些属性信息，这些信息是全局的，其他程序都可以使用。
Runtime类：
没有构造方法摘要，这说明该类不可以创建对象。
又发现还有非静态的方法，说明该类应该提供静态的返回该类对象的方法。
而且发现静态方法只有一个，说明runtime类使用了单例设计模式。
package day20;
import java.io.IOException;
public class RunTimeDemo {
public static void main(String[] args) throws IOException {
Runtime r=Runtime.getRuntime(); //返回与当前 Java 应用程序相关的运行时对象。
//execute:执行 xxx.exe
r.exec("notepad.exe"); //开启执行文件——记事本。
//先在当前文件目录找notepad，没找到，然后去path找，找到了。
//如果执行qq就异常了，因为qq不在path目录下，找不到文件。
Process p=r.exec("notepad.exe");
p.destroy(); //结束子进程。只能结束r.exec()开启的。
}
}
Math类：
math提供了操作数学运算的方法。都是静态的。
常用方法：
abs(); 返回绝对值
ceil(); 返回大于参数的最小整数
floor(); 返回小于参数的最大整数
round(); 返回四舍五入的整数。
pow(a,b); 返回a的b次方
random(); 产生一个大于0小于1的double类型的值。利用这个可以产生随机数。
比如要产生1-10的随机数：Math.ceil（Math.random()*10）;
Date类：
after(date) 测试此日期是否在指定日期之后。
bofore(date) 测试此日期是否在指定日期之前。
compareTo(date) 比较两个日期是否相等。
package day20;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateDemo {
public static void main(String[] args) {
long time=System.currentTimeMillis();
System.out.println(time);
Date date=new Date(); //将当前日期时间封装成Date对象
System.out.println(date); //输出结果就是当前时间Sun May 21 17:14:18 CST 2017
Date date2=new Date(time); //将time代表的毫秒值封装成Date对象
System.out.println(date2); //输出的是time对应的日期时间。
/*日期对象和毫秒值之间的转换
*
* 毫秒值转换成日期：
* 因为可以通过Date对象的方法对该日期的各个字段（年月日）进行操作。
* 1.通过date对象的构造方法new Date(timeMillis)。比如上面例子
* 2.也可以通过setTime设置。
* 日期对象转换成毫秒：
* 因为可以通过具体的数值进行运算。
* 1.通过getTime方法
*/
//对日期对象进行格式化
Date date3=new Date();
DateFormat dateformat=DateFormat.getDateInstance(); //获取日期格式对象，具备着默认的风格。
//DateFormat dateformat=DateFormat.getDateInstance(DateFormat.FULL); //这是另一种格式，上面的是默认格式，还有其他的格式。
dateformat=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
String str_date=dateformat.format(date3);
System.out.println(str_date);
//自定义格式
dateformat=new SimpleDateFormat("yyyy-MM-dd");
String str_date1=dateformat.format(date3);
System.out.println(str_date1);
/*
* 将日期对象转成日期格式的字符串
* 使用的是DateFormat类中的format方法。比如上面的例子。
* 将日期格式的字符串转成日期对象
* 使用的是DateFormat类中的parse方法。
* */
/*
* 该程序运行结果为：
* 1496796013615
* Wed Jun 07 08:40:13 CST 2017
* Wed Jun 07 08:40:13 CST 2017
* 2017年6月7日 上午08时40分13秒
* 2017-06-07
* */
}
}
package day20;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateTest {
/*
* 练习："2017-5-17"到"2017-5-20"中间有多少天？
* 思路：
* 两个日期相减就行了，咋减？
* 必须要有两个可以进行减法运算的数才行。就可以用毫秒值。
* 如何获取毫秒值？通过date对象。
* 如何获取date对象？可以将字符串转成date对象。
*
* 1.将日期格式的字符串转成date对象。
* 2.将date对象转成毫秒值。
* 3.相减，变成天数。
*/
public static void main(String[] args) throws ParseException {
String str_Date1="2017--5--17";
String str_Date2="2017--5--20";
test(str_Date1,str_Date2);
}
public static void test(String str_Date1,String str_Date2) throws ParseException {
//1.将日期格式的字符串转成date对象。 定义日期格式对象
//DateFormat dateFormat=DateFormat.getDateInstance(); //这个是默认格式的日期，下面是自定义格式
DateFormat dateFormat=new SimpleDateFormat("yyyy--MM--dd");
Date date1=dateFormat.parse(str_Date1);
System.out.println(date1);
Date date2=dateFormat.parse(str_Date2);
System.out.println(date2);
//2.将date对象转成毫秒值。
long time1=date1.getTime();
long time2=date2.getTime();
//3.相减
long time=Math.abs(time1-time2);
System.out.println(time/1000/60/60/24);
/*
* 该程序运行结果为：
* Wed May 17 00:00:00 CST 2017
* Sat May 20 00:00:00 CST 2017
* 3
* */
}
}
Calendar类：
常用方法：
set(); 获取指定日期
add(); 日期的偏移
get(); 获取当前日期
package day20;
import java.util.Calendar;
public class CalendarDemo {
public static void main(String[] args) {
Calendar c=Calendar.getInstance();
c.set(2017, 5, 20);
c.add(Calendar.YEAR,-1);
showDate(c);
}
private static void showDate(Calendar c) {
int year=c.get(Calendar.YEAR);
int month=c.get(Calendar.MONTH)+1; //注意月份是0-11表示的，0表示1月以此类推。
int day=c.get(Calendar.DAY_OF_MONTH);
int week=c.get(Calendar.DAY_OF_WEEK); //周日是一周的第一天,所以这里要处理一下
System.out.println(year+"年"+month+"月"+day+"日"+" "+getWeek(week));
}
public static String getWeek(int i) {
String[] weeks={"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
return weeks[i];
}
}
例：
将C盘的一个文件复制到D盘
package day20;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CopyTextTest {
private static final int BUFFER_SIZE = 1024*3;
/*
* 需求：将C盘的一个文件复制到D盘
* 分析：读取C盘文件中的数据，并写入到d盘当中。（这就是复制的原理）
*/
public static void main(String[] args) throws IOException {
method_2(); //这个比较常用,效率高，读一大片写一次，循环次数少。
}
public static void method_1() throws IOException {
//1.读取一个已有的文本文件，使用字符读取流和文件相关联。
FileReader fr=new FileReader("demo.txt");
//2.创建一个目的，用于存储读到的数据。
FileWriter fw=new FileWriter("CopyText_1.txt");
//3.频繁的读写操作。
int ch=0;
while((ch=fr.read())!=-1){
fw.write(ch);
}
//4.关闭流资源。
fw.close();
fr.close();
}
public static void method_2() {
FileReader fr=null;
FileWriter fw=null;
try {
fr=new FileReader("demo.txt");
fw=new FileWriter("CopyText_2.txt");
//创建一个临时容器，用于缓存读取到的字符
char[] buf=new char[BUFFER_SIZE];
//定义一个变量记录往数组里装的字符的个数
int len=0;
while((len=fr.read(buf))!=-1){
fw.write(buf, 0,len);
}
} catch (IOException e) {
//System.out.println("读写失败");
throw new RuntimeException();
}
finally{
if(fr!=null)
try {
fr.close();
} catch (IOException e1) {
e1.printStackTrace();
}
if(fw!=null)
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字符流的缓冲区：
缓冲区的出现提高了对数据的读写效率。上面例子中BUFFER_SIZE就是自定义的缓冲区。
对应类：BufferWriter 特有方法：newline();
BufferReader 特有方法：readline();
缓冲区要结合流才可以使用。
在流的基础上对流的功能就行了增强。
package day20;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
public class BufferedDemo {
public static void main(String[] args) throws IOException {
bufferedWriter();
bufferedReader();
}
public static void bufferedWriter() throws IOException {
FileWriter fw=new FileWriter("demo.txt");
//为了提高写入效率，使用了字符流缓冲区。
//创建一个字符写入流的缓冲区对象，并和指定要被缓冲的流对象相关联。
BufferedWriter bufw=new BufferedWriter(fw);
//使用缓冲区的写入方法将数据写入到缓冲区中。
bufw.write("abcdef");
bufw.newLine();
bufw.write("wqnmlgb");
//使用缓冲区的刷新方法将数据刷新到目的地中。
bufw.flush();
//关闭缓冲区,其实关闭的就是被缓冲的流对象。
bufw.close();
}
public static void bufferedReader() throws IOException {
FileReader fr=new FileReader("demo.txt");
BufferedReader bufr=new BufferedReader(fr);
String line=null;
while((line=bufr.readLine())!=null){
System.out.println(line);
}
bufr.close();
}
}
例：模拟一个BufferedReader.
package day20;
import java.io.FileReader;
import java.io.IOException;
public class MyBufferReader {
/**
* 自定义读取缓存区，其实就是模拟一个BufferedReader.
* 分析：
* 缓冲区中无非就是封装了一个数组，并对外提供了更多的方法对数组进行访问。
* 其实这些方法最终操作的都是数组的角标。
*
* 缓冲的原理：
* 其实就是从源中获取一批数据装进缓冲区中，再从缓冲区中不断地取出一个一个数据。
* 此次取完后，再从源中继续取一批数据装进缓冲区，当源中的数据取完后，用-1作为结束标记。
*/
private FileReader r;
//定义一个数组作为缓冲区
private char[] buf=new char[1024];
//定义一个指针用于操作这个数组中的元素。当操作到最后一个元素后，指针归零。
private int pos=0;
//定义一个计数器用于记录缓冲区中数据个数。当该数据减为0，就从源中继续获取数据到缓冲区。
private int count=0;
MyBufferReader(FileReader r){
this.r=r;
}
public int myRead() throws IOException{
//1.从源中获取一批数据到缓冲区中。需要先做判断，只有计数器为0时，才需要从源中获取数据
if(count==0){
count=r.read(buf);
pos=0; //每次获取数据到缓冲区后，角标归零。
}
if(count<0)
return -1;
char ch=buf[pos++];
count--;
return ch;
/* 这样的代码是初稿，思路很清晰，上面是修改之后的。
if(count==0){
count=r.read(buf);
if(count<0)
return -1;
pos=0; //每次获取数据到缓冲区后，角标归零。
char ch=buf[pos];
pos++;
count--;
return ch;
}else if(count>0){
char ch=buf[pos];
pos++;
count--;
return ch;
}*/
}
public String myReadLine() throws IOException{
StringBuilder sb=new StringBuilder();
int ch=0;
while((ch=myRead())!=-1){
if(ch==‘\r‘)
continue;
if(ch==‘\n‘)
return sb.toString();
//将从缓冲区读到的字符，存储到缓存行数据的缓冲区中。
sb.append((char)ch);
}
if(sb.length()!=0){ //若没有这个if代码块，demo.txt的最后一行如果没有回车符，那么MyRead就会丢失最后一行。
return sb.toString();
}
return null;
}
public void myClose() throws IOException{
r.close();
}
}
package day20;
import java.io.FileReader;
import java.io.IOException;
public class MyBufferReaderDemo {
public static void main(String[] args) throws IOException {
FileReader fr=new FileReader("demo.txt");
MyBufferReader bufr=new MyBufferReader(fr);
String line=null;
while((line=bufr.myReadLine())!=null){
System.out.println(line);
}
bufr.myClose();
}
}
缓冲区中的read方法对FileReader中的Read进行了功能的加强，效率的提高。这就是装饰设计模式。
装饰设计模式：
对一组对象的功能进行增强时，就可以使用该模式就行问题的解决。
装饰和继承都具有一样的特点：进行功能的扩展。那么他们有何区别呢？
假如有一个继承体系：
Writer
|--TextWriter:用于操作文本
|--MediaWriter:用于操作媒体。
想要对操作的动作进行效率的提高，按照面向对象的思想，可以通过继承对具体对象进行功能的扩展。
效率提高需要加入缓冲技术。
Writer
|--TextWriter:用于操作文本
|--BufferTextWriter：加入了缓冲技术的操作文本的对象
|--MediaWriter:用于操作媒体。
|--BufferMediaWriter：加入了缓冲技术的操作媒体的对象
到这里就哦了，但是这样做好像并不理想。
如果这个体系就行功能扩展，又多了流对象。那么这个流要提高效率，是不是也要产生子类呢？对，这时就会发现只为提高功能，进行的继承，导致继承体系越来越臃肿。不够灵活。
重新思考这个问题？
既然加入的都是同一组技术——缓冲。前一种是让缓冲和具体的对象相结合。
可不可以将缓冲进行单独的封装，哪个对象需要缓冲就将那个对象和缓冲关联。
class BufferWriter extends Writer{
Buffer(Writer w){}
}
这时这个体系就变成了这样：
Writer
|--TextWriter:用于操作文本
|--MediaWriter:用于操作媒体
|--BufferWriter:用于提高效率
到这里就可以发现，装饰比继承更加灵活。特点：装饰类和被装饰类都必须所属同一个接口或者父类。
装饰设计模式的一个简单的演示
package day20;
public class PersonDemo {
public static void main(String[] args) {
Person p=new Person();
NewPerson p1=new NewPerson(p);
p1.chifan();
NewPerson2 p2=new NewPerson2();
p2.chifan();
/*
* 那么问题来了，继承也可以解决这种问题，他们有何区别呢？
*/
}
}
class Person{
void chifan(){
System.out.println("吃饭");
}
}
//这个类的出现是为了增强Person而出现的。
class NewPerson{
private Person p;
NewPerson(Person p){
this.p=p;
}
public void chifan(){
System.out.println("开胃酒");
p.chifan();
System.out.println("饭后甜点");
}
}
class NewPerson2 extends Person{
public void chifan(){
System.out.println("开胃酒");
super.chifan();
System.out.println("饭后甜点");
}
}
LineNumberReader 了解即可，可以读行号。
package day20;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
public class LineNumberReaderDemo {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
FileReader fr=new FileReader("demo.txt");
LineNumberReader lnr=new LineNumberReader(fr);
String line=null;
lnr.setLineNumber(100); //默认行号是从1开始的，这个方法可以自己设置从几开始。
while((line=lnr.readLine())!=null){
System.out.println(lnr.getLineNumber()+":"+line);
}
lnr.close();
}
}
到这里，字符流的基本对象学习完了，接下来学习字节流。
字节流
字节流的基本操作与字符流类相同。
但它不仅可以操作字符，还可以操作其他媒体文件。比如Copy一个jpg文件。
package day22;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
demo_write();
demo_read();
}
public static void demo_read() throws IOException {
/*
available()方法就是返回文件的字节数，用这个可以创建一个可文件长度刚好一样的为数组，读文件就简单多了
但是这个慎用，如果获取一个2G多的电影，累死你。
FileInputStream fis=new FileInputStream("demo2.txt");
byte[] buf=new byte[fis.available()];
fis.read(buf);
System.out.println(new String(buf));
*/
//还是这个最常用。
FileInputStream fis=new FileInputStream("demo2.txt");
byte[] buf=new byte[1024];
int len=0;
while((len=fis.read(buf))!=-1){
System.out.println(new String(buf,0,len));
}
fis.close();
/*
//1.创建一个读取流对象，和指定文件关联。
FileInputStream fis=new FileInputStream("demo2.txt");
//2.读数据。一次读取一个字节。读中文就不行，一个汉字两个字节。
int ch=0;
while((ch=fis.read())!=-1){
System.out.println((char)ch);
}
fis.close();
*/
}
public static void demo_write() throws IOException {
//1.创建字节输出流对象。用于操作文件。
FileOutputStream fos=new FileOutputStream("demo2.txt");
//2.写数据。直接写入到了目的地中。
fos.write("abcdefg".getBytes());
fos.close(); //不需要刷新了，但是关闭还是要的。
}
}
练习：复制一个mp3文件。
package day22;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyMp3Test {
/**
* 需求：复制一个mp3文件。其实和复制txt文件是一样的，就是换了一个对象。
*/
public static void main(String[] args) throws IOException {
copy_1();
copy_2();
}
public static void copy_2() throws IOException {
FileInputStream fis=new FileInputStream("LoginScreenLoop.mp3");
BufferedInputStream bufis=new BufferedInputStream(fis);
FileOutputStream fos=new FileOutputStream("CopyMp3.mp3");
BufferedOutputStream bufos=new BufferedOutputStream(fos);
int ch=0;
while((ch=bufis.read())!=-1){
bufos.write(ch);
}
bufos.close();
bufis.close();
}
public static void copy_1() throws IOException {
FileInputStream fis=new FileInputStream("LoginScreenLoop.mp3");
FileOutputStream fos=new FileOutputStream("CopyMp3.mp3");
byte[] buf=new byte[1024];
int len=0;
while((len=fis.read(buf))!=-1){
fos.write(buf,0,len);
}
fos.close();
fis.close();
}
}