<1 File类概述>
流：只能操作数据
package day20;
import java.io.File;
/**
* Created by Administrator on 2017/2/12.
*/
public class FileDemo {
public static void main(String[] args){
consMethod();
}
//创建File对象
public static void consMethod(){
//将a.txt封装成file对象。可以将已有的和未出现的文件或文件夹封装成对象。
File f = new File("a.txt");
File f1 = new File("c:\\abc\\b.txt");
File f2 = new File("c:\\abc", "b.txt"); //b.txt可以替换成字符串str
File d = new File("c:\\abc");
File f3 = new File(d, "b.txt");
sop("f:" + f); //封装的是什么，就打印什么。里面封装的是相对的，所以就打印出相对的a.txt
sop("f1:" + f1);
sop("f2:" + f2);
sop("f3:" + f3);
File f4 = new File("c:\\abc\\zz\\a.txt"); //这种分隔符 不利于跨平台
File f5 = new File("c:" + File.separator + "abc" + File.separator + "zz" + File.separator + "a.txt"); //这句话到了LInux平台也可执行。会自动识别相应的分隔符
}
public static void sop(Object obj){
System.out.println(obj);
}
}
<2 File对象功能：创建和删除>
package day20;
import java.io.File;
import java.io.IOException;
/**
* File类常见方法：
* 1.创建。
* boolean createNewFile()：在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
* 和输出流不一样，输出流对象一建立 就创建文件。而且文件已经存在，会覆盖。
* 2.删除。
* boolean delete()：删除失败时，返回假
* void deleteOnExit()：在程序退出时，删除指定文件。
*
* 3.判断。
*
* 4.获取信息
*
* Created by Administrator on 2017/2/12.
*/
public class FileDemo {
public static void main(String[] args) throws IOException {
// consMethod();
method_1();
}
public static void method_1() throws IOException {
File f = new File("file.txt");
// sop("create: " + f.createNewFile());
sop("delete: " + f.delete());
}
public static void sop(Object obj){
System.out.println(obj);
}
}
package day20;
import java.io.File;
import java.io.IOException;
/**
* File类常见方法：
* 1.创建。
* boolean createNewFile()：在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
* 和输出流不一样，输出流对象一建立 就创建文件。而且文件已经存在，会覆盖。
* boolean mkdir()：创建文件夹
* boolean mkdirs()：创建多级文件夹。
* 2.删除。
* boolean delete()：删除失败时，返回假
* void deleteOnExit()：在程序退出时，删除指定文件。
*
* 3.判断。
* boolean exists()：文件是否存在
* isFile()：
* isDirectory();
* isHidden();
* isAbsolute();
*
* 4.获取信息
*
* Created by Administrator on 2017/2/12.
*/
public class FileDemo {
public static void main(String[] args) throws IOException {
// consMethod();
// method_2();
method_3();
}
public static void method_3() throws IOException {
File f = new File("file.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("file.txt");
// sop("exists: " + f.exists()); //先判断。免得抛异常。这就是把文件封装成File对象的好处
// sop("execute: " + f.canExecute());
//创建文件夹
File dir = new File("abc\\kkk"); //目录abc必须得先存在
sop("mkdir: " + dir.mkdirs());
}
public static void sop(Object obj){
System.out.println(obj);
}
}
package day20;
import java.io.File;
import java.io.IOException;
/**
* File类常见方法：
* 1.创建。
* boolean createNewFile()：在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
* 和输出流不一样，输出流对象一建立 就创建文件。而且文件已经存在，会覆盖。
* boolean mkdir()：创建文件夹
* boolean mkdirs()：创建多级文件夹。
* 2.删除。
* boolean delete()：删除失败时，返回假
* void deleteOnExit()：在程序退出时，删除指定文件。
*
* 3.判断。
* boolean exists()：文件是否存在
* isFile()：
* isDirectory();
* isHidden();
* isAbsolute();
*
* 4.获取信息
* getName():
* getPath():
* getParent():
*
* getAbsolutePath():
* long laseModified()
* long length():
*
*
* Created by Administrator on 2017/2/12.
*/
public class FileDemo {
public static void main(String[] args) throws IOException {
// consMethod();
// method_2();
// method_3();
method_4();
method_5();
}
//类似文件移动
public static void method_5(){
File f1 = new File("c:\\Test.java");
File f2 = new File("d:\\hahah.java");
sop("rename: " + f1.renameTo(f2));
}
public static void method_4(){
File f = new File("c:\\abc\\file.txt");
sop("path: " + f.getPath());
sop("abspath: " + f.getAbsolutePath());
sop("parent: " + f.getParent()); //该方法返回的是绝对路径中的父目录。如果获取的是相对路径，则返回null。
//如果相对路径中有上一层目录，那么该目录就是返回结果。
}
public static void sop(Object obj){
System.out.println(obj);
}
}
<5 File对象：文件列表 >
list(), listRoots()
package day20;
import java.io.File;
/**
* Created by Administrator on 2017/2/13.
*/
public class FileDemo2 {
public static void main(String[] args){
// listRootsDemo();
listDemo();
}
public static void listDemo(){
File f = new File("c:\\");
String[] names = f.list(); //调用list方法的file对象必须是封装了一个目录。该目录还必须存在。（如果是file文件，则返回为null，报空指针异常
for(String name: names){
System.out.println(name);
}
}
public static void listRootsDemo(){
File[] files = File.listRoots();
for(File f: files){
System.out.println(f);
}
}
}
package day20;
import java.io.File;
import java.io.FilenameFilter;
/**
* Created by Administrator on 2017/2/13.
*/
public class FileDemo2 {
public static void main(String[] args){
listDemo_3();
}
public static void listDemo_3(){
File dir = new File("c:\\");
File[] files = dir.listFiles();
for(File f: files){
System.out.println(f.getName() + "::" + f.length());
}
}
public static void listDemo_2(){
File dir = new File("D:\\code\\PycharmProjects\\Test");
String[] arr = dir.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
// System.out.println("dir: " + dir + "...name::" + name);
/*if(name.endsWith(".bmp")){
return true;
}
else{
return false
}*/
return name.endsWith(".bmp");
// return false;
}
});
System.out.println("len: " + arr.length);
for(String name: arr){
System.out.println(name);
}
}
}
package day20;
import java.io.File;
/**
* 列出指定目录下文件或者文件夹，包含子目录中的内容。
* 也就是列出指定目录下所有内容
*
* 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
* 在列出过程中出现的还是目录的话，还可以再次调用本功能。
* 也就是函数自身调用自身。
* 这种表现形式，或者编程手法，称为递归。
* Created by Administrator on 2017/2/13.
*/
public class FileDemo3 {
public static void main(String[] args){
File dir = new File("f:\\");
showDir(dir);
}
public static void showDir(File dir){
System.out.println(dir);
File[] files = dir.listFiles();
for(int x = 0; x < files.length; x++){
if(files[x].isDirectory()){
showDir(files[x]);
}else{
System.out.println(files[x]);
}
}
}
}
代码2
package day20;
import java.io.File;
import java.io.ObjectInput;
/**
* 列出指定目录下文件或者文件夹，包含子目录中的内容。
* 也就是列出指定目录下所有内容
*
* 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
* 在列出过程中出现的还是目录的话，还可以再次调用本功能。
* 也就是函数自身调用自身。
* 这种表现形式，或者编程手法，称为递归。
*
* 递归要注意：
* 1.限定条件。
* 2.要注意递归的次数。尽量避免内存溢出。
* Created by Administrator on 2017/2/13.
*/
public class FileDemo3 {
public static void main(String[] args) {
File dir = new File("f:\\");
// showDir(dir);
// toBin(6);
int n = getSum(8000);
System.out.println(n);
}
public static int getSum(int n){
if(n == 1){
return 1;
}else{
return n + getSum(n - 1);
}
}
public static void toBin(int num){
if(num > 0){
toBin(num/2);
System.out.println(num%2);
// num = num / 2;
}package day20;
import java.io.File;
import java.io.ObjectInput;
/**
* 列出指定目录下文件或者文件夹，包含子目录中的内容。
* 也就是列出指定目录下所有内容
*
* 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
* 在列出过程中出现的还是目录的话，还可以再次调用本功能。
* 也就是函数自身调用自身。
* 这种表现形式，或者编程手法，称为递归。
*
* 递归要注意：
* 1.限定条件。
* 2.要注意递归的次数。尽量避免内存溢出。
* Created by Administrator on 2017/2/13.
*/
public class FileDemo3 {
public static void main(String[] args) {
File dir = new File("f:\\");
showDir(dir, 0);
// toBin(6);
// int n = getSum(8000);
// System.out.println(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++;
// System.out.println(dir);
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]);
}
}
}
}
} /*showA(); void showA(){ showB(); sop(A); } void showB(){ showC(); sop(B); } void showC(){ sop(C); } void sop(Object obj){}*/} <8 列出目录下所有内容-带层次>
package day20;
import java.io.File;
import java.io.ObjectInput;
/**
* 列出指定目录下文件或者文件夹，包含子目录中的内容。
* 也就是列出指定目录下所有内容
*
* 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
* 在列出过程中出现的还是目录的话，还可以再次调用本功能。
* 也就是函数自身调用自身。
* 这种表现形式，或者编程手法，称为递归。
*
* 递归要注意：
* 1.限定条件。
* 2.要注意递归的次数。尽量避免内存溢出。
* Created by Administrator on 2017/2/13.
*/
public class FileDemo3 {
public static void main(String[] args) {
File dir = new File("f:\\");
showDir(dir, 0);
// toBin(6);
// int n = getSum(8000);
// System.out.println(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++;
// System.out.println(dir);
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]);
}
}
}
}
package day20;
import java.io.File;
/**
* 删除一个带内容的目录。
* 删除原理：
* 在Windows中，删除目录时从里面往外删除的。
*
* 既然是从里往外删除，就需要用到递归。
*
* java的删除不走回收站。
* 系统级隐藏的文件 无法删除
* Created by Administrator on 2017/2/13.
*/
public class RemoveDir {
public static void main(String[] args){
File dir = new File("f:\\");
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{
System.out.println(files[x].toString() + ":-file-:" + files[x].delete());
}
}
System.out.println(dir + "::" + dir.delete());
}
}
package day20;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* 练习：
* 僵硬指定目录下的java文件的绝对路径，存储到一个文本文件中。
* 建立一个java文件列表文件。
*
* 1. 对指定的目录进行递归。
* 2. 获取递归过程所有的java文件的路径。
* 3. 将这些路径存储到集合中。
* 4. 将集合中的数据写入到一个文件中。
* Created by Administrator on 2017/2/13.
*/
public class JavaFileList {
public static void main(String[] args) throws IOException {
File dir = new File("f:\\sws");
List<File> list = new ArrayList<File>();
fileToList(dir, list);
// System.out.println(list.size());
File file = new File(dir, "a.txt");
writeToFile(list, file.toString());
}
public static void fileToList(File dir, List<File> list){
File[] files = dir.listFiles();
for(File file: files){
if(file.isDirectory()){
fileToList(file, list);
}else{
list.add(file);
}
}
}
public static void writeToFile(List<File> list, String javaListFile) throws IOException {
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 e;
}finally {
try{
if(bufw != null){
bufw.close();
}
}catch(IOException e){
throw e;
}
}
}
}
<12 Properties获取>
set、get方法
package day20;
import java.util.Properties;
import java.util.Set;
/**
* Properties是hashtable的子类。
* 也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
*
* 它是集合和IO技术相结合的集合容器。
*
* 该对象的特点：可以用于键值对形式的配置文件。
*
* (从流中加载键值对信息)
* Created by Administrator on 2017/2/13.
*/
public class PropertiesDemo {
public static void main(String[] args){
setAndGet();
}
//设置和获取元素
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", 19+"");
Set<String> names = prop.stringPropertyNames();
for(String s: names){
System.out.println(s);
System.out.println(s + ":" + prop.getProperty(s));
}
}
}
package day20;
import java.io.*;
import java.util.Properties;
import java.util.Set;
/**
* Properties是hashtable的子类。
* 也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
*
* 它是集合和IO技术相结合的集合容器。
*
* 该对象的特点：可以用于键值对形式的配置文件。
*
* 那么在加载数据时，需要数据有固定格式：键=值
*
* (从流中加载键值对信息)
* Created by Administrator on 2017/2/13.
*/
public class PropertiesDemo {
public static void main(String[] args) throws IOException {
// method_1();
loadDemo();
}
public static void loadDemo() throws IOException {
Properties prop = new Properties();
FileInputStream fis = new FileInputStream("a.txt");
//将流中的数据加载进集合
prop.load(fis);
prop.setProperty("wangwu", "39");
FileOutputStream fos = new FileOutputStream("a.txt");
prop.store(fos, "haha");
// System.out.println(prop);
prop.list(System.out);
fos.close();
fis.close();
}
//演示：如何将流中的数据存储到集合中。
//想要将a.txt中的键值数据存到集合中进行操作。
/*
1. 用一个流和a.txt文件关联
2. 读取一行数据，将改行数据用"="进行切割。
3. 等号左边作为键，右边作为值。存入到Properties集合中即可.
*/
public static void method_1() throws IOException {
BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
String line = null;
Properties prop = new Properties();
while((line = bufr.readLine()) != null){
String[] arr = line.split("=");
// System.out.println(line);
// System.out.println(arr[0] + "..." + arr[1]);
prop.setProperty(arr[0], arr[1]);
}
bufr.close();
System.out.println(prop);
}
}<14 Properties练习>package day20;
import java.io.*;
import java.util.Properties;
/**
* 用于记录应用程序运行次数。
* 如果使用次数已到，那么给出注册提示。
*
* 很容易想到的是：计数器。
* 可是 该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。
* 可是随着该应用程序的退出，该计数器也在内存中消失了。
*
* 下一次再启动该程序，又重写开始从0计数。
* 这样不是我们想要的。
*
* 程序即使结束，该计数器的值也存在。
* 下次程序启动会先加载该计数器的值并加1后再重新存储起来。
*
* 所以要建立一个配置文件。用于记录该软件的使用次数。
*
* 该配置文件使用键值对的形式。
* 这样便于阅读数据，并操作数据。
*
* 键值对数据时map集合。
* 数据是以文件形式存储，用io技术。
* 那么map+io --> properties.
*
* 配置文件可以实现营业程序数据的共享
* Created by Administrator on 2017/2/13.
*/
public class RunCount {
public static void main(String[] args) throws IOException {
Properties prop = new Properties();
File file = new File("count.txt");
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();
}
}
package day20;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* 练习：
* 僵硬指定目录下的java文件的绝对路径，存储到一个文本文件中。
* 建立一个java文件列表文件。
*
* 1. 对指定的目录进行递归。
* 2. 获取递归过程所有的java文件的路径。
* 3. 将这些路径存储到集合中。
* 4. 将集合中的数据写入到一个文件中。
* Created by Administrator on 2017/2/13.
*/
public class JavaFileList {
public static void main(String[] args) throws IOException {
File dir = new File("f:\\sws");
List<File> list = new ArrayList<File>();
fileToList(dir, list);
// System.out.println(list.size());
File file = new File(dir, "a.txt");
writeToFile(list, file.toString());
}
public static void fileToList(File dir, List<File> list){
File[] files = dir.listFiles();
for(File file: files){
if(file.isDirectory()){
fileToList(file, list);
}else{
list.add(file);
}
}
}
public static void writeToFile(List<File> list, String javaListFile) throws IOException {
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 e;
}finally {
try{
if(bufw != null){
bufw.close();
}
}catch(IOException e){
throw e;
}
}
}
}
将多个读取流合并成一个读取流package day20;
import java.io.*;
import java.util.Enumeration;
import java.util.Vector;
/**
* Created by Administrator on 2017/2/14.
*/
public class SequenceDemo {
public static void main(String[] args) throws IOException {
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();
}
}
package day20;
import java.io.*;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
/**
* Created by Administrator on 2017/2/14.
*/
public class SplitFile {
public static void main(String[] args) throws IOException {
// splitFile();
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>() {
@Override
public boolean hasMoreElements() {
return it.hasNext();
}
@Override
public FileInputStream nextElement() {
return it.next();
}
};
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bmp");
byte[] buf = new byte[1024];
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:\\1.bmp");
FileOutputStream fos = null;
byte[] buf = new byte[1024 * 1024];
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();
}
}