java读取文件中字符串

‘壹’ 怎么用java来读取TXT文件中的字符串

java中所有数据的传输都是通过字节流的形式，包括文件或图片。 那么当你要读取一个文件时，首先将文件的绝对路径告诉java，调用对应的api就可以拿到该文件的字节流，下面是一段读取xml文件的例子 SAXReader reader = new SAXReader(); Document

‘贰’ java怎么读取文本文件中的所有字符

可以用文件流FileInputStream的方式读取，如果文本文件太大了，不建议一次性往内存中读，那往往会使之溢出。也可以一行行的读取,用BufferReader读，具体的实例都可以网络得到的。

‘叁’ java中如何像readLine()读取文件一样读取字符串

最简单的办法 就是用ByteArrayInputStream

比如

Stringa="aaaaa";
ByteArrayInputStreamis=newByteArrayInputStream(a.getBytes());
BufferedReaderbr=newBufferedReader(newInputStreamReader(is));
br.readLine()

当然自己实现一下按行读取也挺方便的。用a.getBytes()获取字符串的字符数组，然后按顺序去读里边的每个字符，检查是否是回车或换行符 不是就用stringbuffer.append把字符加入stringbuffer，是就用stringbuffer.toString返回字符串就行。

‘肆’ java读取字符串

public class StringDemo1 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String str="AAAAA,mmmm,111112121,dddd,11111";

String []st=str.split(",");
for(String sc:st){
System.out.println(sc);

}

}
}

‘伍’ java从读取的文本中 取出指定字符串

这个不难。读取文本就当作读取流的形式。

具体实现
//读取一个文本的字符流
BufferedReader in = new BufferedReader(new FileReader("F:\\json.txt"));
String line = null;
//定义一个空字符串来接受读到的字符串
String str="";
//循环把读取到的字符赋给str
while((line = in.readLine())!=null)
{
str+=line;
}

System.out.println("str="+str);
//判断str中是否有EFG子串，为true则说明有。进去if语句
if(str.contains("EFG")){
System.out.println("yes!");
//取得子串的初始位置
int i=str.indexOf("EFG");
//根据的要取的内容后多少字符+多少个
String strEFG=str.substring(i,i+3);
System.out.println("strEFG="+strEFG);
}

‘陆’ java怎么从一个文件读取字符串,再存到一个字符串数组里

首先，可以直接写入string的，这段程序的这种写法很无聊，让你误解了。
如： out.write(p_send_text);

其次，如果想写入一行并且换行的话，那么得包装一个printwriter，如:
PrintWriter out = new PrintWriter(FileWriter(file, true));
out.println(p_send_text);

在Java里，
char表示一个字符，它可以直接转换为int, byte, long.（ascii/unicode码）
String表示一串字符，它可以通过某些方法转换成一个数组，如char[], byte[]，也可以用其他方法取出其中某个特定位置的字符，如charAt();

与C里面不同，在Java中，通常String用的比较多，char[]基本不用的。

‘柒’ java中怎样将文件的内容读取成字符串

java中有四种将文件的内容读取成字符串

方式一：

Java code

/**

*以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。

*当然也是可以读字符串的。

*/

/*貌似是说网络环境中比较复杂，每次传过来的字符是定长的，用这种方式？*/

publicStringreadString1()

