问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
if (passengerList!=null&&passengerList.size()&0) {
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
List list = new ArrayList();
list不是null，但是list.size()确实等于0
分享到微博？
Hi，欢迎来到 SegmentFault 技术社区！⊙▽⊙ 在这里，你可以提出编程相关的疑惑，关注感兴趣的问题，对认可的回答投赞同票；大家会帮你解决编程的问题，和你探讨技术更新，为你的回答投上赞同票。
明天提醒我
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：java基础（21）
---------------------- &a href=&http://edu.csdn.net&target=&blank&&ASP.Net+Android+IOS开发&/a&、&a href=&http://edu.csdn.net&target=&blank&&.Net培训&/a&、期待与您交流！ ----------------------
、流：即的缩写。
）流用来处理设备间的数据传输。
）对数据的操作是通过流的方式。
）用于操作流的对象都在包中。
）流按操作数据分为两种：字节流和字符流。
）流按流向分为：输入流和输出流。
注意：流只能操作数据，而不能操作文件。
、流的常用基类：
）字节流的抽象基流：和
）字符流的抽象基流：和
注：此四个类派生出来的子类名称都是以父类名作为子类名的后缀，以前缀为其功能；如子类；子类
第二讲字符流
、字符流中的对象融合了编码表。使用的是默认的编码，即当前系统的编码。
、字符流只用于处理文字数据，而字节流可以处理媒体数据。
、既然流是用于操作数据的，那么数据的最常见体现形式是文件。查看，找到一个专门用于操作文件的子类对象：。后缀是父类名。前缀名是流对象的功能。该流对象一被初始化，就必须有被操作的文件存在。
二、字符流的读写
、写入字符流步骤
、创建一个对象，该对象一被初始化，就必须要明确被操作的文件。且该目录下如果已有同名文件，则同名文件将被覆盖。其实该步就是在明确数据要存放的目的地。
、调用方法，将字符串写入到流中。
、调用方法，刷新该流的缓冲，将数据刷新到目的地中。
、调用方法，关闭流资源。但是关闭前会刷新一次内部的缓冲数据，并将数据刷新到目的地中。
刷新后，流可以继续使用；
&&&&&&&而刷新后，将会关闭流，不可再写入字符流。
、其实自身不能写入数据，而是调用系统内部方式完成数据的书写，使用系统资源后，一定要关闭资源。
、文件的数据的续写是通过构造函数，在创建对象时，传递一个参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。（系统中的文件内换行用两个转义字符表示，在系统中只用表示换行）
、由于在创建对象时，需要指定创建文件位置，如果指定的位置不存在，就会发生异常，所以在整个步骤中，需要对异常进行处理。
import java.io.*;
class FileWriterDemo
public static void main(String[] args)
writerDate(&abcde&);//写入数据
writerFrom(&zheshi:\r\nshenma&);//续写数据，并附换行操作
//在硬盘上创建一个文件并写入指定数据
public static void writerDate(String s)
FileWriter fw=
fw=new FileWriter(&demo.txt&);//创建文件
fw.write(s);//将数据写入流
catch (IOException e)
throw new RuntimeException(&写入失败&);
if(fw!=null)
fw.close();//将写入流的数据刷到指定文件内，并关闭流资源
catch (IOException e)
//对已有文件的数据续写指定数据
public static void writerFrom(String s)
FileWriter fw=
fw=new FileWriter(&demo.txt&,true);//传递一个true参数，代表不覆盖已有的文件。
fw.write(s);
catch (IOException e)
throw new RuntimeException(&写入失败&);
if(fw!=null)
fw.close();
catch (IOException e)
、读取字符流步骤
）创建一个文件读取流对象，和指定名称的文件相关联。要保证该文件已经存在，若不存在，将会发生异常。
）调用读取流对象的方法。：一次读一个字符，且会继续往下读。
第一种方式：读取单个字符。第二种方式：通过字符数组进行读取。
）读取后要调用方法将流资源关闭。
import java.io.*;
FileReaderDemo
public static void main(String[] args)
//第一种读取方式
singleCharReader();
//第二种读取方式
arrayCharReader();
//第一种读取方式，单个字符读取
public static void singleCharReader()
FileReader fr=
fr=new FileReader(&demo.txt&);//读取文件位置和文件名
for (int ch=0;(ch=fr.read())!=-1 ; )
System.out.print((char)ch);
catch (IOException e)
throw new RuntimeException(&读取失败&);
if(fr!=null)
fr.close();//关闭读取流资源
catch (IOException e)
//第二种读取方式，通过字符数组进行读取
public static void arrayCharReader()
FileReader fr=
char[] arr=new char[1024];//定义一个字符数组，用于临时存储读取的字符
//读取一个.java文件，并打印在控制台上。
fr=new FileReader(&FileReaderDemo.java&);
for (int len=0;(len=fr.read(arr))!=-1 ; )
//显示字符数组的字符个数
System.out.print(new String(arr,0,len));
catch (IOException e)
throw new RuntimeException(&读取失败&);
if(fr!=null)
fr.close();
catch (IOException e)
、定义文件路径时，可以用“”或者“”。
、在创建一个文件时，如果目录下有同名文件将被覆盖。
、在读取文件时，必须保证该文件已存在，否则出异常。
小练习：文本文件的拷贝
将c盘一个文本文件复制到e盘、
复制的原理：
其实就是将c盘下的文件数据存储到e盘的一个文件中。
1、在e盘创建一个文件。用于存储c盘文件中的数据。
2、定义读取流和c盘文件关联。
3、通过不断的读写完成数据存储。
4、关闭资源。
import java.io.*;
class ReaderWriterTest
publicstatic void main(String[] args)
//调用复制方法
//copy_1();
//用第一种读取方式进行复制
publicstatic void copy_1()
FileWriterfw=
FileReaderfr=
//关联读取和写入的文件
fw=newFileWriter(&E:\\HelloWorld.java&);
fr=newFileReader(&C:\\HelloWorld.java&);
for(int ch=0;(ch=fr.read())!=-1 ; )
fw.write(ch);//一个字符一个字符写入
catch(IOException e)
thrownew RuntimeException(&读写失败&);
if(fr!=null)
fr.close();//对读取流和写入流分别关闭
catch(IOException e)
if(fw!=null)
fw.close();
catch(IOException e)
//第二种读取方式进行复制
publicstatic void copy_2()
FileWriterfw=
FileReaderfr=
//关联读取和写入的文件
fw=newFileWriter(&E:\\HelloWorld.java&);
fr=newFileReader(&C:\\HelloWorld.java&);
char[]arr=new char[1024];
for(int len=0;(len=fr.read(arr))!=-1 ; )
fw.write(arr,0,len);//利用数组一次存入数组中的字符
catch(IOException e)
thrownew RuntimeException(&读写失败&);
if(fr!=null)
fr.close();
catch(IOException e)
if(fw!=null)
fw.close();
catch(IOException e)
三、字符流的缓冲区——和
、缓冲区的出现：提高了流的读写效率，所以在缓冲区创建前，要先创建流对象。即先将流对象初始化到构造函数中。
、缓冲技术原理：此对象中封装了数组，将数据存入，再一次性取出。
、写入流缓冲区的步骤：
&&&&&&& ）创建一个字符写入流对象。
）为了提高字符写入流效率。加入缓冲技术。只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
）调用方法写入数据到指定文件
记住，只要用到缓冲区，就要记得刷新。（关闭流同样会刷新，但为了排除意外事故，保证数据存在，建议写入一次就刷新一次）
）其实关闭缓冲区，就是在关闭缓冲区中的流对象。
&&&&&&& 如：
小知识：缓冲区中提供了一个跨平台的换行符：可以在不同操作系统上调用，用作数据换行。
、读取流缓冲区
&&&&&&& 该缓冲区提供了一个一次读一行的方法，方便于堆文本数据的获取，当返回时表示读到文件末尾。方法返回的时候，只返回回车符之前的数据内容。并不返回回车符。
方法原理：
&&&&&&& 无论是读一行。或者读取多个字符。其实最终都是在在硬盘上一个一个读取。所以最终使用的还是方法一次读一个的方法。
）创建一个读取流对象和文件相关联
）为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲区对象的构造函数。
）调用该缓冲区提供的方法一行一行读取如果到达文件末尾，则返回
&&&&&&& 如：
）关闭流资源
&&&&&&& 如：
示例：通过缓冲区复制一个文本文件。
需求：使用缓冲技术copy一个文本文件
import java.io.*;
class BufferedCopyDemo
public static void main(String[] args)
BufferedWriter bfw=
BufferedReader bfr=
//创建写缓冲对象
bfw=new BufferedWriter(new FileWriter(&ReaderWriterTest_copy.txt&));
//创建读缓冲对象
bfr=new BufferedReader(new FileReader(&ReaderWriterTest.java&));
//利用BufferedReader提供的readLine方法获取整行的有效字符。直到全部获取
for (String line= (line=bfr.readLine())!= )
bfw.write(line);//写入指定文件中
bfw.newLine();//换行
bfw.flush();//将缓冲区数据刷到指定文件中
catch (IOException e)
throw new RuntimeException(&文件copy失败&);
if(bfw!=null)
bfw.close();//关闭写入流
catch (IOException e)
throw new RuntimeException(&写入流关闭失败&);
if(bfr!=null)
bfr.close();//关闭读取流
catch (IOException e)
throw new RuntimeException(&读取流关闭失败&);
、自定义：
&&&&&&& 可根据类中特有一行一行读取方法的原理，自定义一个类中包含相同功能的方法
、初始化自定义的类，加入流对象。
、定义一个临时容器，原封装的是字符数组，此类中可定义一个的容器，最终可实现字符串的提取。
需求：根据readLine方法原理，模拟BufferedReader写一个自己的MyBufferedReader
import java.io.*;
//自定义缓冲类
class MyBufferedReader extends Reader
private R//定义接收的流对象
MyBufferedReader(Reader r)
//自定义整行读取
public String myReadLine()throws IOException
//创建一个容器，用来存储一行的字符
StringBuilder sb =new StringBuilder();
//一个字符一个字符读取
for (int ch=0;(ch=r.read())!=-1 ; )
if(ch=='\r')//如果遇到换行符，则继续
if(ch=='\n')//如果遇到回车符，表示该行读取完毕
return sb.toString();
sb.append((char)ch);//将该行的字符添加到容器
if(sb.length()!=0)//如果读取结束，容器中还有字符，则返回元素
return sb.toString();
//复写父类中的抽象方法
public int read(char[] cbuf, int off, int len) throws IOException
return r.read(cbuf,off,len);
//复写父类的close方法
public void close()throws IOException
r.close();
//测试MyBufferedReader
MyBufferedReaderDemo
public static void main(String[] args)
MyBufferedReader mbr=
mbr=new MyBufferedReader(new FileReader(&BufferedCopyDemo.java&));
for (String line=(line=mbr.myReadLine())!= )
System.out.println(line);//显示效果
catch (IOException e)
throw new RuntimeException(&读取数据失败&);
if(mbr!=null)
mbr.close();
catch (IOException e)
throw new RuntimeException(&读取流关闭失败&);
&&&&&&& 在中有个直接的子类，其中有特有的方法获取和设置行号：
设置初始行号
需求：利用LineNumberReader的特有方法去设置和获取文件中数据的行号
LineNumberReaderDemo
public static void main(String[] args)
LineNumberReader lnr=
//将读取流对象传入
lnr=new LineNumberReader(new FileReader(&LineNumberReaderDemo.java&));
lnr.setLineNumber(100);//设置开始行号
for (String line=(line=lnr.readLine())!= )
System.out.println(lnr.getLineNumber()+&:&+line);//打印每行行号和字符
catch (IOException e)
throw new RuntimeException(&读取数据失败&);
if(lnr!=null)
lnr.close();
catch (IOException e)
throw new RuntimeException(&读取流关闭失败&);
四、装饰设计模式
&&&&&&& 当想对已有对象进行功能增强时，可定义类：将已有对象传入，基于已有对象的功能，并提供加强功能，那么自定义的该类称之为装饰类。
&&&&&&& 装饰类通常都会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。
、装饰和继承的区别：
）装饰模式比继承要灵活。避免了继承体系的臃肿，且降低了类与类之间的关系。
）装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强的功能，所以装饰类和被装饰的类通常都是属于一个体系。
）从继承结构转为组合结构。
注：在定义类的时候，不要以继承为主；可通过装饰设计模式进行增强类功能。灵活性较强，当装饰类中的功能不适合，可再使用被装饰类的功能。
示例：上面讲到的的例子就是最好的装饰设计模式的例子。
第三讲&& 字节流
、字节流和字符流的基本操作是相同的，但字节流还可以操作其他媒体文件。
、由于媒体文件数据中都是以字节存储的，所以，字节流对象可直接对媒体文件的数据写入到文件中，而可以不用再进行刷流动作。
、读写字节流：输入流（读）
输出流（写）
、为何不用进行刷流动作：
&&&&&&& 因为字节流操作的是字节，即数据的最小单位，不需要像字符流一样要进行转换为字节。所以可直接将字节数据写入到指定文件中。
、特有方法：
返回文件中的字节个数
注：可以利用此方法来指定读取方式中传入数组的长度，从而省去循环判断。但是如果文件较大，而虚拟机启动分配的默认内存一般为。当文件过大时，此数组长度所占内存空间就会溢出。所以，此方法慎用，当文件不大时，可以使用。
复制一个图片
1、用字节读取流对象和图片关联。
2、用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。
3、通过循环读写，完成数据的存储。
4、关闭资源。
import java.io.*;
public static void main(String[] args)
//常用方法复制
byteArrayCopy();
//利用输入流的available方法进行复制
availableCopy();
//利用available方法对复制文件大小有限制，慎用
//使用available方法进行复制
public static void availableCopy()
FileInputStream fis=
FileOutputStream fos=
//关联要复制的文件
fis=new FileInputStream(&C:/Users/asus/Desktop/1.jpg&);
//指定复制的路径
fos=new FileOutputStream(&C:/Users/asus/Desktop/3.jpg&);
//利用available方法指定数组长度
byte[] b=new byte[fis.available()];
fis.read(b);//复制关联文件数据
fos.write(b);//粘贴到指定路径
catch (IOException e)
throw new RuntimeException(&图片复制失败&);
if(fis!=null)
fis.close();//关闭输入字节流
catch (IOException e)
throw new RuntimeException(&读取字节流关闭失败&);
if(fos!=null)
fos.close();//关闭输出字节流
catch (IOException e)
throw new RuntimeException(&写入字节流关闭失败&);
//使用读数组方式进行复制
public static void byteArrayCopy()
FileInputStream fis=
FileOutputStream fos=
//关联要复制的文件
fis=new FileInputStream(&C:/Users/asus/Desktop/1.jpg&);
//指定复制的路径
fos=new FileOutputStream(&C:/Users/asus/Desktop/2.jpg&);
//利用数组的读取方式
byte[] b=new byte[1024];
int len=0;
while ((len=fis.read(b))!=-1)//复制文件的全部数据
fos.write(b,0,len);//粘贴到指定路径
catch (IOException e)
throw new RuntimeException(&图片复制失败&);
if(fis!=null)
fis.close();//关闭输入字节流
catch (IOException e)
throw new RuntimeException(&读取字节流关闭失败&);
if(fos!=null)
fos.close();//关闭输出字节流
catch (IOException e)
throw new RuntimeException(&写入字节流关闭失败&);
二、字节流缓冲区
&&&&&&& 同样是提高了字节流的读写效率。
、读写特点：
：会将字节型值提升为型值
：会将型强转为型，即保留二进制数的最后八位。
、原理：将数据拷贝一部分，读取一部分，循环，直到数据全部读取完毕。
）先从数据中抓取固定数组长度的字节，存入定义的数组中，再通过然后再通过方法读取数组中的元素，存入缓冲区。
）循环这个动作，直到最后取出一组数据存入数组，可能数组并未填满，同样也取出包含的元素。
）每次取出的时候，都有一个指针在移动，取到数组结尾就自动回到数组头部，这样指针在自增。
）取出的时候，数组中的元素在减少，取出一个，就减少一个，直到减到即元素取完。
）当文件中的全部数据都被读取出时，方法就返回。
、自定义读取字节流缓冲区
&&&&&&& 需求：根据字节流缓冲区的原理，自定义一个字节流缓冲区。
、字节流的读一个字节的方法为什么返回值类型不是，而是。
&&&&&&&因为有可能会读到连续个二进制的情况，个二进制对应的十进制是那么就会数据还没有读完，就结束的情况。因为我们判断读取结束是通过结尾标记来确定的。
&&&&&&&所以，为了避免这种情况将读到的字节进行类型的提升。并在保留原字节数据的情况前面了补了个，变成了类型的数值。而在写入数据时，只写该类型数据的最低位。
、类型的提升为类型时还是。原因：因为在个前面补的全是导致的。如果在个前面补，即可以保留原字节数据不变，又可以避免的出现。这时将型数据即即可。
自定义字节流读取缓冲区
1、定义一个固定长度的数组
2、定义一个指针和计数器用于读取数组长度，和计数数组元素是否取完为0
3、每次将字节数据存入元素要先将数组中的元素取完
import java.io.*;
class MyBufferedInputStream
privateInputS
privatebyte[] by=new byte[1024];
privateint count=0,pos=0;
MyBufferedInputStream(InputStreamin)
//自定义读方法，一次读一个字节
publicint myRead()throws IOException
//通过in对象读取硬盘上数据，并存储by中。
//存储在数组中的数据被读取完，再通过in对象从硬盘上读取数据
if(count==0)
count=in.read(by);
if(count&0)//文件数据全部被读取出来了
pos=0;//初始化指针
byteb=by[pos];
count--;//每被读一个字节，表示数组中的字节数少一个
pos++;//指针加1
returnb&255;//返回的byte类型提升为int类型，字节数增加，且高24位被补1，原字节数据改变。
//通过与上255，主动将byte类型提升为int类型，将高24位补0，原字节数据不变。
//而在输出字节流写入数据时，只写该int类型数据的最低8位。
elseif(count&0)//如果数组中的数据没被读取完，则继续读取
byteb=by[pos];
pos++;
//自定义关闭资源方法
publicvoid close()throws IOException
in.close();
//测试自定义输入字节流缓冲区
class MyBufferedCopyMp3
publicstatic void main(String[] args)
longstart=System.currentTimeMillis();
//利用字节流的缓冲区进行复制
longend=System.currentTimeMillis();
System.out.println(&复制共用时：&+(end-start)+&毫秒&);
//使用字节流的缓冲区进行复制
publicstatic void copy_2()
BufferedOutputStreambout=
MyBufferedInputStreambin=
//关联复制文件输入流对象到缓冲区
bin=newMyBufferedInputStream(new FileInputStream(&C:/Users/asus/Desktop/一样的月光.mp3&));
//指定文件粘贴位置的输出流对象到缓冲区
bout=newBufferedOutputStream(new FileOutputStream(&C:/Users/asus/Desktop/一样的月光2.mp3&));
while((by=bin.myRead())!=-1)
bout.write(by);//将缓冲区中的数据写入指定文件中
catch(IOException e)
thrownew RuntimeException(&MP3复制失败&);
if(bin!=null)
bin.close();//关闭输入字节流
catch(IOException e)
thrownew RuntimeException(&读取字节流关闭失败&);
if(bout!=null)
bout.close();//关闭输出字节流
catch(IOException e)
thrownew RuntimeException(&写入字节流关闭失败&);
第四讲流操作规律
一、键盘录入
、标准输入输出流
：对应的标准输入设备，键盘。
：对应的是标准的输出设备，控制台。
的类型是是的子类的子类。
、整行录入
当使用输入流进行键盘录入时，只能一个字节一个字节进行录入。为了提高效率，可以自定义一个数组将一行字节进行存储。当一行录入完毕，再将一行数据进行显示。这种正行录入的方式，和字符流读一行数据的原理是一样的。也就是方法。
&&&&&&那么能不能直接使用方法来完成键盘录入的一行数据的读取呢？方法是字符流类中方法。而键盘录入的方法是字节流的方法。
&&&&& 那么能不能将字节流转成字符流再使用字符流缓冲区的方法呢？这就需要用到转换流了。
转换流的由来：
、字符流与字节流之间的桥梁
、方便了字符流与字节流之间的操作
转换流的应用：
&&&&&&字节流中的数据都是字符时，转成字符流操作更高效。
将字节流通向字符流
、获取键盘录入对象。
、将字节流对象转成字符流对象，使用转换流。
、为了提高效率，将字符串进行缓冲区技术高效操作。使用
键盘录入最常见写法
字符流通向字节流
&&&&&& 字符通向字节：录入的是字符，存到硬盘上的是字节。步骤和转换流一样。
需求：将键盘录入的数据，显示在控制台，当输入over时，表示结束
源：键盘录入。
目的：控制台。
import java.io.*;
class TransStreamDemo
public static void main(String[] args)throws IOException
//获取键盘录入对象。
//InputStream in=System.
//将字节流对象转成字符流对象，使用转换流。
//InputStreamReader isr=new InputStreamReader(in);
//为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader
//BufferedReader br=new BufferedReader(isr);
//键盘录入最常见写法
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
//字符流通向字节流
BufferedWriter bw =new BufferedWriter(new OutputStreamWriter(System.out));
while((s=in.readLine())!=null)
if(&over&.equals(s))
bw.write(s.toUpperCase());//写入数据
bw.newLine();//换行
bw.flush();//刷新
bw.close();//关闭流资源
in.close();
二、流操作规律
&&&&&&& 源：键盘录入。
&&&&&&& 目的：控制台。
、需求：想把键盘录入的数据存储到一个文件中。
&&&&&&& 源：键盘
&&&&&&& 目的：文件。
&&&&&&& 使用字节流通向字符流的转换流（桥梁）：
、需求：想要将一个文件的数据打印在控制台上。
&&&&&&& 源：文件
&&&&&&& 目的：控制台
&&&&&&& 使用字符流通向字节流的转换流（桥梁）：
、流操作的基本规律：
&&&&&&& 最痛苦的就是流对象有很多，不知道该用哪一个。
通过三个明确来完成：
明确源和目的。
源：输入流。
目的：输出流。
操作的数据是否是纯文本。
是：字符流
否：字节流
当体系明确后，再明确要使用哪个具体的对象。通过设备来进行区分：
源设备：内存，硬盘，键盘
目的设备：内存，硬盘，控制台
、规律体现
将一个文本文件中数据存储到另一个文件中。复制文件。
）源：因为是源，所以使用读取流：和
&&&&&&&&&&&& 明确体系：是否操作文本：是，
明确设备：明确要使用该体系中的哪个对象：硬盘上的一个文件。体系中可以操作文件的对象是
是否需要提高效率：是，加入体系中缓冲区
）目的：输出流：和
&&&&&&&&&&&& 明确体系：是否操作文本：是，
明确设备：明确要使用该体系中的哪个对象：硬盘上的一个文件。体系中可以操作文件的对象。
是否需要提高效率：是，加入体系中缓冲区
练习：将一个图片文件中数据存储到另一个文件中。复制文件。要按照以上格式自己完成三个明确。
）源：输入流，和
&&&&&&&&&&& 是否是文本？否，
&&&&&&&&&&& 源设备：硬盘上的一个文件。体系中可以操作文件的对象是
&&&&&&&&&&& 是否需要提供效率：是，
）目的：输出流，和
&&&&&&&&&&&& 是否是文本？否，
&&&&&&&&&&&& 源设备：硬盘上的文件，
&&&&&&&&&&&& 是否需要提高效率：是，加入
需求：将键盘录入的数据保存到一个文件中。
是不是纯文本？是，
设备：键盘。对应的对象是——为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。所以既然明确了，那么就将转换成。用体系中转换流
需要提高效率吗？需要，
是否是存文本？是！。
设备：硬盘。一个文件。使用。
&&&&&&&&&&&需要提高效率吗？需要。
扩展：想要把录入的数据按照指定的编码表（）（默认编码表是），将数据存到文件中。
是否是存文本？是！。
设备：硬盘上的一个文件。使用。——但是是使用的默认编码表：。而存储时，需要加入指定编码表。而指定的编码表只有转换流可以指定。所以要使用的对象是。
该转换流对象要接收一个字节输出流，而且还可以操作的文件的字节输出流：
需要高效吗？需要，
&&&&&& 转换流什么使用？
&&&&&& 字符和字节之间的桥梁。通常，涉及到字符编码转换时，需要用到转换流。
练习：将一个文本数据打印在控制台上。要按照以上格式自己完成三个明确。
&&&&&&&&&&& 是文本？是：
&&&&&&&&&&& 设备：硬盘。上的文件：
&&&&&&&&&&& 是否需要提高效率？是：
&&&&&&&&&&& 是文本？是：
&&&&&&&&&&& 设备：控制台。对应对象由于对应的是字节流，所以利用转换流
&&&&&&&&&&& 是否提高效率？是：
2、需求：想把键盘录入的数据存储到一个文件中。
目的：文件
把录入的数据按照指定的编码表（UTF-8），将数据存到文件中。
3、需求：想要将一个文件的数据打印在控制台上。
目的：控制台
import java.io.*;
TransStreamDemo2
public static void main(String[] args)throws IOException
//键盘录入
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//存入文件中，按照指定的编码表（UTF-8）
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(&readin1.txt&),&UTF-8&));
String line=
while((line=br.readLine())!=null)
if(&over&.equals(line))
bw.write(line);
bw.newLine();
bw.flush();
//录入文件数据
BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream(&TransStreamDemo2.java&)));
//显示在控制台
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
String line=
while((line=br.readLine())!=null)
if(&over&.equals(line))
bw.write(line);
bw.newLine();
bw.flush();
、异常的日志信息：
&&&&&&& 当程序在执行的时候，出现的问题是不希望直接打印给用户看的，是需要作为文件存储起来，方便程序员查看，并及时调整的。
import java.io.*;
import java.text.*;
import java.util.*;
ExceptionInfo
public static void main(String[] args)
int[] arr =new int[2];
System.out.println(arr[3]);
catch (Exception e)
Date d=new Date();//创建时间对象
//时间模块格式对象
SimpleDateFormat sdf=new SimpleDateFormat(&yyyy年MM月dd日 HH:mm:ss&);
String s=sdf.format(d);
PrintStream ps=new PrintStream(&info.log&);//打印流对象
System.setOut(ps);//修改输出流设备
ps.println(s);//输出时间
catch (IOException ex)
throw new RuntimeException(&文件创建失败&);
e.printStackTrace(System.out);//将异常信息输出指定输出流
、系统属性信息存入文本
&&&&&&& 获取系统信息：
&&&&&&& 将信息输出到指定输出流中
&&&&&&& 将输出流中数据存入指定文件中
//将系统属性信息保存到指定文本中
import java.util.*;
import java.io.*;
class SystemInfo
public static void main(String[] args)
PrintStream ps =
//获取系统信息：
Properties pop = System.getProperties();
//创建输出流对象，将输出流中数据存入指定文件中
ps = new PrintStream(&systeminfo.txt&);
//将属性列表输出到指定的输出流
pop.list(ps);
catch (Exception e)
throw new RuntimeException(&获取系统信息失败。&);
、通过类的，方法可以对默认设备进行改变
将源改成文件。
将目的改成文件
流的基本应用小结：
流是用来处理数据的。 处理数据时，一定要先明确数据源，与数据目的地（数据汇）。 数据源可以是文件，可以是键盘。 数据目的地可以是文件、显示器或者其他设备。 而流只是在帮助数据进行传输并对传输的数据进行处理，比如过滤处理转换处理等。
字符流继承体系简图
字节流继承体系简图
---------------------- &a href=&http://edu.csdn.net&target=&blank&&ASP.Net+Android+IOS开发&/a&、&a href=&http://edu.csdn.net&target=&blank&&.Net培训&/a&、期待与您交流！ ----------------------
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：8232次
排名：千里之外
原创：22篇}