Suppose you have 'int x;'
To obtain a pointer to that variable, you can write &x. Likewise you can write &someArray. You can use & with anything that you can put on the left of = (I think).
To get back to the item being pointed to (i.e. dereference), you use *x. So you can write *x=2 or (*x)++ to modify the int. (*x++ means *(x++), so be careful. Pointer arithmetic works in increments of the size of the data type, so you can use it to walk arrays if you have a pointer to one of the elements.)
The -> operator can generally be thought of as syntactic sugar, so x->y is a synonym for (*x).y. While this is accurate for C, I think in C++ you can overload the -> operator separately; but it's still useful conceptually.
To declare a pointer variable (or anything more complicated than a primitive/struct/class type), you use the same syntax you would use to dereference your way back to the primitive/struct/class. So if you have a variable x and you want to use *x to get back to the int, you write "int *x;". There are more complicated constructions such as int (*x) or void (*funcptr)() if you ever want them.
When you need to specify a pointer type without a name (such as when parameterising that vector type), you simply do it without the name - e.g. <int *> or <int (*)> or <void (*)()>.
Coming from Java, you'll be used to the garbage collector and the safety of knowing that everything is safely on the heap until you no longer hold any references to it. In C++ you have to be much more careful, and Edgar's snippet above is dangerous. If you make something inside a method without using a pointer, then it will be on the stack and will cease to exist when you return from that method. Don't take a pointer to such an item and store the pointer permanently.
To instantiate an object on the heap and have a pointer to it, you can use 'new', and then it will last - but unlike in Java, it won't be garbage-collected, so you'll have to write 'delete thePointerVariable;' later - unless it's a one-shot allocation that you're happy for the OS to clean up for you on exit.
There is one final feature in C++ that's worth knowing about. If you use & in a declaration (as opposed to an expression), then it has a completely different meaning. So for example if you write "int x;" and then "int &y=x;", then y is a reference. It's like a pointer, but you can only initialise it once, and the initial 'take a pointer' and subsequent 'dereference the pointer' operations all happen automatically. Any attempt to set 'y' (again) will be interpreted as "set the thing that y points to", which in this case is x.