黑马程序员_JavaIO输入与输出上
来源：互联网 发布：知乎 做过最智障的事 编辑：程序博客网 时间：2024/06/17 03:17
----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------
IO流概述：
IO流用来处理设备之间的数据传输。Java对数据的操作是通过流的方式。Java用于操作流的对象都在IO包中。
流按操作数据分为两种：字节流与字符流。
流按流向分为：输入流和输出流。
IO流常用的基类：
字节流的抽象基类：InputStream OutputStream
字符流的抽象基类：Reader Writer
注：由这四个类派生出来的子类都是以其父类名作为子类名的后缀，前缀名是该流对象的功能。
如：InputStream的子类FileInputStream
Reader的子类FileReader
字符流FileWriter：一个专门用于操作文件的Writer的子类对象。
FileWriter特点和应用：
示例：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)throws IOException
{
/*
创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。而且该文件会被创建到指定目录下。
如果该目录下已有同名文件，将被覆盖。
*/
FileWriter fw=new FileWriter("demo.txt");
//调用write方法，将字符串写入到流对象中。
fw.write("i love wanglin");
//刷新流对象中的缓冲中的数据。将数据刷到目的文件中。
fw.flush();
fw.write("tangwei");
//关闭流资源，但是在关闭前会刷新一次内部的缓冲中的数据，将数据刷到目的文件中。
//和flush方法的区别：flush方法刷新后，流可以继续使用。close方法刷新后，会将流关闭。
fw.close();
}
}
IO异常的处理方式
示例：
import java.io.*;
class FileWriterDemo2
{
public static void main(String[] args)
{
FileWriter fw=null;
try
{
fw=new FileWriter("demo.txt");
fw.write("i love wanglin");
}
catch (IOException e)
{
System.out.println("catch:"+e.toString());
}
finally
{
try
{
if(fw!=null)
fw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
}
对文件的续写
示例：
import java.io.*;
class FileWriterDemo3
{
public static void main(String[] args)throws IOException
{
//传递一个true参数，代表不覆盖已有的文件，并在已有文件的结尾处进行数据的续写。
FileWriter fw=new FileWriter("demo.txt",true);
fw.write("nihaomei\r\nxiexie");
fw.close();
}
}
文本文件读取方式一：一次读一个字符。
示例：
import java.io.*;
class FileReaderDemo
{
public static void main(String[] args)throws IOException
{
//创建一个文件读取流对象，和指定名称的文件相关联。
//要保证该文件是已经存在的。如果不存在，会发生FileNotFoundException。
FileReader fr=new FileReader("demo.txt");
//调用读取流对象的read方法。read方法：一次读一个字符，而且会自动往下读。
int ch=0;
while((ch=fr.read())!=-1)
{
System.out.println("ch="+(char)ch);
}
fr.close();
}
}
文本文件读取方式二：通过字符数组进行读取。这种方式效率更高。
示例：
import java.io.*;
class FileReaderDemo2
{
public static void main(String[] args)throws IOException
{
FileReader fr=new FileReader("demo.txt");
//定义一个字符数组，用于存储读到的字符。
char[] buf=new char[1024];
int num=0;
while((num=fr.read(buf))!=-1)
{
System.out.println(new String(buf,0,num));
}
fr.close();
}
}
复制文本文件：
例如：将C盘一个文本文件复制到D盘的一个文本文件。
复制的原理：其实就是将C盘下的文件数据存储到D盘下的文件中。
步骤：
1.在D盘创建一个文本文件，用于存储C盘文件中的数据。
2.定义读取流对象和C盘文件相关联。
3.通过不断的读写完成数据存储。
4.关闭资源。
示例：
import java.io.*;
class CopyText
{
public static void main(String[] args)
{
copy();
}
public static void copy()
{
FileWriter fw=null;
FileReader fr=null;
try
{
//创建目的地。
fw=new FileWriter("RuntimeDemo_copy.txt");
//与已有文件相关联。
fr=new FileReader("RuntimeDemo.java");
char[] buf=new char[1024];
int len=0;
while((len=fr.read(buf))!=-1)
{
fw.write(buf,0,len);
}
}
catch (IOException e)
{
throw new RuntimeException("读写异常");
}
finally
{
if(fr!=null)
try
{
fr.close();
}
catch (IOException e)
{
}
if(fw!=null)
try
{
fw.close();
}
catch (IOException e)
{
}
}
}
}
字符流的缓冲区：缓冲区的出现提高了对数据的读写效率。
对应类：BufferedWriter BufferedReader
缓冲区的特点：缓冲区要结合流才可以使用。在流的基础上对流的功能进行了增强。
BufferedWriter ：字符写入流缓冲区。该缓冲区中提供了一个跨平台的换行符：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 x=1;x<6;x++)
{
bufw.write("wanglin"+x);
bufw.newLine();
bufw.flush();
}
bufw.close();
}
}
BufferedReader：字符读取流缓冲区。该缓冲区提供了一次读一行的方法：readLine()，方便于对文本文件数据的获取。
readLine方法原理：BufferedReader中封装了一个字符数组，readLine方法将read方法一次读一个的字符存储在该字符数组中，当读取到回车符时停止，本行结束。readLine方法再将该行数据一次取出后，重新将下一行数据继续往字符数组中存。
注：readLine方法返回的时候只返回回车符之前的数据内容，并不换回回车符。当返回null时，表示读到文件末尾。
示例：
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();
}
}
通过缓冲区复制一个.java文件。
示例：
import java.io.*;
class CopyTextByBuf
{
public static void main(String[] args)
{
BufferedReader bufr=null;
BufferedWriter bufw=null;
try
{
bufr=new BufferedReader(new FileReader("BufferedWriterDemo.java"));
bufw=new BufferedWriter(new FileWriter("bufWriter_copy.txt"));
String line=null;
while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
try
{
if(bufr!=null)
bufr.close();
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败");
}
try
{
if(bufw!=null)
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}
装饰设计模式：当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强的功能。那么该自定义的类称为装饰类。装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。装饰类因为增强已有对象，故具备的功能和已有的是相同的，只不过提供了更强功能。所以装饰类与被装饰类通常都属于一个体系中。
装饰模式与继承的区别：装饰模式比继承要灵活。避免了继承体系臃肿，而且降低了类与类之间的关系。
示例：
class Person
{
public void chifan()
{
System.out.println("吃饭");
}
}
class SuperPerson
{
private Person p;
SuperPerson(Person p)
{
this.p=p;
}
public void superChifan()
{
System.out.println("开胃酒");
p.chifan();
System.out.println("甜点");
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p=new Person();
SuperPerson sp=new SuperPerson(p);
sp.superChifan();
}
}
LineNumberReader：带行号的字符读取流。行号默认从1开始计数。
示例：
import java.io.*;
class LineNumberReaderDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr=new FileReader("PersonDemo.java");
LineNumberReader lnr=new LineNumberReader(fr);
String line=null;
lnr.setLineNumber(200);//设置行号从200以后开始计数。
while((line=lnr.readLine())!=null)
{
System.out.println(lnr.getLineNumber()+":"+line);
}
lnr.close();
}
}
字节流：通常用于操作非文本文件，如操作媒体文件。
字节读取流：InputStream
字节写入流：OutputStream
示例：
import java.io.*;
class FileStream
{
public static void main(String[] args)throws IOException
{
writeFile();
readFile();
}
public static void writeFile()throws IOException
{
FileOutputStream fos=new FileOutputStream("fos.txt");
fos.write("wanglin".getBytes());
fos.close();
}
public static void readFile()throws IOException
{
FileInputStream fis=new FileInputStream("fos.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.用字节读取流对象和图片相关联。
2.用字节写入流对象创建一个图片文件，用于存储获取到的图片数据。
3.通过循环读写，完成数据的存储。
4.关闭资源。
*/
import java.io.*;
class CopyPic
{
public static void main(String[] args)
{
FileOutputStream fos=null;
FileInputStream fis=null;
try
{
fos=new FileOutputStream("D:\\2.jpg");
fis=new FileInputStream("D:\\1.jpg");
byte[] buf=new byte[1024];
int len=0;
while((len=fis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
}
catch (IOException e)
{
throw new RuntimeException("复制文件失败");
}
finally
{
try
{
if(fis!=null)
fis.close();
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败");
}
try
{
if(fos!=null)
fos.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}
字节流的缓冲区对象：BufferedOutputStream和BufferedInputStream
通过字节流的缓冲区复制Mp3文件。
示例：
import java.io.*;
class CopyMp3
{
public static void main(String[] args)throws IOException
{
long start=System.currentTimeMillis();
copy_1();
long end=System.currentTimeMillis();
System.out.println((end-start)+"毫秒");
}
public static void copy_1()throws IOException
{
BufferedInputStream bufis=new BufferedInputStream(new FileInputStream("F:\\2.mp3"));
BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("F:\\1.mp3"));
int by=0;
while((by=bufis.read())!=-1)
{
bufos.write(by);
}
bufis.close();
bufos.close();
}
}
读取键盘录入：
System.out：对应的是标准输出设备-控制台。
System.in：对应的是标准输入设备-键盘。
示例：
import java.io.*;
class ReadIn
{
public static void main(String[] args)throws IOException
{
InputStream in=System.in;
System.out.println('\r'+0);
System.out.println('\n'+0);
StringBuilder sb=new StringBuilder();
while(true)
{
int ch=in.read();
if(ch=='\r')
continue;
if(ch=='\n')
{
String s=sb.toString();
if("over".equals(s))//自定义键盘录入结束标识。
break;
System.out.println(s.toUpperCase());
sb.delete(0,sb.length());
}
else
sb.append((char)ch);
}
}
}
读取转换流对象：InputStreamReader
将字节读取流对象转成字符读取流对象。
示例：
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args)throws IOException
{
InputStream in=System.in;
InputStreamReader isr=new InputStreamReader(in);
BufferedReader bufr=new BufferedReader(isr);
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
System.out.println(line.toUpperCase());
}
bufr.close();
}
}
写入转换流对象：OutputStreamWriter
将字节写入流对象转成字符写入流对象。
示例：
import java.io.*;
class TransStreamDemo2
{
public static void main(String[] args)throws IOException
{
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
转换流可用于字符编码的转换。
示例：
import java.io.*;
class TransStreamDemo4
{
public static void main(String[] args)throws IOException
{
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("1.txt"),"UTF-8"));
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
流操作的基本规律：流对象有很多，我们该用哪一个？通过三个明确来完成。
1.明确源和目的。
源：输入流。InputStream Reader
目的：输出流。OutputStream Writer
2.操作的数据是否是纯文本。
是：字符流。
不是：字节流。
3.当体系明确后，再明确要使用哪个具体的对象。通过设备来区分：
源设备：内存，硬盘，键盘。
目的设备：内存，硬盘，控制台。
注：如果需要提高读写效率，加入缓冲区对象。
改变标准输入输出设备示例：
import java.io.*;
class TransStreamDemo5
{
public static void main(String[] args)throws IOException
{
//改变标准输入设备。
System.setIn(new FileInputStream("CopyMp3.java"));
//改变标准输出设备。
System.setOut(new PrintStream("3.txt"));
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
制作异常的日志信息：
示例：
import java.io.*;
import java.util.*;
import java.text.*;
class ExceptionInfo
{
public static void main(String[] args)
{
try
{
int[] arr=new int[2];
System.out.println(arr[4]);
}
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("exception.log");
ps.println(s);
System.setOut(ps);
}
catch (IOException ex)
{
throw new RuntimeException("日志文件创建失败");
}
e.printStackTrace(System.out);
}
}
}
打印系统信息：
示例：
import java.util.*;
import java.io.*;
class SystemInfo
{
public static void main(String[] args)throws IOException
{
Properties pro=System.getProperties();
pro.list(new PrintStream("sysinfo.txt"));
}
}
----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------
- 黑马程序员_JavaIO输入与输出上
- 黑马程序员_JavaIO输入与输出下
- 黑马程序员_javaIO流上
- 黑马程序员_JavaIO操作
- 黑马程序员_javaIO流
- 黑马程序员_javaIO编程
- 黑马程序员_javaIO流
- 黑马程序员_javaIO流下
- 黑马程序员_javaIO流_1
- 黑马程序员_javaIO流_2
- 黑马程序员_javaIO流笔记
- 黑马程序员_JavaIO学习笔记
- 【黑马程序员】黑马入学准备篇：IO输入与输出 【上】
- 黑马程序员--java IO输入与输出
- 黑马程序员之IO 输入与输出
- 黑马程序员_IO输入与输出
- 黑马程序员--javaI/O输入与输出
- 黑马程序员--IO输入与输出
- 数据透视表的VLOOKUP模糊查找
- 黑马程序员_基础学习笔记（10）
- 黑马程序员_基础学习笔记（11）
- 关于在C＋＋中调用system函数
- 位操作之一
- 黑马程序员_JavaIO输入与输出上
- Java实现快速排序
- 一个失败的设计
- Java实现简单冒泡排序
- Java实现插入排序
- AdWhirl：iPhone,Android软件内嵌广告
- Java实现选择排序
- Java简单队列的实现
- Java简单栈的实现
