This is the Code to search a string in the last 100 lines of a file.

[Jacob Sonia]

This code is throwing an error when the pattern is '{' but not in any other case

 import java.io.*;
import java.util.regex.*;
public class tailfunction {
    public int countNoOfLines(){
    try{
            File fw = new File("C:\\Users\\Sonia\\Documents\\LDAPnotes.txt");
            BufferedReader pw = new BufferedReader(new FileReader(fw));
            int count = 0;
            while((pw.readLine()) != null){
                count = ++count;
            }
            return count;
     }catch(IOException e){
        e.printStackTrace();
        return 0;
    }
    }

    public void searchPattern(){
        try{
            File fw = new File("C:\\Users\\Sonia\\Documents\\LDAPnotes.txt");
            System.out.println(fw.exists());
            BufferedReader pw = new BufferedReader(new FileReader(fw));
            int count = 0;
            String s = null;
            Pattern p =  Pattern.compile("{");
            while((s = pw.readLine()) != null){
                count = count+1;
                if(count > (countNoOfLines() - 4)){
                   System.out.println(s);
                   
                   Matcher m = p.matcher(s);
                   if(m.find()){
                       System.out.println(m.start());
                       break;
                   }
                }
            }
           
        }catch(IOException e){
            e.printStackTrace();
            
        }
    }
    public static void main(String... args){
            tailfunction f = new tailfunction();
            f.searchPattern();
    }
}
   

[Antany Vasanth]

Hi Jacob,

The "{" is used in pattern to specify the number for occurances. For example \d{2} means two digits.

So if you want to use the pattern "{". You need to escape it.

So try "\\{" instead of "{"

Regards,
Antany.

[Jacob Sonia]

Thanks for it. Also please help me in making the program efficient. Here i am reading the file twice to find the number of lines and then go to the last 100 lines, there must be an efficient way. Please help me.

[Rob Spoor]

How about using a List to store the 100 last records?

List<String> lines = new LinkedList<String>(); // LinkedList is more efficient at removing from the start
File fw = new File("C:\\Users\\Sonia\\Documents\\LDAPnotes.txt");   
BufferedReader pw = new BufferedReader(new FileReader(fw));   
String line = null;
while ((line = pw.readLine()) != null)
{
    lines.add(line);
    if (lines.size() > 100) // so basically 101
    {
        lines.remove(0);
    }
}

I've once written (and thrown away...) a List implementation that used a fixed size array and cycled through that; if the List would grow too large the first element was automatically removed. In essence, it used the following structure:
- Object[] elements - the elements
- int start - the index inside elements of the first element
- int end - the index inside elements one past the last element
- int size - the number of elements

Essentially, in a full list, start == end. By adding one element, both start and end get increased by one (reset to 0 if >= elements.length), thereby removing the first element. size is usually (end + elements.length - start) % elements.length but is needed when start == end: that can either mean an empty list or a full list.

The reason I've thrown this class away is that it was quite a chore to insert elements somewhere in the middle, or remove elements. It shifted either up or down, whichever would have the least number of elements shifted.
Perhaps I should recreate the class but this time as a Collection that does not allow removal, only addition.

[Jacob Sonia]

hey thanks