WeatherAnalysis assignment Takes weatherdata from a CSV file and calculates average, max, min of temperature, rain, snow, humidity, wind

DataPoint.java

/**The DataPoint class represents a single weather data entry
 * 
 * 
 * @author desrtfx
 *
 */
public class DataPoint {
	
	private int year;
	private int month;
	private double temperature;
	private double rainfall;
	private double snowfall;
	private double humidity;
	private double wind;
	
	/** Default constructor
	 * Initializes a new DataPoint with 0 values for every member variable
	 */
	public DataPoint() {
		year = 0;
		month = 0;
		temperature = 0.0;
		rainfall = 0.0;
		snowfall = 0.0;
		humidity = 0.0;
		wind = 0.0;
	}

	/**Constructor for parsed weatherdata
	 * @param year
	 * @param month
	 * @param temperature
	 * @param rainfall
	 * @param snowfall
	 * @param humidity
	 * @param wind
	 */
	public DataPoint(int year, int month, double temperature, double rainfall,
			double snowfall, double humidity, double wind) {
		this.year = year;
		this.month = month;
		this.temperature = temperature;
		this.rainfall = rainfall;
		this.snowfall = snowfall;
		this.humidity = humidity;
		this.wind = wind;
	}

	/**Constructor for String weatherdata
	 * @param year
	 * @param month
	 * @param temperature
	 * @param rainfall
	 * @param snowfall
	 * @param humidity
	 * @param wind
	 */
	public DataPoint(String year, String month, String temperature, String rainfall,
			String snowfall, String humidity, String wind) {
		this.year = Integer.parseInt(year);
		this.month = Integer.parseInt(month);
		this.temperature = Double.parseDouble(temperature);
		this.rainfall = Double.parseDouble(rainfall);
		this.snowfall = Double.parseDouble(snowfall);
		this.humidity = Double.parseDouble(humidity);
		this.wind = Double.parseDouble(wind);
	}
	
	/**Constructor for weatherData as String Array
	 * @param weatherData
	 */
	public DataPoint(String[] weatherData) {
		if (weatherData.length == 7) {
			year = Integer.parseInt(weatherData[0]);
			month = Integer.parseInt(weatherData[1]);
			temperature = Double.parseDouble(weatherData[2]);
			rainfall = Double.parseDouble(weatherData[3]);
			snowfall = Double.parseDouble(weatherData[4]);
			humidity = Double.parseDouble(weatherData[5]);
			wind = Double.parseDouble(weatherData[6]);
		}
		else {
			throw(new RuntimeException("Invalid length of weather data."));
		}
	}
	
	/**Constructor with weatherdata as String (as read from file)
	 * @param weatherData
	 */
	public DataPoint(String weatherData) {
		String[] theData = weatherData.split(",");
		if (theData.length == 7) {
			year = Integer.parseInt(theData[0]);
			month = Integer.parseInt(theData[1]);
			temperature = Double.parseDouble(theData[2]);
			rainfall = Double.parseDouble(theData[3]);
			snowfall = Double.parseDouble(theData[4]);
			humidity = Double.parseDouble(theData[5]);
			wind = Double.parseDouble(theData[6]);
		}
		else {
			throw(new RuntimeException("Invalid length of weather data."));
		}	
	}
	
	
	/**
	 * @return the year
	 */
	public int getYear() {
		return year;
	}

	/**
	 * @param year the year to set
	 */
	public void setYear(int year) {
		this.year = year;
	}

	/**
	 * @return the month
	 */
	public int getMonth() {
		return month;
	}

	/**
	 * @param month the month to set
	 */
	public void setMonth(int month) {
		this.month = month;
	}

	/**
	 * @return the temperature
	 */
	public double getTemperature() {
		return temperature;
	}

	/**
	 * @param temperature the temperature to set
	 */
	public void setTemperature(double temperature) {
		this.temperature = temperature;
	}

	/**
	 * @return the rainfall
	 */
	public double getRainfall() {
		return rainfall;
	}

	/**
	 * @param rainfall the rainfall to set
	 */
	public void setRainfall(double rainfall) {
		this.rainfall = rainfall;
	}

	/**
	 * @return the snowfall
	 */
	public double getSnowfall() {
		return snowfall;
	}

