Write a Java application to display the price difference between two types of camera
technologies, DSLR and Mirrorless. Display the camera manufacturer and the cost of a DSLR versus
a Mirrorless camera. Below represents the camera cost comparisons:
CANON:
MIRRORLESS - R 10 500
DSLR - R 8 500
SONY:
MIRRORLESS - R 9 500
DSLR - R 7 200
NIKON:
MIRRORLESS - R 12 000
DSLR - R 8 000
Using single and two-dimensional arrays, produce the camera technology report and include the
total calculated difference for each camera manufacturer. If the difference between the
Mirrorless camera and DSLR is greater than or equal to R2 500, then display three stars ***.
In your solution, include the camera manufacturer with the greatest cost difference.
in java
Here is a Java code that displays the price difference between DSLR and Mirrorless cameras for different manufacturers:
```java
public class CameraTechnologyReport {
public static void main(String[] args) {
String[] manufacturers = {"CANON", "SONY", "NIKON"};
int[][] prices = {
{10500, 8500},
{9500, 7200},
{12000, 8000}
};
int totalDifference = 0;
int maxDifference = 0;
String manufacturerWithMaxDifference = "";
System.out.println("Camera Technology Report");
System.out.println("------------------------");
for (int i = 0; i < manufacturers.length; i++) {
String manufacturer = manufacturers[i];
int[] manufacturerPrices = prices[i];
int difference = manufacturerPrices[0] - manufacturerPrices[1];
totalDifference += difference;
System.out.println("\nManufacturer: " + manufacturer);
System.out.println("Mirrorless cost: R" + manufacturerPrices[0]);
System.out.println("DSLR cost: R" + manufacturerPrices[1]);
System.out.println("Price difference: R" + difference);
if (difference >= 2500) {
System.out.println("***");
}
if (difference > maxDifference) {
maxDifference = difference;
manufacturerWithMaxDifference = manufacturer;
}
}
System.out.println("\nTotal price difference for all manufacturers: R" + totalDifference);
System.out.println("Manufacturer with the greatest cost difference: " + manufacturerWithMaxDifference);
}
}
```
This code defines a `manufacturers` array that holds the names of the camera manufacturers. The `prices` array is a two-dimensional array that holds the Mirrorless and DSLR prices for each manufacturer.
The code then iterates through the arrays and calculates the price difference for each manufacturer. It also keeps track of the total difference and finds the manufacturer with the greatest difference.
Finally, the code displays the camera technology report by printing the manufacturer names, Mirrorless and DSLR prices, and the price difference. If the difference is greater than or equal to 2500, it displays three stars (`***`). It also prints the total price difference for all manufacturers and the manufacturer with the greatest cost difference.
Sure! Here's a Java application that displays the price difference between two types of camera technologies, DSLR and Mirrorless:
```java
public class CameraPriceComparison {
public static void main(String[] args) {
String[] manufacturers = {"CANON", "SONY", "NIKON"};
int[][] cameraPrices = {{10500, 8500}, {9500, 7200}, {12000, 8000}};
int maxDifference = Integer.MIN_VALUE;
String manufacturerWithMaxDifference = "";
System.out.println("Camera Technology Report:");
System.out.println("-------------------------");
for (int i = 0; i < manufacturers.length; i++) {
int mirrorlessPrice = cameraPrices[i][0];
int dslrPrice = cameraPrices[i][1];
int difference = Math.abs(mirrorlessPrice - dslrPrice);
System.out.println(manufacturers[i] + ":");
System.out.println("MIRRORLESS - R " + mirrorlessPrice);
System.out.println("DSLR - R " + dslrPrice);
System.out.println("Price Difference: R " + difference);
if (difference >= 2500) {
System.out.println("***");
}
System.out.println();
if (difference > maxDifference) {
maxDifference = difference;
manufacturerWithMaxDifference = manufacturers[i];
}
}
System.out.println("Manufacturer with the greatest cost difference: " + manufacturerWithMaxDifference);
System.out.println("Total calculated difference: R " + maxDifference);
}
}
```
This application uses a single-dimensional array `manufacturers` to store the names of the camera manufacturers and a two-dimensional array `cameraPrices` to store the prices of mirrorless and DSLR cameras for each manufacturer.
The `for` loop iterates over the manufacturers array and calculates the price difference between mirrorless and DSLR cameras for each manufacturer. It prints the camera prices and the difference. If the difference is greater than or equal to 2500, it prints three stars.
Finally, it determines the manufacturer with the greatest cost difference and prints the total calculated difference.
You can run this Java program to get the desired camera technology report with the price differences and the manufacturer with the greatest cost difference.
Here's a step-by-step solution to create a Java application that displays the price difference between DSLR and Mirrorless cameras for different camera manufacturers:
Step 1: Import the necessary packages for writing Java code:
```java
import java.util.Arrays;
```
Step 2: Define a class named "CameraComparison" and create a main method:
```java
public class CameraComparison {
public static void main(String[] args) {
// Your code goes here
}
}
```
Step 3: Declare two-dimensional arrays to store the camera manufacturer, camera types, and the cost for each camera type:
```java
String[][] manufacturers = {
{ "CANON", "MIRRORLESS", "DSLR" },
{ "SONY", "MIRRORLESS", "DSLR" },
{ "NIKON", "MIRRORLESS", "DSLR" }
};
int[][] prices = {
{ 10500, 8500 },
{ 9500, 7200 },
{ 12000, 8000 }
};
```
Step 4: Declare variables to store the camera manufacturer and the maximum price difference:
```java
String manufacturerWithMaxDifference = "";
int maxDifference = 0;
```
Step 5: Iterate over the arrays to calculate the differences and find the maximum difference:
```java
for (int i = 0; i < manufacturers.length; i++) {
String manufacturer = manufacturers[i][0];
int mirrorlessPrice = prices[i][0];
int dslrPrice = prices[i][1];
int difference = Math.abs(mirrorlessPrice - dslrPrice);
if (difference >= 2500) {
manufacturerWithMaxDifference = manufacturer;
}
if (difference > maxDifference) {
maxDifference = difference;
}
System.out.println(manufacturer + ":\n" +
"Mirrorless - R " + mirrorlessPrice + "\n" +
"DSLR - R " + dslrPrice + "\n");
}
System.out.println("Manufacturer with the greatest cost difference: " + manufacturerWithMaxDifference);
System.out.println("Max price difference: R " + maxDifference);
// Print three stars if the difference is >= 2500
if (maxDifference >= 2500) {
System.out.println("***");
}
```
Step 6: Save and compile the Java file. Run the program and check the output.
Note: The solution provided assumes that the data is hardcoded in the arrays. If you want to read the data from an external source (e.g., a file or user input), you may need to modify the code accordingly.
I hope this helps! Let me know if you have any further questions.