黑马程序员-java学习笔记-IO

编码；字符串变成字节数组String-->byte[]  str.getBytes(charsetName);

解码；字节数组变成字符串byte[]-->String   new String(byte[] charsetName);

数组变成字符串；byte[] b   ; Arrays.toString(b)

IO流（Input Output）
*IO流用来处理设备之间的数据传输
*java对数据的操作时通过流的方式
*java用于操作流的对象都在IO包中
*流按照操作数据分为两种；字节流和字符流
*流按流向分为，输入流，输出流


*字节流的抽象基类
InputStream  OutputStream
*字符流的抽象基类
Reader     Writer


字符流
Writer的子类对象
FileWriter()//创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。
//而且该文件会被创建在制定目录下，如果该目录下已有同名文件，将被覆盖。
例如 第一步FileWriter f=new FileWriter("demo.txt")
第二部 f.write("abcd");//调用write方法，将字符串写入流中。
f.flush()//刷新流对象中的缓冲.将数据刷新到目的地
f.close()//刷新流资源，并关闭流资源。关闭后不可以使用。
IO异常的处理方式
示例；Public static void main(String[] args)
{
FileWriter f=null;//如果try内f发生异常close就会执行错误，先定义在外面
try
{
f=new FileWriter("demo.txt");
f.write("5545557488");
}
catch(IOException e)
{
System.out.println(e.toString());
}
finally
{
try
{
if(f!=null)
f.close();
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
已有文件的数据续写
FileWriter fw=new FileWriter("545545",ture);传递一个ture参数，代表不覆盖，在文件结尾处续写
fw.write("252545")//换行时\r\n


Reader;
FileReader fr=new FileReader("demo.txt");//创建一个文件读取流对象，和指定名称的文件关联，如果文件不存在就出现异常
int ch=fr.read();//调用读取方法，每次读取一个字符，如果超过长度就返回-1
所以这样读取
int ch=0
while((ch=fr.read())!=-1)
System.out.println((char)ch)
第二种方式，通过字符串数组进行读取
FileReader fr=new FileReader("demo.txt");
char[] buf=new char[3];//定义一个字符数组，用于存储督导的字符，该read（char[]）返回的是督导的字符个数,数组中一般定义1024的整数倍
int num=fr.read(buf);
System.out.println("num="+num+"..."+new String(buf));
-------------------------------------------
简化
int num=0;
while((num=fr.read(buf)!=-1))
System.out.println(new String(buf,0,num))
fr.close;
字符流的缓冲区
*缓冲区的出现提高了对数据的读写效率
*对应类
*BufferedWriter
*BufferedReader
*缓冲区要结合流才可以使用
*在流的基础上对流的功能进行了增强
    写入//先创建一个字符写入流对象
FileWriter fw=new FileWriter("demo.txt");
//为了提高字符写入流效率，加入了缓冲技术
//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可
BufferedWriter bufw=new BufferedWriter(fw);
buff.writer("55555");存入数据
bufw.newLine();换行，跨平台通用
bufw.close();//其实关闭缓冲区就是关闭流对象
读取//先创建读取流对象和关联文件
FileReader fr=new FileReader("demo.txt");
//为了提高效率，加入缓冲技术，将字符流读取对象作为参数传递给缓冲对象的构造函数。
BufferedReader bufr=new BufferedReader(fr);
//循环取出每行的数据，每行！！
String line=null;
while((line=bufr,reanLine())!=null)
System.out.println(line);

装饰设计模式；
当想要对已有的对象进行功能增强时。
可以定义类，将已有对象传入，基于已有功能，并提供加强功能。
那么自定义的该类称为装饰类。

装饰类通常会通过构造函数方法接收被装饰的对象。
并基于被装饰的对象的功能，提供更强的功能。

LineNumberReader;带行号，是BfferedReader的子类
setLineNumber()；设置行号
getLineNumber()；获取行号




字节流；InputStream；输出
OutputStream；输入
特有方法available() 长度获取返回int型数据

FileOutputStream fos=new FileOutputStream("fos.txt");
fos.write("54656".getBytes());//字符串转换成数组
fos.close（）//不需要刷新，但是需要关闭 

字节流缓冲区
BufferedOutputStream
BufferedInputStream

InputStreamReader是字节流通向字符流的桥梁
OutputStreamWriter是字符流通向字节流的桥梁
键盘录入最常见写法
***BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in))

流操作的基本规律；***********
1明确源和目的
源；输入流InputStream Reader
目的;OutputStream  Writer
2操作的数据是不是纯文本
是；字符流
不是；字节流
3当体系明确后，再明确要使用哪个具体的对象
通过设备来区分；
源设备；内存。硬盘，键盘
目的设备；内存，硬盘，控制台。

System方法里获取系统属性信息getProperties() ;静态的



File类（文件）
*用于将文件或文件夹封装成对象
*方便对于文件与文件夹的属性信息进行操作
*File对象可以作为参数传递给流的构造函数
*了解File类中的常用方法

流只能操作数据，而想要操作数据封装成的文件必须要用File

File f=new File("a.txt")//将a.txt 封装成File对象
//可以将已有的和未出现的文件或者文件夹封装成对象
File f2=new File("c:\\abc","a.txt")

File d=new File("c:\\abc")
File f3=new File(d,"a.txt")
//目录分隔符\\不可以跨平台，所以用File.separator代替
例如File f= new File("c:"+File.separator+"a.txt")

File类的常见方法
1创建  boolean createNewFile():在指定位置创建文件，如果文件已存在则创建失败，返回false，和输出流不一样
  boolean mkdir();  创建文件夹（一级）
  boolean mkdirs()；创建文件夹（多级）
2删除  boolean delete()；删除，删除失败返回false
  void  deleteOnExit();在程序退出时删除指定文件
3判断  boolean exists(); 判断文件是否存在
//下面两个方法判断之前，必须要先判断该文件对象封装的内容是否存在
  boolean isDirectory();判断对象是否是目录
  boolean isFile()；判断对象是否是文件
  boolean isHidden()；是否是隐藏
  boolean isAbsolute()；是否是绝对
4获取信息
  getName();获取名称
  getPath()；获取路径
  getParent()；获取父目录//该方法返回的是绝对路径中的父目录，否则返回null
  getAbsolutePath();获取绝对路径
  long lastModified();获取最后一次修改时间 
  long length()；获取文件大小
renameTo();重新命名此抽象路径名表示的文件。重命名
File f1=new File("c:\\a.txt")
File f2=new File("d:\\b.txt")
fi.renameTo(f2);f1命名为f2 并含有剪切功能

listRoot()；列出系统根目录，返回字符串数组
list()；用于获取指定目下所有文件名称，包含隐藏文件，返回字符串数组
listFiles();返回抽象路径名数组，列出目录

properties是hashtable的子类
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
是集合中和IO技术相结合的集合容器
特点；可以用于键值对形式的配置文件。
在加载数据时，需要有固定格式，通常为 ； 键=值
Properties p=new Properties();创建集合
p.setProperty("zhangsan","20");添加
p.setProperty("zhangsan","50");覆盖
p.getProperty();获取

load方法和store方法
Properties p=new Properties();
FileInputStream fis=new FileInputStream(“123.txt”);
p.load(fis);将流中的数据加载进集合
p.setProperty("zhangdan","20");这个方法改变的是内存中的结果，源文件未改动
FileOutputStream fos=new FileOutputStream("123.txt");
p.store(fos,"haha");这个才会更改源文件

store(OutputStream out,string c);这个方法需要接受个输出流


IO中其他类
打印流
PrintWriter与PrintStream可以直接操作输入流和文件
序列流
SequencelnputStream对多个流进行合并
操作对象
ObjectlnputStream与ObjectOutputStream被造作的对象需要实现Serializable(标记接口)


   *PrintStream的构造函数可以接受的参数类型；
1file对象  file
2字符串路径  String
3字节数出流OutputStream

   *PrineWriter的构造函数可以接收；
    1file对象
2字符串路径
3字节输出流OutputStream
4字符输出流Writer

管道流
PipedinputStream和PipedOutputStream  输入输出可以直接进行连接，结合线程使用
构造函数
PipedInputStream()
PipedInputStream(int pipeSixe)
PipedInputStream(PipedOutputStream src)
PipedInputStream(PipedOutputStream src，int pipeSixe)
方法
void close()
void connect(PipedOutputStream src)
int read()；读取管道输入流中的下一个字节
int read(byte[] b,int off,int len)


RandomAccessFile  只能操作文件
内部封装了数组，而且通过指针对数组元素进行操作
随机访问文件，自身具备读写的方法
通过skipBytes(int x)跳过指定的字节 ,seek(int x)设置指针 来达到随机访问
getFilePointer获取指针位置
seek 改变指针位置

操作基本数据类型
DatalnputStream--读与datalnOutputStream--写
DatalnOutputStream(OutputStream out)

操作字节数组
ByteArrayInputStream和ByteArrayOutputStream
ByteArrayInputStream；在构造时，需要接受数据源，而且数据源是一个字节数组
ByteArrayOutputStream；在构造时，不用定义数据目的，因为该对象内部已经封装了可变长度的字节数组
这两个流对象都操作字符数组，不用进行close操作，不用跑出异常
int size()返回缓冲区当前大小
void writeTo(OutputStream out)写入到输出流中
//数据源ByteArrayInputStream bis =new ByteArrayInputStream("uytutuy".getBytes())
//数据目的ByteArrayOutputStream bos= new ByteArrayOutputStream();
int by=0
while((by=bis.read)!=-1)
bos.write(by)


操作字符数组
CharArrayReader与CharArrayWrite

操作字符串
StringReader与StrangWriter