黑马训练营-学习笔记----JavaIO

------- android培训、java培训、期待与您交流！ ----------

 

System：类中的方法和属性都是静态的

out：标准输出，默认是控制台

in：标准输入，默认是键盘

描述系统一些信息

获取系统信息属性：Properties getProperties();

*/

import java.util.*;

class SystemDemo

{

         public static void main(String[] args)

         {

                  Properties prop = System.getProperties();

                  //因为Properties是Hashtale的子类，也就是Map集合的一个子类对象

                  //那么可以通过map的方法取出该集合中的元素

                  //该集合中存储的都是字符串，没有泛型定义

                  //在系统中定义一些特有信息

                  System.setProperty("mykey","mavalue");

                 

                  //获取指定属性信息

                  String value = System.getProperty("os.name");

                  System.out.println("value="+value);

 

                  //能否在jvm启动时，动态加载一些属性信息

                  String v = System.getProperty("haha");

                  System.out.println("v="+v);

                  /*

                  for(Object obj : prop.keySet())

                  {

                          String value = (String)prop.get(obj);

                          System.out.println(obj+"::"+value);

                  }

                  */

         }

}

 

properties是hashtable的子类

也就是说它具备map集合的特点，而且它里面存储的键值对都是字符串

 

是集合中和IO技术相结合的集合容器

该对象的特点：可以用于键值对形式的配置文件

那么在加载数据时，需要数据有固定格式：键=值

 

Runtime对象

该类并没有提供构造函数，说明不可以new对象，那么会直接想到该类中的方法都是静态的

发现该类中还有非静态方法，说明该类肯定会提供方法获取本类对象，而且该方法是静态的

         并且返回值类型是本类类型

有这个特点可以看出该类使用了单例设计模式

该方式是Static Runtime getRuntime();

 

File类常见方法

1.创建

         boolean createNewFile();

                 在指定位置创建文件，如果该文件已经存在，则不再创建，返回false

                 和输出流不一样，输出流对象一建立就会创建，而且如果有会覆盖

         boolean mkdir():创建文件夹

         boolean mkdirs():创建多级文件夹

2.删除

         boolean delete();删除失败时返回假

         void deleteOnExit();在程序退出时删除指定文件

3.判断

         boolean exists():文件是否存在

         boolean isFile()

         boolean isDirectory()

         boolean isHidden()

         boolean isAbsolute();判断是否是绝对路径E:\\JavaProgram\\Java_IO\\file.txt

 

4.获取信息

         String getName():

                     getPath():

                     getParent():

                    

                     getAbsolutePath()

           long lastModified()

           long length()

 

第一种读取方式，读取单个字符

*/

import java.io.*;

 

class FileReaderDemo

{

         public static void main(String[] args) throws IOException

         {

                  //创建一个文件读取流对象，和指定名称的文件相关联

                  //要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException

                  FileReader fr = new FileReader("FileWriterDemo.txt");

 

                  //调用读取流对象的read()方法

                  //read()方法一次只读一个字符，而且自动往下读

                  /*

                  while (true)

                  {

                          int ch = fr.read();

                          if(ch==-1)

                                   break;

                          System.out.println("ch="+(char)ch);

                  }

                  */

 

                  int ch = 0;

                  while((ch=fr.read())!=-1)

                  {

                          System.out.println((char)ch);

                  }

                 

                  fr.close();

         }

}

 

第二种读取方式：通过字符数组进行读取

*/

import java.io.*;

class FileReaderDemo2

{

         public static void main(String[] args) throws IOException

         {

                  FileReader fr = new FileReader("FileWriterDemo.txt");

 

                  //定义一个字符数组，用于存储读到的字符

                  //读read(char[])返回的是读到的字符个数

                  char[] buf = new char[1024];

                  int num = 0;

                  while((num=fr.read(buf))!=-1)

                  {

                          System.out.print(new String(buf,0,num));

                  }

                  fr.close();

         }

}

 

字符流和字节流

字节流的两个基类

         InputStream  OutputStream

字符流的两个基类

         Reader   Writer

字符流的特点

*/

import java.io.*;

class  FileWriterDemo

{

         public static void main(String[] args) throws IOException

         {

                  //创建一个FileWriter对象，该对象一被初始化就必须要明确要被操作的文件

                  //而且该文件会被创建到指定的目录下，如果该目录下已有同名文件，将被覆盖

                  //其实这一步就是在明确数据要存放的位置

                  FileWriter fw = new FileWriter("FileWriterDemo.txt");

                  //调用write方法，将字符串写入到流中

                  fw.write("FileWriter");

                  //刷新流对象中的缓冲中的数据

                  //将数据刷到目标文件中

                  fw.flush();

                  fw.write("haha");

                  fw.close();

                  //关闭流资源，但关之前会刷新流对象，将数据存入目标文件

                  //flush()刷新后还可以再write，但close()后不能再写

         }

}

 

字符读取流缓冲区

该缓冲区提供了一个一次读一行的方法readLine，方便对缓冲区数据的读取

当返回null时结束,readLine方法只返回回车符之前的数据内容，并不返回回车符

*/

import java.io.*;

class BufferedReaderDemo

{

         public static void main(String[] args) throws IOException

         {

                  //创建一个读取流对象和文件相关联

                  FileReader fr = new FileReader("buf.txt");

                  //为了提高效率，将字符读取流对象作为参数传递给缓冲对象的构造函数

                  BufferedReader bufr = new BufferedReader(fr);

                  String line = null;

                  while((line = bufr.readLine())!= null)

                  {

                          System.out.println(line);

                  }

                  bufr.close();

         }

}

 

