How do i add the actual content in Java to the ArrayList instead of the memory location

[Arend van der Kolk]

Hi,

I am creating Java code for a job interview and when adding an item to an ArrayList i keep adding only the memory location into the List not the actual item with id .. etc.

My code contains 3 files and the issue is at "itemList.add(item);" in the 1st class "Packer".

Class 1

   

package com.packer;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.util.*;
    
    import com.mobiquityinc.exception.APIException;
    
    public class Packer {
    	
    	public static void main(String[] args) throws APIException, FileNotFoundException {
    		
    		String absolutePath = "C:/spring-tool-suite-3.8.4.RELEASE-e4.6.3-win32-x86_64/mobiquity/listPackageChallenge.txt";	// args[0];
    		pack(absolutePath);
    	}
    
    	private static String pack(String path) throws APIException, FileNotFoundException {		
    		
    		Integer maxItemId = 0;
    		int nextItem = 0;
    		File file = new File(path);
    		Scanner input = new Scanner(file);
    
    		// Read a line, create a Package and items and calculate ideal Package
    		while (input.hasNextLine()) {
    			Package pack = null;
    			
    			int WeightLimitPackage;
    			// The line before the colon
    			String s = input.nextLine();
    			String[] array = s.split(":");
    			array[0] = array[0].trim();
    			int maxWeight = Integer.parseInt(array[0]);
    			
    			// Rest of line after the colon
    			String b = removeParenthesis(array[1]);
    			String[] arrayB = b.split(" ");
    			
    			// create individual items from this line
    			int maxItemCost = 0;
    			ArrayList<Item> itemList = new ArrayList<Item>();
    			for (int i = 0; i < arrayB.length; i++) {
    				String[] arrayStr = arrayB[i].split(",");
    				Integer id = Integer.parseInt(arrayStr[0]);
    				
    				Double itemWeight = Double.parseDouble(arrayStr[1]);
    				if (itemWeight > 100) throw new APIException(itemWeight);
    				
    				Integer itemCost = Integer.parseInt(arrayStr[2]);
    				if (itemCost > 100) throw new APIException(itemCost);
    				
    				// Create item and add to a list
    				Item item = new Item(id, itemWeight, itemCost);
    //				System.out.println("getId " + item.getId());
    //				System.out.println("itemWeight " + item.getItemWeight());
    //				System.out.println("itemCost " + item.getItemCost());
    				itemList.add(item);
    				
    				// create a Package
    				pack = new Package(maxWeight, arrayB.length, itemList);				
    				// check Package weight; Additional constraint
    				if (pack.getWeightLimitPackage() > 100)
    					throw new APIException(pack.getWeightLimitPackage());				
    				// check number of items in package; ; Additional constraint
    				if (pack.getNumberOfItems() > 15)
    					throw new APIException(pack.getNumberOfItems());
    				
    				pack.findPackage();			
    
    			}
    		}
    		input.close();
    		String finalString = maxItemId + "," + nextItem;
    		return finalString;
    		}
    	
    	// Remove extra characters (, ) and € per line 
    	private static String removeParenthesis(String s) {
    		String[] array = s.split(" ");
    		StringBuilder builder = new StringBuilder();
    		for (String current : array) {
    			current = current.replace("(", "");
    			current = current.replace(")", " ");
    			current = current.replace("€", ""); // Alt code 0128
    			builder.append(current);
    			}
    		return builder.toString();
    	}
    }

Class 2

   

