黑马程序员_java_io(上)

最新推荐文章于 2020-09-25 16:33:17 发布

百鑫

最新推荐文章于 2020-09-25 16:33:17 发布

阅读量583

点赞数

分类专栏：黑马程序员

本文链接：https://blog.csdn.net/u010035035/article/details/8870108

版权

黑马程序员专栏收录该内容

18 篇文章 0 订阅

订阅专栏

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

java_ io(上)
io流是一组有序的数据序列,根据操作的类型,可分为输入流和输出流两种io(Inpout/Output)liu
同了一条通道程序,可以使用这条通道吧源中的字节序列送到目的地,虽然io流经常与词牌文件存取有关,
但是程序的源和目的地也可以是键盘鼠标,内存或者显示器窗口等.
java有数据流处理输入/输出模式,程序与从指定源的输入流中读取源中的数据,源可以是文件.网络.压缩包
或者其他数据

java语言定义了许多专门负责各个方式的输入/输出,这些类都被放在java.io包中.其中所有输入流
类都是抽象类InputStream(字节输入流)或者抽象类Reader(字符输入流)的子类;而所有输出流都是抽象
类OutputStream(字节输出流)或者抽象类Writer(字符流输出流)的子类.

字节流两个基类：
InputStream OutputStream

字符流两个基类：
Reader Writer
注由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

如：InputStream的子类FileInputStream。
如：Reader的子类FileReader。
//------------------------------------------------------------------------

构造方法:

FileWriter:用来写入字符文件的便捷类java.io Writer另请参见:

FileWriter(String fileName, boolean append)
根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。

FileWriter(File file)
根据给定的 File 对象构造一个 FileWriter 对象。

FileWriter(FileDescriptor fd)
构造与某个文件描述符相关联的 FileWriter 对象。

FileWriter(String fileName)
根据给定的文件名构造一个 FileWriter 对象。

FileWriter(File file, boolean append)
示:fw=new FileWriter("demo.txt",true);//在已有文件续写.如果没有就文件就创建
根据给定的 File 对象构造一个 FileWriter 对象。

常用方法:

void write(String str):写入字符串。
abstract void flush():刷新该流的缓冲
abstract void close():关闭此流，但要先刷新它。

  //创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
  //而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
  //其实该步就是在明确数据要存放的目的地。
  FileWriter fw = new FileWriter(“Test.txt”);

  //调用write方法，将字符串写入到流中。
  fw.write("abcde");
  //刷新流对象中的缓冲中的数据。
  //将数据刷到目的地中。

//fw.flush();

  //关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
  //将数据刷到目的地中。
  //和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
  fw.close();

ps:\r\n:回车符.在windows里面需要两个代表回车符.在linux系统\n代表回车符.
//-------------------------------------------------------------------------
IO异常的处理方式续写和回车符:
示例:

import java.io.*;
class FileWriterDemo2 
{
 public static void main(String[] args)
 {
  FileWriter fw=null;//需要在代码块外边建立引用.
  try
  {
   fw=new FileWriter("demo.txt",true);
   fw.write("accd\r\nde");  
  }
  catch (IOException e)
  {
   System.out.println(e.toString());
  }
  finally
  {
   if(fw!=null)//判断fw是否为空.如果输入盘符错误的话.fw会是null;将执行不到close所以要判断
    try
    {
     fw.close();
    }
    catch (IOException e)
    {
     System.out.println("关闭资源失败");
    }  
  } 
 }
}

//---------------------------------------------------------------------

构造方法:

FileReader:用来读取字符文件的便捷类java.io Reader另请参见:

FileReader(File file)
在给定从中读取数据的 File 的情况下创建一个新 FileReader。

FileReader(FileDescriptor fd)
在给定从中读取数据的 FileDescriptor 的情况下创建一个新 FileReader。

FileReader(String fileName)
在给定从中读取数据的文件名的情况下创建一个新 FileReader。

常用方法:

abstract void |close() 关闭该流并释放与之关联的所有资源。

void |mark(int readAheadLimit) 标记流中的当前位置。

boolean |markSupported() 判断此流是否支持 mark() 操作。

int |read() 读取单个字符。

int |read(char[] cbuf) 将字符读入数组。

abstract int |read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。

int |read(CharBuffer target) 试图将字符读入指定的字符缓冲区。

boolean r|eady() 判断是否准备读取此流。

void |reset() 重置该流。

long |skip(long n) 跳过字符。

第一种取出方式:
  //创建一个文件赌球流对象,和指定名称的文件相关联.
  //要保证该文件时已经存在的,如果不存在,会发生异常FileNotFoundException

FileReader fr=new FileReader("demo.txt");
  int ch=0;
  /*
  调用读取流对象的read方法
  read():一次读一个字符,而且会自动往下读.
  */
  while((ch=fr.read())!=-1)
  {
  System.out.println("ch="+(char)ch);
  }
  /*
  while(true)
  {
   int ch=fr.read();
   if(ch==-1)
    break;
  System.out.println("ch="+(char)ch);
  }
  */

