Android 파일 읽 기와 쓰기 작업 방법 요약

Android 파일 읽 기와 쓰기 작업 방법 요약
안 드 로 이 드 의 파일 은 서로 다른 위치 에 놓 여 있 고 읽 는 방식 도 다르다.
본 고 는 안 드 로 이 드 에서 자원 파일 의 읽 기,데이터 영역 파일 의 읽 기,SD 카드 파일 의 읽 기 및 RandomAccessFile 의 방식 과 방법 을 정리 했다.참고 로 제공 하 다.
1.자원 파일 읽 기:
      1)resource 의 raw 에서 파일 데 이 터 를 읽 습 니 다.

String res = ""; 
try{ 
 
 //      Raw    
 InputStream in = getResources().openRawResource(R.raw.test); 
 
 //        
 int length = in.available();   
 
 byte [] buffer = new byte[length];   
 
 //     
 in.read(buffer);   
 
 // test.txt            ，         
 res = EncodingUtils.getString(buffer, "BIG5"); 
  
 //    
 in.close();    
 
 }catch(Exception e){ 
  e.printStackTrace();   
 } 

 2)resource 의 asset 에서 파일 데 이 터 를 읽 습 니 다.

String fileName = "test.txt"; //     
String res=""; 
try{ 
 
 //      asset    
 InputStream in = getResources().getAssets().open(fileName); 
 
 int length = in.available();   
 byte [] buffer = new byte[length];   
 
 in.read(buffer);    
 in.close(); 
 res = EncodingUtils.getString(buffer, "UTF-8");  
 
 }catch(Exception e){ 
 
  e.printStackTrace();   
 
 } 

2.읽 기/data/data/<응용 프로그램 이름>디 렉 터 리 에 있 는 파일:

//    
public void writeFile(String fileName,String writestr) throws IOException{ 
 try{ 
 
  FileOutputStream fout =openFileOutput(fileName, MODE_PRIVATE); 
 
  byte [] bytes = writestr.getBytes(); 
 
  fout.write(bytes); 
 
  fout.close(); 
  } 
 
  catch(Exception e){ 
  e.printStackTrace(); 
  } 
} 
 
//    
public String readFile(String fileName) throws IOException{ 
 String res=""; 
 try{ 
   FileInputStream fin = openFileInput(fileName); 
   int length = fin.available(); 
   byte [] buffer = new byte[length]; 
   fin.read(buffer);  
   res = EncodingUtils.getString(buffer, "UTF-8"); 
   fin.close();  
  } 
  catch(Exception e){ 
   e.printStackTrace(); 
  } 
  return res; 
 
}  

3.SD 카드 에 있 는 파일 을 읽 고 씁 니 다.즉/mnt/sdcard/디 렉 터 리 아래 파일:

//    SD     
public void writeFileSdcardFile(String fileName,String write_str) throws IOException{ 
 try{ 
 
  FileOutputStream fout = new FileOutputStream(fileName); 
  byte [] bytes = write_str.getBytes(); 
 
  fout.write(bytes); 
  fout.close(); 
  } 
 
  catch(Exception e){ 
  e.printStackTrace(); 
  } 
 } 
 
 
// SD     
public String readFileSdcardFile(String fileName) throws IOException{ 
 String res=""; 
 try{ 
   FileInputStream fin = new FileInputStream(fileName); 
 
   int length = fin.available(); 
 
   byte [] buffer = new byte[length]; 
   fin.read(buffer);  
 
   res = EncodingUtils.getString(buffer, "UTF-8"); 
 
   fin.close();  
  } 
 
  catch(Exception e){ 
   e.printStackTrace(); 
  } 
  return res; 
} 

4.File 클래스 를 사용 하여 파일 읽 기와 쓰기:

//    
public String readSDFile(String fileName) throws IOException { 
 
  File file = new File(fileName); 
 
  FileInputStream fis = new FileInputStream(file); 
 
  int length = fis.available(); 
 
   byte [] buffer = new byte[length]; 
   fis.read(buffer);  
 
   res = EncodingUtils.getString(buffer, "UTF-8"); 
 
   fis.close();  
   return res; 
} 
 
