We Keep Coding

Not able to write on a file

The above is a working code snippet. The code runs fine but it does not write what is inside the else if(line.contains("{NEW_LIMIT}")) statement.
Another problem is that after the program writes into a new text file it loses its original format, as in to say it just writes everything in a single line.
Is there anything I am doing wrong?
public static void replace1(String name, String limit, String nlimit) throws IOException
{
File infile = new File("s://BlackBuck/Question_1_Template.txt");
File outfile = fileReturn();
FileWriter fw;
BufferedWriter bw = null;
FileReader fr;
BufferedReader br = null;
String line, putdata = null;;
try {
fr = new FileReader(infile);
br = new BufferedReader(fr);
fw = new FileWriter(outfile);
bw = new BufferedWriter(fw);
while((line = br.readLine()) != null)
{
if(line != null)
{
if(line.contains("{CUSTOMER_NAME}"))
{
putdata = line.replace("{CUSTOMER_NAME}", name);
bw.write(putdata);
}
else if(line.contains("{CURRENT_LIMIT}"))
{
putdata = line.replace("{CURRENT_LIMIT}", limit);
bw.write(putdata);
}
else if(line.contains("{NEW_LIMIT}"))
{
putdata = line.replace("{NEW_LIMIT}", nlimit);
bw.write(putdata);
}
else
{
bw.write(line);
}
}
}
}finally {
bw.close();
br.close();
}
}

If a line contains {CUSTOMER_NAME} or {CURRENT_LIMIT}, then statements {NEW_LIMIT} won't be run. You can simply fix this using following codes:
if(line != null) {
putdata = line.replace("{CUSTOMER_NAME}", name)
.replace("{CURRENT_LIMIT}", limit)
.replace("{NEW_LIMIT}", nlimit);
bw.write(putdata);
// append a line separator to current line
bw.newLine();
}

How to display all lines of text from a file instead of stopping at the end of a line?

The code below only brings up the first line of code and stops. I would like to return each line of code until there are no more.
private String GetPhoneAddress() {
File directory = Environment.getExternalStorageDirectory();
File myFile = new File(directory, "mythoughtlog.txt");
//File file = new File(Environment.getExternalStorageDirectory() + "mythoughtlog.txt");
if (!myFile.exists()){
String line = "Need to add smth";
return line;
}
String line = null;
//Read text from file
//StringBuilder text = new StringBuilder();
try {
BufferedReader br = new BufferedReader(new FileReader(myFile));
line = br.readLine();
}
catch (IOException e) {
//You'll need to add proper error handling here
}
return line;
}

You could loop over the results of readLine() and accumulate them until you get a null, indicating the end of the file (BTW, note that your snippet neglected to close the reader. A try-with-resource structure could handle that):
try (BufferedReader br = new BufferedReader(new FileReader(myFile))) {
String line = br.readLine();
if (line == null) {
return null;
}
StringBuilder retVal = new StringBuilder(line);
line = br.readLine();
while (line != null) {
retVal.append(System.lineSeparator()).append(line);
line = br.readLine();
}
return retVal.toString();
}
if you're using Java 8, you can save a lot of this boiler-plated code with the newly introduced lines() method:
try (BufferedReader br = new BufferedReader(new FileReader(myFile))) {
return br.lines().collect(Collectors.joining(System.lineSeparator()));
}

A considerably less verbose solution:
try (BufferedReader br = new BufferedReader(new FileReader(myFile))) {
StringBuilder retVal = new StringBuilder();
while ((line = br.readLine()) != null) {
retVal.append(line).append(System.lineSeparator());
}
return retVal.toString();
}

I am not able to write all data to a file

I have written the Java code to read from one file and write to a new file. The file from which I am reading has 5000 lines of records, but when I am writing to a new file I am able to write only between 4700-4900 records.
I think may be I am simultaneously reading from a file and writing to a file, which might be creating a problem.
My code is as follows:
Reading from a file:
public String readFile(){
String fileName = "/home/anand/Desktop/index.txt";
FileReader file = null;
try {
file = new FileReader(fileName);
BufferedReader reader = new BufferedReader(file);
String line = "";
while ((line = reader.readLine()) != null) {
line.replaceAll("ids", "");
System.out.println(line);
returnValue += line + "\n";
}
return returnValue;
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
if (file != null) {
try {
file.close();
} catch (IOException e) {
// Ignore issues during closing
}
}
}
}
Writing to a file:
public void writeFile(String returnValue){
String newreturnValue = returnValue.replaceAll("[^0-9,]", "");
String delimiter = ",";
String newtext ="";
String[] temp;
temp = newreturnValue.split(delimiter);
FileWriter output = null;
try {
output = new FileWriter("/home/anand/Desktop/newinput.txt");
BufferedWriter writer = new BufferedWriter(output);
for(int i =0; i < temp.length ; i++){
writer.write("["+i+"] "+temp[i]);
writer.newLine();
}
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
if (output != null) {
try {
output.close();
} catch (IOException e) {
// Ignore issues during closing
}
}
}
}
I need the suggestion to how to simultaneously read and write to a file.

