“黑马程序员”学习笔记八

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

import java.io.File;
import java.io.FilenameFilter;

/*
 将文件或文件夹封装成对象方便对文件或文件夹的属性信息进行操作，File类可以作为参数传递个流对象的构造函数
 将文件封装成对象的三种形式：
 File f1=new File("c:\\abc\\a.txt");
 File f2=new File("c:\\abc","b.txt");
 File d=new File("c:\\abc");
 File f3=new File(d,"c.txt");
 File.separator代表文件跨平台分隔符，可以用"c:"+File.separator+"abc"替换"c:\\abc"就可以夸平台了
 File对象的基本操作：
 1.创建（涉及底层操作，会抛异常）
  boolean createNewFile();在指定位置创建文件，如果该文件已经存在则不创建，返回false,没有就创建返回true
   File f=new File("c:\\abc");
   f.createNewFile("File.txt");
  File createTempFile(文件名前缀，文件名后缀，文件存贮目录);随着程序的运行而建立，程序结束有可能删除，有可能
  没有删除，成为垃圾文件
  boolean f.mkdir();在当前目录创建一级文件夹(一次创建一级)
  boolean f.mkdirs();在当前目录创建多级文件夹（一次创建多级）
 2.删除（涉及底层操作，会抛异常）
  boolean f.delete("File.txt");有则删返回true，没有则返回false
  void f.deleteOnExit("File.txt");程序退出时删除（不会出异常）
 3.判断（excute执行，处决）
  boolean f.canExcute();判断文件能否执行
  -1,0,1 f.compareTo("File.txt");比较文件名大小（还可以自定义比较器）
  boolean f.exists();判断文件是否存在
  boolean isFile();判断是否是文件（先要判断文件是否存在）
  boolean isDirectory();判断是否是目录（先要判断文件夹是否存在）
  boolean isHidden();判断是否隐藏
  boolean isAbsolute();判断时候抽象
 4.获取
 String getName();
   getPath();获取相对路径，返回自定义的目录
   getParent();如果自定义文件前没有目录，获取的是绝对路径的父目录，如果有，返回的是自定义的文件目录
  getAbsolutePath();获取绝对路径，将所有默认前目录全部返回
 long lastModified();获取最后一次修改时间
 long length();
 5.重命名
  File f1=new File("c:\\abc\\a.txt");
  File f2=new File("d:\\abc","b.txt");
  f1.renameTo(f2);将c:\\abc\\a.txt移到d:\\abc并命名为b.txt
  6.list()
  File f1=new File("c:");
  String[] names=f1.list();列出c盘下的所有目录和文件（包括隐藏文件）
  File[] file=f1.lists();和上一行差不多，但返回的是file对象集合
  File[] files=File.listRoots();列出机器所有盘符
      列出目录中的目录中的内容：用到递归方法
     
  7.文件名过滤
  File dir=new File("c:");
  String[] s=dir.list(FileNameFilter filter)(filter过滤器)
 */
public class FileDuiXiang
{

 public static void main(String[] args)
 {
  File f=new File("E:\\KuGou");
  diGui(f);
  //filter();
  System.out.println(diGui(100));
 }
 public static void filter()
 {
  File f=new File("C:\\Users\\ming\\Desktop\\新建文件夹");
  String[] str=f.list(new FilenameFilter()
  {
   public boolean accept(File f,String name)
   {
    return name.endsWith(".avi");
   }
  });
  for(String s:str)
  {
   System.out.println(s);
  }
 }
 public static void diGui(File f)
 {
  
  File[] dir=f.listFiles();
  for(File f1:dir)
  {
   if(f1.isDirectory())
    diGui(f1);
   System.out.println(f1);
  }
 }
 public static int diGui(int n)
 {
  if(n==1)
   return n;
  return n+diGui(n-1);//递归经典用法
 }
}

/*
   按层级列出目录和删除文件
 */
import java.io.File;

public class LieChuCengCiMuLu
{

 public static void main(String[] args)
 {
  File dir=new File("E:\\KuGou");
  lieChu(dir,0);
 }
 public static void lieChu(File dir,int num)
 {
  System.out.println(cengJi(num)+dir.getName());
  num++;
  File[] file=dir.listFiles();
  for(File f:file)
  {
   if(f.isDirectory())
    lieChu(f,num);
   System.out.println(cengJi(num)+f);
  }
 }
 public static String cengJi(int num)
 {
  StringBuilder bu=new StringBuilder();
  bu.append("|--");
  for(int x=0;x<=num;x++)
  {
   bu.insert(0,"  ");
  }
  return bu.toString(); 
 }
 public static void shanChu(File dir)
 {
  File[] f=dir.listFiles();
  for(File fi:f)
  {
   if(fi.isDirectory())
   
    shanChu(fi);
   
   fi.delete();
  }
  dir.delete();
 }

}

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

/*
  目的：建立一个配置文件记录软件使用次数，达到上限，停止软件使用权
  1.配置文件中的数据会很多，所以需要用键值对的形式存入，以免混乱
  2.需要使用IO流和Properties对象
  */
public class PropertiesLianXi
{

