I wanted to write a method that would return the year with the most number of hits as part of ex 4.3

[Varuna Seneviratna]

Hello!
I wanted to write a method that would return the year with the most number of hits as part of ex 4.34 of Objects First With Java third edition.I am not happy how it has come out.I would like your advice.One thing I want to note is the finalCount is initialized to zero.if only intermidiateValue exceeds the finalCount only the maximumCountYear is updated.My point is if intermidiateValue does not exceeds Zero then maximumHourCountYear will not be updated.What I want is to find way of comparing values within the ArrayList without using preset values like zero since it may lead to a wrong out put.I do not know whether I have conveyed the message clearly, I hope you would understand.yearlyCounts is an ArrayList.reader is an object.

/**
     * Analyze yearly data from log file
     */
    public void analyzeYearlyData()
    {
        int year=0;
        while(reader.hasMoreEntries())
        {
            LogEntry entry = reader.nextEntry();
             year=entry.getYear();
            yearlyCounts.add(year);
            
            
            
        }
        
        int finalCount=0;
        int maximumCountYear=0;
        int yearValue=0;
        while(yearlyCounts.size() > 0)
        {
               year=yearlyCounts.get(0);
               int intermidiateCount=0;
               for(int i=0; i < yearlyCounts.size(); i++)
               {
                    yearValue=yearlyCounts.get(i);
                    if(year == yearValue)
                    {
                           intermidiateCount++;
                           int index=yearlyCounts.indexOf(yearValue);
                           yearlyCounts.remove(index);
                    }
                    
               }
               
               if(intermidiateCount > finalCount)
               {
                   maximumCountYear=yearValue;
                }
        }
        
        System.out.println(maximumCountYear);
        
        
    }

From here all the 4 classes are shown

 

/**
 * Read web server data and analyse
 * hourly access patterns.
 * 
 * @author David J. Barnes and Michael Kolling.
 * @version 2008.03.30
 */

import java.util.*;

public class LogAnalyzer
{
    // Where to calculate the hourly access counts.
    private int[] hourCounts;
    // Use a LogfileReader to access the data.
    private LogfileReader reader;
    //Uses to store the yearly accesses data
    private ArrayList<Integer> yearlyCounts;

    /**
     * Create an object to analyze hourly web accesses.
     */
    public LogAnalyzer()
    { 
        // Create the array object to hold the hourly
        // access counts.
        hourCounts = new int[24];
        // Create the reader to obtain the data.
        reader = new LogfileReader();
        yearlyCounts=new ArrayList<Integer>();
        
    }

    /**
     * Analyze the hourly access data from the log file.
     */
    public void analyzeHourlyData()
    {
        while(reader.hasMoreEntries()) {
            LogEntry entry = reader.nextEntry();
            int hour = entry.getHour();
            hourCounts[hour]++;
        }
    }
    /**
     * Analyze yearly data from log file
     */
    public void analyzeYearlyData()
    {
        int year=0;
        while(reader.hasMoreEntries())
        {
            LogEntry entry = reader.nextEntry();
             year=entry.getYear();
            yearlyCounts.add(year);
            
            
            
        }
        
        int finalCount=0;
        int maximumCountYear=0;
        int yearValue=0;
        while(yearlyCounts.size() > 0)
        {
               year=yearlyCounts.get(0);
               int intermidiateCount=0;
               for(int i=0; i < yearlyCounts.size(); i++)
               {
                    yearValue=yearlyCounts.get(i);
                    if(year == yearValue)
                    {
                           intermidiateCount++;
                           int index=yearlyCounts.indexOf(yearValue);
                           yearlyCounts.remove(index);
                    }
                    
               }
               int intermidiate2Value=intermidiateCount;
               finalCount=intermidiate2Value;
               if(intermidiateCount > finalCount)
               {
                   maximumCountYear=yearValue;
                }
        }
        
        System.out.println(maximumCountYear);
        
        
    }

    /**
     * Print the hourly counts.
     * These should have been set with a prior
     * call to analyzeHourlyData.
     */
    public void printHourlyCounts()
    {
        System.out.println("Hr: Count");
        int hour=0;
        while(hour < hourCounts.length){
               System.out.println(hour +":  " + hourCounts[hour]);
               hour++;
               
        }
    }
    
    /**
     * Print the lines of data read by the LogfileReader
     */
    public void printData()
    {
        reader.printData();
    }
    /**
     * Retuens the number of Accesses
     */
    public int numberOfAccesses()
    {
       int hour=0;
       int numberOfAccesses=0;
        while(hour < hourCounts.length)
        {
               numberOfAccesses +=hourCounts[hour];
               hour++;
        }
        
        return numberOfAccesses;
        
    }
    /**
     * Returns the Busiest Hour
     */
    public int busiestHour()
    {
        int i=0;
        int maximumCounts=hourCounts[i];
        int busiestHour=0;
        
        for(i=0; i < hourCounts.length; i++)
        {
            
            if(maximumCounts <  hourCounts[i])
            {
                maximumCounts=hourCounts[i];
                busiestHour=i;
            }
        }
        return busiestHour;
    }
    
