黑马程序员-----Java基础-----IO流-3

-----<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

IO流学习-3

import java.io.*;
public class test1 
{
public static void main(String[] args) throws IOException
{
// TODO Auto-generated method stub
//将a.txt 封装成file对象。可以将已有的和未出现的文件或者文件夹封装成对象
File f1 =new File ("a.txt");

File f2 = new File("c:\\adc","b.txt");

File d = new File("c:\\abc");
File f3 =new File(d,"c.txt");
//Fil.separator跨平台分隔符。
File f4 =new File("c:"+File.separator+"abc"+File.separator+"d.txt");

//show3();
//listRootsDemo();
listDemo();

}

File类常见用法：
1，创建
boolean  createNewFile();在指定位置创建文件，如果该文件存在，创建失败，返回false
和输出流不一样，输出流会覆盖原有文件。
 
2，删除
boolean delete(); 删除失败返回false
void deleteOnExit(); 在程序退出时删除指定文件。
 
boolean mkdir(); 创建文件夹
boolean mkdirs();创建多级文件夹
 
3，判断
boolean exists(); 文件是否存在。
isFile();   是否是文件
ifDirectory(); 是否是文件夹
isHidden(); 是否是隐藏文件
isAbsolute(); 相对路径还是绝对路径
 
4.获取信息
getName();获取名称
getPath();获取路径
getParent();
 
getAbsolute();
getModified();
length();
 
renameTO();//相当于剪切
 
public static void show3()throws IOException
{
File f =new File("file.txt");
sop(f.getPath());
sop(f.getAbsolutePath());
sop(f.getParent());//相对路径返回空。绝对路径返回父目录。
}

public static void show2()throws IOException
{
File f =new File("r.java");
sop(f.exists());//是否存在
sop(f.canExecute());

File dir = new File("adc");
sop(dir.mkdir());
}
public static void show1()throws IOException
{
File f =new File("e.txt");
 
//f.createNewFile();
//f.canExecute()//是否可执行、
//f.mkdir();//建立文件夹、
sop(f.isDirectory());//必须建立文件夹后才可以判断出来真假。
sop(f.isFile());//必须建立文件后才可以判断出来真假。
}
public static void show()throws IOException
{
File f =new File("file.txt");
sop(f.createNewFile());
f.deleteOnExit();
f.delete();
}
public static void sop(Object obj)
{
System.out.println(obj);
}

public static void listRootsDemo()
{
File[] files = File.listRoots();
for(File f :files)
System.out.println(f);//打印盘符
}
public static void listDemo()
{
File f =new File("c:");
String[] names =f.list();//调用list的 file对象必须是封装了一个目录。
for(String s :names) //如果是一个文件返回为空。
System.out.println(s);

}
}
----------
package IO3;
import java.io.*;
public class test2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//file();
file1();
}
public static void file1()
{
File dir =new File("D:\\");
File[] files =dir.listFiles();

for(File f :files)
{
System.out.println(f.getName()+"--"+f.length());
}

}
public static void file()
{
File dir =new File("D:\\迅雷下载");
String[] arr =dir.list(new FilenameFilter()
{
public boolean accept(File dur,String name)
{
return true;
//return name.endsWith(".mp4");//返回只有.MP4文件。
}
});
System.out.println(arr.length);
for(String name : arr){
System.out.println(name);
}
}
}
-------------
package IO3;
//列出指定目录下文件或者文件夹，包含子目录中的内容

 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
 在列出过程中出现的还是目录的话，还可以再次调用本功能。
 也就是函数自身调用自身。
 这种形式，或者变成手法，称为递归。
 
 递归要注意
 
 1.限定条件
 
 2.要注意递归次数，尽量避免内存溢出。
 
import java.io.*;
public class test3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//File dir =new File("d:\\迅雷下载");
//showDir(dir);

//toBin(6);

System.out.println(getSum(5000));

}
public static int getSum(int n) {
if(n==1)
return 1;
return n+getSum(n-1);
}

public static void toBin(int num) {
//将6转换成2进制，下面是循环方法，在下面是递归方法。
// while(num >0)
// {
// System.out.println(num%2);
// num = num/2;
// }
if(num >0)
{
toBin(num/2);
System.out.println(num%2);
}
}



public static void showDir(File dir) {
// TODO Auto-generated method stub
System.out.println(dir);
File[] files =dir.listFiles();
for (int i = 0; i < files.length; i++) {
if(files[i].isDirectory())
showDir(files[i]);
else
System.out.println(files[i]);
}
}
//调用showA输出CBA.
void showA()
{
showB();
sop("A");
}
void showB()
{
showC();
sop("B");
}
void showC()
{
sop("C");
}
public void sop(Object obj)
{
System.out.println(obj);
}
}
---------------
package IO3;
//打印分级目录文件
import java.io.File;


public class test4 {


public static void main(String[] args) {
// TODO Auto-generated method stub
File dir =new File("d:\\迅雷下载");
showDir(dir,0);
}
public static String getLevel(int level) {
StringBuilder sb =new StringBuilder();
for (int i = 0; i < level; i++) {
sb.append("| - - ");
}
return sb.toString();
}
public static void showDir(File dir,int level) {
// TODO Auto-generated method stub
System.out.println(getLevel(level)+dir.getName());
level++;
File[] files =dir.listFiles();
for (int i = 0; i < files.length; i++) {
if(files[i].isDirectory())
showDir(files[i],level);
else
System.out.println(getLevel(level)+files[i]);
}
}


}
-----------
package IO3;

 删除一个带内容的目录
 删除原理
 在windows中，删除目录从里面往外删除的
 
 既然是从里往外删除，就需要用到递归。
 
