黑马程序员java学习，IO字节流及File

字节流
抽象基类InputStream OutputStream
public static void writeFile(){
 FileOutputStream fos=new FileOutputStream("fos.txt");
 fos.write("ddh".getBytes());
 fos.close();
}
public static void readFile(){
 FileInputStream fis=new FileInputStream("fos.txt");
 int ch=0;
 while((ch=fis.read())!=-1){
  System.out.println((char)ch);
 }
 fis.close();
}
public static void readFile_2(){
 FileInputStream fis=new FileInputStream("fos.txt");
 byte[] buf=new byte[1024];
 int len=0;
 while((len=fis.read(buf))!=-1){
  System.out.println(new String(buf,0,len));
 }
 fis.close();
}

//定义一个刚刚好的缓冲区，不在循环
//当数据太大的时候，容易发生内存溢出
byte[] buf=new byte[fis.available()];
fis.read(buf);
System.out.println(new String(buf));
fis.close();
 
拷贝一个图片
public static void copyPicture(){
 FileOutputStream fos=null;
 FileInputStraam fis=null;
 try{
  fos=new FileOutputStream("c:\\2.jpg");
  fis=new FileInputStream("c:\\1.jpg");
  byte[] buf=new byte[1024];
  int len=0;
  while((len=fis.read(buf))!=-1){
   fos.write(buf,0,len);
  }
 }catch(IOException e){throw new RuntimeException("Error");}
 finally{
  try{if(fis!=null) fis.close();}
  catch(IOException e){throw new RuntimeException("Error");}
  try{if(fos!=null) fos.close();}catch(IOException e){throw new RuntimeException("Error");}
 }
}

字节流缓冲区
BufferedInputStream bufis=new BufferedInputStream(new FileInputStream("1.jpg"));
BufferedOutputStream bufos=new BufferedOputStream(new FileOutputStream("2.jpg"));
int by=0;
while((by=bufis.read())!=-1){
 bufos.write(by);
}
bufos.close();
bufis.close();

  自定义字节流的缓冲区 read和write的特点
class MyBufferedInputStream{
 private InputStream in;
 private int pos=0,count=0;
 private byte[] buf=new byte[1024];
 MyBufferedInputStream(InputStream in){
  this.in=in;
 }
 //一个读取一个字节，从缓冲区(字节数组)获取
 public int myRead(){
  //通过in对象读取硬盘上的数据，并存储在buf中
  if(count==0){
   count=in.read(buf);
   if(count<0)
      return -1;
   pos=0;
   byte b=buf(pos);
   
   count--;
   pos++;
   return b;
  }
  else if(count>0){
   byte b=buf[pos];
   count--;
   pos++;
   return b;
  }
  return -1;
 }
 public void myClose(){
  in.close();
 }
} 

读取键盘录入数据，当录入一行数据后，就将该行数据进行打印
如果录入的数据时over，那么停止录入
class ReadIn{
 public static void main(String[] args)throws IOException
{
 InputStream in=System.in;
 StringBuild sb=new StringBuilder();
 while(true){
  int ch=in.read();
  if(ch=='\r')
   continue;
  if(ch=='\n'){
   String s=sb.toString();
   if("over".equals(s))
    break;
   System.out.println(s.toUpperCase());
   sb.delete(0,sb.length());
  }
  else
   sb.append((char)ch);
 }
 
 } 
}
通过刚才的键盘录入数据并打印其大写，发现其实就是读一行数据原理，就是readLine
readLine方法是BufferedReader类中的方法
而键盘录入的read方法是字节流InputStream的方法
将字节流对象转换成字符流对象，使用转换流，InputStreamReader
public static void main(String[] args){
 //获取键盘录入对象
 InputStream in=System.in;
 //将字符流对象转成字符流对象，使用转换流InputStreamReader
 InputStreamReader isr=new InputStreamReader(in);
 //为了提高效率，将字符串进行缓冲区技术高效操作，使用BufferedReader
 //可以将三句话定义成一句话
 //BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
 BufferedReader bufr=new BufferedReader(isr);
 String line=null;
 while((line=bufr.readLine())!=null){
  if("over".equals(line))
   break;
  System.out.println(line.toUpperCase());
 }
 bufr.close();
}
写入转换流流OutStreamWriter
OutputStream out=System.out;
OutputStreamWriter osw=new OutputStreamWriter(out);
BufferedWriter bufw=new BufferedWriter(osw);
String line=null;
while((line=bufr.readLine())!=null){
 if("over".equals(line))
   break;
 bufw.write(line.toUpperCase());
 bufw.newLine();
 bufw.flush();
}
bufr.close();

 流操作规律
1.明确源和目的
  源：输入流，InputStream Reader
  目的:输出流，OutputStream Writer
2.操作的数据是否是纯文本
  是：字符流
  不是：字节流
