java输入输出流的几个小问题

Question

/*使用字符流，统计文件data.txt中包含的单词个数和行的个数。
使用FileInputStream类建立一个与文件有关的输入流，并提供从文件读取一组数据，格式：
FileInputStream datalist = new FileInputStream ("data.txt") ;
使用BufferReader类，目的用其readLine()方法能比较方便的从输入流中读取出一行字符串，格式：
BufferReader in =new BufferReader(new InputStreamReader(datalist));
单词与单词之间的分隔符号是空格。
程序运行说明：新建的文本文件(data.txt)必须与该experiment11_1.java源程序保存在同一个文件夹中。*/import java.io.*;
import java.awt.*;
import java.awt.event.*;
public class lab11_1
{
public static void main(String args[])//用什么办法统计单词的个数
{

int words=0,row=0;//单词和行的个数
String s;
try
{
FileInputStream datalist = new FileInputStream("data.txt");
    BufferedReader in =new BufferedReader(new InputStreamReader(datalist));
    while((s=in.readLine())!=null)
    {
    
     row++;
    }
    in.close();
    datalist.close();
    }
    catch(IOException e)
    {
     System.out.println("File read Error"+e);
    }
    System.out.println("words="+words+"   "+"row="+row);
}
}/*程序中产生10个随机整数（用(int)100*Math.random()生成），
 将它们存入一个数据文件，再从该文件中读取数据，并在屏幕上显示出来。
 
使用File类判断当前目录中是否已经存在文件data.dat，
如存在，则中断程序的运行，否则继续；
使用DataOutputStream及相关IO流类将随机产生的6个整数存入数据文件data.dat；
使用DataInputStream及相关IO流类从数据文件data.dat读取数据，并在屏幕上显示出来。*/
import java.io.*;
class public lab1102
{
public static void main(String args[])
{
try
{
File data=new File("data.dat");/*怎样使用File类判断当前目录中是否已经存在文件data.dat，我的存入随机数，读取随机数对么*/
DataOutputStream out=new DataOutputStream(data);
for(int i=0;i<6;i++)
{
out.writeInt((int)100*Math.random());
}
DataInputStream in= new DataInputStream();
for(int i=0;i<6;i++)
{
in.readInt();
}  
}
catch(IOException e)
{
System.out.println("data.dat already exist");
}
}
}

Answer 1

我以前用的一个类：获取文章的字数或者字符数package util;
/**
 * 获取文章的字数或者字符数
 * 
 * @author ffshi
 */