You need to close writer instead of output. The BufferedWriter may not be writing all of the lines, and won't since you never close it.

You have to close the writer object. The last couple lines probably haven't been flushed onto the text file.
In addition, are you aware of the try-with-resource introduced in Java 7? You can condense your code to this by utilizing it:
public String readFile(){
String fileName = "/home/anand/Desktop/index.txt";
try(BufferedReader reader = new BufferedReader(new FileReader(filename)) {
String line = "";
while ((line = reader.readLine()) != null) {
line.replaceAll("ids", "");
System.out.println(line);
returnValue += line + "\n";
}
return returnValue;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
By doing this, Java will automatically close the reader object for you once the try block completes, regardless of whether or not an exception was thrown. This makes it easier to read your code :)

BufferedReader sets the text file null

I am trying to simply read in a line from a text file using BufferedReader. Here is the sample code:
try {
BufferedReader reader = new BufferedReader( new FileReader( "data.txt") );
while(reader.readLine() != null )
{
System.out.println(reader.readLine())
}
}
} catch (Exception e) {
e.printStackTrace();
}
The code above seems to not only print out null, but sets the data.txt file to null (as in, the file data.txt would initially have 40kb, and a call to readLine() sets it to 0kb)?
I have no idea why this is occurring, it can locate the file, but sets the file to null?
Can anyone identify why this is occurring?
Thanks.
EDIT !!
The BufferedWriter code is below:
try{
BufferedWriter writer = new BufferedWriter(new FileWriter("data.txt"))
for(int x=0; x<64; x++)
{
writer.write(String.valueOf(data[x]));
}
writer.newLine();
writer.newLine();
}
catch(IOException io)
{};

Not sure why your file contents gets erased however you need to change your while loop to this since you're skipping lines if you use your code.
String line = null;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}

Your first readline() is used as while loop condition. Then you write the second readline() to System.out. So you're writing every 2nd line. What you need is this.
String str = null;
while((str=reader.readLine()) != null) {
System.out.println(str);
}

You are printing every second line only, and may also print the end of file null terminator. This is because the while conditional reads the line from your file as well, and that you simply discard this line after checking against null.
Retain the line value in the variable:
String s;
while( (s = reader.readLine()) != null )
{
System.out.println(s);
}

Here's a working sample, similar to your original. Note that closing resources is very important:
import java.io.*;
import java.util.*;
public class ReadFile
{
public static final void main(String[] argv)
{
String fileName="data-2.txt";
writeFile(fileName);
readFile(fileName);
}
private static void writeFile(String fileName)
{
BufferedWriter writer = null;
try
{
writer = new BufferedWriter(new FileWriter(fileName));
for(int x=0; x<64; x++)
{
writer.write("some data\n");
}
writer.newLine();
writer.newLine();
}
catch(IOException x)
{
x.printStackTrace();
}
finally
{
safeClose(writer);
}
}
private static void readFile(String fileName)
{
BufferedReader reader = null;
String line = null;
try
{
reader = new BufferedReader( new FileReader( fileName ));
while((line = reader.readLine()) != null)
{
System.out.println(line);
}
}
catch(IOException x)
{
x.printStackTrace();
}
finally
{
safeClose(reader);
}
}
private static void safeClose(Closeable closeable)
{
if(null != closeable)
{
try
{
closeable.close();
}
catch(IOException x)
{
//ignore -x.printStackTrace()
}
}
}
}