{

try

{

//FileInputStream用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用FileReader。

FileInputStreaminStream=this.openFileInput(FILE_NAME);

ByteArrayOutputStreambos=newByteArrayOutputStream();

byte[]buffer=newbyte[1024];

intlength=-1;

while((length=inStream.read(buffer)!=-1)

{

bos.write(buffer,0,length);

//.write方法SDK的解释是m.

//当流关闭以后内容依然存在

}

bos.close();

inStream.close();

returnbos.toString();

//为什么不一次性把buffer得大小取出来呢？为什么还要写入到bos中呢？returnnew(buffer,"UTF-8")不更好么?

//returnnewString(bos.toByteArray(),"UTF-8");

}

}

方式二：

Java code

方式四：

Java code

/*InputStreamReader+BufferedReader读取字符串，InputStreamReader类是从字节流到字符流的桥梁*/

/*按行读对于要处理的格式化数据是一种读取的好方式*/

()

{

intlen=0;

StringBufferstr=newStringBuffer("");

Filefile=newFile(FILE_IN);

try{

FileInputStreamis=newFileInputStream(file);

InputStreamReaderisr=newInputStreamReader(is);

BufferedReaderin=newBufferedReader(isr);

Stringline=null;

while((line=in.readLine())!=null)

{

if(len!=0)//处理换行符的问题

{

str.append(" "+line);

}

else

{

str.append(line);

}

len++;

}

in.close();

is.close();

}catch(IOExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}

returnstr.toString();

}

‘捌’ java怎样把一个文本内容读取成字符串

java中可以使用Scanner来读取文件的内容，首先先通过File创建一个文件，再通过Scanner的nextLine()方法读取文本的内容。
具体代码如下所示：
public class Demo {
public static void main(String[] args) {
File file = new File("C:/Users/hp/Desktop/data.txt");
Scanner scanner = null;
try {
scanner = new Scanner(file);
String str = null;
while (scanner.hasNextLine()) {
str += scanner.nextLine() + "\r\n";
}
System.out.println(str);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (scanner != null) {
scanner.close();
}
}
}
}
Scanner的主要功能是简化文本扫描，这个类最实用的地方表现在获取控制台输入。

‘玖’ java中读取txt文件时怎么将数字和字符串提取出来

package test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

class Test {

private static BufferedReader bw;

public static void main(String[] args) {
String ss = null;
List<TestPo> list = new ArrayList<TestPo>();
try{
File file=new File("E:\\test.txt");
FileOutputStream out=new FileOutputStream(new File("E:\\test1.txt"),true);
bw=new BufferedReader(new FileReader(file));
boolean flag = true;
int[] temps = null;
while((ss=bw.readLine())!=null){

String[] mark = ss.split(":");
int sum =0;
TestPo po = new TestPo();
int[] temp = new int[mark.length-1];
temps = new int[mark.length-1];
for (int i = 1;i< mark.length;i++) {
temp[i-1] = Integer.parseInt(mark[i].trim());
sum += temp[i-1];
if (flag) {
temps[i-1] = 0;
}
}
flag = false;
po.setMark(temp);
po.setName(mark[0]);
po.setAvg(sum/(mark.length-1));
list.add(po);
out.write(("\t\n"+ss).getBytes());
}

bw.close();
out.close();

int row = list.size();
int[][] marks = new int[row+1][];
for (int i = 0; i < row; i++) {
marks[i] = list.get(i).getMark();
}
marks[row] = temps;
int sumTemp =0 ;
int count = list.get(0).getMark().length;
for (int i = 0; i < count; i++) {
for (int j = 0; j < row; j++) {
sumTemp += marks[j][i];
}
marks[row][i] = sumTemp/row;
sumTemp = 0;
}
for (int[] is : marks) {
for (int i : is) {
System.out.print(i+" ");
}
System.out.println();
}

}catch(IOException e){
e.printStackTrace();
}

for (TestPo po : list) {
System.out.println("Name:"+po.getName()+" AVG:"+po.getAvg());
}
}

}

class TestPo{

private String name;
private Integer avg;
private int[] mark;

public int[] getMark() {
return mark;
}
public void setMark(int[] mark) {
this.mark = mark;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAvg() {
return avg;
}
public void setAvg(Integer avg) {
this.avg = avg;
}

}

‘拾’ JAVA中几种读取文件字符串的效率哪个比较高

方式一

/**
* 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
* 当然也是可以读字符串的。
*/
/* 貌似是说网络环境中比较复杂，每次传过来的字符是定长的，用这种方式？*/
public String readString1()
{
try
{
//FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。
FileInputStream inStream=this.openFileInput(FILE_NAME);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] buffer=new byte[1024];
int length=-1;
while( (length = inStream.read(buffer) != -1)
{
bos.write(buffer,0,length);
// .write方法 SDK 的解释是 Writes count bytes from the byte array buffer starting at offset index to this stream.
// 当流关闭以后内容依然存在
}
bos.close();
inStream.close();
return bos.toString();
// 为什么不一次性把buffer得大小取出来呢？为什么还要写入到bos中呢？ return new(buffer,"UTF-8") 不更好么?
// return new String(bos.toByteArray(),"UTF-8");
}
}

方式二

// 有人说了 FileReader 读字符串更好，那么就用FileReader吧
// 每次读一个是不是效率有点低了？
private static String readString2()
{
StringBuffer str=new StringBuffer("");
File file=new File(FILE_IN);
try {
FileReader fr=new FileReader(file);
int ch = 0;
while((ch = fr.read())!=-1 )
{
System.out.print((char)ch+" ");
}
fr.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("File reader出错");
}
return str.toString();
}

方式三

/*按字节读取字符串*/
/* 个人感觉最好的方式，（一次读完）读字节就读字节吧，读完转码一次不就好了*/
private static String readString3()
{
String str="";
File file=new File(FILE_IN);
try {
FileInputStream in=new FileInputStream(file);
// size 为字串的长度 ，这里一次性读完
int size=in.available();
byte[] buffer=new byte[size];
in.read(buffer);
in.close();
str=new String(buffer,"GB2312");
} catch (IOException e) {
// TODO Auto-generated catch block
return null;
e.printStackTrace();
}
return str;
}

/*InputStreamReader+BufferedReader读取字符串 ， InputStreamReader类是从字节流到字符流的桥梁*/
/* 按行读对于要处理的格式化数据是一种读取的好方式 */
private static String readString4()
{
int len=0;
StringBuffer str=new StringBuffer("");
File file=new File(FILE_IN);
try {
FileInputStream is=new FileInputStream(file);
InputStreamReader isr= new InputStreamReader(is);
BufferedReader in= new BufferedReader(isr);
String line=null;
while( (line=in.readLine())!=null )
{
if(len != 0) // 处理换行符的问题
{
str.append("\r\n"+line);
}
else
{
str.append(line);
}
len++;
}
in.close();
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return str.toString();
}