3.当体系明确后，在明确要使用的哪个具体对象
通过设备来进行区分：
  源设备：内存，硬盘，键盘
  目的设备：内存，硬盘，控制台
 
 键盘：对应的对象时System.in(字节流)，可以将键盘字节流转换成字符流来操作
 InputStreamReader isr=new InputStreamReader(System.in);
 
 需要提高效率，BufferedReader
 BufferedReader bufr=new BufferedReader(isr);
 
 存储时，需要加入指定的编码表，而指定的编码表只有转换流可以指定
所以要使用的对象是OutputStreamWriter,而该转换流对象要接受一个字节输出流，而且还可以操作的文件的字节输出流FileOutputStream
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

 
4.是否需要效率
  是：BufferedReader BufferedWriter
========================================
 File类
用于文件或者文件夹封装成对象
方便对文件与文件夹的属性信息进行操作
File对象可以作为参数传递给流的构造函数
//将a.txt封装成file对象，可以将已有的和未出现的文件或者文件夹构成对象
File f=new File("a.txt");
String str="b.txt";
File f1=new File("c:\\abc",str);
File.separator 目录分隔符

boolean createNewFile();
在指定位置创建文件，如果该文件存在，则不创建，返回false

exists()文件是否存在
创建文件夹
File dir =new File("abc");

mkdir()只能创建文件夹
mkdirs()创建多级目录 

对文件对象是否是文件或者目录时，必须要先判断文件对象封装的内容是否
存在，通过exist()存在
isDirectory()
isFile() 

获取文件列表
File[]files= File.listRoots();
for(File f:files){
sop(f);
}
File f=new File("c:\\abc.txt");
String[] names=f.list(); 

--------
File dir=new File("d:\\java1223\\day18");
String[] arr=dir.list(new FilenameFilter(){
 public boolean accept(File dir,String name){
  return name.endsWith(".java");
 }
});
for(String name:arr){sop(name);}
列出当前目录下所有文内容包括子目录
public static void showDir(File 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]);
 }
}
---------------------------------
pubic static String getLevel(int level){
 StrngBuilder sb=new StringBuilder();
 for(int x=0;x<level;x++){
  sb.append("|--");
 }
 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]);
 }
}
---------------------
删除一个带内容的目录
在windows中，删除目录从里往外删
public static void removeDir(File file){
 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()+files[x].delete());
 }
 System.out.println(dir+dir.delete());
}
----------------------------------------
建立java列表清单
1.对指定的目录进行递归
2.获取在递归过程中所有的java文件路径
3.将这些路径存储到集合
4.将集合中的数据写入到一个文件中
public static void main(String [] args){
 File dir=new file("d:\\javadd");
 List<File> list=new ArrayList<File>();
 fileToList(dir,list);
 
 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){
 BufferedWrite 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 d;
 }
 finally{
  try
  {
   if(bufw!=null)
    bufw.close();
  }
  catch(IOException e)
  {throw e;}
 }
}

--------------------------------------------------------------------------

Properties 是hashtable的子类，具备map集合的特点，而且里面存储的键值对是字符串

是集合中和IO技术想结合的集合容器

该对象的特点：可以用于键值对形式的配置文件
设置和获取元素
public static void setAndGt(){
 Properties prop=new Properties();
 
 prop.setProperty("john","10");
 prop.setProperty("jack","87");
 
 String value=prop.getProperty("jack");
 
 Set<String> names=prop.stringPropertyNames();
 
 for(String s:names){
  sop(prop.getProperty(s));
 }
}
--------
用于一个流和info.txt文件关联
读取一行数据，将进行数据用=进行切割
等号左边的作为键，右边的作为值，存入到Properties中
public static void method()throws IOException{
BuferedReader 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();
}
load()直接加载字符流，在1.6之后
public static void loadDemo{
 Properties prop=new Properties();
 FileInputStream fis=new FileInputStrream("info.txt");
 
 prop.load(fis);
 
 prop.setProperty("robbin","33");
 
 prop.list(System.out);
 fis.close();
}
----------------------- 
 Properties prop=new Properties();
 FileInputStream fis=new FileInputStrream("info.txt");
 
 prop.load(fis);
 
 prop.setProperty("robbin","33");
 
 FileOutputStream fos=new FileOutputStream("info.txt");
 prop.store(fos,"ojweop");
 fis.close();
 fos.close();
----------------------------------------- 
用于记录应用程序的运行次数 
 建立一个配置文件，用于记录该软件的使用次数
    键值对数据时map集合
    数据时以文件形式存储，使用io技术
Properties prop=new Properties();
File file=new File(""count.ini"");
if(!file.exists())
 file.createNewFile();

FileInputStream fis=new FileInputStream(file); 
prop.load(fis);

String value=prop.getProperty("time"); 

if(value!=null)
 count=Integer.parseInt(value);
count++;
prop.setProperty("time",count+"");

FileOutputStream fos=new FileOutputStream(file);
prop.store(fos,"");

fos.close();
fis.close();
-------------------------------------