黑马程序员---Java基础--20天(IO流之三)

---------------------- android培训、java培训、期待与您交流！ ----------------------

1.IO流(File概述)

2.IO流(File对象功能-创建和删除)
3.IO流(File对象功能-判断)
4.IO流(File对象功能-获取)

/*
* File类常见方法:
* 1.创建.
* boolean createNewFile():
* 		在制定位置创建文件,如果该文件已经存在,则不创建,返回false.
* 		和出输出流不一样,输出流对象已建立创建文件,而且文件已经存在,会覆盖.
* boolean mkdir():创建文件夹.
* boolean mkdir():创建多级文件夹.
*
* 2.删除.
* boolean delete():删除失败返回false.如果文件正在被使用,则删除不了返回false.
* void deleteOnExit():在程序退出是删除指定文件.
*
* 3.判断.
* boolean exists():文件是否存在.
* isFile();
* isHidden();
* isAbsolute();
*
* 4.获取信息.
* getName();
* getPath();
* getParent();
*
* getAbsolutePath();
* long lastModified();
* long length();
* */
import java.io.*;
import java.lang.reflect.Field;
public class FileDemo {

/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//method_1();
//method_2();
//method_3();
//method_4();
//method_5();
consMethod();
}
public static void method_5()
{
File f1 = new File("E:\\java\\java0517\\day20\\file.txt");
File f2 = new File("E:\\java\\java0517\\day20\\file1_rename.txt");

sop("rename:"+f1.renameTo(f2));
}
public static void method_4()
{
File f = new File("E:\\java\\java0517\\day20\\file1.txt");

sop("path:"+f.getPath());
sop("abspath:"+f.getAbsolutePath());
sop("parent:"+f.getParent());//该方法返回的是绝对路径的父目录.
//如果获取的是相对路径,返回null.
//如果相对路径中有上一层目录,那么该目录就是返回结果.
}
public static void method_3() throws IOException
{
File f = new File("E:\\java\\java0517\\day20\\file2.txt");
f.createNewFile();
f.mkdir();

//记住在判断文件对象是否是文件或者目的时,必须要先判断该文件对象封装的
//内容是否存在.
//通过exists判断
sop("dir:"+f.isDirectory());
sop("file:"+f.isFile());

sop(f.isAbsolute());
}

public static void method_2()
{
File f = new File("E:\\java\\java0517\\day20\\file.txt");
sop("exists:"+f.exists());

//创建文件夹
File dir = new File("E:\\java\\java0517\\day20\\abc\\kkk\\a\\a\\dd\\ee\\qq\\aaa");
sop("mkdir:"+dir.mkdirs());
}
public static void method_1() throws IOException
{
File f = new File("E:\\java\\java0517\\day20\\file.txt");
sop("create:"+f.createNewFile());
//sop("delete:"+f.delete());
}
public static void consMethod()
{
//将a.txt封装成File对象.可以将已有的和未出现的文件或者文件夹封装成对象.
File f1 = new File("E:\\java\\java0517\\day20\\a.txt");

File f2 = new File("E:\\java\\java0517\\day20","b.txt");

File d = new File("E:\\java\\java0517\\day20");
File f3 = new File(d,"c.txt");

sop("f1:"+f1);
sop("f2:"+f2);
sop("f3:"+f3);

}
public static void sop(Object obj)
{
System.out.println(obj);
}

}

5.IO流(File对象功能-文件列表)

6.IO流(File对象功能-文件列表2)

import java.io.*;

public class FileDemo2 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//listDemo_2();
File dir = new File("e:\\");
File[] files = dir.listFiles();

for(File f : files)
{
System.out.println(f.getName()+";;"+f.length());
}
}
public static void listDemo_2()
{
File dir = new File("e:\\java");
String[] arr = dir.list(new FilenameFilter()
{

public boolean accept(File dir, String name) {
// TODO Auto-generated method stub
//				System.out.println("dir:"+dir+"...name"+name);
//
//				if(name.endsWith(".txt"))
//				{
//					return true;
//				}
//				else
//					return false;
return name.endsWith(".txt");
}
});

System.out.println("len"+arr.length);
for(String name : arr)
{
System.out.println(name);
}

}
public static void listDemo()
{
File f = new File("E:\\");
//调用list方法的file对象必须是封装了一个目录.该目录还必须存在
String[] lists = f.list();
for(String list : lists)
{
System.out.println(list);
}
}
public static void listRootDemo()
{
File[] files = File.listRoots();
for(File f : files)
{
System.out.println(f);
}
}

}

