java 文件指针是什么 Java读取文件问题
很多朋友对于java 文件指针是什么和Java读取文件问题不太懂，今天就由小编来为大家分享，希望可以帮助到大家，下面一起来看看吧！
Java读取文件问题
使用Java操作文本文件的方法详解
摘要:最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类
最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类，这两个类都是抽象类，Writer中 write(char[] ch,int off,int
length)，flush()和close()方法为抽象方法，Reader中read(char[] ch,int off,int length)和close()方法是抽象方法。子类应该分别实现他们。当我们读写文本文件的时候，采用Reader是非常方便的，比如FileReader，InputStreamReader和BufferedReader。其中最重要的类是InputStreamReader，它是字节转换为字符的桥梁。你可以在构造器重指定编码的方式，如果不指定的话将采用底层操作系统的默认编码方式，例如GBK等。当使用FileReader读取文件的时候。FileReader fr= new FileReader("ming.txt");
int ch= 0;
while((ch= fr.read())!=-1)
{
System.out.print((char)ch);
}
其中read()方法返回的是读取得下个字符。当然你也可以使用read(char[] ch,int off,int length)这和处理二进制文件的时候类似，不多说了。如果使用InputStreamReader来读取文件的时候while((ch= isr.read())!=-1)
{
System.out.print((char)ch);
}
这和FileReader并没有什么区别，事实上在FileReader中的方法都是从InputStreamReader中继承过来的。read()方法是比较好费时间的，如果为了提高效率我们可以使用BufferedReader对Reader进行包装，这样可以提高读取得速度，我们可以一行一行的读取文本，使用readLine()方法。BufferedReader br= new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt")));
String data= null;
while((data= br.readLine())!=null)
{
System.out.println(data);
}
当你明白了如何用Reader来读取文本文件的时候那么用Writer写文件同样非常简单。有一点需要注意，当你写文件的时候，为了提高效率，写入的数据会先放入缓冲区，然后写入文件。因此有时候你需要主动调用flush()方法。与上面对应的写文件的方法为：
FileWriter fw= new FileWriter("hello.txt");
String s="hello world";
fw.write(s,0,s.length());
fw.flush();OutputStreamWriter osw= new OutputStreamWriter(new FileOutputStream("hello2.txt"));
osw.write(s,0,s.length());
osw.flush();PrintWriter pw= new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true);
pw.println(s);
不要忘记用完后关闭流！下面是个小例子，帮助新手理解。其实有的时候java的IO系统是需要我们多记记的，不然哪天就生疏了。
import java.io.*;public class TestFile2
{
public static void main(String[] args) throws IOException
{
FileReader fr= new FileReader("ming.txt");
char[] buffer= new char[1024];
int ch= 0;
while((ch= fr.read())!=-1)
{
System.out.print((char)ch);
} InputStreamReader isr= new InputStreamReader(new FileInputStream("ming.txt"));
while((ch= isr.read())!=-1)
{
System.out.print((char)ch);
} BufferedReader br= new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt")));
String data= null;
while((data= br.readLine())!=null)
{
System.out.println(data);
} FileWriter fw= new FileWriter("hello.txt");
String s="hello world";
fw.write(s,0,s.length());
fw.flush(); OutputStreamWriter osw= new OutputStreamWriter(new FileOutputStream("hello2.txt"));
osw.write(s,0,s.length());
osw.flush(); PrintWriter pw= new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true);
pw.println(s);
fr.close();
isr.close();
br.close();
fw.close();
osw.close();
pw.close();
}
}
java中多种方式读文件
一、多种方式读文件内容。
1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader;
public class ReadFromFile{
/**
*以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
*@param fileName文件的名
*/
public static void readFileByBytes(String fileName){
File file= new File(fileName);
InputStream in= null;
try{
System.out.println("以字节为单位读取文件内容，一次读一个字节：");
//一次读一个字节
in= new FileInputStream(file);
int tempbyte;
while((tempbyte=in.read())!=-1){
System.out.write(tempbyte);
}
in.close();
} catch(IOException e){
e.printStackTrace();
return;
}
try{
System.out.println("以字节为单位读取文件内容，一次读多个字节：");
//一次读多个字节
byte[] tempbytes= new byte[100];
int byteread= 0;
in= new FileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
//读入多个字节到字节数组中，byteread为一次读入的字节数
while((byteread= in.read(tempbytes))!=-1){
System.out.write(tempbytes, 0, byteread);
}
} catch(Exception e1){
e1.printStackTrace();
} finally{
if(in!= null){
try{
in.close();
} catch(IOException e1){
}
}
}
}
/**
*以字符为单位读取文件，常用于读文本，数字等类型的文件
*@param fileName文件名
*/
public static void readFileByChars(String fileName){
File file= new File(fileName);
Reader reader= null;
try{
System.out.println("以字符为单位读取文件内容，一次读一个字节：");
//一次读一个字符
reader= new InputStreamReader(new FileInputStream(file));
int tempchar;
while((tempchar= reader.read())!=-1){
//对于windows下，rn这两个字符在一起时，表示一个换行。
//但如果这两个字符分开显示时，会换两次行。
//因此，屏蔽掉r，或者屏蔽n。否则，将会多出很多空行。
if(((char)tempchar)!='r'){
System.out.print((char)tempchar);
}
}
reader.close();
} catch(Exception e){
e.printStackTrace();
}
try{
System.out.println("以字符为单位读取文件内容，一次读多个字节：");
//一次读多个字符
char[] tempchars= new char[30];
int charread= 0;
reader= new InputStreamReader(new FileInputStream(fileName));
//读入多个字符到字符数组中，charread为一次读取字符数
while((charread= reader.read(tempchars))!=-1){
//同样屏蔽掉r不显示
if((charread== tempchars.length)&&(tempchars[tempchars.length-1]!='r')){
System.out.print(tempchars);
}else{
for(int i=0; i<charread; i++){
if(tempchars[i]=='r'){
continue;
}else{
System.out.print(tempchars[i]);
}
}
}
}
} catch(Exception e1){
e1.printStackTrace();
}finally{
if(reader!= null){
try{
reader.close();
} catch(IOException e1){
}
}
}
}
/**
*以行为单位读取文件，常用于读面向行的格式化文件
*@param fileName文件名
*/
public static void readFileByLines(String fileName){
File 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 fileName文件名
*/
public static void readFileByRandomAccess(String fileName){
RandomAccessFile randomFile= null;
try{
System.out.println("随机读取一段文件内容：");
//打开一个随机访问文件流，按只读方式
randomFile= new RandomAccessFile(fileName,"r");
//文件长度，字节数
long fileLength= randomFile.length();
//读文件的起始位置
int beginIndex=(fileLength> 4)? 4: 0;
//将读文件的开始位置移到beginIndex位置。
randomFile.seek(beginIndex);
byte[] bytes= new byte[10];
int byteread= 0;
//一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
//将一次读取的字节数赋给byteread
while((byteread= randomFile.read(bytes))!=-1){
System.out.write(bytes, 0, byteread);
}
} catch(IOException e){
e.printStackTrace();
} finally{
if(randomFile!= null){
try{
randomFile.close();
} catch(IOException e1){
}
}
}
}
/**
*显示输入流中还剩的字节数
*@param in
*/
private static void showAvailableBytes(InputStream in){
try{
System.out.println("当前字节输入流中的字节数为:"+ in.available());
} catch(IOException e){
e.printStackTrace();
}
}
public static void main(String[] args){
String fileName="C:/temp/newTemp.txt";
ReadFromFile.readFileByBytes(fileName);
ReadFromFile.readFileByChars(fileName);
ReadFromFile.readFileByLines(fileName);
ReadFromFile.readFileByRandomAccess(fileName);
}
}
二、将内容追加到文件尾部
import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
*将内容追加到文件尾部
*/
public class AppendToFile{
/**
* A方法追加文件：使用RandomAccessFile
*@param fileName文件名
*@param content追加的内容
*/
public static void appendMethodA(String fileName,
String content){
try{
//打开一个随机访问文件流，按读写方式
RandomAccessFile randomFile= new RandomAccessFile(fileName,"rw");
//文件长度，字节数
long fileLength= randomFile.length();
//将写文件指针移到文件尾。
randomFile.seek(fileLength);
randomFile.writeBytes(content);
randomFile.close();
} catch(IOException e){
e.printStackTrace();
}
}
/**
* B方法追加文件：使用FileWriter
*@param fileName
*@param content
*/
public static void appendMethodB(String fileName, String content){
try{
//打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
FileWriter writer= new FileWriter(fileName, true);
writer.write(content);
writer.close();
} catch(IOException e){
e.printStackTrace();
}
}
public static void main(String[] args){
String fileName="C:/temp/newTemp.txt";
String content="new append!";
//按方法A追加文件
AppendToFile.appendMethodA(fileName, content);
AppendToFile.appendMethodA(fileName,"append end. n");
//显示文件内容
ReadFromFile.readFileByLines(fileName);
//按方法B追加文件
AppendToFile.appendMethodB(fileName, content);
AppendToFile.appendMethodB(fileName,"append end. n");
//显示文件内容
ReadFromFile.readFileByLines(fileName);
}
}
java中file.seek(0);是什么意思
楼主我要告诉你 file.seek(int类型的参数)表示从文件的第几个位置开始收索
这个程序中如果没有了file.seek(0);就会出错：
---------------> file.seek(0);专门用于随机读取流。所以在随机读取流的时候必须写
而且改变seek()中的数字也会出错：
-------->只要你文件足够大参数可以是一个任意整数
--------->你出错是因为file.seek(0);是从位置0开始的下面的那个语句:（System.out.println(file.readInt());）也是从第零个位置开始的
如果你要 file.seek(1);去掉System.out.println(file.readInt());就可以了！
文件描述符是什么
问题一：文件描述符和文件指针的区别文件描述符：在linux系统中打开文件就会获得文件描述符，它是个很小的正整数。每个进程在PCB（Process Control Block）中保存着一份文件描述符表，文件描述符就是这个表的索引，每个表项都有一个指向已打开文件的指针。
文件指针：C语言中使用文件指针做为I/O的句柄。文件指针指向进程用户区中的一个被称为FILE结构的数据结构。FILE结构包括一个缓冲区和一个文件描述符。而文件描述符是文件描述符表的一个索引，因此从某种意义上说文件指针就是句柄的句柄（在Windows系统上，文件描述符被称作文件句柄）。
问题二：谁能解释一下文件描述符标志？文件描述符非负整数打现存文件或新建文件内核返文件描述符读写文件需要使用文件描述符指定待读写文件习惯标准输入（standard input）文件描述符 0标准输（standard output） 1标准错误（standard error） 2尽管种习惯并非 Unix内核特性些 shell应用程序都使用种习惯内核遵循种习惯应用程序能使用 POSIX定义 STDIN_FILENO、STDOUT_FILENO STDERR_FILENO代替 0、1、2三符号量定义位于文件 unistd.h文件描述符效范围 0 OPEN_MAX般说每进程打 64文件（0― 63）于 FreeBSD 5.2.1、Mac OS X 10.3 Solaris 9说每进程打文件少取决于系统内存int及系统管理员设定限制
问题三：文件描述符的定义数量如何在不同平台上定义文件描述符的数量文件描述符极限以及可分配给进程的最大大小由资源限制来定义。这些值应当按照在WebLogicServer文档中建议的、特定于操作系统的文件描述符值来设置：对于WLS8.1：调整硬件、操作系统和网络性能对于WLS7.0：调整硬件、操作系统和网络性能对于WLS6.1：调整硬件、操作系统和网络性能Unix和Linux都有文件描述符。不过，二者的主要区别在于如何设置文件描述符的硬极限值、缺省值和配置过程。Solaris/usr/bin/ulimit实用程序定义允许单个进程使用的文件描述符的数量。它的最大值在rlim_fd_max中定义，在缺省情况下，它设置为65,536。只有root用户才能修改这些内核值。Linux管理用户可以在etc/security/limits.conf配置文件中设置他们的文件描述符极限，如下例所示。softnofile1024hardnofile4096系统级文件描述符极限还可以通过将以下三行添加到/etc/rc.d/rc.local启动脚本中来设置：#Increasesystem-widefiledescriptorlimit.echo4096>/proc/sys/fs/file-maxecho16384>/proc/sys/fs/inode-maxWindows在Windows操作系统上，文件描述符被称作文件句柄。在Windows2000服务器上，打开文件的句柄极限设置为16,384。此数量可以在任务管理器的性能摘要中监视。HP-UXnfile定义打开文件的最大数量。此值通常由以下公式来确定：((NPROC*2)+1000)，其中NPROC通常为：((MAXUSERS*5)+64)。如果MAXUSERS等于400，则经过计算得到此值为5128。通常可以将此值设高一些。maxfiles是每个进程的软文件极限，maxfiles_lim是每个进程的硬文件极限。AIX文件描述符极限在/etc/security/limits文件中设置，它的缺省值是2000。此极限可以通过ulimit命令或setrlimit子例程来更改。最大大小由OPEN_MAX常数来定义。
问题四：文件描述符可以是0吗文件描述符是一个简单的整数，用以标明每一个被进程所打开的文件和socket。
第一个打开的文件是0，第二个是1，依此类推。Unix操作系统通常给每个进程能打开的文件数量强加一个限制。更甚的是，unix通常有一个系统级的限制。 os.chinauni
问题五：如何判断文件描述符在fd open一个文件将返回一个文件描述符。 0-返回的文件描述符就是已经打开的。/proc/pid/fd下面为该进程打开的文件描述符如果我的回答没能帮助您，请继续追问。
问题六：Linux查看进程打开多少文件描述符命令 linux系统下查看进程打开文件在/proc下，对应每个进程有一个以进程号命名的目录，该目录下有一个fd目录，该目录下面的每个文件是一个符号连接，其文件名对应该进程占用的一个文件描述符，而连接指向的内容表示文件描述符对应的实际文件，有多少个文件描述符表示该进程打开了多少文件。
另外Linux
默认的进程打开文件上限是1024个，可以通过ulimit
-n查看。很多系统上限可以通过修改/etc/security/limits.conf文件改变，这个文件有详细的注释，对如何修改做了说明。如果希望
把所有用户的进程打开文件上限改为65536，可以加入下面两行
* soft nofile 65535
* hard nofile 65535
还可以只真对某个用户或某个组做修改，具体方法参见文件注释。修改后需要重新启动系统才能生效。
问题七：linux文件描述符 3是什么？例如 0 1 2代表标准的输出输入和出错，但是3，4又是什么的呢？其他已经被打开的文件
问题八：文件描述符挂起是什么意思具体操作，需要修改两处，并且需重新启动Linux服务器。首先SSH登录服务器，执行ulimit-a查看当前限制。这一步是可选，主要是看下限制，心里有数。第一处修改：vim/etc/security/limits.conf在文件尾部增加:*softnofile65535*hardno
问题九：有人了解java与linux文件描述符之间的关系吗 linux文件描述符？可以认为是linux下的任务管理中打开文件的索引表，是系统中使用的。。。。。。。java是一个平台、一种编程语言。。。。。。不知道要怎么比较了。
问题十：文件描述符fb和tcp连接数有什么关系 C10K的问题在上个世纪90年代就被提出来了。大概的意思是当用户数超过1万时，很多设计不良好的网络服务程序性能都将急剧下降、甚至瘫痪。并且，这个问题并不能通过升级硬件设备解决，是操作系统固有的问题，也就是说，如果你的服务器最高能支撑1000个并发，尽管你升级了计算能力高一倍的 cpu，内存再翻一番，硬盘转速在快一倍，也无法支撑2000个并发。
经典的网络编程模型有4个：
1. Serve one client with each thread/process, and use blocking I/O。即对每个客户都使用不同的线程或进程进行服务，在每个线程或进程中使用阻塞I/O。这是小程序和java常用的策略，对于交互式的应用也是常见的选择，这种策略很能难满足高性能程序的需求，好处是实现极其简单，容易实现复杂的交互逻辑。我们常用的Apache、ftpd等都是这种工作。
2. Serve many clients with single thread, and use nonblocking I/O and readiness notification。即对所有的客户使用单一一个线程或进程进行服务，在这个线程或进程里，采用异步IO的策略。这是经典模型，优点在于实现较简单，方便移植，也能提供足够的性能；缺点在于无法充分利用多CPU的资源。
3. Serve many clients with each thread, and use nonblocking I/O and readiness notification对经典模型2的简单改进，仍然采用异步IO的策略，但对所有的客户使用多个线程或进程进行服务。缺点是容易在多线程并发上出bug，甚至某些OS不支持多线程进行readiness notification
4. Serve many clients with each thread, and use asynchronous I/O在有AI/O支持的OS上，能提供相当高的性能。不过AI/O编程模型和经典模型差别相当大，基本上很难写出一个框架同时支持AI/O和经典模型。这个模型主要是用于window平台上。
关于java 文件指针是什么和Java读取文件问题的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。