Java IO流题库
一、&&& 填空题
Java IO流可以分为& &节点流&& 和处理流两大类，其中前者处于IO操作的第一线，所有操作必须通过他们进行。
输入流的唯一目的是提供通往数据的通道，程序可以通过这个通道读取数据， read
方法给程序提供了一个从输入流中读取数据的基本方法。
read方法从输入流中顺序读取源中的单个字节数据，该方法返回字节值(0-255之间的一个整数)，如果到达源的末尾，该方法返回& -1& &。
Java系统的标准输入对象是System.in，标准输出对象有两个，分别是标准输出System.out和标准错误输出____System.err__。
Java IO体系中，___ ObjectInputStream __是字节输入流，不仅提供了存取所有Java基础类型数据（如：int，double 等）和String的方法,也提供了提供存取对象的方法。
Java IO体系中，____ DataOutputStream __是字节输出流，提供了可以存取所有Java基础类型数据（如：int，double 等）和String的方法,但没有提供存取对象的方法。
___序列化__是指将Java对象转换成字节序列，从而可以保存到磁盘上，也可以在网络上传输，使得不同的计算机可以共享对象。
二、&&& 选择题
使用Java IO流实现对文本文件的读写过程中，需要处理下列（& B& ）异常。（选择一项）
ClassNotFoundException
IOException
SQLException
RemoteException
在Java的IO操作中，（& D& ）方法可以用来刷新流的缓冲。（选择两项）
void release()
void close()
void remove()
void flush()
在Java中，下列关于读写文件的描述错误的是（& B& ）。（选择一项）
Reader类的read()方法用来从源中读取一个字符的数据
Reader类的read(int n )方法用来从源中读取一个字符的数据
Writer类的write(int n)方法用来向输出流写入单个字符
Writer类的write(String str)方法用来向输出流写入一个字符串
阅读下列文件定入的Java代码，共有（ &C& ）处错误。（选择一项）
import java.io.*;
public class TestIO {
public static void main(String []args){
String str ="文件写入练习";
FileWriter fw = null;&&&&&&& //1
fw = new FileWriter("c:\mytext.txt");& //2
fw.writerToEnd(str);&& //3
}catch(IOException e){&& //4
e.printStackTrace();
//此处省略关闭流
分析如下Java代码，有标注的四行代码中，有错误的是第（ D ）处。（选择一项）
import java.io.FileW
import java.io.IOE
public class Test {
public static void main(String[ ] args) {
String str = "Hello World";
FileWriter fw = null;
fw = new FileWriter("c:\\hello.txt"); // 1
fw.write(str); &&&&&&&&&&&&&&&&&&&&// 2
} catch (IOException e) {
e.printStackTrace(); &&&&&&&&&&&&&&// 3
} finally {
fw.close(); &&&&&&&&&&&&&&&&&&&&&&&// 4
以下选项中关于如下代码的说法正确的是（ &AD& ）。（选择二项）
public class TestBuffered {
public static void main(String[] args) throws IOException {
BufferedReader br =
new BufferedReader(new FileReader("d:/bjsxt1.txt"));
BufferedWriter bw =
new BufferedWriter(new FileWriter("d:/bjsxt2.txt"));
String str = br.readLine();
while(str !=null){
bw.write(str);
bw.newLine();
str = br.readLine();
br.close();
bw.close();
该类使用字符流实现了文件复制，将d:/bjsxt1.txt复制为d:/bjsxt2.txt
FileReader和FileWriter是处理流，直接从文件读写数据
BufferedReader和BufferedWriter是节点流，提供缓冲区功能，提高读写效率
readLine()可以读取一行数据，返回值是字符串类型，简化了操作
InputStreamReader是转换流，可以将字节流转换成字符流，是字符流与字节流之间的桥梁。它的实现使用的设计模式是（ &C& ）。（选择一项）
适配器模式
三、&&& 判断题
假设文件”a.txt”的长度为100字节，那么当正常运行语句”OutputStream f=new FileOutputStream(new File(“a.txt”));”之后，文件”a.txt”的长度变为0字节。（& T& ）
ByteArrayInutStream和ByteArrayOutputStream对内存中的字节数组进行读写操作，属于字节流，属于处理流而不是节点流。 （& F& ）
实现Serializable接口的可以被序列化和反序列化。该接口中没有定义抽象方法，也没有定义常量。（& T& ）
序列化是指将字节序列转换成Java对象，只有实现了Serializable接口的类的对象才可以被序列化。（& F& ）
四、&&& 简答题
输入流和输出流的联系和区别，字符流和字节流的联系和区别
列举常用的字节输入流和字节输出流并说明其特点，至少5对。
说明缓冲流的优点和原理
序列化的定义、实现和注意事项
五、&&& 编码题
1.实现字符串和字节数组之间的相互转换。必如将字符串“北京尚学堂bjsxt”转换为字节数组，并将字节数组再转换回字符串。
public class TestConvert
public static void main(String[] args) throws IOException
//准备一个字符串
String contents = " 近日，北京尚学堂科技有限公司正式成为央视网广告合作伙伴";
System.out.println(contents);
//String---byte []
byte[] buf = contents.getBytes();
//byte[]----String
String contents2 = new String(buf, 0, buf.length);
System.out.println(contents2);
2.实现字节数组和任何基本类型和引用类型执行的相互转换
提示：使用ByteArrayInutStream和ByteArrayOutputStream。
public class TestByteArrayStream
public static void main(String[] args) throws IOException,
ClassNotFoundException
int num = 50;
boolean flag =
User user = new User("bjsxt", "bjsxt");
//使用数据包把数据封装起来
//各种数据类型-----&byte[]
ByteArrayOutputStream
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);//包装流
oos.writeInt(num);
oos.writeBoolean(flag);
oos.writeObject(user);
byte[] buf = baos.toByteArray();
baos.close();
//byte[]-----------&各种数据类型
ByteArrayInputStream bais = new ByteArrayInputStream(buf);
ObjectInputStream ois = new ObjectInputStream(bais);
int num2 = ois.readInt();
boolean flag2 = ois.readBoolean();
User user2 = (User) ois.readObject();
System.out.println(num2);
System.out.println(flag2);
System.out.println(user2);
bais.close();
3.分别使用文件流和缓冲流复制一个长度大于100MB的视频文件，并观察效率的差异。
public class TestCopy4
public static void main(String[] args) throws IOException
//创建输入流和输出流
InputStream fis = new FileInputStream(new File("d:/1.mp4"));
OutputStream fos = new FileOutputStream("d:/2.mp4");
//使用输入流和输出流复制文件
byte[] buf = new byte[10];
int len = fis.read(buf);
while (len != -1)
fos.write(buf, 0, len);
len = fis.read(buf);
//System.out.println(len);
//关闭输入流和输出流
fis.close();
fos.close();
public class TestCopy
public static void main(String[] args) throws IOException
//创建输入流和输出流
InputStream fis = new FileInputStream(new File("d:/1.mp4"));
OutputStream fos = new FileOutputStream("d:/2.mp4");
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
//使用输入流和输出流复制文件
byte[] buf = new byte[10];
int len = bis.read(buf);
while (len != -1)
bos.write(buf, 0, len);
len = bis.read(buf);
//关闭输入流和输出流
bis.close();
bos.close();
4.复制文件夹d:/sxtjava下面所有文件和子文件夹内容到d:/sxtjava2。
提示：涉及单个文件复制、目录的创建、递归的使用
public class CopyDir
* 复制单个文件
* @param sourceFile 源文件
* @param targetFile 目标文件
* @throws IOException
public static void copyFile(File sourceFile, File targetFile) throws IOException
BufferedInputStream inBuff =
BufferedOutputStream outBuff =
// 新建文件输入流
inBuff = new BufferedInputStream(new FileInputStream(sourceFile));
// 新建文件输出流
outBuff = new BufferedOutputStream(new FileOutputStream(targetFile));
// 缓冲数组
byte[] b = new byte[1024 * 5];
while ((len = inBuff.read(b)) != -1)
outBuff.write(b, 0, len);
// 刷新此缓冲的输出流
outBuff.flush();
if (inBuff != null)
inBuff.close();
if (outBuff != null)
outBuff.close();
* 复制目录
* @param sourceDir 源目录
* @param targetDir 目标目录
* @throws IOException
public static void copyDirectiory(String sourceDir, String targetDir)
throws IOException
// 检查源目录
File fSourceDir = new File(sourceDir);
if (!fSourceDir.exists() || !fSourceDir.isDirectory())
System.out.println("源目录不存在");
//检查目标目录，如不存在则创建
File fTargetDir = new File(targetDir);
if (!fTargetDir.exists())
fTargetDir.mkdirs();
// 遍历源目录下的文件或目录
File[] file = fSourceDir.listFiles();
for (int i = 0; i & file. i++)
if (file[i].isFile())
File sourceFile = file[i];
// 目标文件
File targetFile = new File(fTargetDir, file[i].getName());
copyFile(sourceFile, targetFile);
//递归复制子目录
if (file[i].isDirectory())
// 准备复制的源文件夹
String subSourceDir = sourceDir + File.separator + file[i].getName();
// 准备复制的目标文件夹
String subTargetDir = targetDir + File.separator + file[i].getName();
// 复制子目录
copyDirectiory(subSourceDir, subTargetDir);
public static void main(String[] args) throws IOException
copyDirectiory("d:/sxtjava", "d:/sxtjava2");
1.使用IO包中的类读取D盘上exam.txt文本文件的内容，每次读取一行内容，将每行作为一个输入放入ArrayList的泛型集合中并将集合中的内容使用加强for进行输出显示。
public class Test
public static void main(String[] args) throws IOException
String path = "D:\\exam.txt";
outputMethod(path);
public static void outputMethod(String path) throws IOException
List&String& list = new ArrayList&String&(); // 创建集合对象
// 创建缓冲区对象
BufferedReader br = new BufferedReader(new FileReader(path));
String line = br.readLine(); // 读取数据每次读一行
while (line != null)
list.add(line);
line = br.readLine();
br.close();
for (String s : list)
System.out.println(s);
2.假设从入学开始所有书写的Java类代码都在d:/sxtjava文件夹下，包括多级子文件夹。使用IO流获取从入学开始，到目前为止已经写了多少行Java代码。
其实就是获取d:/sxtjava文件夹及其子文件夹下的所有.java文件，使用readLine()读取其中每一行，每读取一行，行数加1。所有的文件读取完毕，得到总共已经写的Java代码行数。需要结合递归实现。
public class TestCountDir
* 统计一个java文件的行数
private void countLine(File sourceFile) throws IOException
BufferedReader br =
// 新建文件输入流
br = new BufferedReader(new FileReader(sourceFile));
while (br.readLine() != null)
//System.out.println(count);
br.close();
* 统计一个目录下所有Java文件的行数
private void countDir(String sourceDir) throws IOException
// 检查源目录
File fSourceDir = new File(sourceDir);
if (!fSourceDir.exists() || !fSourceDir.isDirectory())
System.out.println("源目录不存在");
// 遍历目录下的文件或目录
File[] file = fSourceDir.listFiles();
for (int i = 0; i & file. i++)
if (file[i].isFile())
if (file[i].getName().toLowerCase().endsWith(".java"))
// System.out.println(file[i].getName());
countLine(file[i]);
//递归统计代码行数
if (file[i].isDirectory())
// 准备统计的文件夹
String subSourceDir = sourceDir + File.separator + file[i].getName();
// 统计子目录
countDir(subSourceDir);
public static void main(String[] args) throws IOException
TestCountDir tcd = new TestCountDir();
tcd.countDir("d:/sxtjava");
System.out.println(tcd.count);
3.由控制台按照固定格式输入学生信息，包括学号，姓名，年龄信息，当输入的内容为exit退出；将输入的学生信息分别封装到一个Student对象中，再将每个Student对象加入到一个集合中，要求集合中的元素按照年龄大小正序排序；最后遍历集合，将集合中学生信息写入到记事本，每个学生数据占单独一行。
public class Student implements Comparable&Student&
//省略getter和setter方法
//省略构造方法
public int compareTo(Student stu)
return this.age - stu.
public String toString()
return "Student [age=" + age + ", name=" + name
+ ", num=" + num + "]";
public class Test
public static void main(String[] args)
Set&Student& stuSet = saveStudentInfo();
outputInfo(stuSet);
private static Set&Student& saveStudentInfo()
Scanner input = new Scanner(System.in);
// 保存学生信息的TreeSet集合对象
Set&Student& stuSet = new TreeSet&Student&();
while (true)
// 输入提示
System.out.println("请输入学生信息:(学号#姓名#年龄)");
String inputData = input.nextLine();
// 判断是否退出 inputData.equals("exit")
if ("exit".equals(inputData))
// 将用户输入的学生信息分割为String[]
String[] info = inputData.split("#");
// 将输入信息封装到Student对象中
Student stu
= new Student(Integer.parseInt(info[0]), info[1],
Integer.parseInt(info[2]));
// 将学生对象加入集合
stuSet.add(stu);
return stuS
private static void outputInfo(Set&Student& stuSet)
File file = new File("e:/student.txt");
// 创建文件输出流对象
FileWriter fw =
fw = new FileWriter(file);
Iterator&Student& it = stuSet.iterator();
while (it.hasNext())
String info = it.next().toString();
// 将info字符串，写入记事本
fw.write(info);
// 完成换行功能
fw.write("\r\n");
} catch (Exception e)
e.printStackTrace();
fw.close();
} catch (IOException e)
e.printStackTrace();
Java:IO流与文件基础 说明: 本章内容将会持续更新,大家可以关注一下并给我提供建议,谢谢啦. 走进流 什么是流 流:从源到目的地的字节的有序序列. 在Java中,可以从其中读取一个字节序列的对象 ...
流的概念和作用 学习Java IO,不得不提到的就是JavaIO流. 流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输 ...
Java流操作有关的类或接口: Java流类图结构: 流的概念和作用 流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输 ...
大家在使用Java IO流中OutputStream.PrintWriter --时,会经常用到它的flush()方法. 与在网络硬件中缓存一样,流还可以在软件中得到缓存,即直接在Java代码中缓存. ...
java io流 对文件夹的操作 检查文件夹是否存在 显示文件夹下面的文件 ....更多方法参考 /phpyangbo/p/5965781.html ,与文 ...
Java IO流分类以及主要使用方式如下: IO流 |--字节流 |--字节输入流 InputStream: int read();//一次读取一个字节 int read(byte[] bys);// ...
java io流 运行错误时,保存异常到文件里面 下面这个实例,运行后,输入数字,为正确,如果输入字符串,则报错,保存错误信息 //运行错误时,保存异常到文件里面 //下面这个实例,运行后,输入数字, ...
java io流 创建文件 写入数据 改变system.out.print的输出位置 //创建文件 //写入数据 //改变system.out.print的输出位置 import java.io.*; ...
java io流 数据流传输 把这段当公式用就可以了 //数据流传输 import java.io.*; public class Index{ public static void main(Str ...
Git学习笔记与IntelliJ IDEA整合 一.Git学习笔记(基于Github) 1.安装和配置Git 下载地址:/downloads Git简要使用说明:h ...
前言 在使用React进行构建应用时,我们总会有一个步骤将组建或者虚拟DOM元素渲染到真实的DOM上,将任务交给浏览器,进而进行layout和paint等步骤,这个函数就是React.render() ...
日 最近,因为工作需要,我从网上买了一本&Spring MVC学习指南&,ISBN编号: 978-7-115-38639-7,定价:49.00元.此书是[美]Paul D ...
$(&#button&).click(function() { /获取表单中id为idname和count的文本值付给property的两个属性 var property={&qu ...
当我们无法使用xftp方式上传文件到Linux系统时,我们可以使用在Windows下压缩文件夹,然后到Linux系统下解压缩的方式,完成整个上传工作. 第一步:在Windows系统下,将整个文件夹压缩 ...
LINQ and LINQ Providers
LINQ is a feature of the programming languages C# and Microsoft Visual Bas ...
谷歌chrome浏览器自带http抓包工具 chrome://net-internals/ 谷歌chrome浏览器http请求模拟插件:postman 火狐http请求模拟插件:httprequest ...
[问题2015S02]
设 \(a,b,c\) 为复数且 \(bc\neq 0\), 证明下列 \(n\) 阶方阵 \(A\) 可对角化: \[A=\begin{pmatrix} a & b ...
格式化日期 我们可以使用 time 模块的 strftime 方法来格式化日期,: time.strftime(format[, t]) #!/usr/bin/python # -*- coding: ...
转自:http://blog.csdn.net/bcmissrain/article/details/7190886 其实就算是现在,我还是有不少地方概念模糊,但是下面的内容是是没有什么问题的.稍微介 ...在当前目录创建一个文件夹，然后在文件夹里创建一个文件，然后在文件里写入一些文字？如何写？-CSDN论坛
在当前目录创建一个文件夹，然后在文件夹里创建一个文件，然后在文件里写入一些文字？如何写？
在当前目录创建一个文件夹，然后在文件夹里创建一个文件，然后在文件里写入一些文字？如何写？
当前目录是程序目录，还是系统的当前目录阿？
System.IO.DirectoryInfo&a=System.IO.Directory.CreateDirectory("a");
System.IO.StreamWriter&sw=System.IO.File.CreateText(a.FullName);
sw.WriteLine("sdadsasda");
sw.Close();
Directory.CreateDirectory&(String)&&按&path&的指定创建所有目录和子目录。
using&(StreamWriter&sw&=&new&StreamWriter("TestFile.txt"))&
&&&&&&&&&&&&//&Add&some&text&to&the&file.
&&&&&&&&&&&&sw.Write("This&is&the&");
&&&&&&&&&&&&sw.WriteLine("header&for&the&file.");
&&&&&&&&&&&&sw.WriteLine("-------------------");
&&&&&&&&&&&&//&Arbitrary&objects&can&also&be&written&to&the&file.
&&&&&&&&&&&&sw.Write("The&date&is:&");
&&&&&&&&&&&&sw.WriteLine(DateTime.Now);
这是写文件和创建文件。
string&dir=Application.StartupP
//可以获得应用程序目录
回复Java读取txt文件和写入txt文件的简单实例_java
作者：用户
本文讲的是Java读取txt文件和写入txt文件的简单实例_java，
写Java程序时经常碰到要读如txt或写入txt文件的情况，但是由于要定义好多变量，经常记不住，每次都要查，特此整理一下，简单易用，方便好懂！
package edu.thu.keyword.
import java.io
写Java程序时经常碰到要读如txt或写入txt文件的情况，但是由于要定义好多变量，经常记不住，每次都要查，特此整理一下，简单易用，方便好懂！
package edu.thu.keyword.
import java.io.F
import java.io.InputStreamR
import java.io.BufferedR
import java.io.BufferedW
import java.io.FileInputS
import java.io.FileW
public class cin_txt {
static void main(String args[]) {
try { // 防止文件建立或读取失败，用catch捕捉错误并打印，也可以throw
/* 读入TXT文件 */
String pathname = "D:\\twitter\\13_9_6\\dataset\\en\\input.txt"; // 绝对路径或相对路径都可以，这里是绝对路径，写入文件时演示相对路径
File filename = new File(pathname); // 要读取以上路径的input。txt文件
InputStreamReader reader = new InputStreamReader(
new FileInputStream(filename)); // 建立一个输入流对象reader
BufferedReader br = new BufferedReader(reader); // 建立一个对象，它把文件内容转成机能读懂的语言
String line = "";
line = br.readLine();
while (line != null) {
line = br.readLine(); // 一次读入一行数据
/* 写入Txt文件 */
File writename = new File(".\\result\\en\\output.txt"); // 相对路径，如果没有则要建立一个新的output。txt文件
writename.createNewFile(); // 创建新文件
BufferedWriter out = new BufferedWriter(new FileWriter(writename));
out.write("我会写入文件啦\r\n"); // \r\n即为换行
out.flush(); // 把缓存区内容压入文件
out.close(); // 最后记得关闭文件
} catch (Exception e) {
e.printStackTrace();
以上这篇Java读取txt文件和写入txt文件的简单实例就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持云栖社区。
以上是云栖社区小编为您精心准备的的内容，在云栖社区的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索简单的java项目实例、java web简单实例、java简单工厂模式实例、java读取串口数据实例、java文件的读取和写入，以便于您获取更多的相关知识。
稳定可靠、可弹性伸缩的在线数据库服务，全球最受欢迎的开源数据库之一
6款热门基础云产品6个月免费体验；2款产品1年体验;1款产品2年体验
弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率
开发者常用软件，超百款实用软件一站式提供
云栖社区()为您免费提供相关信息，包括
简单的java项目实例、java web简单实例、java简单工厂模式实例、java读取串口数据实例、java文件的读取和写入的信息
，所有相关内容均不代表云栖社区的意见！File f1 = new File("E:" + File.separator + "jay-x-program"
+ File.separator + "myJ2se" + File.separator + "src"
+ File.separator + "jay_x__thread_file");
这个是我的路径，如果大家需要运行这个小程序的话，需要把这个路径改成自己的文件夹路径。
/*创建一个一个文件目录， 在该目录下创建一个文件 txt 然后写入内容进去， 再读取文件，read() 和read（byte[] b） 显示读取后文件的各类信息*/package jay_x__thread_
import java.io.Fimport java.io.FileInputSimport java.io.FileOutputSimport java.io.IOEimport java.util.D
public class java_x_文件_字节流 { public static void main(String[] args) {
// File.separator的使用。
File f1 = new File("E:" + File.separator + "jay-x-program"
+ File.separator + "myJ2se" + File.separator + "src"
+ File.separator + "jay_x__thread_file");
System.out.println("f1是否是一个文件" + f1.isFile());
System.out.println("f1是否是一个目录" + f1.isDirectory());
System.out.println("该文件的路径" + f1.getAbsolutePath());
String str[] = f1.list();
System.out.println("显示该文件下的所有子文件：");
for (int i = 0; i & str. i++) {
System.out.println(str[i]);
File f2 = new File(f1, "text1.txt");
if (!f2.exists()) {
f2.createNewFile();
System.out.println("该文件的路径" + f2.getAbsolutePath());
System.out.println("上次修改是：" + f2.lastModified());
System.out.println("上次修改是：" + new Date(f2.lastModified()));
String s = new String("将string转换成 字节数组!");
String s2 = new String("第二次输入");
byte[] bs = s.getBytes();
byte bs2[] = s2.getBytes();
FileOutputStream fos = new FileOutputStream(f2);
System.out.println("写入之前" +
"\t的字节数" + f2.length());
fos.write(bs);
System.out.println("完事后的字节数" + f2.length());
System.out
.println("\n\n\n接下来就是读取文件内容了：" + f2.getAbsolutePath());
FileInputStream fis = new FileInputStream(f2);
System.out.println("read():");
while ((b = fis.read()) != -1) {
char c = (char)
System.out.print(c);
System.out.println("测试read()的返回值：" + b);// -1
fos.write(bs2);
// 问题：fis.read()每次读了一次后会显示到下一行，不能够重复应用！
System.out.println("\n\n\n(byte[] b, int off, int len):");
byte[] bs3 = new byte[100];
int length = (int) f2.length();
while ((b2 = fis.read(bs3, 0, length)) != -1) {
* int read(byte[] b, int off, int len) 从此输入流中将最多 len
* 个字节的数据读入一个字节数组中
System.out.println("(b2 = fis.read(bs3,0,length))"
+ (b2 = fis.read(bs3, 0, length)));// -1
System.out.println("测试read(bs3, 0, length)的返回值：" + b2);// -1
// 将字节数组转换成字符串
String str3 = new String(bs3, 0, length);
System.out.println("String(bs3,0,length)结果:" + str3);
// String str4 = new String(bs3, 0, b2);
// System.out.println("String(bs3,0,b2)结果:" + str4);
// Exception in thread "main"
// java.lang.StringIndexOutOfBoundsException: String index out
// of range: -1
* void write(byte[] b) 将 b.length 个字节从指定字节数组写入此文件输出流中。 void
* write(byte[] b, int off, int len) 将指定字节数组中从偏移量 off 开始的 len
* 个字节写入此文件输出流。 void write(int b) 将指定字节写入此文件输出流。
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
以上是我最近学习Java记录的笔记和自己参照书本和老师所讲编写的代码和注释。 这是我的QQ，欢迎各位学习编程的同学加我好友，或者给我的个人主页留言（/），一起讨论，学习。呵呵。
下载次数: 3
浏览: 14366 次
来自: 上海
恩，而且相对而言，理解起来也是有一定难度的。
而且很有用的一块 ...
IO, 每个人Javaer 都应该好好学习的东西!
jayxigua 写道lucky16 写道楼主阿, 下次发帖注 ...
lucky16 写道楼主阿, 下次发帖注意一下格式,看到我眼都 ...
楼主阿, 下次发帖注意一下格式,看到我眼都花了!
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'