java根據文件路徑讀取文件

❶ java讀取指定目錄下的文件內容

publicclassReadFromFile{
/**
*以位元組為單位讀取文件，常用於讀二進制文件，如圖片、聲音、影像等文件。
*/
(StringfileName){
Filefile=newFile(fileName);
InputStreamin=null;
try{
System.out.println("以位元組為單位讀取文件內容，一次讀一個位元組：");
//一次讀一個位元組
in=newFileInputStream(file);
inttempbyte;
while((tempbyte=in.read())!=-1){
System.out.write(tempbyte);
}
in.close();
}catch(IOExceptione){
e.printStackTrace();
return;
}
try{
System.out.println("以位元組為單位讀取文件內容，一次讀多個位元組：");
//一次讀多個位元組
byte[]tempbytes=newbyte[100];
intbyteread=0;
in=newFileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
//讀入多個位元組到位元組數組中，byteread為一次讀入的位元組數
while((byteread=in.read(tempbytes))!=-1){
System.out.write(tempbytes,0,byteread);
}
}catch(Exceptione1){
e1.printStackTrace();
}finally{
if(in!=null){
try{
in.close();
}catch(IOExceptione1){
}
}
}
}

/**
*以字元為單位讀取文件，常用於讀文本，數字等類型的文件
*/
(StringfileName){
Filefile=newFile(fileName);
Readerreader=null;
try{
System.out.println("以字元為單位讀取文件內容，一次讀一個位元組：");
//一次讀一個字元
reader=newInputStreamReader(newFileInputStream(file));
inttempchar;
while((tempchar=reader.read())!=-1){
//對於windows下，
這兩個字元在一起時，表示一個換行。
//但如果這兩個字元分開顯示時，會換兩次行。
//因此，屏蔽掉
，或者屏蔽
。否則，將會多出很多空行。
if(((char)tempchar)!='
'){
System.out.print((char)tempchar);
}
}
reader.close();
}catch(Exceptione){
e.printStackTrace();
}
try{
System.out.println("以字元為單位讀取文件內容，一次讀多個位元組：");
//一次讀多個字元
char[]tempchars=newchar[30];
intcharread=0;
reader=newInputStreamReader(newFileInputStream(fileName));
//讀入多個字元到字元數組中，charread為一次讀取字元數
while((charread=reader.read(tempchars))!=-1){
//同樣屏蔽掉
不顯示
if((charread==tempchars.length)
&&(tempchars[tempchars.length-1]!='
')){
System.out.print(tempchars);
}else{
for(inti=0;i<charread;i++){
if(tempchars[i]=='
'){
continue;
}else{
System.out.print(tempchars[i]);
}
}
}
}

}catch(Exceptione1){
e1.printStackTrace();
}finally{
if(reader!=null){
try{
reader.close();
}catch(IOExceptione1){
}
}
}
}

/**
*以行為單位讀取文件，常用於讀面向行的格式化文件
*/
(StringfileName){
Filefile=newFile(fileName);
BufferedReaderreader=null;
try{
System.out.println("以行為單位讀取文件內容，一次讀一整行：");
reader=newBufferedReader(newFileReader(file));
StringtempString=null;
intline=1;
//一次讀入一行，直到讀入null為文件結束
while((tempString=reader.readLine())!=null){
//顯示行號
System.out.println("line"+line+":"+tempString);
line++;
}
reader.close();
}catch(IOExceptione){
e.printStackTrace();
}finally{
if(reader!=null){
try{
reader.close();
}catch(IOExceptione1){
}
}
}
}

/**
*隨機讀取文件內容
*/
(StringfileName){
RandomAccessFilerandomFile=null;
try{
System.out.println("隨機讀取一段文件內容：");
//打開一個隨機訪問文件流，按只讀方式
randomFile=newRandomAccessFile(fileName,"r");
//文件長度，位元組數
longfileLength=randomFile.length();
//讀文件的起始位置
intbeginIndex=(fileLength>4)?4:0;
//將讀文件的開始位置移到beginIndex位置。
randomFile.seek(beginIndex);
byte[]bytes=newbyte[10];
intbyteread=0;
//一次讀10個位元組，如果文件內容不足10個位元組，則讀剩下的位元組。
//將一次讀取的位元組數賦給byteread
while((byteread=randomFile.read(bytes))!=-1){
System.out.write(bytes,0,byteread);
}
}catch(IOExceptione){
e.printStackTrace();
}finally{
if(randomFile!=null){
try{
randomFile.close();
}catch(IOExceptione1){
}
}
}
}

/**
*顯示輸入流中還剩的位元組數
*/
(InputStreamin){
try{
System.out.println("當前位元組輸入流中的位元組數為:"+in.available());
}catch(IOExceptione){
e.printStackTrace();
}
}

publicstaticvoidmain(String[]args){
StringfileName="C:/temp/newTemp.txt";
ReadFromFile.readFileByBytes(fileName);
ReadFromFile.readFileByChars(fileName);
ReadFromFile.readFileByLines(fileName);
ReadFromFile.readFileByRandomAccess(fileName);
}
}

❷ java怎麼通過文件的路徑讀取文件

packagefile.system.demo.exception;

importjava.io.File;
importjava.io.FileNotFoundException;
importjava.util.Scanner;

publicclassReadFile{
	publicstaticStringgetFile(Stringrealpath){
		Scannerscanner=null;
		Stringtext="";
		try{
		Filefile=newFile(realpath);
			scanner=newScanner(file);
		}catch(FileNotFoundExceptione){
			e.printStackTrace();
		}
		if(scanner!=null){
		while(scanner.hasNextLine()){
			text+=scanner.nextLine();
		}
			scanner.close();
		}
		//System.out.println(text);
		
		returntext;
	}
	
	
	staticclassInnerTest{
		publicstaticvoidmain(String[]args){
			Stringrealpath="D:\test.txt";
			Stringtext=getFile(realpath);
			System.out.println(text);
		}
	}
	
}

實現方式有很多，還可以用位元組流FileInputStream,字元流FileReader等方式讀取

❸ java中怎樣從一個文件中讀取文件信息

java讀取文件路徑、所佔空間大小等文件消息，主要是使用FileInputStream類來操作，示例如內下：

importjava.io.File;
importjava.io.FileInputStream;

publicclassceshi{
	publicstaticvoidmain(String[]args)throwsException{

		容java.io.FilelocalFile=newFile("D:\1.txt");
		FileInputStreamins=newFileInputStream(localFile);
		intcountLen=ins.available();
		byte[]m_binArray=newbyte[countLen];
		ins.read(m_binArray);
		ins.close();
		System.out.println(localFile.getAbsoluteFile()+""
				+localFile.getFreeSpace());
	}
}

運行結果如下：

❹ Java實現讀取某個路徑下的文件目錄

importjavax.swing.*;

importjavax.swing.table.AbstractTableModel;

importjavax.swing.table.TableCellRenderer;

importjavax.swing.event.TreeModelListener;

importjavax.swing.event.TreeSelectionListener;

importjavax.swing.event.TreeSelectionEvent;

importjavax.swing.tree.TreeModel;

importjavax.swing.tree.TreePath;

importjavax.swing.tree.TreeCellRenderer;

importjava.awt.*;

importjava.awt.event.*;

importjava.io.File;

importjava.io.FileInputStream;

importjava.io.IOException;

importjava.io.FileFilter;

importjava.util.Calendar;

importjava.util.ArrayList;

importjava.text.SimpleDateFormat;

importjava.text.MessageFormat;

/**

*@authorHardneedl

*/

{

=newDimension(300,200);

=newDimension(1024,768);

=newDimension(600,400);

privateJLabelstatusLabel;

privateJTreetree;

privateJTabledetailTable;

;

publicDimensiongetMaximumSize(){returnmaxSize;}

publicDimensiongetMinimumSize(){returnminSize;}

(){returnpreferredSize;}

publicStringgetTitle(){return"JavaExplorer";}

JavaExplorer()throwsHeadlessException{

init();

doLay();

attachListeners();

}

privatevoidinit(){

statusLabel=newJLabel(){publicColorgetForeground(){returnColor.BLUE;}};

tree=newJTree(newFileTreeModel());

tree.setCellRenderer(newDirCellRenderer());

detailTable=newJTable(tableModel=newFileTableModel());

detailTable.getColumnModel().getColumn(2).setCellRenderer(newTableCellRenderer(){

privateJLabellabel=newJLabel();

=newSimpleDateFormat("yyyy年mm月dd日HH時MM分ss秒");

(JTabletable,Objectvalue,booleanisSelected,booleanhasFocus,introw,intcolumn){

if(valueinstanceofCalendar){

Calendarcal=(Calendar)value;

label.setText(format.format(cal.getTime()));

}

returnlabel;

}

});

detailTable.getColumnModel().getColumn(0).setCellRenderer(newTableCellRenderer(){

privateJLabellabel=newJLabel();

(JTabletable,Objectvalue,booleanisSelected,booleanhasFocus,introw,intcolumn){

if(valueinstanceofFile){

Filef=(File)value;

label.setText(f.getName());

label.setForeground(f.isDirectory()?Color.RED:Color.BLACK);

}

returnlabel;

}

});

}

privatevoiddoLay(){

Containercontainer=getContentPane();

JSplitPanesplitPane=newJSplitPane(JSplitPane.HORIZONTAL_SPLIT,newJScrollPane(tree),newJScrollPane(detailTable));

container.add(splitPane,BorderLayout.CENTER);

container.add(statusLabel,BorderLayout.SOUTH);

pack();

}

privatevoidattachListeners(){

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

tree.addTreeSelectionListener(newSelectionListener());

tree.addTreeSelectionListener(new_DirSelectionListener());

DirCellSelectedListenerck=newDirCellSelectedListener(tree);

detailTable.addKeyListener(ck);

detailTable.addMouseListener(ck);

}

publicstaticvoidmain(String[]args){

newJavaExplorer().setVisible(true);

}

{

staticfinalStringroot="我的電腦";

privateFile[]rootFiles;

=newFileFilter(){

publicbooleanaccept(Filef){returnf.isDirectory();}

};

privateFileTreeModel(){rootFiles=File.listRoots();}

publicObjectgetRoot(){returnroot;}

publicObjectgetChild(Objectparent,intindex){

if(parent==getRoot())returnrootFiles[index];

if(parentinstanceofFile){

Filepf=(File)parent;

returnpf.listFiles(dirFilter)[index];

}

returnnull;

}

publicintgetChildCount(Objectparent){

if(parent==getRoot())returnrootFiles.length;

if(parentinstanceofFile){

Filepf=(File)parent;

File[]fs=pf.listFiles(dirFilter);

returnfs==null?0:fs.length;

}

return0;

}

publicbooleanisLeaf(Objectnode){returnfalse;}

publicvoidvalueForPathChanged(TreePathpath,ObjectnewValue){}

(TreeModelListenerl){}

(TreeModelListenerl){}

publicintgetIndexOfChild(Objectparent,Objectchild){

if(parent==getRoot()){

for(inti=0,j=rootFiles.length;i<j;i++)

if(rootFiles[i]==child)returni;

}

if(parentinstanceofFile){

Filepf=(File)parent;

File[]fs=pf.listFiles(dirFilter);

for(inti=0,j=fs.length;i<j;i++){

if(fs[i].equals(child))returni;

}

}

return-1;

}

}

{

publicintgetRowCount(){returndir==null||dir.isFile()?0:dir.listFiles().length;}

publicintgetColumnCount(){return3;}

privateFiledir;

privatevoidsetDir(Filedir){

this.dir=dir;

fireTableDataChanged();

}

publicClass<?>getColumnClass(intcolumnIndex){

switch(columnIndex){

case0:returnFile.class;

case1:returnInteger.class;

case2:returnCalendar.class;

default:returnString.class;

}

}

publicStringgetColumnName(intcolumn){

switch(column){

case0:return"名稱";

case1:return"大小";

case2:return"修改日期";

default:return"";

}

}

publicObjectgetValueAt(introwIndex,intcolumnIndex){

File[]fs=dir.listFiles();

Filef=fs[rowIndex];

switch(columnIndex){

case0:returnf;

case1:

if(f.isDirectory())returnnull;

try{

if(f.canRead())

returnnewFileInputStream(f).available();

}catch(IOExceptione){

e.printStackTrace();

}

case2:

Calendarcl=Calendar.getInstance();

cl.setTimeInMillis(f.lastModified());

returncl;

}

returnnull;

}

}

privateclass_{

publicvoidvalueChanged(TreeSelectionEvente){

TreePathpath=e.getNewLeadSelectionPath();

if(path!=null){

Objectobj=path.getLastPathComponent();

if(objinstanceofFile){

Filef=(File)obj;

File[]fs=f.listFiles();

statusLabel.setText(fs==null?null:MessageFormat.format("{0}個文件",fs.length));

}

else

statusLabel.setText(null);

}

}

}

{

publicbooleanisOpaque(){returntrue;}

(JTreetree,Objectvalue,booleanselected,booleanexpanded,booleanleaf,introw,booleanhasFocus){

if(valueinstanceofFile){

Strings=((File)value).getName();

setText(s.isEmpty()?value.toString():s);

}

else

setText(value.toString());

setForeground(selected?Color.BLUE:Color.BLACK);

setBackground(selected?Color.YELLOW:Color.WHITE);

returnthis;

}

}

{

publicvoidvalueChanged(TreeSelectionEvente){

Objectobj=e.getNewLeadSelectionPath().getLastPathComponent();

if(objinstanceofFile){

tableModel.setDir((File)obj);

}

}

}

,MouseListener{

privateJTreetree;

(JTreet){tree=t;}

privatevoidaction(InputEvente){

if(einstanceofMouseEvent){

}

if(einstanceofKeyEvent){

}

}

privatevoidexpand(Filef){

if(f.isDirectory()){

ArrayList<File>L=newArrayList<File>();

L.add(f);

FileparentFile=f.getParentFile();

while(parentFile!=null){

L.add(parentFile);

parentFile=parentFile.getParentFile();

}

TreePathtreePath=newTreePath(FileTreeModel.root);

for(inti=L.size()-1;i>-1;i--){

treePath=treePath.pathByAddingChild(L.get(i));

}

tree.setSelectionPath(treePath);

}

}

publicvoidkeyTyped(KeyEvente){}

publicvoidkeyPressed(KeyEvente){

if(e.getKeyCode()!=KeyEvent.VK_ENTER)return;

if(e.getSource()==detailTable){

introw=detailTable.getSelectedRow();

if(row!=-1){

Filef=(File)detailTable.getValueAt(row,0);

expand(f);

}

}

}

publicvoidkeyReleased(KeyEvente){

}

publicvoidmouseClicked(MouseEvente){

if(e.getClickCount()==2){

if(e.getSource()==detailTable){

introw=detailTable.getSelectedRow();

if(row!=-1){

Filef=(File)detailTable.getValueAt(row,0);

expand(f);

}

}

}

}

publicvoidmousePressed(MouseEvente){

}

publicvoidmouseReleased(MouseEvente){

}

publicvoidmouseEntered(MouseEvente){

}

publicvoidmouseExited(MouseEvente){

}

}

}

❺ java根據路徑讀取文件

直接貼代碼吧。不過這里要做一個簡單的說明，對於這個程序，我們必須保證我們在C盤下有一個Users\HP\Desktop的文件夾，因為在後面寫入文件的時候，如果路徑中的文件不存在，是程序可以自動為其添加，但如果沒有了這個路徑，則程序會報找不到文件路徑的異常。你可以對這個異常進行人性的處理，還可以在程序要向這個路徑寫入數據之前，創建出這個路徑。
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Scanner;
public class ListRoots {

private static final String LOG_BASE_PATH = "C:\\Users\HP\\Desktop\\";
private static ArrayList<String> mfiles = new ArrayList<String>();

/**
* 得到給定路徑下的目錄或是文件
* @param strPath
* @throws Exception
*/
private static void displayDirsOrFiles(String strPath) throws Exception {
try {
File f = new File(strPath);
if (f.isDirectory()) {
File[] fList = f.listFiles();
for (int j = 0; j < fList.length; j++) {
if (fList[j].isDirectory()) {
System.out.println("Directory is: " + fList[j].getPath());
displayDirsOrFiles(fList[j].getPath()); // 對當前目錄下仍是目錄的路徑進行遍歷
}
}
for (int j = 0; j < fList.length; j++) {
if (fList[j].isFile()) {
String name = fList[j].getPath().toString();
System.out.println("Filename is: " + name);
mfiles.add(fList[j].getPath());
}
}
}
} catch (Exception e) {
System.err.println("Error： " + e);
}
}

/**
* 向文件中寫入數據
* @param dirOrfiles
* @throws IOException
*/
private static void writeDetailToFiles(ArrayList<String> dirOrfiles) throws IOException {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd H:m:s");
toFiles(getLogPath(), format.format(new Date()) + " -- 檢測到文件" + dirOrfiles.size() + "個:" + "\r\n");
for (String file : dirOrfiles) {
toFiles(getLogPath(), file + "\r\n");
}
toFiles(getLogPath(), "--------------------------------------------------------------------------------------------------------------------------\r\n");
}

/**
* 獲得寫入數據的路徑
* @return
*/
private static String getLogPath() {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
return LOG_BASE_PATH + format.format(new Date()) + ".txt";
}

/**
* 向dir路徑下寫入數據data
* @param path
* @param data
*/
private static void toFiles(String path, String data) throws IOException {
File file = new File(path);
if (!file.exists()) {
file.createNewFile();
}

FileWriter fw = new FileWriter(file, true);
fw.write(data);
fw.flush();
fw.close();
}
public static void main(String[] args) {

Scanner input = new Scanner(System.in);
System.out.println("請輸入待遍歷目錄路徑(Format: F:\\a\\b)：");
String strPath = input.nextLine();

try {
displayDirsOrFiles(strPath.replace("\\", "\\\\"));
writeDetailToFiles(mfiles);
} catch (Exception e) {
e.printStackTrace();
}
}
}

❻ Java實現獲取指定路徑下的指定格式的文件

獲取指定路徑下的指定格式的文件

package filenameFilter;

import java io File;

/* * 實現功能 *

獲取指定路徑下的指定格式的文件

* */

public class Test {

public static void listPath（File file） {

// 接收篩選過後的文件對象數組

//用文件對象調用listFiles（FilenameFilter filter） 方法

//返回抽象路徑名數組 這些路徑名表示此抽象路徑名表示的目錄中滿足指定過濾器的文件和目錄

File files[] = file listFiles（new MyFilenameFilter（））

/*//遍歷出指定文件路徑下符合條件的文件

for （File f : files） {

System out println（f）

}*/

//遍歷出指定文件路徑下的所有符合篩選條件的文件

for（File f: files）{

if（f isDirectory（））{

listPath（f）

}else{

System out println（f）

}

}

}

public static void main（String[] args） {

// 創建指定目錄的文件對象

File file = new File（ F:\test ）

// 調用文件曬篩選的方法 並將文件對象出入

listPath（file）

} }

package filenameFilter;

import java io File;

import java io FilenameFilter;

//實現FilenameFilter介面 可用於過濾器文件名 //本方法實現的是篩選指定格式結尾的文件 public class MyFilenameFilter implements FilenameFilter {

/**

* @param args

*

*

實現功能 實現FilenameFilter介面 定義出指定的文件篩選器

*

*/

@Override

//重寫accept方法 測試指定文件是否應該包含在某一文件列表中

public boolean accept（File dir String name） {

// TODO Auto generated method stub

// 創建返回值

boolean flag = true;

// 定義篩選條件

//endWith（String str） 判斷是否是以指定格式結尾的

if （name toLowerCase（） endsWith（ jpg ）） {

} else if （name toLowerCase（） endsWith（ txt ）） {

} else if （name toLowerCase（） endsWith（ gif ）） {

} else {

flag = false;

}

// 返回定義的返回值

//當返回true時 表示傳入的文件滿足條件

return flag;

}

❼ Java讀取配置文件的幾種方法

在現實工作中，我們常常需要保存一些系統配置信息，大家一般都會選擇配置文件來完成，本文根據筆者工作中用到的讀取配置文件的方法小小總結一下，主要敘述的是spring讀取配置文件的方法。
一、讀取xml配置文件
（一）新建一個java bean
package chb.demo.vo;
public class HelloBean {
private String helloWorld;
public String getHelloWorld() {
return helloWorld;
}
public void setHelloWorld(String helloWorld) {
this.helloWorld = helloWorld;
}
}
（二）構造一個配置文件
?xml version="1.0" encoding="UTF-8"?
!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" ""
beans
bean id="helloBean" class="chb.demo.vo.HelloBean"
property name="helloWorld"
valueHello!chb!/value
/property
/bean
/beans
（三）讀取xml文件
1.利用
ApplicationContext context = new ("beanConfig.xml");
HelloBean helloBean = (HelloBean)context.getBean("helloBean");
System.out.println(helloBean.getHelloWorld());
2.利用FileSystemResource讀取
Resource rs = new FileSystemResource("D:/software/tomcat/webapps/springWebDemo/WEB-INF/classes/beanConfig.xml");
BeanFactory factory = new XmlBeanFactory(rs);
HelloBean helloBean = (HelloBean)factory.getBean("helloBean");
System.out.println(helloBean.getHelloWorld());
值得注意的是：利用FileSystemResource，則配置文件必須放在project直接目錄下，或者寫明絕對路徑，否則就會拋出找不到文件的異常。
二、讀取properties配置文拿鎮件
這里介紹兩種啟敬技術：利用spring讀取properties 文件和利用java.util.Properties讀取
（一）利用spring讀取properties 文件
我們還利用上面的HelloBean.java文件，構造如下beanConfig.properties文件：
helloBean.class=chb.demo.vo.HelloBean
helloBean.helloWorld=Hello!chb!
屬性文件中的"helloBean"名稱即是Bean的別名設定，.class用於指定類來消旁粗源。
然後利用org.springframework.beans.factory.support.來讀取屬性文件
BeanDefinitionRegistry reg = new DefaultListableBeanFactory();
reader = new (reg);
reader.loadBeanDefinitions(new ClassPathResource("beanConfig.properties"));
BeanFactory factory = (BeanFactory)reg;
HelloBean helloBean = (HelloBean)factory.getBean("helloBean");
System.out.println(helloBean.getHelloWorld());
（二）利用java.util.Properties讀取屬性文件
比如，我們構造一個ipConfig.properties來保存伺服器ip地址和埠，如：
ip=192.168.0.1
port=8080
則，我們可以用如下程序來獲得伺服器配置信息：
InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("ipConfig.properties");
Properties p = new Properties();
try {
p.load(inputStream);
} catch (IOException e1) {
e1.printStackTrace();
}
System.out.println("ip:"+p.getProperty("ip")+",port:"+p.getProperty("port"));

❽ java編程：從一個名為file的文件中逐行讀取然後將讀取的內容放進另一個文件file1中。

/**
* 以行為單位讀取文件，常用於讀面向行的格式化文件
*
* @param fileName
* 文件名
*/
public static void readFileByLines(String fileName) {
file = new File(fileName);
BufferedReader reader = null;
try {
System.out.println("以行為單位讀取文件內容，一次讀一整行：");
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int line = 1;
// 一次讀入一行，直到讀入null為文件結束
while ((tempString = reader.readLine()) != null) {
// 顯示行號
System.out.println("line " + line + ": " + tempString);
line++;
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 文件寫入
*
* @param filePath 路徑名稱
* @param sb 要寫入的字元
*/
public void writeFromBuffer(String filePath, String sb)throws IOException {
File file = new File(filePath);
FileWriter fw;
try {
fw = new FileWriter(file);
if (sb.toString() != null && !"".equals(sb.toString())) {
fw.write(sb.toString());
}
fw.close();
} catch (IOException e) {
throw new IOException("文件寫入異常！請檢查路徑名是否正確!");
}

}

自己組織一下，讀取的數據可以放在stringbuffer里然後在傳給寫入方法

❾ 用java怎麼從指定文件中的指定位置開始讀取

FileInputStream fis = FileInputStream(File file);指定文件
fis.skip(long n);指定位置
byte[] bs = new byte[int length]; 指定長度版
fis.read(bs); 得到內容權