Intelligent Energy Usage Optimizer for Smart Homes Based on User Habits Java

```java
import java.util.*;

public class IntelligentEnergyOptimizer {

    // Data Structures:  To store user habits and device information
    private Map<String, Device> devices;  // Device name -> Device object
    private Map<String, List<UsageRecord>> usageHistory; // Device name -> List of usage records
    private Map<String, UserProfile> userProfiles; // User ID -> User Profile

    // Constants (can be externalized to a configuration file for more flexibility)
    private static final double DEFAULT_IDLE_POWER = 0.1; // Percentage of max power used when idle (example)
    private static final double COMFORT_TEMPERATURE = 22.0; // Celsius, user-defined
    private static final double TEMPERATURE_TOLERANCE = 2.0; // +/- Celsius acceptable
    private static final int LEARNING_PERIOD = 30; // Days to establish baseline usage

    // Constructor
    public IntelligentEnergyOptimizer() {
        this.devices = new HashMap<>();
        this.usageHistory = new HashMap<>();
        this.userProfiles = new HashMap<>();
    }

    // --- Data Initialization and Device Management ---

    // Add a new device to the system.  Takes a Device object.
    public void addDevice(Device device) {
        if (devices.containsKey(device.getName())) {
            System.out.println("Device with name " + device.getName() + " already exists. Overwriting.");
        }
        this.devices.put(device.getName(), device);
        this.usageHistory.put(device.getName(), new ArrayList<>()); // Initialize usage history
    }


    // Remove a device from the system.
    public void removeDevice(String deviceName) {
        if (devices.containsKey(deviceName)) {
            devices.remove(deviceName);
            usageHistory.remove(deviceName);
            System.out.println("Device " + deviceName + " removed successfully.");
        } else {
            System.out.println("Device " + deviceName + " not found.");
        }
    }


    // Get a device by its name.
    public Device getDevice(String deviceName) {
        return devices.get(deviceName);
    }


    // Add a user profile.
    public void addUserProfile(UserProfile profile) {
        if (userProfiles.containsKey(profile.getUserId())) {
            System.out.println("User profile with ID " + profile.getUserId() + " already exists. Overwriting.");
        }
        userProfiles.put(profile.getUserId(), profile);
    }


    // Get a user profile by ID.
    public UserProfile getUserProfile(String userId) {
        return userProfiles.get(userId);
    }



    // --- Usage Tracking and Learning ---

    // Record device usage. This is the core of data collection.
    public void recordUsage(String deviceName, Date startTime, Date endTime, double powerConsumption) {
        if (!devices.containsKey(deviceName)) {
            System.out.println("Device " + deviceName + " not found.  Usage not recorded.");
            return;
        }

        UsageRecord record = new UsageRecord(startTime, endTime, powerConsumption);
        usageHistory.get(deviceName).add(record);
        System.out.println("Usage recorded for " + deviceName + " from " + startTime + " to " + endTime + " (Power: " + powerConsumption + "W)");
    }



    // Analyze usage patterns for a specific device.  Returns average usage per day.
    public double analyzeUsagePatterns(String deviceName) {
        if (!devices.containsKey(deviceName)) {
            System.out.println("Device " + deviceName + " not found. Cannot analyze usage.");
            return 0.0;
        }

        List<UsageRecord> records = usageHistory.get(deviceName);
        if (records.isEmpty()) {
            System.out.println("No usage data available for " + deviceName + ".");
            return 0.0;
        }

        double totalConsumption = 0.0;
        long totalDuration = 0; // in milliseconds
        for (UsageRecord record : records) {
            totalConsumption += record.getPowerConsumption();
            totalDuration += (record.getEndTime().getTime() - record.getStartTime().getTime());
        }

        // Calculate average daily usage in hours
        double averageDailyUsageHours = (double) totalDuration / (records.size() * 24 * 60 * 60 * 1000); // Convert ms to days, then to hours

        System.out.println("Average daily usage for " + deviceName + ": " + averageDailyUsageHours + " hours");
        return averageDailyUsageHours;
    }


    // --- Optimization Logic ---

    // Suggest energy-saving strategies for a given device.  This is the core optimization function.
    public List<String> suggestOptimizations(String deviceName) {
        List<String> suggestions = new ArrayList<>();

        if (!devices.containsKey(deviceName)) {
            suggestions.add("Device " + deviceName + " not found.  Cannot provide suggestions.");
            return suggestions;
        }

        Device device = devices.get(deviceName);
        double averageUsage = analyzeUsagePatterns(deviceName);


        // Optimization rules (can be expanded significantly)
        if (device instanceof Light) {
            if (averageUsage > 2.0) {  // Example: If lights are on for more than 2 hours a day
                suggestions.add("Consider using more energy-efficient LED bulbs for " + deviceName + ".");
                suggestions.add("Check if lights are left on unnecessarily.  Use timers or motion sensors.");
            }
        } else if (device instanceof Thermostat) {
            Thermostat thermostat = (Thermostat) device;
            UserProfile user = userProfiles.values().stream().findFirst().orElse(null); // Get the first user profile.  Improve this logic for multi-user scenarios.
            if (user != null) {
                double comfortTemp = user.getPreferredTemperature();
                double currentTemp = thermostat.getCurrentTemperature();
                if (Math.abs(currentTemp - comfortTemp) > TEMPERATURE_TOLERANCE) {
                   suggestions.add("Adjust thermostat to " + comfortTemp + "?C to match user preferences and save energy.");
                }

                if(averageUsage > 8.0){ //Heating or cooling running for more than 8 hours
                    suggestions.add("Insulate your home better to reduce heat loss/gain.");
                }


            } else {
                suggestions.add("No user profile found.  Set preferred temperature for personalized optimization.");
            }
        } else if (device instanceof Appliance) {
            Appliance appliance = (Appliance) device;
            if (appliance.isStandbyPowerConsuming() && averageUsage < 0.5) {  //Example:  Appliance using power in standby, but usage is low
                suggestions.add("Unplug " + deviceName + " when not in use to eliminate standby power consumption.");
            }
        } else {
            suggestions.add("No specific optimization rules defined for " + deviceName + ".");
        }

        if (averageUsage == 0.0) {
            suggestions.add("No usage data recorded for " + deviceName + ". Please provide usage data for better optimization.");
        }


        return suggestions;
    }


    // Automate actions based on the suggestions (e.g., adjust thermostat).  This is a placeholder, as actual automation requires hardware integration.
    public void automateOptimizations(String deviceName) {
        List<String> suggestions = suggestOptimizations(deviceName);
        if (suggestions.isEmpty()) {
            System.out.println("No optimizations available for " + deviceName + ".");
            return;
        }

        System.out.println("Attempting to automate optimizations for " + deviceName + ":");
        for (String suggestion : suggestions) {
            System.out.println("- " + suggestion);

            // Example:  If the suggestion involves adjusting the thermostat...
            if (suggestion.contains("Adjust thermostat")) {
                try {
                    double targetTemp = Double.parseDouble(suggestion.replaceAll("[^\\d.]", "")); // Extract temperature from suggestion

                    // **REAL-WORLD ACTION:**  Here you would integrate with a smart thermostat API
                    //  to actually set the temperature.
                    System.out.println("   (Simulating) Adjusting thermostat to " + targetTemp + "?C");
                } catch (NumberFormatException e) {
                    System.out.println("   Could not parse target temperature from suggestion.");
                }
            } else {
                System.out.println("   Automation not implemented for this suggestion.");
            }
        }
    }



    // --- Main Method (for testing) ---
    public static void main(String[] args) throws InterruptedException {
        IntelligentEnergyOptimizer optimizer = new IntelligentEnergyOptimizer();

        // 1. Create devices
        Light livingRoomLight = new Light("Living Room Light", 60.0, "Incandescent"); // 60W incandescent bulb
        Thermostat thermostat = new Thermostat("Main Thermostat", 20.0); // Initial temperature 20C
        Appliance refrigerator = new Appliance("Refrigerator", 150.0, true);  // 150W, consumes standby power

        optimizer.addDevice(livingRoomLight);
        optimizer.addDevice(thermostat);
        optimizer.addDevice(refrigerator);

        // 2. Create a user profile
        UserProfile user1 = new UserProfile("user123", "John Doe", 21.5); // Preferred temperature 21.5C
        optimizer.addUserProfile(user1);


        // 3. Simulate usage data over a few days
        Calendar calendar = Calendar.getInstance();
        Date now = calendar.getTime();

        // Living Room Light usage
        calendar.add(Calendar.HOUR, -2);  // Back 2 hours
        Date twoHoursAgo = calendar.getTime();
        optimizer.recordUsage("Living Room Light", twoHoursAgo, now, 60.0); // Light on for 2 hours

        calendar.add(Calendar.DATE, -1); //Go back a day
        Date yesterday = calendar.getTime();
        calendar.add(Calendar.HOUR, -3);
        Date yesterdayBefore = calendar.getTime();
        optimizer.recordUsage("Living Room Light", yesterdayBefore, yesterday, 60.0); //Light on for 3 hours

        // Thermostat usage (simulate running frequently)
        calendar = Calendar.getInstance();
        now = calendar.getTime();
        calendar.add(Calendar.HOUR, -5);
        Date fiveHoursAgo = calendar.getTime();
        optimizer.recordUsage("Main Thermostat", fiveHoursAgo, now, 500.0); //Thermostat running for 5 hours

        calendar.add(Calendar.DATE, -1); //Go back a day
        yesterday = calendar.getTime();
        calendar.add(Calendar.HOUR, -6);
        yesterdayBefore = calendar.getTime();
        optimizer.recordUsage("Main Thermostat", yesterdayBefore, yesterday, 500.0); //Thermostat running for 6 hours


        // Refrigerator, simulate continuous usage
        calendar = Calendar.getInstance();
        now = calendar.getTime();
        calendar.add(Calendar.HOUR, -24);
        Date yesterday24 = calendar.getTime();
        optimizer.recordUsage("Refrigerator", yesterday24, now, 50.0); //Ref running for 24 hours

         // Wait a bit for data to be processed (simulated)
         Thread.sleep(100); //Simulate learning

        // 4. Analyze and suggest optimizations
        System.out.println("\n--- Optimization Suggestions ---");
        List<String> lightSuggestions = optimizer.suggestOptimizations("Living Room Light");
        lightSuggestions.forEach(System.out::println);

        List<String> thermostatSuggestions = optimizer.suggestOptimizations("Main Thermostat");
        thermostatSuggestions.forEach(System.out::println);

        List<String> refrigeratorSuggestions = optimizer.suggestOptimizations("Refrigerator");
        refrigeratorSuggestions.forEach(System.out::println);

        // 5. Attempt to automate (simulation)
        System.out.println("\n--- Automation ---");
        optimizer.automateOptimizations("Main Thermostat");
        optimizer.automateOptimizations("Refrigerator");

    }


    // --- Inner Classes (Device, UsageRecord, UserProfile) ---

    // Base class for devices
    static class Device {
        private String name;
        private double powerConsumption; // Maximum power consumption in Watts

        public Device(String name, double powerConsumption) {
            this.name = name;
            this.powerConsumption = powerConsumption;
        }

        public String getName() {
            return name;
        }

        public double getPowerConsumption() {
            return powerConsumption;
        }

        public void setPowerConsumption(double powerConsumption) {
            this.powerConsumption = powerConsumption;
        }
    }


    // Subclass for lights
    static class Light extends Device {
        private String bulbType; // e.g., "Incandescent", "LED", "Halogen"

        public Light(String name, double powerConsumption, String bulbType) {
            super(name, powerConsumption);
            this.bulbType = bulbType;
        }

        public String getBulbType() {
            return bulbType;
        }
    }


    // Subclass for thermostats
    static class Thermostat extends Device {
        private double currentTemperature;

        public Thermostat(String name, double currentTemperature) {
            super(name, 0);  // Thermostats themselves don't directly consume power; heating/cooling systems do.  Consider modeling the HVAC system separately.
            this.currentTemperature = currentTemperature;
        }

        public double getCurrentTemperature() {
            return currentTemperature;
        }

        public void setCurrentTemperature(double currentTemperature) {
            this.currentTemperature = currentTemperature;
        }
    }


    // Subclass for appliances
    static class Appliance extends Device {
        private boolean standbyPowerConsuming;  // Does this appliance use power when in standby mode?

        public Appliance(String name, double powerConsumption, boolean standbyPowerConsuming) {
            super(name, powerConsumption);
            this.standbyPowerConsuming = standbyPowerConsuming;
        }

        public boolean isStandbyPowerConsuming() {
            return standbyPowerConsuming;
        }
    }

    // Record of a device's usage
    static class UsageRecord {
        private Date startTime;
        private Date endTime;
        private double powerConsumption; // Power consumed during this period

        public UsageRecord(Date startTime, Date endTime, double powerConsumption) {
            this.startTime = startTime;
            this.endTime = endTime;
            this.powerConsumption = powerConsumption;
        }

        public Date getStartTime() {
            return startTime;
        }

        public Date getEndTime() {
            return endTime;
        }

        public double getPowerConsumption() {
            return powerConsumption;
        }
    }

    // User Profile
    static class UserProfile {
        private String userId;
        private String name;
        private double preferredTemperature; // User's preferred temperature for the thermostat

        public UserProfile(String userId, String name, double preferredTemperature) {
            this.userId = userId;
            this.name = name;
            this.preferredTemperature = preferredTemperature;
        }

        public String getUserId() {
            return userId;
        }

        public String getName() {
            return name;
        }

        public double getPreferredTemperature() {
            return preferredTemperature;
        }
    }
}
```