public class StatWordCount { private final char[] CHS = { ',', '；', '.', '!', '?', ';', '+', '。', '？',
'！' }; // 符号数组 private final char[] CHN = { '\n', '\r' }; // 转义符数组 private final char[] SPACE = { ' ', '　' }; // 空格的数组(前半角，后全角) /**
 * 根据指定条件来筛选文章的字数
 * 
 * @param wordContent
 *            文章内容
 * @param compriseInterpunction
 *            是否包含指定字符
 * @param compriseSpace
 *            是否包含空格
 * @return 返回文章经过指定筛选后的长度
 */
public int getWordCount(String wordContent, boolean compriseInterpunction,
boolean compriseSpace) {
if (wordContent == null) {
return 0;
} else if (wordContent.length() == 0) {
return 0;
} else {
// 既要包含符号又要包含空格
if (compriseInterpunction && compriseSpace) {
// 清除转义符
String regex = "[" + new String(CHN) + "]";
wordContent = wordContent.replaceAll(regex, " ");
return this.getWordCount(wordContent);
}
// 不包含符号包含空格
else if (!compriseInterpunction && compriseSpace) {
// 使用正则表达式去掉指定的符号和转义符
String regex1 = "[" + new String(CHN) + "]";
String regex2 = "[" + new String(CHS) + "]";
wordContent = wordContent.replaceAll(regex1, " ");
wordContent = wordContent.replaceAll(regex2, " ");
return this.getWordCount(wordContent);
}
// 包含指定符号不包含空格
else if (compriseInterpunction && !compriseSpace) {
// 使用正则表达式去掉空格和转义符
String regex1 = "[" + new String(CHN) + "]";
String regex2 = "[" + new String(SPACE) + "]";
wordContent = wordContent.replaceAll(regex1, " ");
wordContent = wordContent.replaceAll(regex2, " ");
return this.getWordCount(wordContent);
}
// 空格和指定符号都不包含
else {
// 使用正则表达式去掉空格,指定符号和转义符
String regex1 = "[" + new String(CHN) + "]";
String regex3 = "[" + new String(CHS) + "]";
String regex2 = "[" + new String(SPACE) + "]";
wordContent = wordContent.replaceAll(regex1, " ");
wordContent = wordContent.replaceAll(regex2, " ");
wordContent = wordContent.replaceAll(regex3, " ");
return this.getWordCount(wordContent);
}
}
} /**
 * 返回文章中的字数
 * 
 * @param wordCount
 *            文章内容
 * @return
 */
@SuppressWarnings("unused")
private int getWordCount(String wordContent) {
int count = 0;
if (wordContent == null) { // 判断是否为null,如果为null直接返回0
count = 0;
} else if (wordContent.length() == 0) { // 判断是否为空,如果为空直接返回0
count = 0;
} else { // 判断获取字数
wordContent = wordContent.trim(); // 清空空格
// 临时变量
String s4 = "";
String s3 = "";
String s1 = "";
boolean bb = false;
if (wordContent.length() > 0) {
s4 = String.valueOf(wordContent
.charAt(wordContent.length() - 1));
}
for (int i = 0; i < wordContent.length(); i++) {
s3 = String.valueOf(wordContent.charAt(i));
int num = s3.getBytes().length;
if (s3.hashCode() == 32 || s3.getBytes().length == 2) {
bb = true;
}
if (num == 2) {
count++;
} else {
if (i + 1 < wordContent.length() && (i > 1)) {
s1 = String.valueOf(wordContent.charAt(i + 1));
if ((s1.hashCode() == 32 || s1.getBytes().length == 2)
&& (s3.hashCode() != 32)) {
count++;
}
}
}
}
if (!bb) {
count++;
} else {
if (s4.getBytes().length == 1) {
count++;
}
}
}
return count;
} /**
 * 根据条件来获取文章的字符数
 * 
 * @param wordContent
 *            文章内容
 * @param compriseInterpunction
 *            是否包含指定符号
 * @param compriseSpace
 *            是否包含空格
 * @return 返回字符长度
 */
public int getWordCharacter(String wordContent,
boolean compriseInterpunction, boolean compriseSpace) {
// 既要包含符号又要包含空格
if (compriseInterpunction && compriseSpace) {
// 清除转义符
String regex = "[" + new String(CHN) + "]";
wordContent = wordContent.replaceAll(regex, " ");
// 首部的空格不算
wordContent = wordContent.replaceAll("^\\s+", "");
return wordContent.length();
}// 不包含符号包含空格
else if (!compriseInterpunction && compriseSpace) {
// 首部的空格不算
wordContent = wordContent.replaceAll("^\\s+", "");
// 使用正则表达式去掉指定的符号和转义符
String regex1 = "[" + new String(CHN) + "]";
String regex2 = "[" + new String(CHS) + "]";
wordContent = wordContent.replaceAll(regex1, " ");
wordContent = wordContent.replaceAll(regex2, " ");
return wordContent.length();
}// 包含指定符号不包含空格
else if (compriseInterpunction && !compriseSpace) {
// 使用正则表达式去掉空格和转义符
return this.getNoSpaceCount(wordContent);
}// 空格和指定符号都不包含
else {
// 使用正则表达式去掉指定符号
String regex1 = "[" + new String(CHS) + "]";
wordContent = wordContent.replaceAll(regex1, " ");
return this.getNoSpaceCount(wordContent);
}
} /**
 * 获取文章中非空格的字符总数
 * 
 * @param wordContent
 *            文章内容
 * @return
 */
private int getNoSpaceCount(String wordContent) {
int spaceCount = 0;
if (wordContent == null) {
spaceCount = 0;
} else if (wordContent.length() == 0) {
spaceCount = 0;
} else {
// 替换首部的
wordContent = wordContent.replaceAll("^\\s+", "");
wordContent = wordContent.replaceAll(" ", "");
// 使用正则替换转义符
String regex = "[" + new String(CHN) + "]";
wordContent = wordContent.replaceAll(regex, "");
spaceCount = wordContent.length();
}
return spaceCount;
}
}

Answer 2