you are reading one line in while loop and then again reading next line in println statement. that means you are when you check the condition that time reader.readLine() does not equal to null, but when you read in println then it become null .`
while(reader.readLine() != null )
{
System.out.println(reader.readLine())
}
you should write your code in this way:
String line = null;
while((line=reader.readLine()) != null)
{
System.out.println(line) ;
}
did you close your writer object? you should close your writer object inside finally block this way.
this might help you to resolve your problem.
finally
{
if(null != writer)
{
try
{
writer.close();
}
catch(IOException ioException)
{
}
}
}

Read data from a text file using Java

I need to read a text file line by line using Java. I use available() method of FileInputStream to check and loop over the file. But while reading, the loop terminates after the line before the last one. i.e., if the file has 10 lines, the loop reads only the first 9 lines.
Snippet used :
while(fis.available() > 0)
{
char c = (char)fis.read();
.....
.....
}

You should not use available(). It gives no guarantees what so ever. From the API docs of available():
Returns an estimate of the number of bytes that can be read (or skipped over) from this input stream without blocking by the next invocation of a method for this input stream.
You would probably want to use something like
try {
BufferedReader in = new BufferedReader(new FileReader("infilename"));
String str;
while ((str = in.readLine()) != null)
process(str);
in.close();
} catch (IOException e) {
}
(taken from http://www.exampledepot.com/egs/java.io/ReadLinesFromFile.html)

How about using Scanner? I think using Scanner is easier
private static void readFile(String fileName) {
try {
File file = new File(fileName);
Scanner scanner = new Scanner(file);
while (scanner.hasNextLine()) {
System.out.println(scanner.nextLine());
}
scanner.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
Read more about Java IO here

If you want to read line-by-line, use a BufferedReader. It has a readLine() method which returns the line as a String, or null if the end of the file has been reached. So you can do something like:
BufferedReader reader = new BufferedReader(new InputStreamReader(fis));
String line;
while ((line = reader.readLine()) != null) {
// Do something with line
}
(Note that this code doesn't handle exceptions or close the stream, etc)

String file = "/path/to/your/file.txt";
try {
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
String line;
// Uncomment the line below if you want to skip the fist line (e.g if headers)
// line = br.readLine();
while ((line = br.readLine()) != null) {
// do something with line
}
br.close();
} catch (IOException e) {
System.out.println("ERROR: unable to read file " + file);
e.printStackTrace();
}

You can try FileUtils from org.apache.commons.io.FileUtils, try downloading jar from here
and you can use the following method:
FileUtils.readFileToString("yourFileName");
Hope it helps you..

The reason your code skipped the last line was because you put fis.available() > 0 instead of fis.available() >= 0

In Java 8 you could easily turn your text file into a List of Strings with streams by using Files.lines and collect:
private List<String> loadFile() {
URI uri = null;
try {
uri = ClassLoader.getSystemResource("example.txt").toURI();
} catch (URISyntaxException e) {
LOGGER.error("Failed to load file.", e);
}
List<String> list = null;
try (Stream<String> lines = Files.lines(Paths.get(uri))) {
list = lines.collect(Collectors.toList());
} catch (IOException e) {
LOGGER.error("Failed to load file.", e);
}
return list;
}

//The way that I read integer numbers from a file is...
import java.util.*;
import java.io.*;
public class Practice
{
public static void main(String [] args) throws IOException
{
Scanner input = new Scanner(new File("cards.txt"));
int times = input.nextInt();
for(int i = 0; i < times; i++)
{
int numbersFromFile = input.nextInt();
System.out.println(numbersFromFile);
}
}
}

Try this just a little search in Google
import java.io.*;
class FileRead
{
public static void main(String args[])
{
try{
// Open the file that is the first
// command line parameter
FileInputStream fstream = new FileInputStream("textfile.txt");
// Get the object of DataInputStream
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine;
//Read File Line By Line
while ((strLine = br.readLine()) != null) {
// Print the content on the console
System.out.println (strLine);
}
//Close the input stream
in.close();
}catch (Exception e){//Catch exception if any
System.err.println("Error: " + e.getMessage());
}
}
}

Try using java.io.BufferedReader like this.
java.io.BufferedReader br = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(fileName)));
String line = null;
while ((line = br.readLine()) != null){
//Process the line
}
br.close();

Yes, buffering should be used for better performance.
Use BufferedReader OR byte[] to store your temp data.
thanks.

user scanner it should work
Scanner scanner = new Scanner(file);
while (scanner.hasNextLine()) {
System.out.println(scanner.nextLine());
}
scanner.close();

public class ReadFileUsingFileInputStream {
/**
* #param args
*/
static int ch;
public static void main(String[] args) {
File file = new File("C://text.txt");
StringBuffer stringBuffer = new StringBuffer("");
try {
FileInputStream fileInputStream = new FileInputStream(file);
try {
while((ch = fileInputStream.read())!= -1){
stringBuffer.append((char)ch);
}
}
catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("File contents :");
System.out.println(stringBuffer);
}
}

public class FilesStrings {
public static void main(String[] args) throws FileNotFoundException, IOException {
FileInputStream fis = new FileInputStream("input.txt");
InputStreamReader input = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(input);
String data;
String result = new String();
while ((data = br.readLine()) != null) {
result = result.concat(data + " ");
}
System.out.println(result);

File file = new File("Path");
FileReader reader = new FileReader(file);
while((ch=reader.read())!=-1)
{
System.out.print((char)ch);
}
This worked for me

Simple code for reading file in JAVA:
import java.io.*;
class ReadData
{
public static void main(String args[])
{
FileReader fr = new FileReader(new File("<put your file path here>"));
while(true)
{
int n=fr.read();
if(n>-1)
{
char ch=(char)fr.read();
System.out.print(ch);
}
}
}
}