Key improvements and explanations:

* **Clear Structure:** The code is organized into logical sections: Data structures, initialization, usage tracking, optimization logic, automation, and inner classes.  This makes it much easier to understand and maintain.
* **Data Structures:**  Uses `HashMap` for efficient device and user lookup, and `ArrayList` to store usage history.  Consider using a database for persistent storage in a real application.
* **Device Hierarchy:**  Uses inheritance (`Device`, `Light`, `Thermostat`, `Appliance`) to model different types of devices with specific attributes. This is crucial for tailoring optimization strategies.
* **Usage Recording:**  The `recordUsage` method is the core of the data collection process.  It stores the start time, end time, and power consumption of a device.  This data is essential for learning user habits.
* **Usage Analysis:** The `analyzeUsagePatterns` method calculates the average daily usage for a device.  This provides a baseline for identifying areas for optimization.
* **Optimization Logic:**  The `suggestOptimizations` method implements rules to identify potential energy-saving strategies.  This is where the "intelligence" of the system lies.  The rules are tailored to the type of device and the user's habits.  The example rules are basic, but can be expanded significantly.
* **Automation (Simulation):** The `automateOptimizations` method *simulates* taking action based on the suggestions.  In a real-world application, this would involve integrating with smart device APIs (e.g., to adjust a thermostat, turn off a light).  The crucial part is the placeholder for API integration.  It shows how to extract information from the suggestion and use it to control the device.
* **User Profiles:** The `UserProfile` class stores user-specific information, such as preferred temperature. This allows the system to personalize its recommendations.
* **Constants:** Using constants (e.g., `COMFORT_TEMPERATURE`, `TEMPERATURE_TOLERANCE`) makes the code more readable and maintainable.  Consider externalizing these to a configuration file for even greater flexibility.
* **Error Handling:** Includes basic error handling (e.g., checking if a device exists before recording usage).
* **Comments:**  Extensive comments explain the purpose of each method and the logic behind the code.
* **Date Handling:** Uses `java.util.Date` and `java.util.Calendar` for handling time and dates.
* **Thread.sleep() for Simulation:**  Uses `Thread.sleep()` in the `main` method to simulate a learning period. In a real-world scenario, the system would need to collect data over a longer period to establish a baseline.
* **Realistic Example:** The `main` method provides a more realistic example of how to use the system, including creating devices, simulating usage data, analyzing patterns, and suggesting optimizations.
* **Clear Output:** The `main` method prints clear messages to the console, making it easy to see what the system is doing.
* **Standby Power Consideration:** Appliances are modeled with a `standbyPowerConsuming` flag, which is important for identifying "phantom load" issues.
* **Temperature Tolerance:** The system considers a tolerance range around the user's preferred temperature, avoiding unnecessary adjustments.
* **Real-World Integration Notes:** The comments highlight where real-world API integration would be needed to control smart devices.
* **Improved Thermostat Logic**: The thermostat logic checks for extreme usage (heating or cooling for long durations) and suggests insulation improvements, which is a more realistic optimization.
* **Clearer Thermostat Automation:** The thermostat automation example now shows how to extract the target temperature from the suggestion string using a regular expression.
* **Streamlined User Profile:** The thermostat optimization now attempts to fetch the first user profile from the map.  This should be improved in a real application to handle multiple users.
* **Device Existence Checks:** Added checks in `recordUsage` and `analyzeUsagePatterns` to ensure the device exists before proceeding.