缓冲区的出现是为了提高流的操作效率，所以在创建缓冲区之前，必须要先有流对象

该缓冲区提供了一个跨平台的换行符 newLine();

*/

import java.io.*;

class BufferedWriterDemo

{

         public static void main(String[] args) throws IOException

         {

                  //创建一个字符写入流对象

                  FileWriter fw = new FileWriter("buf.txt");

                  //为了提高写入流的效率，加入了缓冲技术

                  //只要将要被提高效率的流对象作为参数传递给缓冲区的构造函数即可

                  BufferedWriter bufw = new BufferedWriter(fw);

                  for(int i=0;i<5;i++)

                  {

                          bufw.write("abcde"+i);

                          bufw.newLine();

                          //只要用到缓冲区，就要记得刷新

                          bufw.flush();

                  }

                  //其实关闭缓冲区就是在关闭流对象

                  bufw.close(); //fw.close();

         }

}

 

列出指定目录下文件或者文件夹，包含子目录中的内容

也就是列出指定目录下所有内容

因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可

在列出过程中出现的还是目录的话，还可以再次调用本功能，也就是

函数自身调用自身。  这种表现形式或者编程手法成为递归

 

打印流：

该流提供了打印方法，可以将各种数据类型的数据都原样打印

字节打印流：printStream

         构造函数可以接受的参数类型：

         1.file对象  file

         2.字符串路径  String

         3.字节输出流  OutputStream

 

字符打印流：printWriter

         构造函数可以接受的参数类型：

         1.file对象  file

         2.字符串路径  String

         3.字节输出流  OutputStream

         4.字符输出流  Writer

 

读取键盘录入

System.out:对应的是标准输出设备，控制台

System.in:对应的是标准的输入设备，键盘

 

通过键盘录入数据

当录入一行数据后，就将该行数据打印

如果录入的数据是over，那么将停止录入

 

流操作的基本规律：

从众多的流对象里选取合适的使用要通过三个明确来完成

1.明确源和目的

         源：输入流  InputStream   Reader

         目的：输出流  OutputStream  Writer

2.操作的数据是否是纯文本

         是：字符流

         不是：字节流

3.当体系明确后，再明确要使用哪个具体的对象

         通过设备来进行区分：

         源设备：内存，硬盘，键盘

         目的设备：内存，硬盘，控制台

 

1.将一个文本文件中的数据存储到另一个文件，复制文件

         源：InputStream  Reader

                 是不是操作文本文件：是，就可以选择Reader，这样体系就明确了

                 接下来明确要使用该体系中的哪个对象

                 明确设备：硬盘

                  Reader体系中可以操作文件的对象是FileReader

                 是否需要提高效率：是，加入Reader体系中的缓冲区BufferedReader

                  FileReader fr = new FileReader("a.txt");

                  BufferedReader bufr = new BufferedReader(fr);

 

         目的：OutputStream  Writer

                 是否是纯文本：是，Writer

                 设备：硬盘

                  Writer体系中可以操作文本文件的对象FileWriter

 

                 是否需要提高效率：是，加入Writer体系中的缓冲区BufferedWriter

                  FileWriter fw = new FileWriter("b.txt");

                  BufferedWriter bufw = new BufferedWriter(fw);

 

2.将键盘录入的数据保存到一个文件中。这个需求中源和目的都存在

         源：InputStream  Reader

                 是不是纯文本：是，Reader

                 设备：键盘，对应的对象是System.in

                         为了操作键盘的文本数据方便，转成字符流按照字符串操作最方便

                         既然明确了Reader，那么就将System.in转换成Reader

                         用到了Reader体系中的转换流：InputStreamReader

 

                          InputStreamReader isr = new InputStreamReader(System.in);

                 需要提高效率吗，需要，BufferedReader

                          BufferedReader bufr = new BufferedReader(isr);

 

         目的：OutputStream  Writer

                 是否是纯文本：是，Writer

                 设备：硬盘，FileWriter

                  FileWriter fw = new FileWriter("c.txt");

                 需要提高效率吗：需要

                  BufferedReader bufw = new BufferedWriter(fw);

 

用于操作字节数组的流对象

ByteArrayInputStream:在构造的时候，需要接受数据源，而且数据源是一个字节数组

ByteArrayOutputStream:在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变

                                                    长度的字节数组，就是数据的目的地

这两个流对象操作的都是数组，并没有使用系统资源，所以不用进行close关闭

用流的读写思想来操作数组

RandomAccessFile

该类不是IO体系中的子类而是直接继承自Object

但它是IO包中的成员，因为它具备读和写的功能

它的内部封装了一个数组，而且通过指针对数组的元素进行操作

可以通过getFilePointer获取指针位置，同时可以通过seek改变指针位置

 

其实完成读写的原理就是内部封装了字节输入流和输出流

通过构造函数可以看出，该类只能操作文件，而且操作文件还有模式:只读r，读写rw

如果模式为只读（r），不会创建文件，会去读取一个已存在的文件，如果该文件不存在，则会出现异常

如果模式为读写（rw），要操作的文件不存在，会自动创建，如果存在不会覆盖

 

装饰设计模式

当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入

基于已有的功能，提供加强功能，那么自定义的该类成为装饰类

装饰类通常会通过构造方法来接受被装饰的对象，并基于被装饰的对象的功能

提供更强的功能

 

装饰设计模式与继承

装饰设计模式比继承要灵活，避免了继承体系的臃肿，而且降低了类与类之间的关系

 

装饰类因为增强了已有对象，具备的功能和已有的是相同的，只不过提供了更强

的功能，所以装饰类和被装饰类通常都属于同一个体系中

------- android培训、java培训、期待与您交流！ ----------