7.IO流(列出目录下所有内容-递归)

8.IO流(列出目录下所有内容-带层次)

/*
* 列出指定目录下文件或者文件夹,包含目录中的内容.
* 也就是列出指定目录下所有内容.
*
* 因为目录中还有目录,只要使用同一个列出目录功能的函数完成即可.
* 在列出过程中出现的还是目录的话,还可以再次调用本功能.
* 也就是函数自身调用自身.
* 这种变线行驶,或者变成手法,成为递归.
*
* 递归要注意:
* 1.限定条件.
* 2.要注意递归的次数.尽量避免内存溢出.
* */
import java.io.*;
public class FileDemo3 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//File dir = new File("e:\\java\\java0517");
//showDir(dir,0);
toBin(6);//求二进制
int n = getSum(8000);
System.out.println("n="+n);
}
public static String getLevel(int level)
{
StringBuilder sb = new StringBuilder();
sb.append("|--");
for(int x=0; x<level; x++)
{
//sb.append("|--");
sb.insert(0,"|  ");
}
return sb.toString();
}
public static void showDir(File dir,int level)
{
System.out.println(getLevel(level)+dir.getName());

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 int getSum(int n)
{
if(n==1)
return 1;
return n+getSum(n-1);
}
public static void toBin(int num)
{
if(num>0)
{
toBin(num/2);
System.out.println(num%2);
}
}

}

9.IO流(删除带内容的目录)

/*
* 删除一个带内容的目录.
* 删除原理:
* 在windows中,删除目录从里面往外删除.
*
* 既然是从里往外删除,就需要用到递归.
* */
import java.io.*;
public class RemoveDir {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
File dir = new File("e:\\test");
removeDir(dir);
}
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());
}

}

10.IO流(创建java文件列表)

/*
* 练习:将制定目录下的java文件的绝对路径,存储到一个文本文件中.
* 建立一个java文件列表
*
* 思路:
* 1.对指定的目录进行递归.
* 2.获取递归过程所有的java文件的路径.
* 3.将这些路径存储到集合中去.
* 4.将集合中的数据写入到一个文件中
* */
import java.io.*;
import java.util.*;
public class JavaFileList {

/**
* @param args
*/
public static void main(String[] args) throws IOException
{
// TODO Auto-generated method stub
File dir = new File("e:\\java\\java0517");

List<File> list = new ArrayList<File>();

fileToList(dir,list);

System.out.println(list.size());

File file = new File(dir,"javalist.txt");

writeToFile(list,file.toString());

}

public static void writeToFile( List<File> list,String javaListFile)throws IOException
{
// TODO Auto-generated method stub
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) {
// TODO Auto-generated catch block
throw e;
}finally
{
if(bufw!=null)
bufw.close();

}

}

public static void fileToList(File dir, List<File> list) {
// TODO Auto-generated method stub
File[] files = dir.listFiles();

for(File file : files)
{
if(file.isDirectory())
fileToList(file, list);
else
{
if(file.getName().endsWith(".java"))
list.add(file);
}
}
}

}

11.IO流(Properties简述)

12.IO流(Properties存取)
13.IO流(Properties存取配置文件)

/*
* Properties是HashTable的子类.
* 也就是说它具备集合的特点.而且它里面存储的键值对都是字符串.
*
* 是集合中和IO技术中相结合的集合容器.
*
* 该对象的特点:可以用于键值对形式的配置文件.
*
* 那么加载数据时,需要数据有固定格式:键=值.
*
* 练习:限制程序运行次数.
* 当运行次数超过5次时,给出请您注册的提示.
* */
import java.io.*;
import java.util.*;
public class PropertiesDemo {

/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//		method_1();
loadDemo();
}
public static void loadDemo() throws IOException
{
Properties prop = new Properties();
FileInputStream fis = new FileInputStream("E:\\java\\java0517\\day20\\info.txt");

//将流中的数据加载进集合
prop.load(fis);
prop.setProperty("wangwu", "39");

FileOutputStream fos = new FileOutputStream("E:\\java\\java0517\\day20\\info.txt");

prop.store(fos, "haha");

prop.list(System.out);

fos.close();
fis.close();
}
//演示:如若将流中的数据存储到集合中.
//1.用一个流和info.txt文件关联。
//2.读取一行数据，将该行数据用"="进行切割。
//3.等号左边作为键，右边作为值。存入到Properties集合中即可。
public static void method_1() throws IOException
{
BufferedReader bufr =
new BufferedReader(new FileReader("E:\\java\\java0517\\day20\\info.txt"));
String line = null;
Properties prop = new Properties();

while((line=bufr.readLine())!=null)
{

String[] arr = line.split("=");

//System.out.println(arr[0]+";;;"+arr[1]);
prop.setProperty(arr[0], arr[1]);
}
bufr.close();
System.out.println(prop);

}
//设置和获取元素。
public static void setAndGet()
{
Properties prop = new Properties();

prop.setProperty("zhangsan","30");
prop.setProperty("lisi","39");

//		System.out.println(prop);
String value = prop.getProperty("lisi");
//System.out.println(value);

prop.setProperty("lisi",89+"");

Set<String> names = prop.stringPropertyNames();
for(String s : names)
{
System.out.println(s+":"+prop.getProperty(s));
}
}
}

