黑馬程序員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();
-------------------------------------