	/**
	 * @param snowfall the snowfall to set
	 */
	public void setSnowfall(double snowfall) {
		this.snowfall = snowfall;
	}

	/**
	 * @return the humidity
	 */
	public double getHumidity() {
		return humidity;
	}

	/**
	 * @param humidity the humidity to set
	 */
	public void setHumidity(double humidity) {
		this.humidity = humidity;
	}

	/**
	 * @return the wind
	 */
	public double getWind() {
		return wind;
	}

	/**
	 * @param wind the wind to set
	 */
	public void setWind(double wind) {
		this.wind = wind;
	}

	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return String
				.format("DataPoint [year=%s, month=%s, temperature=%s, rainfall=%s, snowfall=%s, humidity=%s, wind=%s]",
						year, month, temperature, rainfall, snowfall, humidity,
						wind);
	}
	
	
	

}

DataPoints.java

import java.util.ArrayList;



/**
 * Class DataPoints holds an ArrayList for the actual weatherData
 * The ArrayList is of type DataPoint to store the parsed weatherData
 * 
 * Methods for easy adding and calculations exist
 * 
 * @author desrtfx
 *
 */
public class DataPoints {
	// The actual data list
	private ArrayList<DataPoint> dataPoints;
	
	// Default constructor, initialise the ArrayList
	public DataPoints() {
		dataPoints = new ArrayList<DataPoint>();
	}
	
	// Add a DataPoint to the ArrayList
	public void add(DataPoint dataPoint) {
		dataPoints.add(dataPoint);
	}
	
	// Add a DataPoint passed as String Array to the ArrayList
	public void add(String[] weatherData) {
		dataPoints.add(new DataPoint(weatherData));
	}

	// Add a DataPoint passed as String to the ArrayList
	public void add(String weatherData) {
		dataPoints.add(new DataPoint(weatherData));
	}

	// Add a DataPoint split into the individual values to the ArrayList
	public void add(int year, int month, double temperature, double rainfall,
			double snowfall, double humidity, double wind) {
		dataPoints.add(new DataPoint(year, month, temperature, rainfall, snowfall, humidity, wind));
	}

	
	// Return the ArrayList
	public ArrayList<DataPoint> getDataPoints() {
		return this.dataPoints;
	}
	
	// Return a certain DataPoint from the ArrayList
	public DataPoint getDataPoint(int index) {
		return dataPoints.get(index);
	}
	
	// Calculate and return the average Temperature
	public double getAverageTemperature() {
		double avg = 0.0;
		for(DataPoint d:dataPoints) {
			avg += d.getTemperature();
		}
		avg /= dataPoints.size();
		return avg;
	}

	// Calculate and return the maximum Temperature
	public double getMaxTemperature() {
		double max = Double.MIN_VALUE;
		for(DataPoint d:dataPoints) {
			if (max < d.getTemperature()) {
				max = d.getTemperature();
			}
		}
		return max;
	}
	
	// Calculate and return the minimum Temperature
	public double getMinTemperature() {
		double min = Double.MAX_VALUE;
		for(DataPoint d:dataPoints) {
			if (min > d.getTemperature()) {
				min = d.getTemperature();
			}
		}
		return min;
	}

	
	// Calculate and return the average Rainfall
	public double getAverageRainfall() {
		double avg = 0.0;
		for(DataPoint d:dataPoints) {
			avg += d.getRainfall();
		}
		avg /= dataPoints.size();
		return avg;
	}
	
	// Calculate and return the maximum Rainfall
	public double getMaxRainfall() {
		double max = Double.MIN_VALUE;
		for(DataPoint d:dataPoints) {
			if (max < d.getRainfall()) {
				max = d.getRainfall();
			}
		}
		return max;
	}
	
	// Calculate and return the minimum Rainfall
	public double getMinRainfall() {
		double min = Double.MAX_VALUE;
		for(DataPoint d:dataPoints) {
			if (min > d.getRainfall()) {
				min = d.getRainfall();
			}
		}
		return min;
	}

	// Calculate and return the average Snowfall
	public double getAverageSnowfall() {
		double avg = 0.0;
		for(DataPoint d:dataPoints) {
			avg += d.getSnowfall();
		}
		avg /= dataPoints.size();
		return avg;
	}
	