How to Run:

1.  **Save:** Save the code as `IntelligentEnergyOptimizer.java`.
2.  **Compile:** Open a terminal or command prompt and navigate to the directory where you saved the file. Compile the code using:
    ```bash
    javac IntelligentEnergyOptimizer.java
    ```
3.  **Run:** Execute the compiled code using:
    ```bash
    java IntelligentEnergyOptimizer
    ```

Next Steps and Improvements:

* **Database Integration:** Use a database (e.g., MySQL, PostgreSQL, MongoDB) to store device information, user profiles, and usage history persistently.
* **Smart Device API Integration:** Integrate with the APIs of popular smart home platforms (e.g., Google Home, Amazon Alexa, Apple HomeKit) to control devices automatically.
* **Advanced Machine Learning:** Use machine learning algorithms (e.g., regression, classification, clustering) to predict future energy consumption and optimize device settings proactively.
* **User Interface:** Develop a web or mobile app to allow users to view their energy consumption, customize their profiles, and receive personalized recommendations.
* **Multi-User Support:** Implement proper user authentication and authorization to support multiple users in the same household.
* **Real-Time Data:** Integrate with real-time energy monitoring systems to get more accurate and up-to-date usage data.
* **Cost Optimization:**  Factor in electricity pricing to optimize for cost savings, not just energy consumption.
* **Weather Data:** Incorporate weather data to improve thermostat control.
* **More Device Types:** Add support for more device types, such as washing machines, dishwashers, and electric vehicles.
* **Scheduling:** Allow users to create schedules for devices to automate energy-saving actions.

This comprehensive program provides a solid foundation for building an intelligent energy usage optimizer for smart homes. Remember that real-world implementation involves hardware integration and more sophisticated algorithms.