1、用来将文件或者文件夹封装成对象
2、方便对文件与文件夹进行操作
3、File对象可以作为参数传递给流的构造函数。
4、了解File类中的常用方法。
File
| static String | separator |
import java.io.File;
public class Test{
public static void main(String...args){
/*
将1.Java封装成 File 对象.
可以将已有的和未出现的文件或者文件夹封装成对象。
*/
File f1 = new File("C:\\1.Java");
File f2 = new File("C:\\","1.Java");
File f3 = new File("C:","1.Java");
File f4 = new File("C:"+File.separator+"1.Java");
sop(f1);
sop(f2);
sop(f3);
sop(f4);
}
public static void sop(Object obj){
System.out.println(obj);
}
}
File对象功能-创建和删除
| boolean | createNewFile() |
| boolean | mkdir() |
| boolean | mkdirs() |
| boolean | delete() |
| void | deleteOnExit() |
import java.io.File;
import java.io.IOException;
public class Test{
public static void main(String...args) throws Exception {
File f = new File("C:\\文件夹\\1.Java");
File f1 = new File("C:\\文件夹");
//创建一个目录。
f1.mkdir();
//创建一个文件夹，如果传入文件名中还有文件夹，会自动创建根文件夹和子文件夹。
f.mkdirs();
/*
调用文件的创建方法，如果该文件的目录不存在，那么将报异常，
如果该文件存在的话，就不创建文件，如果不存在就创建该文件。
*/
f.createNewFile();
/*
休息4秒种
*/
Thread.sleep(4000);
/*
创建了一个文件，如果虚拟机退出，那么该文件将自动删除。
*/
f.deleteOnExit(); //只能删除最底层文件
}
public static void sop(Object obj){
System.out.println(obj);
}
}
IO流(File对象功能-判断)
| boolean | exists() |
| boolean | isAbsolute() |
| boolean | isDirectory() |
| boolean | isFile() |
| boolean | isHidden() |
import java.io.File;
import java.io.IOException;
public class Test{
public static void main(String...args)throws IOException{
File f = new File("C:\\1.Java");
f.mkdirs();
//是否是可执行文件
sop(f.canExecute());
//文件是否存在
sop(f.exists());
//是否是一个文件
sop(f.isFile());
//是否是一个目录
sop(f.isDirectory());
//是否是隐藏文件
sop(f.isHidden());
}
public static void sop(Object obj){
System.out.println(obj);
}
}
IO流(File对象功能-获取)
| File | getAbsoluteFile() |
| String | getAbsolutePath() |
| File | getCanonicalFile() |
| String | getCanonicalPath() |
| long | getFreeSpace() |
| String | getName() |
| String | getParent() |
| File | getParentFile() |
| String | getPath() |
| boolean | renameTo(File dest) |
import java.io.File;
public class Test{
public static void main(String...args){
File f1 = new File("C:\\1.Java");
File f2 = new File("C:\\2.java");
f2.renameTo(f1);
}
}
| static File[] | listRoots() |
| String[] | list() |
import java.io.File;
public class Test{
public static void main(String...args){
File[] file = File.listRoots();
for(File f : file){
System.out.println(f);
}
File f = new File("D:\\");
String[] name = f.list();
for(String fileName : name){
System.out.println(fileName);
}
}
}
IO流(列出目录下所有内容-递归)
/*
列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容
因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现还是目录的话，还可以在此调用本功能
也就是函数自身调用自身，
这种表现形式，或者编程手法，成为递归。
递归要注意：
1、制条件
2、要注意递归次数，避免内存溢出
*/
import java.io.*;
class Test
{
public static void main(String[]args)
{
File dir =new File("E:\\java201407");
showDir(dir);
}
public static void showDir(File dir)
{
sop(dir);
File[] files = dir.listFiles();
for(int x=0;x<files.length;x++)
{
if(!files[x].isHidden()&&files[x].isDirectory())
showDir(files[x]);
else
sop(files[x]);
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
/*列出C盘内容会因为权限不够问题报出空指针异常*/
IO流(列出目录下所有内容-带层次)
/*
列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容
因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现还是目录的话，还可以在此调用本功能
也就是函数自身调用自身，
这种表现形式，或者编程手法，成为递归
递归要注意：
1、制条件
2、要注意递归次数，避免内存溢出
*/
import java.io.File;
public class Test{
public static void main(String...args){
File dir = new File("E:\\java201407");
dir(dir,0);
}
public static String getLevel(int level){
StringBuilder sb = newStringBuilder();
for(int x=0;x<level;x++){
sb.append(" ");
}
return sb.toString();
}
public static void dir(File dir,int level){
sop(getLevel(level)+dir);
level++;
File[] files = dir.listFiles();
for(File file:files){
if(!file.isHidden()){
if(file.isDirectory())
dir(file,level);
else
sop(getLevel(level+1)+file);
}
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
IO流(删除带内容的目录)
import java.io.*;
class Test
{
public static void main(String[]args)
{
File dir =new File("D:\\a1");
removeDir(dir);
}
public static void removeDir(File dir)
{
File[] files = dir.listFiles();
for(int x=0;x<files.length;x++)
{
if(!files[x].isHidden()&&files[x].isDirectory())
removeDir(files[x]);
else
sop(files[x].toString()+"--remove file--"+files[x].delete());
}
sop(dir.toString()+"--remove dir--"+dir.delete());
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
/*将一个指定目录下Java文件的绝对路径存储到一个文本文件中*/
import java.io.File;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.util.List;
import java.util.ArrayList;
public class Test{
public static void main(String...args){
File dir = new File("G:\\Java");
List<File> list = new ArrayList<File>();
showdir(dir,list);
writeToFile(list,"C:\\1.Java",0);
sop(list.size());
}
public static void writeToFile(List<File> list,String fileName,int level){
BufferedWriter bufw = null;
try{
bufw = newBufferedWriter(new FileWriter(fileName));
String filePath = null;
for(File file:list){
if(!file.isDirectory())
filePath = getLevel(level+1)+file.getAbsolutePath();
else
filePath = getLevel(level)+file.getAbsolutePath();
bufw.write(getLevel(level)+filePath);
bufw.newLine();
bufw.flush();
}
}
catch (Exception e){
throw new RuntimeException("写入失败") ;
}
finally{
if(bufw!=null)
try{
bufw.close();
}
catch (Exception e){
sop("写入关闭失败");
}
}
}
public static String getLevel(int level){
StringBuilder sb = newStringBuilder();
for(int x=0;x<level;x++){
sb.append("");
}
return sb.toString();
}
public static void showdir(File dir,List<File> list){
File[] files = dir.listFiles();
if(dir.exists()){
for(File file:files)
if(!file.isHidden())
if(file.isDirectory()){
list.add(file);
showdir(file,list);
}
else
list.add(file);
}
else
sop("目录不存在");
}
public static void sop(Object obj){
System.out.println(obj);
}
}
IO流(Properties简述)
Properties 是 Hashtable 的子类
也就是说它具备Map集合的特点，而且它里面存储的键值对都是字符串
是集合中和IO技术相结合的集合容器
该对象特点：可以用于键值对形式的配置文件。
那么在加载数据时候，需要数据有固定格式：键=值
IO流(Properties存取)
import java.util.Properties;
import java.util.Set;
public class Test{
public static void main(String...args){
Properties prop = System.getProperties();
Set<String> names = prop.stringPropertyNames();
for(String name : names){
sop(name+"::"+prop.getProperty(name));
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
IO流(Properties存取配置文件)
| String | getProperty(String key) | |
| String | getProperty(String key,String defaultValue) | |
| void | list(PrintStream out) | |
| void | list(PrintWriter out) | |
| void | load(InputStream inStream) | |
| void | load(Reader reader) | |
| Object | setProperty(String key,String value) | |
| void | store(OutputStream out,String comments) | |
| void | store(Writer writer,String comments) | |
IO流(Properties练习)
/*
演示，如何将流中的数据存储到集合中
想要将 info.properties 中的键值对数据存到集合中进行操作。
思路：
1、用一个流和info.txt文件关联
2、读取一行数据。将改行数据用"="进行切割。
3、等号左边作为键，右边作为值，存入到Properties集合中即可
*/
import java.io.*;
import java.util.*;
public class Test{
public static void main(String...args)throws IOException{
Properties prop = new Properties();
FileInputStream fis=new FileInputStream("C:\\info.Properties");
//BufferedReader bufr = newBufferedReader(new FileReader("C:\\info.Properties"));
prop.load(fis);
sop(prop);
prop.list(System.out); //列出对象
/*for(String line=null;(line =bufr.readLine())!=null;){
String[]arr= line.split("=");
prop.setProperty(arr[0],arr[1]);
}*/
prop.setProperty("zhizuoren","jiefeng");
FileOutputStream fos=new FileOutputStream("C:\\info.Properties");
String one = prop.getProperty("zhizuoren");
prop.store(fos,"jiefeng");
sop(one);
fis.close();
fos.close();
}
public static void sop(Object obj){
System.out.println(obj);
}
}
/*用于记录程序运行次数，如果次数已经到了，给出注册提示并且结束运行*/
import java.io.*;
import java.util.*;
class Runcount
{
public static void main(String[] args) throws IOException
{
Properties prop =new Properties();
File file =new File("count.ini");
if (!file.exists())
file.createNewFile();
FileInputStream fis= newFileInputStream(file);
prop.load(fis);
int count =0;
String value = prop.getProperty("time");
if (value !=null)
{
count =Integer.parseInt(value);
if (count>=5)
{
System.out.println("您好，您的体验次数已到，如继续使用请注册");
return;
}
int x;
x=4-count;
System.out.println("您好，您的体验次数剩余"+x+"次");
}
count++;
prop.setProperty("time",count+"");
FileOutputStream fos =new FileOutputStream(file);
prop.store(fos,"");
fos.close();
fis.close();
System.out.println("您好，欢迎光临戒风Blog");
}
}
IO流(PrintWriter)
打印流
PrintWriter 与 PrintStream。可以直接操作输入流和文件。
/*
打印流
该流提供了打印方法，可以将各种数据烈性的数据都原样打印。
字节打印流
PrintStream
构造函数可以接受的参数类型
1、file对象。
2、字符串路径。String
3、字节输出流 OutpuStream
字符打印流
PrintWriter
构造函数可以接受的参数类型
1、file对象。
2、字符串路径。String
3、字节输出流 OutpuStream
4、字符输出流 Writer
*/
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.FileWriter;
public class Test{
public static void main(String...args)throws IOException{
BufferedReader bufr =new BufferedReader(new InputStreamReader(System.in));
PrintWriter out =new PrintWriter(new FileWriter("C:\\1.Java"),true);
for(String line = null;(line=bufr.readLine())!=null;){
if("over".equals(line))
break;
out.println(line);
/*
由于PrintWriter加入一个参数，true表示自动刷新，所以这里就不用刷新。
out.flush();
*/
}
bufr.close();
out.close();
}
}
IO流(合并流)
序列流、SequenceInputStream。对多个流进行合并
import java.util.Vector;
import java.io.FileInputStream;
import java.io.SequenceInputStream;
import java.io.IOException;
import java.io.FileOutputStream;
import java.util.Enumeration;
public class Test{
public static void main(String...args)throws IOException{
Vector<FileInputStream> v = new Vector<FileInputStream>();
v.add(new FileInputStream("C:\\1.Java"));
v.add(new FileInputStream("C:\\2.Java"));
v.add(new FileInputStream("C:\\3.Java"));
Enumeration <FileInputStream> en = v.elements();
SequenceInputStream sis = newSequenceInputStream(en);
FileOutputStream fos =new FileOutputStream("C:\\4.Java");
byte[] buf =new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
sis.close();
fos.close();
}
}
IO流(切割文件)
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Enumeration;
import java.io.SequenceInputStream;
public class Test{
public static void main(String...args)throws IOException{
splitFile();
merge();
}
public static void splitFile()throws IOException{
FileInputStream fis =new FileInputStream("D:\\1.mp3");
FileOutputStream fos = null;
byte[] buf = new byte[1024*1024];
int len = 0;
int count= 1;
while((len=fis.read(buf))!=-1){
fos = newFileOutputStream("D:\\splitfiles\\"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}
public static void merge()throws IOException{
ArrayList<FileInputStream>al = new ArrayList<FileInputStream>();
for(int x=1;x<=3;x++){
al.add(new FileInputStream("D:\\splitfiles\\"+x+".part"));
}
final Iterator<FileInputStream>it = al.iterator();
Enumeration<FileInputStream>en =new Enumeration<FileInputStream>(){
public boolean hasMoreElements(){
return it.hasNext();
}
public FileInputStream nextElement(){
return it.next();
}
};
SequenceInputStream sis =new SequenceInputStream (en);
FileOutputStream fos =new FileOutputStream("D:\\1复件.mp3");
byte[] buf = new byte[1024];
int len=0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}
1304
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