	// Calculate and return the maximum Snowfall
	public double getMaxSnowfall() {
		double max = Double.MIN_VALUE;
		for(DataPoint d:dataPoints) {
			if (max < d.getSnowfall()) {
				max = d.getSnowfall();
			}
		}
		return max;
	}
	
	// Calculate and return the minimum Snowfall
	public double getMinSnowfall() {
		double min = Double.MAX_VALUE;
		for(DataPoint d:dataPoints) {
			if (min > d.getSnowfall()) {
				min = d.getSnowfall();
			}
		}
		return min;
	}

	// Calculate and return the average Humidity
	public double getAverageHumidity() {
		double avg = 0.0;
		for(DataPoint d:dataPoints) {
			avg += d.getHumidity();
		}
		avg /= dataPoints.size();
		return avg;
	}
	
	// Calculate and return the maximum Humidity
	public double getMaxHumidity() {
		double max = Double.MIN_VALUE;
		for(DataPoint d:dataPoints) {
			if (max < d.getHumidity()) {
				max = d.getHumidity();
			}
		}
		return max;
	}
	
	// Calculate and return the minimum Humidity
	public double getMinHumidity() {
		double min = Double.MAX_VALUE;
		for(DataPoint d:dataPoints) {
			if (min > d.getHumidity()) {
				min = d.getHumidity();
			}
		}
		return min;
	}
	
	// Calculate and return the average Wind
	public double getAverageWind() {
		double avg = 0.0;
		for(DataPoint d:dataPoints) {
			avg += d.getWind();
		}
		avg /= dataPoints.size();
		return avg;
	}
	
	// Calculate and return the maximum Wind
	public double getMaxWind() {
		double max = Double.MIN_VALUE;
		for(DataPoint d:dataPoints) {
			if (max < d.getWind()) {
				max = d.getWind();
			}
		}
		return max;
	}
	
	// Calculate and return the minimum Wind
	public double getMinWind() {
		double min = Double.MAX_VALUE;
		for(DataPoint d:dataPoints) {
			if (min > d.getWind()) {
				min = d.getWind();
			}
		}
		return min;
	}

	// return the size of the ArrayList - number of DataPoints
	public int size() {
		return dataPoints.size();
	}
	
	
	
	
	
	
	
	}
	

sheffieldata.csv

WeatherAnalysis.java

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class WeatherAnalysis {
	
	// Method to prepare the formatted output
	public static String prepareLine(String text, double average, double max, double min) {
		String theString = String.format("%12s: Average: %#9.4f Max: %#9.4f Min: %#9.4f", text, average, max, min);
		return theString;
	}

	public static void main(String[] args) {

		// prepare the DataPoints ArrayList
		DataPoints theData = new DataPoints();

		BufferedReader file = null;
		String line;

		// Open the file
		try {
			file = new BufferedReader(new FileReader(System.getProperty("user.dir") +
					"\\sheffieldata.csv"));

			// Read the data line by line
			while ((line = file.readLine()) != null) {
				// add the data to the ArrayList 
				// The method add is overloaded in the DataPoints class so
				// that it takes a string as argument and parses the data
				theData.add(line);
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (file != null) {
				try {
					file.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
		// Tell how many lines have been read - just for information - can be omitted
		System.out.println(theData.size() + " lines of Data read.");
		System.out.println("");

		// print the statistics
		System.out.println(prepareLine("Temperature", theData.getAverageTemperature(), theData.getMaxTemperature(), theData.getMinTemperature()));
		System.out.println(prepareLine("Rainfall", theData.getAverageRainfall(), theData.getMaxRainfall(), theData.getMinRainfall()));
		System.out.println(prepareLine("Snowfall", theData.getAverageSnowfall(), theData.getMaxSnowfall(), theData.getMinSnowfall()));
		System.out.println(prepareLine("Humidity", theData.getAverageHumidity(), theData.getMaxHumidity(), theData.getMinHumidity()));
		System.out.println(prepareLine("Wind", theData.getAverageWind(), theData.getMaxWind(), theData.getMinWind()));
		
		
		
		
	}

}