Wallet Java Lab Problem specification Your new Wallet class implements a wallet
ID: 3690722 • Letter: W
Question
Wallet Java Lab
Problem specification
Your new Wallet class implements a wallet that contains banknotes. A banknote is representedasanintforsimplicity,1fora$1bill,5fora$5bill,andsoon. Youare required to use just a simple array of int to hold the banknotes. You may NOT use an array list.
Here are some example wallets printed out:
Here's the outline of the Wallet class. You will implement each method as described below.
}
}
}
}
}
}
}
}
}
} }
Instance variables
Use exactly and only these instance variables:
Wallet uses the contents[] array to store ints representing banknotes. count holds the number of banknotes in contents[], so must be updated every time a banknote is added or removed.
count is 0 when a wallet is empty. MAX is the maximum number of banknotes a wallet can hold, so count is MAX – 1 when a wallet is full. count will always be the index where the next banknote is to be added.
Banknotes in a wallet are maintained in the order of arrival. A new banknote is simply added to the end of contents[] and count is incremented by 1.
When a banknote is removed from a wallet, the first occurrence of the value is removed fromcontents[]andcountisdecrementedby1. Importantly,allbanknotesabovethe removed value must be moved ‘down’ so that no ‘holes’ open in the array. For example, if wallet w is Wallet[1, 5, 10, 50, 5]:
- then after w.remove(5), w will be Wallet[1, 10, 50, 5]:
Methods
You will complete the method bodies as follows:
initialize the wallet to empty
allocate memory for the contents[] array
initialize count
public Wallet(int a[])
initialize the wallet using the array of int named a[] an overloaded constructor
allocate memory for the contents[] array
initialize contents[] from a[]
initialize count
return a textual representation of the wallet, in the standard format. For example:
use a StringBuffer to build the returned value
convert the StringBuffer to a String and return the String
calculate the value of the banknotes in the wallet. For example, if wallet is: Wallet[5, 50, 10, 5], value is 70
must use count to do this, to traverse ONLY the banknotes in the wallet
(cannot use contents.length since this traverses every element in the array
including elements that may not have been explicitly initialized, which is dangerous)
return this number of dollars
reverse the order of banknotes in a wallet e.g.
Wallet[1, 5, 10, 50, 5] when reversed becomes Wallet[5, 50, 10, 5, 1]
(IMPORTANT NOTE: do not create a new Wallet object!)
suggested algorithm:
start an index pointing at the first banknote in contents[]
start another index pointing at the last of the banknotes in contents[] while these indexes do not meet or cross over
swap values at the indexes (use a temp variable to do this) move two indexes towards one another
public void add(int banknote)
add banknote to the wallet
banknoteisthebanknotetoadde.g.50,5,etc
add banknote to the end of contents[] and update count
public void transfer(Wallet donor)
transfer the contents of one wallet (the donor wallet) to the end of another, the receiver. (The receiver will be the Wallet object calling the method (i.e. the invoking object)). Leavethedonorwalletempty. Forexample:
if the receiver is Wallet[5, 10, 50, 50]
and donor is Wallet[5, 5, 10, 1, 50, 5]
then after the transfer:
receiver will be Wallet[5, 10, 50, 50, 5, 5, 10, 1, 50, 5] and donor will be Wallet[]
should call the add() method as you implement this
to set a wallet to empty, simply set its count to 0
sort the banknotes in a wallet into ascending order e.g.
Wallet[5, 50, 10, 5, 1] when sorted becomes Wallet[1, 5, 5, 10, 50]
(IMPORTANT NOTE: do not create a new Wallet object!)
suggested algorithm:
we saw in Week 7 a sort method that works for an array of Integer objects containing MAX elements
take this method and modify syntax to work for contents[] and count
public boolean remove(int banknote) removefirstoccurrenceofbanknotefromthewallet. Returntrueifbanknotewas removed, false otherwise
(this banknote may not be in the wallet)
if banknote is removed, must update contents[] so that no holes appear, and count
return whether two wallets have exactly the same banknotes in exactly the same order Extra credit
create a new wallet and add to it pairs of banknotes removed from two other wallets. Return the new wallet. For example:
if w1 is Wallet[5, 1, 50, 20, 50, 5]
and w2 is Wallet[20, 10, 5, 5, 5, 50, 10] then after the method call
Wallet w3 = w1.removeBanknotePairs(w2);
w1 will be: Wallet[1, 50]
w2 will be: Wallet[10, 5, 10]
w3 will be: Wallet[5, 5, 50, 50, 20, 20, 5, 5]
The WalletTester class
TheWalletTesterclasstestsyournewWalletclass. SourcecodeforWalletTesteris given below, and can be downloaded from Blackboard, Course Documents, Week 10 folder, Example programs.
Extra credit
When you have completed all other methods, implement and test removeBanknotePairs() for 20% extra credit. You must test your method using the w1 and w2 wallets given above in the description of removeBanknotePairs().
Explanation / Answer
output:
run:
myWallet contains: Wallet[5,50,10,5]
value of myWallet is: $70
myWallet reversed contains: Wallet[5,10,50,5]
now myWallet contains: Wallet[]
yourWallet contains: Wallet[1,5,50,5,5]
yourWallet sorted is: Wallet[1,5,5,5,50]
yourWallet with $5s removed is: Wallet[1,5,5,50]
tom has same banknotes in same order as dick: false
tom has same banknotes in same order as harry: true
w1 is: Wallet[5,50]
w2 is: Wallet[10,5,10]
w3 is: Wallet[5,5,20,50]
BUILD SUCCESSFUL (total time: 0 seconds)
Wallet.java :
import java.util.Arrays;
public class Wallet
{
// max possible # of banknotes in a wallet
private static final int MAX = 10;
private int contents[];
private int count; // number of banknotes stored in contents[]
public Wallet()
{
contents=new int[MAX];
count=0;
}
public Wallet(int a[])
{
contents=new int[MAX];
for(int i=0;i<a.length;i++)
{
contents[i]=a[i];
count++;
}
}
public String toString()
{
String s="[";
for(int i=0;i<count;i++)
if(i<count-1)
s=s+Integer.toString(contents[i])+",";
else
s=s+Integer.toString(contents[i]);
return "Wallet"+s+"]";
}
public int value()
{
int sum=0;
for(int i=0;i<count;i++)
{
sum=sum+contents[i];
}
return sum;
}
public void reverse()
{
contents = reverseArray(contents);
}
@SuppressWarnings("empty-statement")
int[] reverseArray(int[] data)
{
int[] reversedData = new int[MAX];
int i=0,j=count-1;
for(i=0;i< count; i++)
{
reversedData[i] = data[j--];
}
return reversedData;
}
public void add(int banknote)
{
contents[count++]=banknote;
}
public void transfer(Wallet donor)
{
int n=donor.count;
for(int i=0;i<n;i++)
{
add(donor.contents[i]);
donor.remove(contents[i]);
}
}
public void sort()
{
for (int i = 0; i < count; i++) {
for (int j = i + 1; j < count; j++) {
int tmp = 0;
if (contents[i] > contents[j]) {
tmp = contents[i];
contents[i] = contents[j];
contents[j] = tmp;
}
}
}
}
public boolean remove(int banknote)
{
int f=10,i=0;
for( i=0;i<count;i++)
{
if(contents[i]==banknote);
{
f=i;
break;
}
}
if(f!=10)
{
for(int k=i+1;k<count-1;k++)
contents[k]=contents[k+1];
count--;
return true;
}
else
return false;
}
public boolean sameBanknotesSameOrder(Wallet other)
{
if(count==other.count)
{
int f=0;
for(int i=0;i<count;i++)
if(contents[i]!=other.contents[i])
f=1;
if(f==0)
return true;
else
return false;
}
else
return false;
}
//EXTRA CREDIT methods follow...
@SuppressWarnings("empty-statement")
public Wallet removeBanknotePairs(Wallet w)
{
Wallet t=new Wallet();
int i=0,j=0;
if(count<w.count)
{
for(i=0;i<count;i++)
{
for(j=0;j<w.count;j++)
if(contents[i]==w.contents[j])
{
t.add(contents[i]);
remove(contents[i]);
w.remove(contents[j]);
}
}
}
else
{
for(i=0;i<w.count;i++)
{
for(j=0;j<count;j++)
if(contents[i]==w.contents[j])
{
t.add(contents[i]);
remove(contents[i]);
w.remove(contents[j]);
break;
}
}
}
return t;
}
}
WalletTester.java :
public class WalletTester
{
public static void main(String args[])
{
// create a new Wallet object using an array
int a[] = {5, 50, 10, 5};
Wallet myWallet = new Wallet(a);
// show the contents of myWallet
System.out.println("myWallet contains: " +
myWallet.toString());
// print the value of myWallet
System.out.println(" value of myWallet is: $" +
myWallet.value());
// reverse the order of banknotes in myWallet
myWallet.reverse();
System.out.println(" myWallet reversed contains: " +
myWallet.toString());
// transfer all the banknotes from myWallet to yourWallet!
Wallet yourWallet = new Wallet();
yourWallet.add(1);
yourWallet.transfer(myWallet);
System.out.println(" now myWallet contains: " +
myWallet.toString());
System.out.println("yourWallet contains: " +
yourWallet.toString());
// sort yourWallet
yourWallet.sort();
System.out.println(" yourWallet sorted is: " +
yourWallet.toString());
// remove all $5 banknotes from yourWallet
while (yourWallet.remove(5))
;
System.out.println(" yourWallet with $5s removed is: " +
yourWallet.toString());
// check whether two wallets have the same banknotes
// in the same order
int b[] = {10, 5, 10};
Wallet tom = new Wallet(b);
int c[] = {10, 10, 5};
Wallet dick = new Wallet(c);
int d[] = {10, 5, 10};
Wallet harry = new Wallet(d);
System.out.println(
" tom has same banknotes in same order as dick: " +
tom.sameBanknotesSameOrder(dick));
System.out.println(
"tom has same banknotes in same order as harry: " +
tom.sameBanknotesSameOrder(harry));
// EXTRA CREDIT – compare two wallets and remove banknote pairs
int e[] = {5, 1, 50, 20, 50, 5};
Wallet w1 = new Wallet(e);
int f[] = {20, 10, 5, 5, 5, 50, 10};
Wallet w2 = new Wallet(f);
Wallet w3 = w1.removeBanknotePairs(w2);
System.out.println(" w1 is: " + w1.toString());
System.out.println("w2 is: " + w2.toString());
System.out.println("w3 is: " + w3.toString());}}
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.