package com.packer;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    public class Package {
    	
    	// Package details
    	private int Id;
    	private int weightLimitPackage;
    	private int numberOfItems;
    	
    	ArrayList<Item> list;
    	ArrayList<ArrayList<Item>> combinations;
    	
    	public Package (int weight, int items, ArrayList<Item> itemList) {
    		this.weightLimitPackage = weight;
    		this.numberOfItems = items;
    		this.list = itemList;
    		this.combinations = new ArrayList<ArrayList<Item>>();
    		
    		// System.out.println("weightLimitPackage " + this.weightLimitPackage);
    		// System.out.println("numberOfItems " + this.numberOfItems);
    	}
    
    	public long getId() {
    		return Id;
    	}
    
    	public void setId(int id) {
    		Id = id;
    	}
    
    	public int getWeightLimitPackage() {
    		return weightLimitPackage;
    	}
    
    	public void setWeightLimitPackage(int weightLimitPackage) {
    		this.weightLimitPackage = weightLimitPackage;
    	}
    
    	public int getNumberOfItems() {
    		return numberOfItems;
    	}
    
    	public void setNumberOfItems(int numberOfItems) {
    		this.numberOfItems = numberOfItems;
    	}
    
    	public void findPackage() {
    		combinations = createCombinations();	// <-- leeg
    		if(combinations.size() == 0){
    			System.out.println("-");
    		}else{
    			ArrayList<Item> bestCombination = getBestPackage();
    			Collections.sort(bestCombination);
    			printOutput(bestCombination);
    			//System.out.println(bestCombination.toString());
    		}		
    	}
    	
    	public void printOutput(ArrayList<Item> items){
    		StringBuilder sb = new StringBuilder();
    		boolean isFirst = true;
    		for (Item i : items) {
    			if(isFirst){
    				sb.append(i.getId());
    				isFirst = false;
    			}else{
    				sb.append("," + i.getId());
    			}
    		}
    		System.out.println(sb);
    	}
    
    	public ArrayList<Item> getBestPackage() {
    		ArrayList<Item> bestCombination = new ArrayList<Item>();
    		double bestCost = 0;
    		double bestWeight = 100; //max weight is 100
    		for(ArrayList<Item> combination : combinations){
    			double combinationWeight = getWeight(combination);
    			if(combinationWeight > weightLimitPackage){
    				continue;
    			}else{
    				double combinationPrice = getPrice(combination);
    				if(combinationPrice > bestCost){
    					bestCost = combinationPrice;
    					bestCombination = combination;
    					bestWeight = combinationWeight;
    				}else if(combinationPrice == bestCost){	//use lightest weight
    					if(combinationWeight < bestWeight){
    						bestCost = combinationPrice;
    						bestCombination = combination;
    						bestWeight = combinationWeight;
    					}
    				}
    			}
    		}
    		return bestCombination;
    	}
    
    	public double getWeight(ArrayList<Item> list) {
    		double total = 0;
    		for(Item i : list){
    			total += i.getItemWeight();
    		}
    		return total;
    	}
    	
    	public double getPrice(ArrayList<Item> list) {
    		double total = 0;
    		for(Item i : list){
    			total += i.getItemCost();
    		}
    		return total;
    	}
    
    	public ArrayList<ArrayList<Item>> createCombinations() {
    		for(int x = 0; x < list.size(); x++){
    			Item currentItem = list.get(x);
    			int combinationSize = combinations.size();
    			for(int y = 0; y < combinationSize; y++){
    				ArrayList<Item> combination = combinations.get(y);
    				ArrayList<Item> newCombination = new ArrayList<Item>(combination);
    				newCombination.add(currentItem);
    				combinations.add(newCombination);
    			}
    			ArrayList<Item> current = new ArrayList<Item>();
    			current.add(currentItem);
    			combinations.add(current);
    		}		
    		return combinations;
    	}
    }

Class 3

   

package com.packer;
    
    public class Item implements Comparable<Item> {
    	
    	// item details
    	private int id;
    	private double itemWeight;
    	private int itemCost;
    	
    	// Additional constraints
    	private final int maxWeightItem = 100;
    	
    	public Item (int id, double itemWeight, int itemCost) {
    		this.id = id;
    		this.itemWeight = itemWeight;
    		this.itemCost = itemCost;
    		
    		// System.out.println(this.id);
    		// System.out.println(this.itemWeight);
    		// System.out.println(this.itemCost);
    	}
    	
    	public int compareTo(Item i){
    		return this.id - i.id;
    	}
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public double getItemWeight() {
    		return itemWeight;
    	}
    
    	public void setItemWeight(double itemWeight) {
    		this.itemWeight = itemWeight;
    	}
    
    	public int getItemCost() {
    		return itemCost;
    	}
    
    	public void setItemCost(int itemCost) {
    		this.itemCost = itemCost;
    	}
    }