//    
public void writeSDFile(String fileName, String write_str) throws IOException{ 
 
  File file = new File(fileName); 
 
  FileOutputStream fos = new FileOutputStream(file); 
 
  byte [] bytes = write_str.getBytes(); 
 
  fos.write(bytes); 
 
  fos.close(); 
} 

5.그리고 File 류 는 다음 과 같은 자주 사용 하 는 동작 도 있 습 니 다.

String Name = File.getName(); //           ： 
String parentPath = File.getParent(); //             
String path = File.getAbsoultePath();//     
String path = File.getPath();//     
File.createNewFile();//     
File.mkDir(); //      
File.isDirectory(); //          
File[] files = File.listFiles(); //                 
File.renameTo(dest); //          
File.delete(); //         

6.RandomAccessFile 을 사용 하여 파일 의 읽 기와 쓰기:
RandomAccessFile 의 사용 방법 이 비교적 유연 하고 기능 도 비교적 많아 서 seek 와 유사 한 방식 으로 파일 의 임 의 위치 로 이동 할 수 있 습 니 다.파일 표시 기 에서
현재 위치 에서 읽 기와 쓰기 시작 합 니 다.
그것 은 두 가지 구조 방법 이 있다.

new RandomAccessFile(f,"rw");//    
new RandomAccessFile(f,"r");//    

사용 사례:

/* 
 *     ：   RandomAccessFile    ，             。 
 */ 
 
import java.io.*; 
 
public class RandomAccessFileDemo { 
 public static void main(String[] args) throws Exception { 
 RandomAccessFile file = new RandomAccessFile("file", "rw"); 
 //    file       
 file.writeInt(20);//  4    
 file.writeDouble(8.236598);//  8    
 file.writeUTF("    UTF   ");//                    ，  readShort()   
 file.writeBoolean(true);//  1    
 file.writeShort(395);//  2    
 file.writeLong(2325451l);//  8    
 file.writeUTF("    UTF   "); 
 file.writeFloat(35.5f);//  4    
 file.writeChar('a');//  2    
 
 file.seek(0);//                 
 
 //    file      ，           
 System.out.println("―――――― file         ――――――"); 
 System.out.println(file.readInt()); 
 System.out.println(file.readDouble()); 
 System.out.println(file.readUTF()); 
 
 file.skipBytes(3);//        3   ，         boolean  short 。 
 System.out.println(file.readLong()); 
 
 file.skipBytes(file.readShort()); //      “    UTF   ”    ，  readShort()         ，     2。 
 System.out.println(file.readFloat()); 
  
 //           
 System.out.println("――――――    （ file fileCopy）――――――"); 
 file.seek(0); 
 RandomAccessFile fileCopy=new RandomAccessFile("fileCopy","rw"); 
 int len=(int)file.length();//      （   ） 
 byte[] b=new byte[len]; 
 file.readFully(b); 
 fileCopy.write(b); 
 System.out.println("    ！"); 
 } 
} 

7.자원 파일 을 읽 을 때 seek 와 같은 방식 으로 파일 의 임 의 위치 로 이동 하여 지정 한 위치 에서 지정 한 바이트 수 를 읽 을 수 있 습 니까?
답 은 돼.
FileInputStream 과 InputStream 에는 다음 함수 가 있 습 니 다.

public long skip (long byteCount); //       n    
public int read (byte[] buffer, int offset, int length); //       length    buffer offset     。offset    buffer      ，     。 

               seek   ，         ：
[java] view plain copy
//  read_raw   txt  ，   raw   。 
//read_raw.txt      ："ABCDEFGHIJKLMNOPQRST" 
public String getRawString() throws IOException { 
  
 String str = null; 
  
 InputStream in = getResources().openRawResource(R.raw.read_raw); 
  
 int length = in.available(); 
 byte[] buffer = new byte[length]; 
  
 in.skip(2); //       
 in.read(buffer,0,3); //      
  
 in.skip(3); //       
 in.read(buffer,0,3); //      
  
 //  str="IJK" 
 str = EncodingUtils.getString(buffer, "BIG5"); 
  
  
 in.close(); 
  
 return str; 
} 

 위의 실례 를 통 해 알 수 있 듯 이 skip 함 수 는 C 언어의 seek 동작 과 약간 유사 하지만,그것들 사이 에는 약간 다르다.