import java.io.*;
public class test5 {
public static void main(String[] args) {
File dir =new File("d:\\remove");
removeDir(dir);
}
public static void removeDir(File dir)
{
File[] files =dir.listFiles();
for (int i = 0; i < files.length; i++) {
if(files[i].isDirectory())//有隐藏文件，files[i].isHidden()&&files[i].isDirectory.
removeDir(files[i]);
else
System.out.println(files[i].toString()+"-file-"+files[i].delete());
}
System.out.println(dir+":dir:"+dir.delete());
}


} 

 将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。
 建立一个java文件列表文件。
 思路：
 1，对指定的目录进行递归。
 2，获取递归过程中所有的java文件的路径。
 3，将这些路径存储到集合中。
 4，将集合中的数据写入到一个文件中。
 
import java.util.*;
import java.io.*;
public class test5 
{
public static void main(String[] args) throws IOException
{

File dir = new File("d:\\java");
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 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)throws IOException
{
BufferedWriter bfw =null;
try {
bfw =new BufferedWriter(new FileWriter(javaListFile));
for(File f :list)
{
String path = f.getAbsolutePath();
bfw.write(path);
bfw.newLine();
bfw.flush();
}
} 
catch (IOException e) 
{
throw e;
}
finally
{
try {
if(bfw!=null);
bfw.close();
} catch (IOException e) {
throw e;
}
}
}
}
---------------
package IO3;
import java.io.*;
import java.util.*;

 Properties是hashtable的子类；
 也就是说它具备map集合的特点，而且他里面存储的键值对都是字符串。
 
 是集合和IO技术相结合的集合容器。
 该对象的特点：
 可以用于键值对形式的配置文本。
 那么在加载数据时，需要数据有固定格式：键=值
 
public class test6 
{
//演示，如何将流中的数据存储到集合中
//想要将info.txt中键值数据存到集合中进行操作。

思路：
1,用一个流和info。txt文件关联
2，读取一行数据，将该行数据用=进行切割
3，等号左边为键，右边为值，存入到properties中即可。
 
public static void loadDemo()throws IOException
{
Properties prop = new Properties();

//FileInputStream fis = new FileInputStream("info.txt");
FileReader fis = new FileReader("info.txt");

//将流中的数据加载进集合。
prop.load(fis);
//修改数据,是内存中的。
prop.setProperty("wefi", "3900");
//保存修改后的数据
FileOutputStream fos =new FileOutputStream("info.txt");
prop.store(fos, "haha");

prop.list(System.out);
fis.close();
fos.close();
}
public static void show()throws IOException
{
BufferedReader bfr =new BufferedReader(new FileReader("info.txt"));
String line =null;
while((line =bfr.readLine())!=null)
{
String[] arr =line.split("=");
System.out.println(arr[0]+"---"+arr[1]);
//System.out.println(line);
}
bfr.close();
}
public static void main(String[] args)throws IOException
{
// TODO Auto-generated method stub
//setAndGet();
loadDemo();
//show();
}
//设置和获取元素
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", "90");
Set<String> names =prop.stringPropertyNames();
for(String s :names)
{
System.out.println(s+":"+prop.getProperty(s));//打印名字和年龄。
}
}


}
---------------
package IO3;

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


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("count.ini");
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();
}
}
--------------
package IO3;

 打印流
 该 流提供了打印方法，可以将各种数据类型的数据都原样打印。
  
 PrintStream
  构造函数可以接受的参数类型
 1，file对象 File
 2,字符串路径 String
 3，字节输出流 OutputStream
 
 PrintWriter
 构造函数可以接受的参数类型
 1，file对象 File
 2,字符串路径 String
 3，字节输出流 OutputStream
 4，字符输出流 Writer
 
 
import java.io.*;
public class test8 {
public static void main(String[] args)throws IOException
{
BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
// PrintWriter out = new PrintWriter(System.out);
// PrintWriter out = new PrintWriter(System.out,true);//自动刷新。
// PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);//自动刷新。
//提高效率
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("a.txt")),true) ;//自动刷新。

String line =null;
while((line =bfr.readLine())!= null)
{
if("over".equals(line))
{
break;
}
out.println(line.toUpperCase());
//out.flush();
}
out.close();
bfr.close();
}
}
------------
package IO3;
合并流
import java.util.*;
import java.io.*;
public class test9 {
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())!= -1)
{
fos.write(buf ,0 ,len);
}
fos.close();
sis.close();
}
}
-----------------
package IO3;
切割流
import java.util.*;
import java.io.*;
public class test91
{
public static void main(String[] args) throws IOException
{
//split();//切割
merge();//合并
}

public static void merge()  throws IOException
{
ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
for(int x =1;x <=4 ; x++)
{
al.add(new FileInputStream("split\\"+x+".part"));
}
final Iterator<FileInputStream> it =al.iterator();

Enumeration<FileInputStream> en =new Enumeration<FileInputStream>() {
//枚举
@Override
public FileInputStream nextElement() {
// TODO Auto-generated method stub
return it.next();
}

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

FileOutputStream fos = new FileOutputStream("split\\0.jpg");
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 split() throws IOException
{
FileInputStream fis =new FileInputStream("1.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("split//"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}

}