Java Program to Calculate Total Income from a Collection of Room Objects

import java.util.*;

class Main {

    public static void main(String[] args) {

       Room a = new Room("Delux", "enSuite", 4, 550);

       Room b = new Room("Single", "Single", 1, 150);

       Room c = new Room("Double", "Double", 2, 250);

       Room d = new Room("Premier", "Premier", 4, 550);

       Collection<Room> rooms = List.of(a, b, c, d);

       System.out.println(calculateTotalIncome(rooms));

    }

    static double calculateTotalIncome(Collection<Room> rooms) {

        return rooms.stream()

        .mapToDouble(r -> r.getRate())   // .mapToDouble(Room::getRate)

        .sum();

    }

}

class Room {

    String name;

    String type;

    int capacity;

    double rate;

   Room(String name,

    String type,

    int capacity,

    double rate) {

        this.name = name;

        this.type = type;

        this.capacity = capacity;

        this.rate = rate;

    }

    

    public double getRate() {

        return this.rate;

    }

    

}


Output: 1500.0


package com.linkedin.collections;

import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

public class RoomService {

    // 1. Declare a Collection to store Room Inventory
    Set<Room> rooms;
    public RoomService() {
       
    // 2. Initialize Collection and assign it to the Room Inventory
       rooms = new HashSet<>();
    }

    public Collection<Room> getInventory(){
       
    // 3. Return the Room Inventory
       
       return new HashSet<>(rooms);
    }
    
    public void createRoom(String name, String type, int capacity, double rate) {
    
    // 4. Add a new Room to the Room Inventory using the provided parameters
    rooms.add(new Room(name, type, capacity,rate));
    }

    public void createRooms(Room[] rooms) {
    
    // 5. Add the Rooms provided in the Array to the Room Inventory
       this.rooms.addAll(Arrays.asList(rooms));
    }
    
    public void removeRoom(Room room) {
       
    // 6. Remove the provided Room from the Room Inventory
       rooms.remove(room);
    }

// checks for a room object
    public boolean hasRoom(Room room) {
       if (rooms.contains(room))
          return true;
       return false;
    }

// convert collection into arrays
    public Room[] asArray() {
       return rooms.toArray(new Room[0]);
    }

// filter based on room type
    public Collection<Room> getByType(String type) {
       Set<Room> rm = new HashSet<>(rooms);
       rm.removeIf(r -> !r.getType().equals(type));
       return rm;
    }
}

Comments

Post a Comment

Popular posts from this blog

Transform values with a stream

The goal is to transform an array of numbers into a comma-delimited string using functional programming. The code snippet you provided has a minor issue: String.join(",", strings[0]) is incorrect because it tries to join a single element ( strings[0] ) rather than all elements in the strings array. Here's the corrected code for the transformValues method: import java.util.Arrays; class Answer {     // Change these boolean values to control whether you see      // the expected answer and/or hints.     static boolean showExpectedResult = true;     static boolean showHints = true;     // Transform an array of numbers into a comma-delimited list     // using functional programming.     static String transformValues(int[] numbers) {         // Convert the int array to a stream of integers         // Map each integer to its String representation         // ...
Read more

Collections Framework

 The Java Collections Framework provides a comprehensive set of interfaces, implementations, and algorithms to work with collections of objects in Java. It offers a unified architecture for representing and manipulating collections, making it easier to work with data structures in Java programs. The Collections Framework is a fundamental part of Java programming and is widely used in various applications ranging from simple data manipulation tasks to complex algorithms and data processing pipelines.  Key components of the Collections Framework: Interfaces Collection : The root interface of the Collections Framework hierarchy. Represents a group of objects, known as elements. Subinterfaces include List , Set , and Queue . List : Represents an ordered collection of elements where duplicate elements are allowed. Allows elements to be accessed and inserted by index. Implementations include ArrayList , LinkedList , and Vector . Set : Represents a collection of unique elements ...
Read more

Inspect a collection

Calculate the cart total  import java.util.List; import java.util.concurrent.atomic.AtomicReference; public class Main {     public static void main(String[] args) {         List<Item> items = List.of(             new Item("Item1", 10.0f, 2),             new Item("Item2", 5.0f, 4),             new Item("Item3", 20.0f, 1)         );         float total = getCartTotal(items);         System.out.println("Cart Total: " + total);  // Output: Cart Total: 60.0     }     static float getCartTotal(List<Item> items) {         AtomicReference<Float> total = new AtomicReference<>(0.0f);         items.forEach(item -> {             total.updateAndGet(v -> v + item.getQuantity() * item.getPrice())...
Read more