第二种出去方式:

fr=new FileReader("FileWriterDemo.java");
  //定义一个字符数组.用于存储到字符.
  //该read(char[])返回的是读到的个数
  char[] buf=new char[1024];
  //定义一个变量来记住个数
  int num=0;
  //用while循环来判断结尾是否读到的个数为-1
  while((num=fr.read(buf))!=-1)
  {
   //打印个数和字符数组.new String(buf,0,num)是Sting类中打印数组从0开始.到nun结束
   System.out.print(num+"....."+new String(buf,0,num));
   //注意输出语句没加ln.是因为数组的长度是1024,如果到了1024就会换行.所以不加.
  }

练习:拷贝文件

/*
需求:拷贝文本文件.
1.在D盘创建一个文件,用于存储c盘文件中的数据
2.定义读取流和c文件箱关联.
3.通过不断的读写完成数据存储.
4.关闭资源
*/
import java.io.*;
class  CopyText
{
 public static void main(String[] args) 
 {
  copy_2();
 }
 public static void copy_2()//建立字符数组集体拷贝
 {
  FileReader fr=null;//在代码块外边给fr初始化.要不然在代码块里面建立对象别的地方会访问不到
  FileWriter fw=null;
  try
  {
   fr=new FileReader("MathDemo.java");//建立对象并指定好目录
   fw=new FileWriter("MathDemo_copy.txt");
   char[] buf=new char[1024];//建立字符数组,用来储存数据

   int len=0;//定义一个变量来记住字符数
   while((len=fr.read(buf))!=-1)//因为字符数到末尾会是-1.进行判断
   {
    fw.write(buf,0,len);//写出数据.并从零开始.到字符数那里结束
   }
  }
  catch (IOException e)//路径不存在抛异常
  {
   throw new RuntimeException("路径不存在");
  }
  finally
  {
   try
   {
    if(fr!=null)//对close判断.是否为空如果建立对象不成功的话close根本不识别.
     fr.close();
   }
   catch (IOException e)
   {
    System.out.println("写入失败");
   }
   try
   {
    if(fw!=null)
     fw.close();
   }
   catch (IOException e)
   {
    System.out.println("读取失败");
   }
  }
 }
 public static void copy_1()//一个字符一个字符的拷贝
 {
  FileReader fr=null;
  FileWriter fw=null;
  try
  {
   fr=new FileReader("SystemDemo.java");
   fw=new FileWriter("System_copy.txt");

   int ch=0;
   while((ch=fr.read())!=-1)
   {
    fw.write(ch);
   }
  }
  catch (IOException e)
  {
   throw new RuntimeException("路径不存在");
  }
  finally
  {
   try
   {
    if(fr!=null)
     fr.close();
   }
   catch (IOException e)
   {
    System.out.println("写入失败");
   }
   try
   {
    if(fw!=null)
     fw.close();
   }
   catch (IOException e)
   {
    System.out.println("读取失败");
   }
  }
 }
}

//--------------------------------------------------------------------------
BufferedWriter类与BufferedReader类

Bufferedwriter类和BufferedReader类分别继承了Reader类和Writer类.这两个类同样具备了内部缓存机制.
可以可进行单位进行输入输出.

在使用BufferedWriter类的Writer()方法时,数据并没有立即写入至输出流中.而是首先进入缓存区中.
如果想理解将缓存区中个的数据写入输出流中,一定要动用flush()方法.
缓冲区的出现提高了对数据的读写效率。

对应类
BufferedWriter
BufferedReader

字符输出流缓冲区:
  缓冲区要结合流才可以使用。
  在流的基础上对流的功能进行了增强
  缓冲区的出现是为了提高流的操作小路而出现的.
  所以在创建缓冲区之前,必须要先有流对象.
  该缓冲区提供了一个夸平台的换行符.
  newLine();

字符读取流缓冲区:
该缓冲区提供了一个一次读一行的方法 readLine,方便与对文本进行数据的获取.
当返回null时候,表示读到文件末尾.

示例:

