import java.util.*;
import java.io.*;
public class ReadFile
{
	static List list;

	public static void main(String[] args)
	{
		Scanner read = new Scanner(System.in);
		System.out.println("Enter the number of lines (k) you want to print";
		int k = read.nextInt();

		list = new ArrayList();
		File file = new File(args[0]);

		try
		{
			FileReader fr = new FileReader(file);
			BufferedReader in = new BufferedReader(fr);
			String s;
		
			//read each line from the file
			s = in.readLine();

			while(s!=null)
		 	{
				
				list.add(s);	
				s = in.readLine();
			}
			in.close();

		}
		catch(Exception ex)
		{ 
			ex.printStackTrace();
		}
		printRandom(k);
	}

	public static void printRandom(int k)
	{
		long i = Math.round(Math.random()*list.size());

		if(k<=list.size())
		{
			for(int m =0; m<k; m++)
			{
				System.out.println("Read:" + list.get((int)(i)));
				i = Math.round(Math.random()*list.size());
			}
		}
		else
		{
			System.out.println("No of Lines too much...";
			System.exit(0);
		}
		
	}

}

ekt_bear: At a high level, this is the idea:

1. Sweep through file line by line to compute N
2. Select some subset of K integers from the numbers 1 through N
3. Sweep through the file again, adding the corresponding line numbers to the file.

import java.util.*;
import java.io.*;
public class ReadFile
{
	static List list;

	public static void main(String[] args) throws Exception
	{
		//receive input for number of lines to print
		Scanner read = new Scanner(System.in);
		System.out.println("Enter the number of lines (k) you want to print";
		int k = read.nextInt();

		list = new ArrayList();
		File file = new File(args[0]);
		//get the file size
    		int filesize=(int)file.length();
    		FileInputStream fis= new FileInputStream(file); 

		//size of required to read to at a time (1kb)
		int size = 1024;
		

		try
		{
			byte b[]=new byte[size];
			

    			int ch,c=0;

   			 while(filesize>0)
           		{

                 		ch=fis.read(b,0,size);
				//read file of 1kb


       				filesize = filesize-ch;
				//update the file size

				//create temporary file name
                		String fname=c+"."+file.getName()+"";
       			c++;
				//create temporary file
				File tempFile = new File(fname);
        			FileOutputStream fos= new FileOutputStream(tempFile);
        			fos.write(b,0,ch);
        			fos.flush();
        			fos.close();

      		        	//read temporary file
				FileReader fr = new FileReader(fname);
				BufferedReader in = new BufferedReader(fr);
				String s;
		
				//read each line from the file
				s = in.readLine();

				while(s!=null)
		 		{
					//add each line of file to a list object
					list.add(s);	
					s = in.readLine();
				}
				//delete temporary file to save memory
				tempFile.delete();

				in.close();
			}
		}
		catch(Exception ex)
		{ 
			ex.printStackTrace();
		}
		printRandom(k);
	}
	public static void printRandom(int k)
	{
		//Generate random number
		long i = Math.round(Math.random()*list.size());

		//ensure k (required no of lines) is not more than number of lines in the list
		if(k<=list.size())
		{
			//generate reqired number of lines(k)
			for(int m =0; m<k; m++)
			{
				//print an random selected line
				System.out.println("Read:" + list.get((int)(i)));
				i = Math.round(Math.random()*list.size());
			}
		}
		else
		{
			System.out.println("No of Lines too much...";
			System.exit(0);
		}
		
	}

}

lordZOUGA:
sweeping through a file of unknown length line by line?? Even if the file is say up to 1terabyte??

  //This adds each line to the list			
   while(s!=null)
   {
				
	list.add(s);	
	s = in.readLine();
   }
   //This gets the no of lines in the list
   list.size()

Javanian: ok, then i will seat back and wait for a solution

using System;
using System.IO;

public class Program
{
public static void Main()
{
	string fileName = "file.txt";	// Name of file to read
	int linesToRead = 5;			// Number of random lines read
	
	Random random = new Random();
	int totalLines = 0;
	int[] groups = new int[linesToRead];
	string[] randomLines = new string[linesToRead];
	StreamReader sr = null;
	
	// Count the number of lines in the file. (Hint: I hate exceptions!)
	try { sr = new StreamReader(fileName); }
	catch (Exception e) { Console.WriteLine(e.Message); return; }
	while (!sr.EndOfStream) {
		sr.ReadLine();
		totalLines++;
	}
	
	// "You don high?" -- Javanian
	if (linesToRead > totalLines) {
		Console.WriteLine("Can't dash me {0} naira when you have only {1} ",
			linesToRead, totalLines);
		goto end;	// The more they hate you, the more I love you!
	}
	
	// Split the lines into groups so we will pick one random line from each.
	// This will make the result set more semantically random.
	for (; linesToRead > 0; linesToRead--) {
		groups[linesToRead - 1] = totalLines / linesToRead;
		totalLines -= groups[linesToRead - 1];
	}
	
	// Randomly select the line number to read from each group.
	for (int i = 0, min = 0, max = 0; i < groups.Length; min = max, i++)
		groups[i] = random.Next(min, max += groups[i]);
	
	// With the line numbers to read set, now read them!
	sr.BaseStream.Position = 0;
	for (int i = 0, line = 0; !sr.EndOfStream; line++)
		if (groups[i] == line) {
			randomLines[i++] = sr.ReadLine();
			if (i == groups.Length)
				break;
		} else sr.ReadLine();
	
	// Prove to the agnostic that this algorithm works 
	for (int i = 0; i < randomLines.Length; i++)
		Console.WriteLine("Random Line {0}: {1}", i + 1, randomLines[i]);
	
	end:
	sr.Close();
}
}

while (!sr.EndOfStream) {
		sr.ReadLine();
		totalLines++;
	}

ekt_bear: goto end; // The more they hate you, the more I love you!

lmao!

Javanian:

while (!sr.EndOfStream) {
		sr.ReadLine();
		totalLines++;
	}

You are doing the samething i did

ekt_bear: I think your algorithm works, mkwayisi. However, the splitting the lines into groups stuff is not something I mentioned...but can of course be corrected pretty easily.

₱®ÌИСΞ:
Done in Java
http://pastebin.com/znMpn3TH

Pass the file path as d only arguement

Java fileClass.java c:/file.txt

mkwayisi:

With your implementation, you did not eliminate the possibility of the same number being generated multiple times. So if your random numbers generated are say {1, 1, 2, 2, 3}, you'd end up displaying same lines multiple times as well.

ekt_bear:
If there are N lines, this will take O(N) time, won't it?

Plus most languages will do some sort of buffered I/O which reads big blocks of the file at a time, no?