[Arend van der Kolk]

I forgot to add what the program actually does. It reads from the file attached and chooses the best item with max value.

And this is an other example that does work correctly on the file: https://github.com/gavinc88/MiniProjects/blob/master/Package.java

Make a text (.txt) file with following content to the test the program(of course change the Directory in class 1 to your own directory):

81 : (1,53.38,€45) (2,88.62,€98) (3,78.48,€3) (4,72.30,€76) (5,30.18,€9) (6,46.34,€48)
8 : (1,15.3,€34)
75 : (1,85.31,€29) (2,14.55,€74) (3,3.98,€16) (4,26.24,€55) (5,63.69,€52) (6,76.25,€75) (7,60.02,€74) (8,93.18,€35) (9,89.95,€78)
56 : (1,90.72,€13) (2,33.80,€40) (3,43.15,€10) (4,37.97,€16) (5,46.81,€36) (6,48.77,€79) (7,81.80,€45) (8,19.36,€79) (9,6.76,€64)

[Stefan Evans]

I don't see anything overtly wrong here.

"when adding an item to an ArrayList i keep adding only the memory location into the List not the actual item with id"

Why do you think this?
What proof do you have?
hint:  check out the default implementation of toString() for an object...

[Campbell Ritchie]

Another thing: if you are using that code for an interview, you will have problems. For example the pack() method is too long. For another, you probably shouldn't use com.packer as a package name. That package name belongs to somebody else, as you will find out if you go through the Java™ Tutorials.
If you are using a Scanner to read lines from the file, why are you then using String#split and String#trim? Wouldn't it be better to create a regex which strips the whitespace, too? Or use a second Scanner?
Why does the Packer class have all static methods?
What does line 28 mean? Why have you got a capital W?
What does all the commented‑out code mean?
Why is the text file in that particular location on your disc?

Stephan is, I think ahead of me. I fail to understand what you mean about adding the contents rather than memory locations in the List. What did you expect the List to contain? The whole idea of object‑orientation is that you retain the information in the object, so the contents of the String live in the String object. Why would you expect the List to contain the contents of the String object rather than a reference to the object?

[Liutauras Vilda]

Line 21.

Don't use File object. Use Path (since Java 1.7) object instead, its use:

Path p = Paths.get(uri);

File has its own flaws used along with Scanner. We have seen it in practice.

[Liutauras Vilda]

Arend van der Kolk wrote:

public Package (int weight, int items, ArrayList<Item> itemList)

This constructor. Probably not the constructor itself but its parameters. In particular second and third. I think they are very very confusing because of presence of them two in the same place.

Third parameter I'd expect to be "items". Second, probably "itemsCount", in fact - you don't need probably that second if indeed it represents items count, because you could get that by issueing "itemList.size()".

By the way, parameter "weight", why is it an int? Is it in grams?

[Liutauras Vilda]

Also, you got weird indentation, I've never seen it before. Package statement supposed to be aligned with import statements.

Another thing, you got quite a few static methods in class 1 (Packer). It might makes sense to have them static or might not, but why they are in the class Packer? What method removeParenthesis has to do with Packer class?

Then, you have method "pack" where you're passing in file path, so what are you packing? Isn't it confusing? Non descriptive?

I'd expect you to open file, which is in the path... but not pack it. Method names supposed to make sense, so everybody reading could understand what your program does. As a proof you can see that Campbell failed to understand, it suggests that program is confusing.

I'd suggest you to keep structure like:

public final class Something {

    public static void main(String[] args) {
        new Something().run();
    }

    private final void run() {
        // step 1
        // step 2
        // step 3
    }

    // method to achieve step 1
    // method to achieve step 2
    // method to achieve step 3
}

Now, if you follow that advice, you'll get procedural code, but from that you'd have more chances to make it object oriented. Give a try if you willing to and see if you like it more than what you have now.