/*
需求:复制一个java文件
*/
import java.io.*;
class  CopyTextBuf
{
 public static void main(String[] args) 
 {
  BufferedReader bufr=null;
  BufferedWriter bufw=null;
  try
  {
   //为了提高效率.加入缓冲技术,将字符读取流对象作为参数传递给缓冲区的构造函数.
   //建立缓冲区,创建流对象和文件相关联的
   bufr=new BufferedReader(new FileReader("BufferedReaderDemo.java"));//字符读取流

   bufw=new BufferedWriter(new FileWriter("BufferedReaderDemoCopy_1.txt"));//字符输出流
   String s=null;//因为读取一行到末尾的时候会返回null.就可以以null作为循环条件来循环
   while((s=bufr.readLine())!=null)
   {
    bufw.write(s);//读取一行.输出一行
    bufw.newLine();//换行
   }
  }
  catch (IOException e)
  {
   throw new RuntimeException("文件路径错误");
  }
  finally
  {
   try
   {
    if(bufr!=null)
     bufr.close();
   }
   catch (IOException e)
   {
    System.out.println("读取关闭文件失败");
   }
   try
   {
    if(bufw!=null)
     bufw.close();
   }
   catch (IOException e)
   {
    System.out.println("输出关闭文件失败");
   }
  }
 }
}

//-------------------------------------------------------------------

装饰设计模式:
以前是通过继承将每一个子类都具备缓冲功能。
那么继承体系会复杂，并不利于扩展。

现在优化思想。单独描述一下缓冲内容。
将需要被缓冲的对象。传递进来。也就是，谁需要被缓冲，谁就作为参数传递给缓冲区。
这样继承体系就变得很简单。优化了体系结构。

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

class MyBufferReader
{
MyBufferReader(MyTextReader text)
{}
MyBufferReader(MyMediaReader media)
{}
}
上面这个类扩展性很差。
找到其参数的共同类型。通过多态的形式。可以提高扩展性。

class MyBufferReader extends MyReader
{
private MyReader r;
MyBufferReader(MyReader r)
{}
}

MyReader//专门用于读取数据的类。
|--MyTextReader
|--MyMediaReader
|--MyDataReader
|--MyBufferReader

LineNumberReader:
BufferedReaderd 的子类,也属于装饰类跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int)
和 getLineNumber()，它们可分别用于设置和获取当前行号.

  演示:
   FileReader fr=new FileReader("demo.txt");//建立输入流对象于文件相关联
   LineNumberReader lnr=new LineNumberReader(fr);//建立缓冲区.
   String line =null;
   lnr.setLinNumber(100);//设置行号
   while((line=lnr.readLine())!=null)
   {
    System.out.println(lnr.getLineNumber()+":"+line);//获取行号,和打印一行
   }
   lnr.close
演示:

/*
明白了BufferedReader类中特有方法readLine的原理后，
可以自定义一个类中包含一个功能和readLine一致的方法。
来模拟一下BufferedReader
*/
import java.io.*;
class MyBufferedReader extends Reader
{
 private Reader r;
 MyBufferedReader(Reader r)//建立构造函数.一开始就要有流
 {
  this.r = r;
 }
 //可以一次读一行数据的方法。
 public String myReadLine()throws IOException
 {
  //定义一个临时容器。原BufferReader封装的是字符数组。
  //为了演示方便。定义一个StringBuilder容器。因为最终还是要将数据变成字符串。
  StringBuilder sb = new StringBuilder();
  int ch = 0;
  while((ch=r.read())!=-1)
  {
   if(ch=='\r')
    continue;//判断如果是\r的话在运行.判刑下个\n,如果是最后一行了.返回字符串
   if(ch=='\n')
    return sb.toString();
   else
    sb.append((char)ch);
  }

  if(sb.length()!=0)
   return sb.toString();
  return null;  
 }

 /*
 覆盖Reader类中的抽象方法。
 */
 public int read(char[] cbuf, int off, int len) throws IOException
 {
  return r.read(cbuf,off,len) ;
 }
 public void close()throws IOException
 {
  r.close();
 }
 public void myClose()throws IOException
 {
  r.close();
 }
}
class  MyBufferedReaderDemo
{
 public static void main(String[] args) throws IOException
 {
  FileReader fr = new FileReader("buf.txt");

  MyBufferedReader myBuf = new MyBufferedReader(fr);//自定义的装饰类

  String line = null;

  while((line=myBuf.myReadLine())!=null)
  {
   System.out.println(line);
  }
  myBuf.myClose();//关闭资源
 }
}

常用方法:

int |available() 返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。

void |close() 关闭此输入流并释放与该流关联的所有系统资源。

void |mark(int readlimit) 在此输入流中标记当前的位置。

boolean | markSupported() 测试此输入流是否支持 mark 和 reset 方法。

abstract int| read() 从输入流中读取数据的下一个字节。

int |read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。

int |read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组。

void|reset() 将此流重新定位到最后一次对此输入流调用 mark 方法时的位置。

long| skip(long n) 跳过和丢弃此输入流中数据的 n 个字节。

OutputStream类是字节输入流的抽象类,次抽象表示输出字节流的所有类的超类.OutputStream

常用方法:

void |close() 关闭此输出流并释放与此流有关的所有系统资源。

void |flush() 刷新此输出流并强制写出所有缓冲的输出字节。

void |write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。

void |write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。

abstract void |write(int b) 将指定的字节写入此输出流。