    /**
     * Returns the hour which had the
     * least number of counts
     * 
     */
    public int quitestHour()
    {
        int i=0;
        int minimumCounts=hourCounts[i];
        int quitestHour=0;
        for(i=0; i < hourCounts.length; i++)
        {
            if(minimumCounts > hourCounts[i])
            {
                   minimumCounts=hourCounts[i];
                   quitestHour=i;
            }
        }
        
        return quitestHour;
    }
}


   

 


import java.io.File;
import java.io.FileNotFoundException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.Random;
import java.util.Scanner;

/**
 * A class to read information from a file of web server accesses.
 * Currently, the log file is assumed to contain simply
 * date and time information in the format:
 *
 *    year month day hour minute
 * Log entries are sorted into ascending order of date.
 * 
 * @author David J. Barnes and Michael Kolling.
 * @version 2008.03.30
 */
public class LogfileReader
{
    // The data format in the log file.
    private String format;
    // Where the file's contents are stored in the form
    // of LogEntry objects.
    private ArrayList<LogEntry> entries;
    // An iterator over entries.
    private Iterator<LogEntry> dataIterator;
    
    /**
     * Create a LogfileReader to supply data from a default file.
     */
    public LogfileReader()
    {
        this("weblog.txt");
    }
    
    /**
     * Create a LogfileReader that will supply data
     * from a particular log file. 
     * @param filename The file of log data.
     */
    public LogfileReader(String filename)
    {
        // The format for the data.
        format = "Year Month(1-12) Day Hour Minute";       
        // Where to store the data.
        entries = new ArrayList<LogEntry>();
        
        // Attempt to read the complete set of data from file.
        boolean dataRead;
        try{
            // Locate the file with respect to the current environment.
            URL fileURL = getClass().getClassLoader().getResource(filename);
            if(fileURL == null) {
                throw new FileNotFoundException(filename);
            }
            Scanner logfile = new Scanner(new File(fileURL.toURI()));
            // Read the data lines until the end of file.
            while(logfile.hasNextLine()) {
                String logline = logfile.nextLine();
                // Break up the line and add it to the list of entries.
                LogEntry entry = new LogEntry(logline);
                entries.add(entry);
            }
            logfile.close();
            dataRead = true;
        }
        catch(FileNotFoundException e) {
            System.out.println("Problem encountered: " + e);
            dataRead = false;
        }
        catch(URISyntaxException e) {
            System.out.println("Problem encountered: " + e);
            dataRead = false;
        }
        // If we couldn't read the log file, use simulated data.
        if(!dataRead) {
            System.out.println("Failed to read the data file: " +
                               filename);
            System.out.println("Using simulated data instead.");
            createSimulatedData(entries);
        }
        // Sort the entries into ascending order.
        Collections.sort(entries);
        reset();
    }
    
    /**
     * Does the reader have more data to supply?
     * @return true if there is more data available,
     *         false otherwise.
     */
    public boolean hasMoreEntries()
    {
        return dataIterator.hasNext();
    }
    
    /**
     * Analyze the next line from the log file and
     * make it available via a LogEntry object.
     * 
     * @return A LogEntry containing the data from the
     *         next log line.
     */
    public LogEntry nextEntry()
    {
        return dataIterator.next();
    }
    
    /**
     * @return A string explaining the format of the data
     *         in the log file.
     */
    public String getFormat()
    {
        return format;
    }
    
    /**
     * Set up a fresh iterator to provide access to the data.
     * This allows a single file of data to be processed
     * more than once.
     */
    public void reset()
    {
        dataIterator = entries.iterator();
    }

    /**
     * Print the data.
     */    
    public void printData()
    {
        for(LogEntry entry : entries) {
            System.out.println(entry);
        }
    }

    /**
     * Provide a sample of simulated data.
     * NB: To simplify the creation of this data, no
     * days after the 28th of a month are ever generated.
     * @param data Where to store the simulated LogEntry objects.
     */
    private void createSimulatedData(ArrayList<LogEntry> data)
    {
        // For each data item (year, month, day, hour, min) the lowest
        // valid value is listed.
        int[] lowest = { 2006, 1, 1, 0, 0, };
        // For each data item (year, month, day, hour, min) the range of
        // valid values is listed. (Note the simplification of having
        // only 28 days in any month to avoid generating invalid dates.)
        int[] range = { 3, 12, 28, 24, 60 };
        // Use a fixed seed to generate the random data, so
        // that the data is reproducable.
        Random rand = new Random(12345);
        // Build each simulated line in a string buffer.
        StringBuffer line = new StringBuffer();
        // How many simulated lines we want.
        int numLines = 100;
        // The number of data values per simulated line.
        int itemsPerLine = lowest.length;
        for(int i = 0; i < numLines; i++) {
            for(int j = 0; j < itemsPerLine; j++) {
                int value = lowest[j]+rand.nextInt(range[j]);
                line.append(value);
                line.append(' ');
            }
            // Convert the line to a LogEntry.
            LogEntry entry = new LogEntry(line.toString());
            data.add(entry);
            line.setLength(0);
        }
    }
}

   

 

