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); 得到内容权