FileInputStream 与 FileOutputStream 类
FileInputStream类与FileOutputStream类都是用来操作磁盘文件的,如果用户的文件读取需求比较简单,测可以使用FileInputStream类.该类继承自InputStream类
FlieOutputSream类与FileInputStreamLEI对应提供了基本的文件写入能力,FileOutputStream类是OutputStream类的子类.

示例:

/*
需求:拷贝一个图片
1.创建一个字符输入流和图片相关联.
2.用字节写入流对创建图片文件,用于存储到图片数据.
3.通过循环续写,完成数据的存储.
4.关闭资源.
*/
import java.io.*;
class  CopyPic
{
 public static void main(String[] args) 
 {
  FileInputStream fis=null;
  FileOutputStream fos=null;
  try
  {
   fis=new FileInputStream("D:\\2.jpg");//建立字符输入流对象和文件相关联
   fos=new FileOutputStream("copy.jpg");//建立字符输出流对象指定路径和文件名字
   byte[] buf=new byte[1024];//创建一个字符数组.用来缓存

   int num=0;//定义一个变量用于判断结尾处是否是-1

   while((num=fis.read(buf))!=-1)
   {
    fos.write(buf,0,num); //循环一次.字符数组输出一次.
   }
  }
  catch (IOException e)//处理异常
  {
   throw new RuntimeException("路径错误");
  }
  finally
  {
   try
   {
    if(fos!=null)//判断创建文件失败是否为null;
     fos.close();
   }
   catch (IOException e)
   {
    System.out.println("输出关闭失败");
   }
   try
   {
    if(fis!=null)
     fis.close();
   }
   catch (IOException e)
   {
    System.out.println("输入关闭失败");
   }
  }
 }
}

//------------------------------------------------------

用缓冲区技术拷贝Mp3

  BufferedInputStream buis=null;
  BufferedOutputStream buos=null;
  try
  {
   buis=new BufferedInputStream(new FileInputStream("D:\\Maid with the Flaxen Hair.mp3"));
   buos=new BufferedOutputStream(new FileOutputStream("copy.mp3"));

int num=0;

   while((num=buis.read())!=-1)
   {
    buos.write(num);
   }
  }
  buis.close();
  buos.colse();

//-------------------------------------------------
InputStreamReader和OutputStreamWriter

InputStreamReader :

是字节流通向字符流的桥梁。
每次调用 InputStreamReader 中的一个 read()
方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。
为了达到最高效率，可要考虑在 BufferedReader 内包装 InputStreamReader。

构造方法：
  InputStreamReader(InputStream in)
  InputStreamReader(InputStream in, String charsetName)
示例：
  BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

OutputStreamWriter :
是字符流通向字节流的桥梁：

将要写入流中的字符编码成字节
每次调用 write() 方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区中累积。
为了获得最高效率，可考虑将 OutputStreamWriter 包装到 BufferedWriter 中，以避免频繁调用转换器。

构造方法：

OutputStreamWriter(OutputStream out)
OutputStreamWriter(OutputStream out, String charsetName)

示例：
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
System.in 默认设备为键盘

System.setIn(InputStream in)\\ 重新分配“标准”输入流。
System.out 默认设备为控制台

System. setOut(PrintStream out) \\重新分配“标准”输出流。

PrintStream 的构造方法：

PrintStream(String fileName)\\ 创建具有指定文件名称且不带自动行刷新的新打印流。
---------------------------------------------------------------------

异常的日志信息

printStackTrace()//将此 throwable 及其追踪输出至标准错误流。

printStackTrace(PrintStream s)// 将此 throwable 及其追踪输出到指定的输出流。

示例:

import java.io.*;
import java.util.*;
import java.text.*;
class  ExceptionInfo
{
 public static void main(String[] args)throws IOException 
 {
  try
  {
   int[] arr = new int[2];
   System.out.println(arr[3]);
  }
  catch (Exception e)
  {
   
   try
   {
    Date d = new Date();//建立日期类
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//格式化日期
    String s = sdf.format(d);

    PrintStream ps = new PrintStream("exeception.log");//设置异常文件
    ps.println(s);
    System.setOut(ps);

    
   }
   catch (IOException ex)
   {
    throw new RuntimeException("日志文件创建失败");
   }
   e.printStackTrace(System.out);//异常信息
  }
 }
}

---------------------------------------------------------------------
获取系信息
方法：

list(PrintStream out)// 将属性列表输出到指定的输出流

示例：

import java.io.*;
import java.util.*;
class  SystemInfo
{
 public static void main(String[] args) throws IOException
 {
  Properties prop=System.getProperties();
  
  //System.out.println(prop);
  prop.list(new PrintStream("sysinfo.txt"));
  //Properties中的list方法PrintStream创建具有指定文件名称且不带自动行刷新的新打印流。
 }
}

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