14.IO流(Properties练习)

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

/*
* 用于记录应用程序运行次数.
* 如果使用次数已到,那么给出注册提示.
*
* 很容易想到的是:计数器.
* 可是该计数器定义在程序中,随着程序的运行而在内存中存在,并进行自增.
* 可是随着该应用程序的的退出,该计数器也在内存中消失了.
*
* 下一次再启动该程序,又重新开始从0计数.
* 这样不是我们想要的.
*
* 程序即使结束,该计数器的值也存在.
* 下次程序启动会先加载该计数器的值并加1后重新存储起来.
*
* 所以要建立一个配置文件.用于记录该软件的使用次数.
*
* 该配置文件使用键值对的形式.
* 这样便于阅读数据,并操作数据.
*
* 键值对数据时map集合.
* 数据是以文件形式存储,使用io技术.
* 那么map+io -->properties
*
* 配置文件可以实现应用程序数据的共享.
* */
public class RunCount {

/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
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, "");

fos.close();
fis.close();
}

}

15.IO流(PrintWriter)

/*
* 打印流:
* 该打印流提供了打印方法,可以将各种数据类型的数据都原样打印.
*
* 字节打印流:
* PrintStream
* 构造函数可以接收的参数类型.
* 1.file对象.File
* 2.字符串路径.String
* 3.字节输出流.OutputStream.
*
* 字符打印流:
* PrintWriter
* 构造函数可以接收的参数类型.
* 1.file对象.File
* 2.字符串路径.String
* 3.字节输出流.OutputStream
* 4.字符输出流.Writer
* */
import java.io.*;
public class PrintStreamDemo {

/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(new FileWriter("a.txt"));
String line = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
out.println(line.toUpperCase());

}
out.close();
bufr.close();

}

}

16.IO流(合并流)

import java.io.*;
import java.util.*;

public class SequenceDemo {

/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
Vector<FileInputStream> v = new Vector<FileInputStream>();

v.add(new FileInputStream("c:\\1.txt"));
v.add(new FileInputStream("c:\\2.txt"));
v.add(new FileInputStream("c:\\3.txt"));

Enumeration<FileInputStream> en = v.elements();

SequenceInputStream sis = new SequenceInputStream(en);

FileOutputStream fos = new FileOutputStream("c:\\4.txt");

byte[] buf = new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
fos.close();
sis.close();
}

}

17.IO流(切割文件)

import java.io.*;
import java.util.*;
public class SplitFile {

/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
merge();
}
public static void merge() throws IOException
{
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for(int x=1; x<=3; x++)
{
al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));
}
final Iterator<FileInputStream> it = al.iterator();

Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()
{

public FileInputStream nextElement() {
// TODO Auto-generated method stub
return it.next();
}

public boolean hasMoreElements() {
// TODO Auto-generated method stub
return it.hasNext();
}
};
SequenceInputStream sis = new SequenceInputStream(en);

FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.png");

byte[] buf = new byte[400];

int len = 0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
fos.close();
sis.close();

}

public static void splitFile() throws IOException
{
FileInputStream fis = new FileInputStream("c:\\a.png");

FileOutputStream fos = null;

byte[] buf = new byte[400];

int len = 0;
int count = 1;
while((len=fis.read(buf))!=-1)
{
fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();

}

}

---------------------- android培训、java培训、期待与您交流！ ----------------------详细请查看：http://edu.csdn.net/heima