Thread: Generics

So your problem is what?

Lol, I can't figure out how to get it to send me back the size or in fact, I can't figure out ANY of the peek(),pop(),size()...

I've never implemented a stack before, but ill give it my best shot.

public int size(E item)
   {
      return list.size();
 
   }

that should be

public int size()
   {
      return list.size();
 
   }

and your pop method should remove a specific object not just remove();

No problem, sorry i can't help you further

Any idea on how to configure peek()?

Well I've been trying to get the get() method working but keep getting errors with the:

	public int get(E item)
	{
		return list.get(item);
	}

I can't figure out how to basically get the index number.

The LinkedList class already has a get(int index) method.

But again, a Stack usually is only concerned with get(0).

The get method returns a variable of type E.

If, using the for loop I gave earlier, you check if list.get(int index) and it equals it then it has it.

Warning: this will return the first occurrence of something. If you are looking for the value 1 and have a 1 at index 3 and at index 7, it will return 3.

Also, if that class doesn't override Object's equals, it will only return an index if they have the same reference in memory.

import java.util.*;
 
public class GenericStack<E>
{
    private LinkedList<E> list = new LinkedList<E>();
 
    public void push(E item) //the parameter is an item of type E
    {
         //list is our linked list, put the new item at the end
        list.add(item);
    }
    public boolean pop(E item)
    {
		return list.remove(item);
	}
	public E peek()
	{
		return list.getLast();
	}
	public int size()
	{
		return list.size();
 
	}
	public int index(E item)
	{
		return list.indexOf(item);
	}
	public int get(E item)
	{
		return list.get(item);
	}
}

public class GenericStackApp
{
 
    public static void main (String args[])
    {
	  {
		    int index;
		    index = 0;
			DeedsHeading.getHeading("Assignment 1, Parts 3 & 4");
	        //lets make our stack be a stack of Strings
	        GenericStack<String> stack = new GenericStack<String>();
 
	        //and push a String on it
	        System.out.print("  Pushing 8 items onto the GenericStack.\n");
	        System.out.print("  Index   Item\n");
	        //push/index
	        stack.push("Oranges");
	        index = stack.index("Oranges");
			System.out.print("    " + index);
	        System.out.print("\t  Oranges\n");
	        stack.push("Apples");
	        index = stack.index("Apples");
	        System.out.print("    " + index);
	        System.out.print("\t  Apples\n");
	        stack.push("Bananas");
	        index = stack.index("Bananas");
	        System.out.print("    " + index);
	        System.out.print("\t  Bananas\n");
	        stack.push("Strawberry");
	        index = stack.index("Strawberry");
	        System.out.print("    " + index);
	        System.out.print("\t  Strawberry\n");
	        stack.push("Basil");
	        index = stack.index("Basil");
	        System.out.print("    " + index);
	        System.out.print("\t  Basil\n");
	        stack.push("Oregano");
	        index = stack.index("Oregano");
	        System.out.print("    " + index);
	        System.out.print("\t  Oregano\n");
	        stack.push("Pepper");
	        index = stack.index("Pepper");
	        System.out.print("    " + index);
	        System.out.print("\t  Pepper\n");
	        stack.push("Garlic");
	        index = stack.index("Garlic");
	        System.out.print("    " + index);
	        System.out.print("\t  Garlic\n\n");
 
 
	        System.out.print("  The stack now contains " + stack.size() + " items\n\n");
	        System.out.print("  The most recent entry was \"" + stack.peek() + "\"\n\n");
 
	        //Remove 5 items
	        System.out.print("  Removing five items from the stack\n");
	        stack.pop("Garlic");
	        System.out.print("  Pop:  Garlic\n");
	        stack.pop("Pepper");
	        System.out.print("  Pop:  Pepper\n");
	        stack.pop("Oregano");
	        System.out.print("  Pop:  Oregano\n");
	        stack.pop("Basil");
	        System.out.print("  Pop:  Basil\n");
	        stack.pop("Strawberry");
	        System.out.print("  Pop:  Strawberry\n");
 
	        //What is left
	        System.out.print("\nThe stack still contains " + stack.size() + " item(s)\n");
	        stack.get(0);
    }
    }
 
 
}

This is what I have so far. (thought it'd make it easier if I added my code for reference =/)

list.get(item) is invalid.

List.contains(item)
is valid

list.get(int index) is valid.

If you want the index, do a for loop and check for all the indexes to see if

item = list.get(index);

Besides, if you're trying to get the item itself, your return type would be type E.

Also, maybe this is just to show what it is, but I can't find this variable/class

DeedsHeading.getHeading("Assignment 1, Parts 3 & 4");

For instance, if you want to get the top, usually the only place a Stack can get to,
you'd be this:

public E top()
{
return list.getFirst();
}

if you want to get an item at an index, you'd do this

public E item(int index)
{
return list.get(index);
}

I know of no method that will get the item outright.

Anyway, if you already have a method to get the index of the item.

You could do this to see if the item is there

public boolean containsItem(E item)
{
if (list.contains(item))
return true;
else
return false;
}

Also, list.get(item)

is invalid.

First, the get method of LinkedList takes an int, not a generic parameter as a parameter.

Second, get returns an generic variable, not an int variable.

You simply cannot have a method

public int getItem(E item)
{
return list.get(item);
}

 
import java.util.*;
 
public class GenericStack<E>
{
    private LinkedList<E> list = new LinkedList<E>();
 
    public void push(E item) //the parameter is an item of type E
    {
         //list is our linked list, put the new item at the end
        list.add(item);
// most stacks only put new item at beginning.  Just saying.
 
    }
    public void pop(E item)
    {
if (!list.contains(item))
return;
    // their remove method is boolean as theirs returns true if the list contains the item.
// yours doesn't so it just should remove the item...er...provided that the item is there in the first place
       list.remove(item);
    }
    public E peek()
    {
        return list.getLast();
    }
    public int size()
    {
        return list.size();
 
    }
    public int index(E item)
    {
        return list.indexOf(item);
    }
 
    public E get(int index)
    {
        return list.get(index);
    }
 
}

Here's how most stack classes are

public class GenericStack<E>
{
    private LinkedList<E> list = new LinkedList<E>();
 
    public void push(E item) //the parameter is an item of type E
    {
         //list is our linked list, put the new item at the end
        list.addFirst(item);
// most stacks only put new item at beginning.  Just saying.
 
    }
    public void pop()
    {
if (list.size() ==0)
return;
    // their remove method is boolean as theirs returns true if the list contains the item.
// yours doesn't so it just should remove the item...er...provided that the item is there in the first place
       list.removeFirst();
    }
 
    public int size()
    {
        return list.size();
 
    }
  public E top()
{
return list.getFirst();
}
 
 
}

The main final task is to display what is left in the LinkedList, I'm just struggling to find an easy solution without actually just programming it into the code to say the actual ones that I know are left....

Well, add a method called toString() to your generic stack class.

public String toString()
{
return list.toString();
}

then later, in your main class, you can

stack.toString() to show a list of remaining items.

Yeah I thought of doing that but then the issue is, he wants the index number to be displayed correspondingly. I got the get() working, so I can just For loop it and run up the index number to the corresponding item i think.

The best part, I think, is that your index number, say your list
has
[5, 3, 2, 1, 9]

left would be

index 0 = 5;
index 1 = 3;
index 2 =2;
index 3 = 1;
index 4 = 9;