pipedstream-90
刘耀文的大沙雕
钟意阿满
Java中的几个关于文件流的问题.
、Java包含哪三个版本？每个版本有什么功能？各个版本的应用领域？
答案:JavaSE\JavaME\JavaEE。
2、在Java中如何定义变量名？变量的作用是什么？
答案:path:\Java路径。
3、定义变量分哪两个步骤？是否必须在Java程序的前面声明变量？
答案:自己看书去,这是书上原话,字太多了,所以我就不打了。
4、以下程序段的输出结果为__________________________。
for(i=0;i<5;i++) 。
{for(j=0;j<5;j++) 。
{if(i==j)
continue;
System.out.print(i*5+j+"\t");} 。
System.out.println("i="+i);} 。
答案是
1 2 3 4 i=0
5 7 8 9 i=1
10 11 13 14 i=2。
15 16 17 19 i=3。
20 21 22 23 i=4。
5、以下程序段的输出结果为_________。
label_break:for(i=0;i<5;i++) 。
{for(j=0;j<5;j++) 。
{if(i==3)
break label_break; 。
System.out.print(i*5+j+"\t");} 。
System.out.println("i="+i);} 。
答案是
0 1 2 3 4 i=0
5 6 7 8 9 i=1
10 11 12 13 14 i=2。
6、请举例说明现实生活中类、对象的现象及其之间的关系。
答案:类的实例化是对象.对象抽象为类。
7、接口与类有什么区别和联系？在Java中使用接口的意义是什么？
答案是:接口是一种特殊的抽象类.这种抽象类中只包含常量和方法的定义,而没有变量和方法的实现.。
8、定义一个数组后为什么不能立即进行访问？
答案是:创建一个数组后需要分配空间.当空间分配后才可以引用数组中的元素.。
9、字符流与字节流的区别是（ ）。 C。
A 每次读入的字节数不同
B前者带有缓冲，后者没有
C前者是块读写，后者是字节读写 。
D二者没有区别，可以互换使用 。
10、如果想要读取一个大文件的末尾的一段内容，并且知道该段落的确切位置，最方便的流是（ ）。 D。
A File stream
B Piped Stream 。
C Random access stream 。
D Filter stream 。
11、为了对读取的内容进行处理后再输出，需要使用（ ）。 B。
A File stream
B Piped Stream 。
C Random access stream 。
D Filter stream 。
请修改以下出错程序：
12、创建一个桌子类table，该类中有桌子名称、重量、桌面宽度、长度和桌子高度属性，并含有以下几个方法。
（1）构造方法：初始化所有成员变量 。
（2）area()：计算桌面的面积。
（3）display()：在屏幕上输出所有成员变量的值。
（4）changeWeight(int w)：改变桌子重量。
在main()方法中实现创建一个桌子对象，计算桌面的面积，改变桌子的重量，并在屏幕上输出所有桌子属性的值。
public class Table { 。
String name;
float weight, width, length,height; 。
public void Table(String N,float W,float L,float H) 。
{ name="N";
weight=40;
width=W;
length=L;
height=H;
}
void area(){
float area;
area=W*L;
System.out.println("桌子的面积是："+area);} 。
void display(){ 。
System.out.println("桌子的名称是："+name+ 。
"桌子的重量是："+weight+ 。
"桌子的宽度是："+width+ 。
"桌子的宽度是："+length+ 。
"桌子的高度是："+height);} 。
void changeweight (int w){ 。
weight=w;
System.out.println("桌子的重量是："+weight);} 。
public static void main(String args[]) 。
{ Table b=new Table("书桌",20f,15f,10f,10f) 。
b.area;
b.changeweight(30); 。
b.display();}
}
Table.java [33:1] ';' expected 。
b.area;
^
1 error
编译 Table. 时出错
答案是:我把正确的程序写在下面了,你自己看了。
public class Table { 。
String name;
float weight, width, length,height; 。
public void Table(String N,float W,float L,float H) 。
{ name="N";
weight=40;
width=W;
length=L;
height=H;
}
void area(){
float area;
float L = 0;
float W=0;
area=W*L;
System.out.println("桌子的面积是："+area);} 。
void display(){ 。
System.out.println("桌子的名称是："+name+ 。
"桌子的重量是："+weight+ 。
"桌子的宽度是："+width+ 。
"桌子的宽度是："+length+ 。
"桌子的高度是："+height);} 。
void changeweight (int w){ 。
weight=w;
System.out.println("桌子的重量是："+weight);} 。
public static void main(String args[]) 。
{ Table b=new Table() ;。
b.area();
b.changeweight(30); 。
b.display();}
抱起亚轩找小葵
为实现进程之间的通信,需要使用合适的流是 A．Data stream B．File stream C．Buffered stream
至于PipedInputStream（抱歉你可能写错了）
在官方网的解释是这样的：
传送输入流应该连接到传送输出流；传送输入流会提供要写入传送输出流的所有数据字节。通常，数据由某个线程从 PipedInputStream 对象读取，并由其他线程将其写入到相应的 PipedOutputStream。不建议对这两个对象尝试使用单个线程，因为这样可能会死锁该线程。传送输入流包含一个缓冲区，可在缓冲区限定的范围内将读操作和写操作分离开。
ADPipedInputStream类与PipedOutputStream类用于在应用程序中创建管道通信.一个PipedInputStream实例对象必须和一个PipedOutputStream实例对象进行连接而产生一个通信管道.PipedOutputStream可以向管道中写入数据,PipedIntputStream可以读取PipedOutputStream向管道中写入的数据.这两个类主要用来完成线程之间的通信.一个线程的PipedInputStream对象能够从另外一个线程的PipedOutputStream对象中读取数据. 。
PipedInputStream与PipedOutputStream类的编程实例(两个线程间进行通信的实例程序)。
//Sender.java 发送者，这个线程主要用于向另一个线程发送数据。
import java.io.*;。
public class Sender extends Thread{ //表明是个线程类。
private PipedOutputStream out = new PipedOutputStream(); //发送者是要向外面写数据，所以发送者内部创建PipedOutputStream对象用于向外写数据。
public PipedOutputStream getOutputStream(){ //返回管道输出流对象。
return out;
//这是一个线程类，所以它应该覆盖Thread的run方法,run方法在线程类启动时自动运行。
public void run(){ //这里的run方法用于向PipedOutputStream中写入一串数据 。
字串2
String strInfo = new String("hello,receiver!");。
try{ //write和close方法都可能有异常出现。
out.write(StrInfo.getBytes());。
out.close();
catch(Exception e){。
e.printStackTrace();。
//Receiver.java //接收者，也是一个线程类。
import java.io.*;。
public class Receiver extends Thread{。
private PipedInputStream in = new PipedInputStream(); //接受者是要读取外面的数据，所以接受者内部创建PipedInputStream对象用于读取外面的数据。
public PipedInputStream getInputStream(){ //返回管道输入流对象。
return in;
//这是一个线程类，所以它应该覆盖Thread的run方法,run方法在线程类启动时自动运行。
public void run(){ //这里的run方法用于接收数据 。
byte[] buf = new byte[1024]; //字节数组。
try{ //read和close方法都可能有异常出现。
int len = in.read(buf); //读取数据，len表示实际读取到的内容（长度）
System.out.println("the following message comes from sender:\n" = new String(buf ,o,len) ); 。
字串8
in.close();
catch(Exception e){。
e.printStackTrace();。
//PipedStreamTest.java //启动类。
import java.io.*;。
public calss PipedStreamTest{。
public static void main(String[] args) throws Exception {。
Sender t1 = new Sender(); //创建发送者对象;。
Receiver t2 = new Receiver(); //创建接收者对象;。
PipedOutputStream out = t1.getOutputStream();。
PipedInputStream in = t2.getIntStream();。
out.connect(in); //用于连接到PipedInputStream上,与in.connect(out)等价,connect方法有异常出现的可能。
t1.start(); //启动线程。
t2.start(); //启动线程。
PipedWriter和PipedReader类，它用来处理字符文本的管道通信. 。
使用管道流类，可以实现名个/doc/">程序模块之间的松耦合通信,这样我们在/doc/">程序中就可以灵活的将多个这样的模块的输入流与输出流相联，然后以拼装成满足各种应用的/doc/">程序,而不用对模块内部进行修改.使用管道连接的模块具有强内聚弱耦合的特点,若模块被替换或被拆卸不会影响到其他的模块. 。
字串7
大圣杰锅是
java 管道流
好像是选D
piped流主要的使用地方是牵涉到多线程的时候，当使用多线程时，往往需要使用piped流，
小韩在追星
编写一个利用管道流，实现线程之间的通信，实现文件传输功能Java程序
管道流实际上就是整行的读取和写入，不用每个字节每个字节的读取和写入。
读写是两个不同的分支，通常都是分开单独使用的。
可以通过BufferedReader 流的形式进行流缓存，之后通过readLine方法获取到缓存的内容。
BufferedReader bre = null;。
try {
String file = "D:/test/test.txt";。
bre = new BufferedReader(new FileReader(file));//此时获取到的bre就是整个文件的缓存流。
while ((str = bre.readLine())!= null) // 判断最后一行不存在，为空结束循环。
System.out.println(str);//原样输出读到的内容。
}；
备注一： 流用完之后必须close掉，如上面的就应该是：bre.close()，否则bre流会一直存在，直到程序运行结束。
可以通过“FileOutputStream”创建文件实例，之后过“OutputStreamWriter”流的形式进行存储，举例：
OutputStreamWriter pw = null;//定义一个流。
pw = new OutputStreamWriter(new FileOutputStream(“D:/test.txt”),"GBK");//确认流的输出文件和编码格式，此过程创建了“test.txt”实例。
pw.write("我是要写入到记事本文件的内容");//将要写入文件的内容，可以多次write。
pw.close();//关闭流。
备注二：文件流用完之后必须及时通过close方法关闭，否则会一直处于打开状态，直至程序停止，增加系统负担。
小韩在追星
import java.io.BufferedReader;。
import java.io.BufferedWriter;。
import java.io.File;。
import java.io.FileOutputStream;。
import java.io.IOException;。
import java.io.InputStreamReader;。
import java.io.PipedInputStream;。
import java.io.PipedOutputStream;。
import java.io.PrintWriter;。
public class Day10A {。
private BufferedReader br;// 字符效率读取流。
private BufferedWriter bw;// 字符效率写出流。
private PipedInputStream pis;// 管道读取流。
private PipedOutputStream pos;// 管道输出流,。
private byte[] readBytes;// 读取缓冲区。
private byte[] writeBytes;// 写出缓冲区。
private String path = "C:\\Users\\Administrator\\Desktop";。
private File file = null;。
private FileOutputStream fos = null;。
Day10A() {
writeBytes = new byte[1024];。
file = new File(path, "测试.txt");。
try {
if (!file.exists()) {。
file.createNewFile();。
fos = new FileOutputStream(file);。
} else {
fos = new FileOutputStream(file, true);。
}
br = new BufferedReader(new InputStreamReader(System.in));。
bw = new BufferedWriter(new PrintWriter(fos));。
pis = new PipedInputStream();。
pos = new PipedOutputStream();。
pis.connect(pos);。
} catch (IOException e) {。
e.printStackTrace();。
}
}
public static void main(String[] args) {。
Day10A d = new Day10A();。
d.readFunction();。
d.writerFunction();。
}
private void readFunction() {。
new Thread(new Runnable() {。
public void run() {。
while (true) {。
try {
for (String str = br.readLine();!str.contentEquals("over"); str = br.readLine()) {。
readBytes = str.getBytes();。
pos.write(readBytes);。
}
} catch (Exception e) {。
}
break;
}
try {
pos.close();。
} catch (IOException e) {。
e.printStackTrace();。
}
}
}).start();
}
private void writerFunction() {。
new Thread(new Runnable() {。
@Override
public void run() {。
try {
String str = "";。
for (int len = pis.read(writeBytes); len != -1; len = pis.read(writeBytes)) {。
str = new String(writeBytes, 0, len);。
bw.write(str + "\r\n");。
bw.flush();。
}
} catch (Exception e) {。
}
}
}).start();
}