주의해 야 할 것 은:
1.skip 함 수 는 항상 현재 위치 에서 시작 합 니 다.실제 응용 에서 이 함수 의 반환 값 을 다시 판단 해 야 한다.
2.read 함수 도 항상 현재 위치 에서 읽 기 시작 합 니 다.
3.또한 reset 함 수 를 사용 하여 파일 의 현재 위 치 를 0 으로 초기 화 할 수 있 습 니 다.즉,파일 의 시작 위치 입 니 다.
어떻게 파일 의 현재 위 치 를 얻 습 니까?
나 는 관련 함수 와 방법 을 찾 지 못 했다.어떻게 해야만 파일 의 현재 위 치 를 얻 을 수 있 는 지 모르겠다.그것 도 그리 중요 하지 않 은 것 같다.
8.어떻게 FileInputStream 에서 InputStream 을 얻 습 니까?

public String readFileData(String fileName) throws IOException{ 
 String res=""; 
 try{ 
   FileInputStream fin = new FileInputStream(fileName); 
  InputStream in = new BufferedInputStream(fin); 
 
   ... 
 
  } 
  catch(Exception e){ 
   e.printStackTrace(); 
  } 
 
} 

9.APK 자원 파일 의 크기 가 1M 를 초과 할 수 없 는데 초과 하면 어떻게 합 니까?우 리 는 이 데 이 터 를 다시 data 디 렉 터 리 에 복사 한 후에 다시 사용 할 수 있다.데 이 터 를 복사 하 는 코드 는 다음 과 같 습 니 다.

public boolean assetsCopyData(String strAssetsFilePath, String strDesFilePath){ 
  boolean bIsSuc = true; 
  InputStream inputStream = null; 
  OutputStream outputStream = null; 
   
  File file = new File(strDesFilePath); 
  if (!file.exists()){ 
   try { 
    file.createNewFile(); 
    Runtime.getRuntime().exec("chmod 766 " + file); 
   } catch (IOException e) { 
    bIsSuc = false; 
   } 
    
  }else{//   
   return true; 
  } 
   
  try { 
   inputStream = getAssets().open(strAssetsFilePath); 
   outputStream = new FileOutputStream(file); 
    
   int nLen = 0 ; 
    
   byte[] buff = new byte[1024*1]; 
   while((nLen = inputStream.read(buff)) > 0){ 
    outputStream.write(buff, 0, nLen); 
   } 
    
   //   
  } catch (IOException e) { 
   bIsSuc = false; 
  }finally{ 
   try { 
    if (outputStream != null){ 
     outputStream.close(); 
    } 
    
    if (inputStream != null){ 
     inputStream.close(); 
    } 
   } catch (IOException e) { 
    bIsSuc = false; 
   } 
    
  } 
   
  return bIsSuc; 
 }  

 요약:
1.apk 에는 두 가지 자원 파일 이 있 는데 두 가지 다른 방식 으로 열 어서 사용 합 니 다.
raw=getResources().openRawResource(R.raw.test);
asset=getResources().getAssets().open(fileName)을 사용 합 니 다.
이 데 이 터 는 읽 을 수 있 을 뿐 쓸 수 없습니다.더 중요 한 것 은 이 디 렉 터 리 의 파일 크기 가 1M 를 초과 해 서 는 안 된다 는 것 이다.
또한 주의해 야 할 것 은 InputStream 을 사용 할 때 함수 이름 뒤에 throws IOException 을 추가 해 야 한 다 는 것 이다.
2.SD 카드 의 파일 은 FileInputStream 과 FileOutputStream 을 사용 하여 파일 작업 을 합 니 다.
3.데이터 영역(/data/data/..)에 저 장 된 파일 은 openFileOutput 과 openFileInput 만 사용 할 수 있 습 니 다.
FileInputStream 과 FileOutputStream 을 사용 하여 파일 작업 을 할 수 없 음 을 주의 하 십시오.
4.RandomAccessFile 류 는 파일 의 작업 에 만 국한 되 고 다른 IO 장치 에 접근 할 수 없습니다.파일 의 임의의 위치 로 이동 하여 현재 위치 부터 읽 고 쓸 수 있 습 니 다.
5.InputStream 과 FileInputStream 은 모두 skip 과 read(buffre,offset,length)함 수 를 사용 하여 파일 의 무 작위 읽 기 를 실현 할 수 있 습 니 다.