 public static void main(String[] args) throws IOException
 {
  pieZhi();
 }
 public static void pieZhi()throws IOException
 {
  File f=new File("C:\\Users\\ming\\Desktop\\新建文件夹\\count.ini");
  if(!f.exists())
   f.createNewFile();
  FileInputStream fis=new FileInputStream(f);
  Properties p=new Properties();
  p.load(fis);
  int count=0;
  String s=p.getProperty("time");
  if(s!=null)
  {
   count=Integer.parseInt(s);
   if(count>=5)
   {
    System.out.println("免费使用次数已到");
       return;
   }
  }
  count++;
  p.setProperty("time", count+"");
  FileOutputStream fos=new FileOutputStream(f);
  p.store(fos,"");
  fos.close();
  fis.close();
 }
 
}

 

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

/*
  打印流：
  该流提供了打印方法，可以将各种数据类型的数据都原样打印
  字节打印流：PrintStream
  构造函数可以接受的参数类型1.File对象(File)2.字符串(String)3.字节输出流(OutputStream)
  字符打印流：PrintWriter
  构造函数可以就收的参数类型：
  1.File对象
  2.字符串
  3.字节输出流
  4.字符输出流（Writer）
 */
  
public class DaYinLiu
{

 public static void main(String[] args)throws IOException
 {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  PrintWriter pw=new PrintWriter(new BufferedWriter(new FileWriter("")),true);
  //PrintWriter(流对象,true);true代表自动刷新，前面不是流对象就不能加true
  String line=null;
  while((line=br.readLine())!=null)
  {
   if(line.equals("over"))
    break;
   pw.println(line);//打印流有自动换行
  }
  pw.close();
  br.close();
 }

}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

/*
  合并流： SequenceInputStream (Sequence数据库，系统按照一定规则自动增加数字序列化)
  当多个流对象关联同一个文件时将多个流对象序列化成一个流对象
  SequenceInputStream(args1,args2);构造函数中的参数可以是两个流对象，
   也可以是一个流对象集合（Enumeration枚举，是Set集合子类Vector(矢量，为...导航)中的方法）
  */
public class HeBingLiu
{

 public static void main(String[] args)throws IOException
 {
  heBing();
 }
 public static void heBing()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> e=v.elements();
  SequenceInputStream sis=new SequenceInputStream(e);
  FileOutputStream fos=new FileOutputStream("4.txt");
  byte[] b=new byte[1024];
  int num=0;
  while((num=sis.read(b))!=-1);
  {
   fos.write(b, 0, num);
  }
  fos.close();
  sis.close();
 }
 public static void spilt()throws IOException
 {
  FileInputStream fis=new FileInputStream("");
  FileOutputStream fos=null;
  int num=0,count=1;
  byte[] b=new byte[1024*1024];
  while((num=fis.read(b))!=-1)
  {
   fos=new FileOutputStream((count++)+".part");
   fos.write(b,0,num);
   fos.close();
  }
  fis.close();
 }
 public static void splitHeBing()throws IOException
 {
  ArrayList al=new ArrayList();
  for(int x=1;x<=3;x++)
  {
   al.add(new FileInputStream(x+".part"));
  }
  final Iterator<FileInputStream> it=al.iterator();
  Enumeration<FileInputStream> e=new Enumeration<FileInputStream>()
  {
   public boolean hasMoreElements()
   {
    return it.hasNext();
   }
   public FileInputStream nextElement()
   {
    return it.next();
   }
  };//匿名内部类，用迭代器的方法复写Enumeration中的方法
  SequenceInputStream sis=new SequenceInputStream(e);
  FileOutputStream fos=new FileOutputStream("");
  int num=0;
  byte[] b=new byte[1024];
  while((num=sis.read(b))!=-1)
  {
   fos.write(b,0,num);
  }
  fos.close();
  sis.close();
 }
}

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

/*
  管道流：PipedInputStream PipedOutputStream
  为避免死锁，不建议使用单线程，需用多线程（流和多线程相结合）
  管道流的出现实现了流与流之间的通信
 */
public class GuanDaoLiu
{

 public static void main(String[] args)throws IOException
 {
  PipedInputStream pi=new PipedInputStream();
  PipedOutputStream po=new PipedOutputStream();
  Read r=new Read(pi);
  Write w=new Write(po);
  pi.connect(po);
  new Thread(r).start();
  new Thread(w).start();
 }

}
class Read implements Runnable
{
 private PipedInputStream pi;
 Read(PipedInputStream pi)
 {
  this.pi=pi;
 }
 public void run()
 {
  byte[] b=new byte[1024];
  int line=0;
  try
  {
   while((line=pi.read(b))!=-1)
   {
    String s=new String(b,0,line);
    System.out.println(s);//这里能不能换成和文件相关联的流对象
   }
   pi.close();
  }
  catch(Exception e)
  {
   System.out.println("管道流读取失败");
  }
 }
}
class Write implements Runnable
{
 private PipedOutputStream po;
 Write(PipedOutputStream po)
 {
  this.po=po;
 }
 public void run()
 {
  try
  {
   po.write("我很纠结".getBytes());//这里能不能换成和文件关联的流对象？
   po.close();
  }
  catch(Exception e)
  {
   System.out.println("管道流输出失败");
  }
 }
}