这个看过，呵呵/*使用字符流，统计文件data.txt中包含的单词个数和行的个数。
使用FileInputStream类建立一个与文件有关的输入流，并提供从文件读取一组数据，格式：
FileInputStream datalist = new FileInputStream ("data.txt") ;
使用BufferReader类，目的用其readLine()方法能比较方便的从输入流中读取出一行字符串，格式：
BufferReader in =new BufferReader(new InputStreamReader(datalist));
单词与单词之间的分隔符号是空格。
程序运行说明：新建的文本文件(data.txt)必须与该experiment11_1.java源程序保存在同一个文件夹中。*/import java.io.*;
import java.awt.*;
import java.awt.event.*;
public class lab11_1
{
public static void main(String args[])
{

int words=0,row=0;//单词和行的个数
String s;
try
{
FileInputStream datalist = new FileInputStream("data.txt");
    BufferedReader in =new BufferedReader(new InputStreamReader(datalist));
    while((s=in.readLine())!=null)
    {
     for(int i=1;i<s.length();i++)
     {
     while(s.charAt(i)==' ')
     words++;
     }
     row++;
    }
    in.close();
    datalist.close();
    }
    catch(IOException e)
    {
     System.out.println("File read Error"+e);
    }
    System.out.println("words="+words+"   "+"row="+row);
}
}
第一个我改了，编译也通过了，但运行不出。

Answer 3

1.第一题不给出具体代码了，就直接说一下思路吧。你目前已经得到了每一行的字符串，那么你只需要写一个方法，这个方法能够得到一行的单词数。
这个方法可以使用正则表达式来切割，也可以使用另一种方法，就是第一次读到字母时，你判定这是一个单词的开始，然后读到一个空白字符时，表明读完一个单词，这样就能统计出来了。
2.
if(data.exists()) // 如果文件data存在。
    // TO DO

Answer 4

不知我的第一个那种方法对不对File data=new File("data.dat");
if(data.exists())
第二题这样么，File data不就创建了一个文件了么，怎么在之前判断呢

Answer 5

我改的，
LZ看看
第一个程序：
/*使用字符流，统计文件data.txt中包含的单词个数和行的个数。
使用FileInputStream类建立一个与文件有关的输入流，并提供从文件读取一组数据，格式：
FileInputStream datalist = new FileInputStream ("data.txt") ;
使用BufferReader类，目的用其readLine()方法能比较方便的从输入流中读取出一行字符串，格式：
BufferReader in =new BufferReader(new InputStreamReader(datalist));
单词与单词之间的分隔符号是空格。
程序运行说明：新建的文本文件(data.txt)必须与该experiment11_1.java源程序保存在同一个文件夹中。*/
package net.csdn.blog.johnston;import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;/**
 * @author Administrator
 *
 */
public class CountNumber { /**
 * @param args
 */
public static void main(String[] args) {  //用什么办法统计单词的个数 // TODO Auto-generated method stub
int words=0,row=0;//单词和行的个数
        String s;
        try
        {
            FileInputStream datalist = new FileInputStream("f:/data.txt");
            BufferedReader in =new BufferedReader(new InputStreamReader(datalist));
            while((s=in.readLine())!=null)
            {
                String [] str = s.split(" ");//如果单词之间只是空格话，就可以这样去写。如果是其他如/T，等你再加几个条件！这个只能过滤一个空格！或者你可以单个字符一个一个的检查！
                words += str.length;
                row++;
            }
            in.close();
            datalist.close();
        }
        catch(IOException e)
        {
            System.out.println("File read Error"+e);
        }
        System.out.println("words="+words+"   "+"row="+row); }}第二个程序：/*程序中产生10个随机整数（用(int)100*Math.random()生成），
 将它们存入一个数据文件，再从该文件中读取数据，并在屏幕上显示出来。
 
使用File类判断当前目录中是否已经存在文件data.dat，
如存在，则中断程序的运行，否则继续；
使用DataOutputStream及相关IO流类将随机产生的6个整数存入数据文件data.dat；
使用DataInputStream及相关IO流类从数据文件data.dat读取数据，并在屏幕上显示出来。*/package net.csdn.blog.johnston;import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;/**
 * @author Administrator
 *
 */
public class TestRandom { /**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
try
        {
File file = new File("f:/data.dat");
if (!file.exists()) { //判断文件是否存在,不存在执行如下操作
FileOutputStream data=new FileOutputStream(file);
            DataOutputStream out=new DataOutputStream(data);
            for(int i=0;i<6;i++)
            {
                out.writeInt((int)(100*Math.random()));   
             //out.writeChars("a" + i);
            }
            out.flush(); //关闭流
            data.close();
            out.close();
            
            FileInputStream fis = new FileInputStream(file);
            DataInputStream in= new DataInputStream(fis);
            for(int i=0;i<6;i++)
            {
                System.out.println(in.readInt());       
            }  
            fis.close();//关闭流
            in.close();
} else { //文件存在，不操作
 System.out.println("data.dat already exist");
}
           
        }
        catch(IOException e)
        {
            System.out.println("Exception!");
        } }}