java try finally connectoin close-凯发k8官方网
一、流的概念和作用。
流是一种有顺序的，有起点和终点的字节集合，是对数据传输的总成或抽象。即数据在两设备之间的传输称之为流，流的本质是数据传输，根据数据传输的特性讲流抽象为各种类，方便更直观的进行数据操作。
二、io流的分类。
根据数据处理类的不同分为：字符流和字节流。
根据数据流向不同分为：输入流和输出流。
三、字符流和字节流。
字符流的由来：因为数据编码的不同，而有了对字符进行高效操作的流对象，其本质就是基于字节流读取时，去查了指定的码表。字符流和字节流的区别：
(1)读写单位不同：字节流一字节(8bit)为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
(2)处理对象不同：字节流能处理所有类型的数据(例如图片，avi)，而字符流只能处理字符类型的数据。
(3)字节流操作的时候本身是不会用到缓冲区的，是对文件本身的直接操作。而字符流在操作的时候是会用到缓冲区的，通过缓冲区来操作文件。
结论：优先使用字节流，首先因为在硬盘上所有的文件都是以字节的形式进行传输或保存的，包括图片等内容。但是字符流只是在内存中才会形成，所以在开发中字节流使用广泛。
四、输入流和输出流。
对输入流只能进行读操作，对输出流只能进行写操作。程序中根据数据传输的不同特性使用不同的流。
五、输入字节流inputstream。
inputstream是所有输入字节流的父类，它是一个抽象类。
bytearrayinputstream、stringbufferinputstream、fileinputstream 是三种基本的介质流，它们分别从byte 数组、stringbuffer、和本地文件中读取数据。pipedinputstream 是从与其它线程共用的管道中读取数据，与piped 相关的知识后续单独介绍。
objectinputstream 和所有filterinputstream的子类都是装饰流(装饰器模式的主角)。意思是fileinputstream类可以通过一个string路径名创建一个对象，fileinputstream(string name)。而datainputstream必须装饰一个类才能返回一个对象，datainputstream(inputstream in)。
讲解demo。
读取文件，节省空间。
/*
to change this license header, choose license headers in project properties.
to change this template file, choose tools | templates
and open the template in the editor.
*/
package javaio;
import java.io.file;
import java.io.fileinputstream;
import java.io.ioexception;
import java.io.inputstream;
/**
字节流读取文件内容
节省空间的方式
@author xk
*/
public class iotest {
public static void main(string[] args) throws ioexception {
string filename = "d:" file.separator "hello.txt";
file f = new file(filename);
inputstream in = new fileinputstream(f);
byte[] b = new byte[(int)f.length()];
in.read(b);
system.err.println("长度为=" f.length());
in.close();
system.err.println(new string(b));
}
}
逐一字节读：
/*
to change this license header, choose license headers in project properties.
to change this template file, choose tools | templates
and open the template in the editor.
*/
package javaio;
import java.io.file;
import java.io.fileinputstream;
import java.io.ioexception;
import java.io.inputstream;
/**
逐字节读
读取文件内容，节省空间
@author xk
*/
public class iotest {
public static void main(string[] args) throws ioexception {
string filename = "d:" file.separator "hello.txt";
file f = new file(filename);
inputstream in = new fileinputstream(f);
byte[] b = new byte[(int)f.length()];
for(int i = 0;i< b.length;i ){
b[i] = (byte) in.read();
}
in.close();
system.err.println(new string(b));
}
}
注意：上面的几个例子都是在知道文件的内容多大，然后才展开的，有时候我们不知道文件有多大，这种情况下，我们需要判断是否独到文件的末尾。
/*
to change this license header, choose license headers in project properties.
to change this template file, choose tools | templates
and open the template in the editor.
*/
package javaio;
import java.io.file;
import java.io.fileinputstream;
import java.io.ioexception;
import java.io.inputstream;
/**
逐字节读取文件内容
@author xk
*/
public class iotest {
public static void main(string[] args) throws ioexception {
string filename = "d:" file.separator "hello.txt";
file f = new file(filename);
inputstream in = new fileinputstream(f);
byte[] b = new byte[1024];
int count = 0;
int temp = 0;
while((temp = in.read())!=(-1)){
b[count ] = (byte)temp;
}
in.close();
system.err.println(new string(b));
}
}
注意：当读到文件末尾的时候会返回-1.正常情况下是不会返回-1的。
pushbackinputstream回退流操作：
/*
to change this license header, choose license headers in project properties.
to change this template file, choose tools | templates
and open the template in the editor.
*/
package javaio;
import java.io.bytearrayinputstream;
import java.io.ioexception;
import java.io.pushbackinputstream;
/**
@author xk
*/
public class iotest {
public static void main(string[] args) throws ioexception {
string str = "hello,rollenholt";
pushbackinputstream push = null;
bytearrayinputstream bat = null;
bat = new bytearrayinputstream(str.getbytes());
push = new pushbackinputstream(bat);
int temp = 0;
while ((temp = push.read()) != -1) {
if (temp == ',') {
push.unread(temp);
temp = push.read();
system.out.print("(回退" (char) temp ") ");
} else {
system.out.print((char) temp);
}
}
}
}
六、输出字节流outputstream。
outputstream是所有输出流的父类，它是一个抽象类。
bytearrayoutputstream、fileoutputstream是两种基本的介质流，它们分别向byte 数组、和本地文件中写入数据。pipedoutputstream 是向与其它线程共用的管道中写入数据，
objectoutputstream 和所有filteroutputstream的子类都是装饰流。具体例子跟inputstream是对应的。
实例demo:
向文件中写入字符串：
/*
to change this license header, choose license headers in project properties.
to change this template file, choose tools | templates
and open the template in the editor.
*/
package javaio;
import java.io.file;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.outputstream;
/**
@author xk
*/
public class outputstreamdemo {
public static void main(string[] args) throws ioexception {
string filename = "d:" file.separator "hello.txt";
file f = new file(filename);
outputstream os = new fileoutputstream(f);
string str = "xukuntest";
byte[] b = str.getbytes();
os.write(b);
os.close();
}
}
/**
字节流
向文件中一个字节一个字节的写入字符串
/
import java.io.;
class hello{
public static void main(string[] args) throws ioexception {
string filename="d:" file.separator "hello.txt";
file f=new file(filename);
outputstream out =new fileoutputstream(f);
string str="hello world！！";
byte[] b=str.getbytes();
for (int i = 0; i < b.length; i ) {
out.write(b[i]);
}
out.close();
}
}
/**
字节流
向文件中追加新内容：
/
import java.io.;
class hello{
public static void main(string[] args) throws ioexception {
string filename="d:" file.separator "hello.txt";
file f=new file(filename);
outputstream out =new fileoutputstream(f,true);//true表示追加模式，否则为覆盖
string str="rollen";
//string str="\r\nrollen"; 可以换行
byte[] b=str.getbytes();
for (int i = 0; i < b.length; i ) {
out.write(b[i]);
}
out.close();
}
}
/**
文件的复制
/
import java.io.;
class hello{
public static void main(string[] args) throws ioexception {
if(args.length!=2){
system.out.println("命令行参数输入有误，请检查");
system.exit(1);
}
file file1=new file(args[0]);
file file2=new file(args[1]);
if(!file1.exists()){
system.out.println("被复制的文件不存在");
system.exit(1);
}
inputstream input=new fileinputstream(file1);
outputstream output=new fileoutputstream(file2);
if((input!=null)&&(output!=null)){
int temp=0;
while((temp=input.read())!=(-1)){
output.write(temp);
}
}
input.close();
output.close();
}
}
/**
使用内存操作流将一个大写字母转化为小写字母
/
import java.io.;
class hello{
public static void main(string[] args) throws ioexception {
string str="rollenholt";
bytearrayinputstream input=new bytearrayinputstream(str.getbytes());
bytearrayoutputstream output=new bytearrayoutputstream();
int temp=0;
while((temp=input.read())!=-1){
char ch=(char)temp;
output.write(character.tolowercase(ch));
}
string outstr=output.tostring();
input.close();
output.close();
system.out.println(outstr);
}
}
/**
验证管道流
/
import java.io.;
/**
消息发送类
*/
class send implements runnable{
private pipedoutputstream out=null;
public send() {
out=new pipedoutputstream();
}
public pipedoutputstream getout(){
return this.out;
}
public void run(){
string message="hello , rollen";
try{
out.write(message.getbytes());
}catch (exception e) {
e.printstacktrace();
}try{
out.close();
}catch (exception e) {
e.printstacktrace();
}
}
}
/**
接受消息类
/
class recive implements runnable{
private pipedinputstream input=null;
public recive(){
this.input=new pipedinputstream();
}
public pipedinputstream getinput(){
return this.input;
}
public void run(){
byte[] b=new byte[1000];
int len=0;
try{
len=this.input.read(b);
}catch (exception e) {
e.printstacktrace();
}try{
input.close();
}catch (exception e) {
e.printstacktrace();
}
system.out.println("接受的内容为 " (new string(b,0,len)));
}
}
/*
测试类
*/
class hello{
public static void main(string[] args) throws ioexception {
send send=new send();
recive recive=new recive();
try{
//管道连接
send.getout().connect(recive.getinput());
}catch (exception e) {
e.printstacktrace();
}
new thread(send).start();
new thread(recive).start();
}
}
dataoutputstream类示例
import java.io.dataoutputstream;
import java.io.file;
import java.io.fileoutputstream;
import java.io.ioexception;
public class dataoutputstreamdemo{
public static void main(string[] args) throws ioexception{
file file = new file("d:" file.separator "hello.txt");
char[] ch = { 'a', 'b', 'c' };
dataoutputstream out = null;
out = new dataoutputstream(new fileoutputstream(file));
for(char temp : ch){
out.writechar(temp);
}
out.close();
}
}
java.util.zip.zipoutputstream
import java.io.file;
import java.io.fileinputstream;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.util.zip.zipentry;
import java.util.zip.zipoutputstream;
public class zipoutputstreamdemo1{
public static void main(string[] args) throws ioexception{
file file = new file("d:" file.separator "hello.txt");
file zipfile = new file("d:" file.separator "hello.zip");
inputstream input = new fileinputstream(file);
zipoutputstream zipout = new zipoutputstream(new fileoutputstream(
zipfile));
zipout.putnextentry(new zipentry(file.getname()));
// 设置注释
zipout.setcomment("hello");
int temp = 0;
while((temp = input.read()) != -1){
zipout.write(temp);
}
input.close();
zipout.close();
}
}
【案例】zipoutputstream类压缩多个文件
import java.io.file;
import java.io.fileinputstream;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.util.zip.zipentry;
import java.util.zip.zipoutputstream;
/**
一次性压缩多个文件
*/
public class zipoutputstreamdemo2{
public static void main(string[] args) throws ioexception{
// 要被压缩的文件夹
file file = new file("d:" file.separator "temp");
file zipfile = new file("d:" file.separator "zipfile.zip");
inputstream input = null;
zipoutputstream zipout = new zipoutputstream(new fileoutputstream(
zipfile));
zipout.setcomment("hello");
if(file.isdirectory()){
file[] files = file.listfiles();
for(int i = 0; i < files.length; i){
input = newfileinputstream(files[i]);
zipout.putnextentry(newzipentry(file.getname()
file.separator files[i].getname()));
int temp = 0;
while((temp = input.read()) !=-1){
zipout.write(temp);
}
input.close();
}
}
zipout.close();
}
}
【案例】zipfile类展示
import java.io.file;
import java.io.ioexception;
import java.util.zip.zipfile;
/**
*zipfile演示
*/
public class zipfiledemo{
public static void main(string[] args) throws ioexception{
file file = new file("d:" file.separator "hello.zip");
zipfile zipfile = new zipfile(file);
system.out.println("压缩文件的名称为：" zipfile.getname());
}
}
【案例】解压缩文件(压缩文件中只有一个文件的情况)
import java.io.file;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.io.outputstream;
import java.util.zip.zipentry;
import java.util.zip.zipfile;
/**
解压缩文件(压缩文件中只有一个文件的情况)
*/
public class zipfiledemo2{
public static void main(string[] args) throws ioexception{
file file = new file("d:" file.separator "hello.zip");
file outfile = new file("d:" file.separator "unzipfile.txt");
zipfile zipfile = new zipfile(file);
zipentry entry =zipfile.getentry("hello.txt");
inputstream input = zipfile.getinputstream(entry);
outputstream output = new fileoutputstream(outfile);
int temp = 0;
while((temp = input.read()) != -1){
output.write(temp);
}
input.close();
output.close();
}
}
【案例】zipinputstream类解压缩一个压缩文件中包含多个文件的情况
import java.io.file;
import java.io.fileinputstream;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.io.outputstream;
import java.util.zip.zipentry;
import java.util.zip.zipfile;
import java.util.zip.zipinputstream;
/**
解压缩一个压缩文件中包含多个文件的情况
*/
public class zipfiledemo3{
public static void main(string[] args) throws ioexception{
file file = new file("d:" file.separator "zipfile.zip");
file outfile = null;
zipfile zipfile = new zipfile(file);
zipinputstream zipinput = new zipinputstream(new fileinputstream(file));
zipentry entry = null;
inputstream input = null;
outputstream output = null;
while((entry = zipinput.getnextentry()) != null){
system.out.println("解压缩" entry.getname() "文件");
outfile = new file("d:" file.separator entry.getname());
if(!outfile.getparentfile().exists()){
outfile.getparentfile().mkdir();
}
if(!outfile.exists()){
outfile.createnewfile();
}
input = zipfile.getinputstream(entry);
output = new fileoutputstream(outfile);
int temp = 0;
while((temp = input.read()) != -1){
output.write(temp);
}
input.close();
output.close();
}
}
}
七.几个特殊的输入流类分析
linenumberinputstream
主要完成从流中读取数据时，会得到相应的行号，至于什么时候分行、在哪里分行是由改类主动确定的，并不是在原始中有这样一个行号。在输出部分没有对应的部分，我们完全可以自己建立一个linenumberoutputstream，在最初写入时会有一个基准的行号，以后每次遇到换行时会在下一行添加一个行号，看起来也是可以的。好像更不入流了。
pushbackinputstream
其功能是查看最后一个字节，不满意就放入缓冲区。主要用在编译器的语法、词法分析部分。输出部分的bufferedoutputstream 几乎实现相近的功能。
stringbufferinputstream
已经被deprecated，本身就不应该出现在inputstream部分，主要因为string 应该属于字符流的范围。已经被废弃了，当然输出部分也没有必要需要它了！还允许它存在只是为了保持版本的向下兼容而已。
sequenceinputstream
可以认为是一个工具类，将两个或者多个输入流当成一个输入流依次读取。完全可以从io 包中去除，还完全不影响io 包的结构，却让其更“纯洁”――纯洁的decorator 模式。
【案例】将两个文本文件合并为另外一个文本文件
import java.io.file;
import java.io.fileinputstream;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.io.outputstream;
import java.io.sequenceinputstream;
/**
将两个文本文件合并为另外一个文本文件
/
public class sequenceinputstreamdemo{
public static voidmain(string[] args) throws ioexception{
file file1 = newfile("d:" file.separator "hello1.txt");
file file2 = newfile("d:" file.separator "hello2.txt");
file file3 = newfile("d:" file.separator "hello.txt");
inputstream input1 =new fileinputstream(file1);
inputstream input2 =new fileinputstream(file2);
outputstream output =new fileoutputstream(file3);
// 合并流
sequenceinputstreamsis = new sequenceinputstream(input1, input2);
int temp = 0;
while((temp =sis.read()) != -1){
output.write(temp);
}
input1.close();
input2.close();
output.close();
sis.close();
}
}
printstream
也可以认为是一个辅助工具。主要可以向其他输出流，或者fileinputstream 写入数据，本身内部实现还是带缓冲的。本质上是对其它流的综合运用的一个工具而已。一样可以踢出io 包！system.err和system.out 就是printstream 的实例！
【案例】使用printstream进行格式化输出
/*
使用printstream进行输出
并进行格式化
/
import java.io.;
class hello {
public static void main(string[] args) throws ioexception {
printstream print = new printstream(new fileoutputstream(newfile("d:"
file.separator "hello.txt")));
string name="rollen";
int age=20;
print.printf("姓名：%s. 年龄：%d.",name,age);
print.close();
}
}
【案例】使用outputstream向屏幕上输出内容
/**
使用outputstream向屏幕上输出内容
/
import java.io.;
class hello {
public static void main(string[] args) throws ioexception {
outputstream out=system.out;
try{
out.write("hello".getbytes());
}catch (exception e) {
e.printstacktrace();
}
try{
out.close();
}catch (exception e) {
e.printstacktrace();
}
}
}
【案例】输入输出重定向
import java.io.file;
import java.io.filenotfoundexception;
import java.io.fileoutputstream;
import java.io.printstream;
/**
为system.out.println()重定向输出
/
public class systemdemo{
public static void main(string[] args){
// 此刻直接输出到屏幕
system.out.println("hello");
file file = new file("d:" file.separator "hello.txt");
try{
system.setout(new printstream(new fileoutputstream(file)));
}catch(filenotfoundexception e){
e.printstacktrace();
}
system.out.println("这些内容在文件中才能看到哦！");
}
【案例】system.in重定向
import java.io.file;
import java.io.fileinputstream;
import java.io.filenotfoundexception;
import java.io.ioexception;
/*
*system.in重定向
/
public class systemin{
public static void main(string[] args){
file file = new file("d:" file.separator "hello.txt");
if(!file.exists()){
return;
}else{
try{
system.setin(newfileinputstream(file));
}catch(filenotfoundexception e){
e.printstacktrace();
}
byte[] bytes = new byte[1024];
int len = 0;
try{
len = system.in.read(bytes);
}catch(ioexception e){
e.printstacktrace();
}
system.out.println("读入的内容为：" new string(bytes, 0, len));
}
}
}
八.字符输入流reader
定义和说明：
在上面的继承关系图中可以看出：
reader 是所有的输入字符流的父类，它是一个抽象类。
charreader、stringreader是两种基本的介质流，它们分别将char 数组、string中读取数据。pipedreader 是从与其它线程共用的管道中读取数据。
bufferedreader 很明显就是一个装饰器，它和其子类负责装饰其它reader 对象。
filterreader 是所有自定义具体装饰流的父类，其子类pushbackreader 对reader 对象进行装饰，会增加一个行号。
inputstreamreader 是一个连接字节流和字符流的桥梁，它将字节流转变为字符流。filereader可以说是一个达到此功能、常用的工具类，在其源代码中明显使用了将fileinputstream 转变为reader 的方法。我们可以从这个类中得到一定的技巧。reader 中各个类的用途和使用方法基本和inputstream 中的类使用一致。后面会有reader 与inputstream 的对应关系。
【案例】以循环方式从文件中读取内容
/*
字符流
从文件中读出内容
/
import java.io.;
class hello{
public static void main(string[] args) throws ioexception {
string filename="d:" file.separator "hello.txt";
file f=new file(filename);
char[] ch=new char[100];
reader read=new filereader(f);
int temp=0;
int count=0;
while((temp=read.read())!=(-1)){
ch[count ]=(char)temp;
}
read.close();
system.out.println("内容为" new string(ch,0,count));
}
}
【案例】bufferedreader的小例子
注意：bufferedreader只能接受字符流的缓冲区，因为每一个中文需要占据两个字节，所以需要将system.in这个字节输入流变为字符输入流，采用：
bufferedreader buf = new bufferedreader(newinputstreamreader(system.in));
下面是一个实例：
import java.io.bufferedreader;
import java.io.ioexception;
import java.io.inputstreamreader;
/**
使用缓冲区从键盘上读入内容
*/
public class bufferedreaderdemo{
public static void main(string[] args){
bufferedreader buf = new bufferedreader(
newinputstreamreader(system.in));
string str = null;
system.out.println("请输入内容");
try{
str = buf.readline();
}catch(ioexception e){
e.printstacktrace();
}
system.out.println("你输入的内容是：" str);
}
}
【案例】scanner类从文件中读出内容
import java.io.file;
import java.io.filenotfoundexception;
import java.util.scanner;
/**
*scanner的小例子，从文件中读内容
*/
public class scannerdemo{
public static void main(string[] args){
file file = new file("d:" file.separator "hello.txt");
scanner sca = null;
try{
sca = new scanner(file);
}catch(filenotfoundexception e){
e.printstacktrace();
}
string str = sca.next();
system.out.println("从文件中读取的内容是：" str);
}
}
九.字符输出流writer
定义和说明：
在上面的关系图中可以看出：
writer 是所有的输出字符流的父类，它是一个抽象类。
chararraywriter、stringwriter 是两种基本的介质流，它们分别向char 数组、string 中写入数据。
pipedwriter 是向与其它线程共用的管道中写入数据，
bufferedwriter 是一个装饰器为writer 提供缓冲功能。
printwriter 和printstream 极其类似，功能和使用也非常相似。
outputstreamwriter 是outputstream 到writer 转换的桥梁，它的子类filewriter 其实就是一个实现此功能的具体类(具体可以研究一sourcecode)。功能和使用和outputstream 极其类似，后面会有它们的对应图。
实例操作演示：
【案例】向文件中写入数据
/**
字符流
写入数据
/
import java.io.;
class hello{
public static void main(string[] args) throws ioexception {
string filename="d:" file.separator "hello.txt";
file f=new file(filename);
writer out =new filewriter(f);
string str="hello";
out.write(str);
out.close();
}
}
注意：这个例子上之前的例子没什么区别，只是你可以直接输入字符串，而不需要你将字符串转化为字节数组。当你如果想问文件中追加内容的时候，可以使用将上面的声明out的哪一行换为：
writer out =new filewriter(f,true);
这样，当你运行程序的时候，会发现文件内容变为：hellohello如果想在文件中换行的话，需要使用“\r\n”比如将str变为string str="\r\nhello";这样文件追加的str的内容就会换行了。
十.字符流与字节流转换
转换流的特点：
(1)其是字符流和字节流之间的桥梁
(2)可对读取到的字节数据经过指定编码转换成字符
(3)可对读取到的字符数据经过指定编码转换成字节
何时使用转换流？
当字节和字符之间有转换动作时；
流操作的数据需要编码或解码时。
具体的对象体现：
inputstreamreader:字节到字符的桥梁
outputstreamwriter:字符到字节的桥梁
这两个流对象是字符体系中的成员，它们有转换作用，本身又是字符流，所以在构造的时候需要传入字节流对象进来。
字节流和字符流转换实例：
【案例】将字节输出流转化为字符输出流
/**
将字节输出流转化为字符输出流
/
import java.io.;
class hello{
public static void main(string[] args) throws ioexception {
string filename= "d:" file.separator "hello.txt";
file file=new file(filename);
writer out=new outputstreamwriter(new fileoutputstream(file));
out.write("hello");
out.close();
}
}
【案例】将字节输入流转换为字符输入流
/**
将字节输入流变为字符输入流
/
import java.io.;
class hello{
public static void main(string[] args) throws ioexception {
string filename= "d:" file.separator "hello.txt";
file file=new file(filename);
reader read=new inputstreamreader(new fileinputstream(file));
char[] b=new char[100];
int len=read.read(b);
system.out.println(new string(b,0,len));
read.close();
}
}
十一.file类
file类是对文件系统中文件以及文件夹进行封装的对象，可以通过对象的思想来操作文件和文件夹。 file类保存文件或目录的各种元数据信息，包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名，判断指定文件是否存在、获得当前目录中的文件列表，创建、删除文件和目录等方法。
【案例 】创建一个文件
import java.io.;
class hello{
public static void main(string[] args) {
file f=new file("d:\hello.txt");
try{
f.createnewfile();
}catch (exception e) {
e.printstacktrace();
}
}
}
【案例2】file类的两个常量
import java.io.;
class hello{
public static void main(string[] args) {
system.out.println(file.separator);
system.out.println(file.pathseparator);
}
}
此处多说几句：有些同学可能认为，我直接在windows下使用\进行分割不行吗？当然是可以的。但是在linux下就不是\了。所以，要想使得我们的代码跨平台，更加健壮，所以，大家都采用这两个常量吧，其实也多写不了几行。
【案例3】file类中的常量改写案例1的代码：
import java.io.;
class hello{
public static void main(string[] args) {
string filename="d:" file.separator "hello.txt";
file f=new file(filename);
try{
f.createnewfile();
}catch (exception e) {
e.printstacktrace();
}
}
}
【案例4】删除一个文件(或者文件夹)
import java.io.;
class hello{
public static void main(string[] args) {
string filename="d:" file.separator "hello.txt";
file f=new file(filename);
if(f.exists()){
f.delete();
}else{
system.out.println("文件不存在");
}
}
}
【案例5】创建一个文件夹
/**
创建一个文件夹
/
import java.io.;
class hello{
public static void main(string[] args) {
string filename="d:" file.separator "hello";
file f=new file(filename);
f.mkdir();
}
}
【案例6】列出目录下的所有文件
/**
使用list列出指定目录的全部文件
/
import java.io.;
class hello{
public static void main(string[] args) {
string filename="d:" file.separator;
file f=new file(filename);
string[] str=f.list();
for (int i = 0; i < str.length; i ) {
system.out.println(str[i]);
}
}
}
总结
以上是凯发k8官方网为你收集整理的java try finally connectoin close_java i/o流详解的全部内容，希望文章能够帮你解决所遇到的问题。
- 上一篇： java lt10_pat 1006 换
- 下一篇： java逆数组如何print_java