Basic abstract graph implementation in Java I am trying to write a graph implementation in Java. I would appreciate it if someone can please review the code for me and give constructive feedback.

import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;

public class Graph {
    private int V;  // Number of vertices

    private int E;  // Number of edges

    private HashMap&lt;Integer, LinkedList&lt;Integer&gt;&gt; adj;  // adjacency list

    Graph() {
        adj = new HashMap&lt;&gt;();
    }

    /**
     * Returns the number of vertices
     * @return Number of vertices in the graph
     */
    public int vertices() {
        return this.V;
    }

    /**
     * Number of edges in the graph
     * @return Returns the number of edges in the graph
     */
    public int edges() {
        return this.E;
    }


    public void addEdge(int v, int w) {
        if(adj.containsKey(v)) {
            adj.get(v).add(w);
            ++E;
        } else if(adj.containsKey(w)) {
            adj.get(w).add(v);
            ++E;
        } else {
            LinkedList&lt;Integer&gt; llOne = new LinkedList&lt;&gt;();
            LinkedList&lt;Integer&gt; llTwo = new LinkedList&lt;&gt;();
            llTwo.add(v);
            llOne.add(w);
            adj.put(v, llOne);
            adj.put(w, llTwo);
            ++V; ++E;
        }
    }

    @Override
    public String toString() {
        StringBuilder returnString = new StringBuilder();
        for (int key : adj.keySet()) {
            returnString.append(key).append(": ");
            LinkedList&lt;Integer&gt; nodesList = adj.get(key);
            returnString.append(Arrays.toString(nodesList.toArray()));
        }
        return returnString.toString();
    }
}
Thinking about naming...

When I see a single capital letter, it makes me think of generic type.  I find your usage misleading.
Single letter variable names can be OK when it's obvious what they are, such as indexers in loops, I would suggest avoiding them for anything with larger scope, particularly at the field level.
int V;  // Number of vertices, why not just call it numberOfVertices?  You don't need the comment and the rest of the code is that little bit easier to interpret?
edges(): Typically in Java I'd expect this type of method to be called getEdges, it's really just returning the field.  In fact, when I first saw it, I thought it would be returning some collection of edges, but it doesn't it just returns a count.  Consider renaming it to match what it returns.
LinkedList&lt;Integer&gt; llOne = new LinkedList&lt;&gt;();.  Generally, avoid embedding the type information (ll) in the variable name.  Think about what the list is representing and call it that, rather than 'one' and 'two'.