----------------------ASP.Net+Unity开发、.Net培训、期待与您交流! ---------------------
File概述 File对象功能-创建和删除-判断-获取
File类:用来将文件或文件夹封装成对象
方便对文件与文件夹的属性信息进行操作
File对象可以作为参数传递给流的构造函数
File类常见方法
1.创建
boolean createNewFile(); 在指定位置创建文件,如果已经存在,在不创建,返回false。
boolean mkdir(); 创建文件夹
boolean mkdirs(); 创建多级文件夹
2.删除
boolean delete(); 删除失败返回false
void deleteOnExit(); 程序退出时删除
3.判断
boolean exists(); 文件是否存在
boolean isFile(); 判断是否是文件
boolean isDirectory(); 判断是否是目录
boolean isHidden(); 判断是否隐藏
boolean isAbsolute(); 判断是否绝对路径
4.获取信息
string getName(); 获取名称
string getPath(); 获取路径
string getParent(); 获取父目录
string getAbsolutePath(); 获取绝对路径
long lastModified(); 获取最后被修改时间
long length(); 获取文件大小
public class FileDemo {
//创建File对象
public static void consMethod()
{
//将a.txt封装成File对象,可以将已有的和未出现的文件或文件夹封装成对象
File f1 = new File("a.txt");
File f2 = new File("f:\\abc","b.txt");
File d = new File("f:\\abc");
File f3 = new File(d,"c.txt");
sop("f1:"+f1);
sop("f2:"+f2);
sop("f3:"+f3);
File f4 = new File("f:"+File.separator+"abc"+File.separator+"a.txt");
}
public static void method_1() throws IOException
{
File f = new File("file.txt");
sop("create:"+f.createNewFile()); //创建
sop("delete:"+f.delete()); //删除
}
public static void method_2() throws IOException
{
File f = new File("file.txt");
sop("execute:"+f.exists()); //判断是否存在
File dir = new File("abc");
sop("dir:"+dir.mkdir());
}
public static void method_3() throws IOException
{
File f = new File("file.txt");
//判断文件对象是否是文件或目录时,必须先通过exists判断该文件对象封装的内容是否存在
sop("dir:"+f.isDirectory()); //判断是否是目录
sop("file:"+f.isFile()); //判断是否是文件
sop("isAbsolute:"+f.isAbsolute()); //判断是否绝对路径
}
public static void method_4() throws IOException
{
File f = new File("file.txt");
sop("path:"+f.getPath()); //获取路径
sop("abspath:"+f.getAbsolutePath()); //获取绝对路径
sop("parent:"+f.getParent()); //获取父目录,返回绝对路径中的父目录
//如果获取的相对路径,返回null.
//如果相对路径由上一层目录,返回上一层目录
}
public static void method_5() throws IOException
{
File f1 = new File("file.txt");
File f2 = new File("haha.txt");
sop("rename:"+f1.renameTo(f2));
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args) throws IOException {
method_2();
}
}
File对象功能-文件列表
listRoots(); 机器所有盘符
list(); 指定路径所有文件与文件夹,相对路径。
listFiles(); 指定路径所有文件与文件夹,绝对路径。
public class FileDemo2 {
public static void listRootsDemo()
{
File[] files = File.listRoots();
for(File f : files)
{
System.out.println(f);
}
}
public static void listDemo()
{
File f = new File("f:\\");
//调用list方法的file对象必须封装了对象,该目录还必须存在
String[] names = f.list();
for(String name : names)
{
System.out.println(name);
}
}
public static void listDemo_2()
{
File dir = new File("f:\\");
String[] arr = dir.list(new FilenameFilter()
{
public boolean accept(File dir, String name)
{
return name.endsWith(".mp3");
}
}
);
System.out.println("len:"+arr.length);
for(String name : arr)
{
System.out.println(name);
}
}
public static void main(String[] args) {
File dir = new File("f:\\");
File[] files = dir.listFiles();
for(File f : files)
{
System.out.println(f.getName()+"::"+f.length());
}
}
}
列出目录下所有内容-递归 列出目录下所有内容-带层次
目录中还有目录,使用同一个列出目录的函数即可
列出的目录中还有目录,再次调用本功能
函数自身调用自身,这种编程手法,称为递归
递归要注意:
1.限定条件
2.注意递归次数,避免内存溢出
public class FileDemo3 {
public static void showDir(File dir,int level)
{
System.out.println(getLevel(level)+dir);
level++;
File[] files = dir.listFiles();
for(int x=0; x<files.length; x++)
{
if(files[x].isDirectory())
showDir(files[x],level);
else
System.out.println(getLevel(level)+files[x]);
}
}
public static String getLevel(int level)
{
StringBuilder sb = new StringBuilder();
for(int x = 0; x<level; x++)
{
sb.append("|--");
}
return sb.toString();
}
public static void main(String[] args) {
File dir = new File("f:\\");
showDir(dir,0);
}
}
删除带内容的目录
从里往外删,需要用到递归
public class RemoveDir {
public static void removeDir(File dir)
{
File[] files = dir.listFiles();
for(int x=0; x<files.length; x++)
{
if(files[x].isDirectory())
removeDir(files[x]);
else
System.out.println(files[x].toString()+":-file-:"+files[x].delete());
}
System.out.println(dir+"::dir::"+dir.delete());
}
public static void main(String[] args) {
File dir = new File("f:\\testdir");
removeDir(dir);
}
}
创建java文件列表
思路:
1.对指定目录进行递归
2.获取递归过程中所有的java文件的路径
3.将这些路径存储到集合中
4.将集合中的数据写入到一个文件中
public class JavaFileList {
public static void fileToList(File dir, List<File> list)
{
File[] files = dir.listFiles();
for(File file : files)
{
if(file.isDirectory())
fileToList(file,list);
else
{
if(file.getName().endsWith(".java"));
list.add(file);
}
}
}
public static void writeToFile(List<File> list, String javaListFile)
{
BufferedWriter bufw = null;
try
{
bufw = new BufferedWriter(new FileWriter(javaListFile));
for(File f : list)
{
String path = f.getAbsolutePath();
bufw.write(path);
bufw.newLine();
bufw.flush();
}
}
catch(IOException e)
{
throw new RuntimeException();
}
finally
{
try
{
if(bufw!=null)
bufw.close();
}
catch(IOException e)
{
throw new RuntimeException();
}
}
}
public static void main(String[] args) {
File dir = new File("E:\\workspace");
List<File> list = new ArrayList<File>();
fileToList(dir,list);
File file = new File(dir,"javalist.txt");
writeToFile(list,file.toString());
}
}
Properties简述
Properties是hashtable的子类,具备map集合的特点,它里面存储的键值对都是字符串,不需要泛型。
是集合中和IO技术相结合的集合容器,该对象的特点:可以用于键值对形式的配置文件。
在加载数据时,需要数据有固定格式,键-值
Properties存取 Properties存取配置文件
public class PropertiesDemo {
public static void method_1() throws IOException
{
//将info.txt中的键值数据存储到集合进行操作
//1.用一个流和info.txt关联
//2.读取一行数据,将该行数据用"="切割
//3.等号左边为键,右边为值,存入Properties集合即可
BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));
String line = null;
Properties prop = new Properties();
while((line=bufr.readLine())!=null)
{
String[] arr = line.split("=");
prop.setProperty(arr[0],arr[1]);
}
bufr.close();
System.out.println(prop);
}
public static void loadDemo() throws IOException
{
Properties prop = new Properties();
FileInputStream fis = new FileInputStream("info.txt");
prop.load(fis);
System.out.println(prop);
prop.setProperty("wangwu", "20"); //只改变内存中的数据,文件中不变
System.out.println(prop);
FileOutputStream fos = new FileOutputStream("info.txt");
prop.store(fos, "haha"); //改变文件中数据
fis.close();
fos.close();
}
public static void setAndGet()
{
Properties prop = new Properties();
prop.setProperty("zhangsan","30");
prop.setProperty("lisi", "40");
String value = prop.getProperty("lisi");
System.out.println(value);
Set<String> names = prop.stringPropertyNames();
for(String s : names)
{
System.out.println(s+":"+prop.getProperty(s));
}
}
public static void main(String[] args) throws IOException {
//setAndGet();
loadDemo();
//method_1();
}
}
Properties练习
记录程序运行次数
如果已达到次数,给出提示
使用计数器
建立配置文件,使用键值对
键值对是map集合
数据以文件形式存储,使用IO技术
map+io-->properties
/*
记录程序运行次数
如果已达到次数,给出提示
使用计数器
建立配置文件,使用键值对
键值对是map集合
数据以文件形式存储,使用IO技术
map+io-->properties
*/
public 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 = new FileInputStream(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;
}
}
count++;
prop.setProperty("time", count+"");
FileOutputStream fos = new FileOutputStream(file);
prop.store(fos, "");
fis.close();
fos.close();
}
}
PrintWriter
打印流,提供打印方法,可以将各种数据类型的数据原样打印
字节打印流:
PrintStream
构造函数可以接收的参数类型
1.file对象
2.字符串路径 String
3.字节输出流 OutputStream
字符打印流:
PrintWriter
构造函数可以接收的参数类型
1.file对象
2.字符串路径 String
3.字节输出流 OutputStream
4.字符输出流
public class PrintStreamDemo {
public static void main(String[] args) throws IOException {
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out,true);
//PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);
String line = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
out.println(line.toUpperCase());
}
bufr.close();
out.close();
}
}
合并流
多个读取流合并成一个读取流
Vector:Vector 类可以实现可增长的对象数组。
Enumeration:枚举。Enumeration接口定义了从一个数据结构得到连续数据的手段。
public class SequenceDemo {
public static void main(String[] args) throws IOException
{
Vector<FileInputStream> v = new Vector<FileInputStream>();
v.add(new FileInputStream("1.txt"));
v.add(new FileInputStream("2.txt"));
v.add(new FileInputStream("3.txt"));
Enumeration<FileInputStream> en = v.elements();
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("4.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
sis.close();
fos.close();
}
}
切割文件
public class SplitFile
{
public static void split() throws IOException
{
FileInputStream fis = new FileInputStream("0.jpg");
FileOutputStream fos = null;
byte[] buf = new byte[1024*1024];
int len = 0;
int count = 1;
while((len=fis.read(buf))!=-1)
{
fos = new FileOutputStream(+(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<=4; x++)
{
al.add(new FileInputStream(+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("10.jpg");
byte[] buf = new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
sis.close();
fos.close();
}
public static void main(String[] args) throws IOException
{
merge();
}
}
对象的序列化
ObjectStreamDemo
public class ObjectStreamDemo {
public static void writeObj() throws IOException
{
ObjectOutputStream oos =
new ObjectOutputStream(new FileOutputStream("obj.txt"));
oos.writeObject(new Person("lisi",39,"chn"));
oos.close();
}
public static void readObj() throws Exception
{
ObjectInputStream ois =
new ObjectInputStream(new FileInputStream("obj.txt"));
Person p = (Person)ois.readObject();
System.out.println(p);
ois.close();
}
public static void main(String[] args) throws Exception {
//writeObj();
readObj();
}
}
Person
public class Person implements Serializable {
public static final long serialVersionUID = 42L;
private String name;
int age;
static String country = "chn";
Person(String name, int age, String country)
{
this.name = name;
this.age = age;
this.country = country;
}
public String toString()
{
return name+":"+age+":"+country;
}
}
管道流
class Read implements Runnable
{
private PipedInputStream in;
Read(PipedInputStream in)
{
this.in = in;
}
public void run()
{
try
{
byte[] buf = new byte[1024];
int len = in.read(buf);
String s = new String(buf,0,len);
System.out.println(s);
in.close();
}
catch(IOException e)
{
throw new RuntimeException("管道写入流失败");
}
}
}
class Write implements Runnable
{
private PipedOutputStream out;
Write(PipedOutputStream out)
{
this.out = out;
}
public void run()
{
try
{
out.write("piped".getBytes());
out.close();
}
catch(IOException e)
{
throw new RuntimeException("管道读取流失败");
}
}
}
public class PipedStreamDemo {
public static void main(String[] args) throws IOException {
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
in.connect(out);
Read r = new Read(in);
Write w = new Write(out);
new Thread(r).start();
new Thread(w).start();
}
}
RandomAccessFile
该类不算IO体系中的子类,而是直接继承自Object
但是它是IO包中的成员,因为它具备读和写的功能。
内部封装了一个数组,通过指针对数组的元素进行操作
可以通过getFilePointer获取指针位置,同时可以通过seek改变指针的位置
其实完成读写的原理就是内部封装了字节流。
通过构造函数可以看出该类只能操作文件,
而且操作文件还有模式:只读 r 读写 rw 等。
而且该对象的构造函数要操作的文件不存在,会自动创建,如果存在,不会覆盖。
如果模式为只读,不归创建文件,回去读取一个已存在的文件,如果文件不存在,会出现异常,如果模式是读写,操作的文件不存在,则会自动创建,如果存在,不会覆盖。
public class RandomAcessFileDemo {
public static void writerFile() throws IOException
{
RandomAccessFile raf = new RandomAccessFile("raf.txt","rw");
//调整对象中指针
//raf.seek(8);
//跳过指定字节数
//raf.skipBytes(8);
raf.write("李四".getBytes());
raf.writeInt(97);
raf.write("王五".getBytes());
raf.writeInt(99);
raf.close();
}
public static void writeFile_2() throws IOException
{
RandomAccessFile raf = new RandomAccessFile("raf.txt","rw");
raf.seek(8*3);
raf.write("周七".getBytes());
raf.writeInt(103);
raf.close();
}
public static void readFile() throws IOException
{
RandomAccessFile raf = new RandomAccessFile("raf.txt","r");
//raf.seek(8*3);
byte[] buf = new byte[4];
raf.read(buf);
String name = new String(buf);
int age = raf.readInt();
System.out.println("name="+name);
System.out.println("age="+age);
raf.close();
}
public static void main(String[] args) throws IOException {
//writerFile();
readFile();
//writeFile_2();
}
}
操作基本数据类型的流对象DataStream
可以用于操作基本数据类型的流对象
public class DataStreamDemo {
public static void writeData() throws IOException
{
DataOutputStream dos =
new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeInt(123);
dos.writeBoolean(true);
dos.writeDouble(9876.543);
dos.close();
}
public static void readData() throws IOException
{
DataInputStream dis =
new DataInputStream(new FileInputStream("data.txt"));
int i = dis.readInt();
boolean b = dis.readBoolean();
double d = dis.readDouble();
System.out.println("i="+i);
System.out.println("b="+b);
System.out.println("d="+d);
dis.close();
}
public static void writeUTFDemo() throws IOException
{
DataOutputStream dos =
new DataOutputStream(new FileOutputStream("utfdata.txt"));
dos.writeUTF("你好");
dos.close();
}
public static void readUTFDemo() throws IOException
{
DataInputStream dis =
new DataInputStream(new FileInputStream("utfdata.txt"));
String s = dis.readUTF();
System.out.println(s);
dis.close();
}
public static void main(String[] args) throws IOException {
//writeData();
//readData();
//writeUTFDemo();
//readUTFDemo();
}
}
ByteArrayStream
用于操作字节数组的流对象
ByteArrayInputStream:在构造的时候,需要接收数据源,而且数据源是一个字节数组。
ByteArrayOutputStream:在构造的时候,不用定义数据目的,因为该对象中已经封装了可变长度的字节数组,这就是目的地。
因为这两个流对象都操作数组,没有使用系统资源,所以不用进行close关闭。
public class ByteArrayStream {
public static void main(String[] args) {
//数据源
ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEF".getBytes());
//数据目的
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int by = 0;
while((by=bis.read())!=-1)
{
bos.write(by);
}
System.out.println(bos.size());
System.out.println(bos.toString());
}
}
转换流的字符编码
public class EncodeStream {
public static void writeText() throws IOException
{
OutputStreamWriter osw =
new OutputStreamWriter(new FileOutputStream("gbk.txt"),"GBK");
osw.write("你好");
osw.close();
}
public static void readText() throws IOException
{
InputStreamReader isr =
new InputStreamReader(new FileInputStream("gbk.txt"),"GBK");
char[] buf = new char[10];
int len = isr.read(buf);
String str = new String(buf,0,len);
System.out.println(str);
isr.close();
}
public static void main(String[] args) throws IOException {
//writeText();
readText();
}
}
字符编码
编码:字符串变成字节数组 String-->byte[]:str.getByte();
解码:字节数组变成字符串 byte[]-->String:new String(byte[]);
public class EncodeDemo {
public static void main(String[] args) throws Exception {
String s = "你好";
byte[] b1 = s.getBytes("gbk");
System.out.println(Arrays.toString(b1));
String s1 = new String(b1,"iso8859-1");
System.out.println("s1="+s1);
//对s1进行iso8859-1编码
byte[] b2 = s1.getBytes("iso8859-1");
System.out.println(Arrays.toString(b2));
String s2 = new String(b2,"gbk");
System.out.println("s2="+s2);
String s3 = new String(b1,"utf-8");
System.out.println("s3="+s3);
byte[] b3 = s3.getBytes("utf-8");
System.out.println(Arrays.toString(b3));
}
}
练习
有五个学生,每个学生有三门成绩,从键盘输入以上数据(包括姓名,三门课成绩),从键盘输入格式:zhangsan,30,40,60 计算出总成绩,并把学生的信息和计算出的总总分数由高到低存放到stuinfo.txt中。
1.描述学生对象
2.定义一个可以操作学生对象的工具类
思想:
1.通过获取键盘录入的一行数据,并将该行中的信息去除封装成学生对象。
2.存储使用到集合,因为要排序,所以使用TreeSet
3.将集合中的信息写入文件中
class Student implements Comparable<Student>
{
private String name;
private int ma,cn,en;
private int sum;
Student(String name, int ma, int cn, int en)
{
this.name = name;
this.ma = ma;
this.cn = cn;
this.en = en;
sum = ma + cn + en;
}
public int compareTo(Student s)
{
int num = new Integer(this.sum).compareTo(new Integer(s.sum));
if(num==0)
return this.name.compareTo(s.name);
return num;
}
public String getName()
{
return name;
}
public int getSum()
{
return sum;
}
public int hashCode()
{
return name.hashCode()+sum*39;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new ClassCastException("类型不匹配");
Student s = (Student)obj;
return this.name.equals(s.name) && this.sum==s.sum;
}
public String toString()
{
return "student["+name+", "+ma+", "+cn+", "+en+"]";
}
}
class StudentInfoTool
{
public static Set<Student> getStudents() throws IOException
{
return getStudents(null);
}
public static Set<Student> getStudents(Comparator<Student> cmp) throws IOException
{
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
String line = null;
Set<Student> stus = null;
if(cmp==null)
stus = new TreeSet<Student>();
else
stus = new TreeSet<Student>(cmp);
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
String[] info = line.split(",");
Student stu = new Student(info[0],Integer.parseInt(info[1]),
Integer.parseInt(info[2]),
Integer.parseInt(info[3]));
stus.add(stu);
}
bufr.close();
return stus;
}
public static void write2File(Set<Student> stus) throws IOException
{
BufferedWriter bufw =
new BufferedWriter(new FileWriter("stuinfo.txt"));
for(Student stu : stus)
{
bufw.write(stu.toString()+"\t");
bufw.write(stu.getSum()+"");
bufw.newLine();
bufw.flush();
}
bufw.close();
}
}
public class StudentInfoTest {
public static void main(String[] args) throws IOException {
Comparator<Student> cmp = Collections.reverseOrder();
Set<Student> stus = StudentInfoTool.getStudents(cmp);
StudentInfoTool.write2File(stus);
}
}
----------------------ASP.Net+Unity开发、.Net培训、期待与您交流! ---------------------
详细请查看:http://edu.csdn.net