/**
 * Store the data from a single line of a
 * web-server log file.
 * Individual fields are made available via
 * accessors such as getHour() and getMinute().
 * 
 * @author David J. Barnes and Michael Kolling.
 * @version 2008.03.30
 */
public class LogEntry implements Comparable<LogEntry>
{
    // Where the data values extracted from a single
    // log line are stored.
    private int[] dataValues;
    // At which index in dataValues the different fields
    // from a log line are stored.
    private static final int YEAR = 0, MONTH = 1, DAY = 2,
                             HOUR = 3, MINUTE = 4;
                      
    /**
     * Decompose a log line so that the individual fields
     * are available.
     * @param logline A single line from the log.
     */
    public LogEntry(String logline)
    {
        // The array to store the data for a single line.
        dataValues = new int[5];
        // Break up the log line.
        LoglineTokenizer tokenizer = new LoglineTokenizer();
        tokenizer.tokenize(logline,dataValues);
    }
    
    /**
     * @return The hour field from the log line.
     */
    public int getHour()
    {
        return dataValues[HOUR];
    }

    /**
     * @return The minute field from the log line.
     */
    public int getMinute()
    {
        return dataValues[MINUTE];
    }
    /**
     * Returns the year
     */
    public int getYear()
    {
        return dataValues[YEAR];   
    }
    /**
     * Return the Month
     */
    public int getMonth()
    {
        return dataValues[MONTH];
    }
    /**
     * Return the Day
     */
    public int getDay()
    {
        return dataValues[DAY];   
    }
    
    /**
     * Create a string representation of the data.
     * This is not necessarily identical with the
     * text of the original log line.
     * @return A string representing the data of this entry.
     */
    public String toString()
    {
        StringBuffer buffer = new StringBuffer();
        for(int value : dataValues) {
           // Prefix a leading zero on single digit numbers.
            if(value < 10) {
                buffer.append('0');
            }
            buffer.append(value);
            buffer.append(' ');
        }
        // Drop any trailing space.
        return buffer.toString().trim();
    }
    
    /**
     * Compare the date/time combination of this log entry
     * with another.
     * @param otherEntry The other entry to compare against.
     * @return A negative value if this entry comes before the other.
     *         A positive value if this entry comes after the other.
     *         Zero if the entries are the same.
     */
    public int compareTo(LogEntry otherEntry)
    {
        if(otherEntry == this) {
            // They are the same object.
            return 0;
        }
        else {
            // Compare corresponding fields.
            for(int i = 0; i < dataValues.length; i++) {
                int difference = dataValues[i] - otherEntry.dataValues[i];
                if(difference != 0) {
                    return difference;
                }
            }
            // No value is different, so the two entries represent
            // identical times.
            return 0;
        }
    }
}

   

  

import java.util.Scanner;

/**
 * Break up line from a web server log file into
 * its separate fields.
 * Currently, the log file is assumed to contain simply
 * integer date and time information.
 * 
 * @author David J. Barnes and Michael Kolling.
 * @version 2008.03.30
 */
public class LoglineTokenizer
{
    /**
     * Construct a LogLineAnalyzer
     */
    public LoglineTokenizer()
    {
    }

    /**
     * Tokenize a log line. Place the integer values from
     * it into an array. The number of tokens on the line
     * must be sufficient to fill the array.
     *
     * @param logline The line to be tokenized.
     * @param dataLine Where to store the values.
     */
    public void tokenize(String logline, int[] dataLine)
    {
        try {
            // Scan the logline for integers.
            Scanner tokenizer = new Scanner(logline);
            for(int i = 0; i < dataLine.length; i++) {
                dataLine[i] = tokenizer.nextInt();
            }
        }
        catch(java.util.NoSuchElementException e) {
            System.out.println("Insuffient data items on log line: " + logline);
            throw e;
        }
    }
}


  

The Log file is attached to execute the programme.






Regards Varuna

[Steve Luke]

        int finalCount=0;
        int maximumCountYear=0;
        int yearValue=0;
        while(yearlyCounts.size() > 0)
        {
               year=yearlyCounts.get(0);
               int intermidiateCount=0;
               for(int i=0; i < yearlyCounts.size(); i++)
               {
                    yearValue=yearlyCounts.get(i);
                    if(year == yearValue)
                    {
                           intermidiateCount++;
                           int index=yearlyCounts.indexOf(yearValue);
                           yearlyCounts.remove(index);
                    }
                    
               }
               
               if(intermidiateCount > finalCount)
               {
                   maximumCountYear=yearValue;
                }
        }        

Ask yourself 2 questions:

1) What is the purpose of finalCount? [What are you using it for, and do you need it]
2) When do you really want to assign intermediateCount to maximumCountYear? [be specific, then consider what value might be best to use when deciding to make that assignment or not]

[Varuna Seneviratna]

In this code there is no point in having finalCount, But what I want is to find a way to use value intermidiateValue derived by counting the number of times an year has come up in the logLine and compare it with another obtained the same way, then from a "if" to update the finalCount and maximumCountYear.What I am saying is usually done at the start of loops.I am asking whether there is a way to do it that way after a loop execution has finished and before the start of the next round of the same loop.

Regards Varuna