Converting an array into a LinkedList

For starts I would think you would want:

next = new ListNode(charArray[i]);

to be

next = new ListNode(charArray[i+1]);

Something else I noticed:

for (int i = 0; i < charArray.length - 1; i++) {
     temp = new ListNode(charArray[i]);
     next = new ListNode(charArray[i+1]);
     temp.next = next;

          if (i == 0) {
            head = temp;
           }
     }

I don't think this is going to yield what you want. It will not give you A->B->B->A etc etc. more over it would give -> A->B, B->B etc etc. Not sure if that's what you are after.

More over I think this should get ya good:

String map = "ABBACBCCA";
        ListNode<Character> head = null;
        ListNode<Character> newHead = null;
        ListNode<Character> next = null;

        char[] charArray = map.toCharArray();

        head = newHead = new ListNode<Character>(charArray[0]);
        for (int i = 1; i < charArray.length - 1; i++) {
            next = new ListNode<Character>(charArray[i]);

            newHead.next = next;

            newHead = next;
        }

Basically create and link and create and link. (tested out fine for me) Incoming ugly!

System.out.println(head.data);
        ListNode<Character> nextptr = head.next;
        while (true) {

            if (nextptr.next == null) {
                break;
            }
            System.out.println(nextptr.data);
            nextptr = nextptr.next;
        }

Using the debugger is your best bet, if you want to continue developing your own code. You should probably create some public methods to set the next element of LinkList nodes like I have done in this example. Explaining would be lengthy, so here's the code.

public class Test {

 public static void main(String[] args) {
    ListNode<Character> head = new Test().arrayToLinkList();

    while ((head = head.nextNode()) != null) {
        System.out.println(head.readData());
    }
 }

 public ListNode<Character> arrayToLinkList() {
    String map = "ABBACBCCA";
    char[] charArray = map.toCharArray();
    ListNode<Character> head, next;
    head = new ListNode<Character>(charArray[0]);
    next = head;
    for (int i = 0; i < charArray.length - 1; i++) {
        next = next.next(new ListNode<Character>(charArray[i + 1]));
    }
    return head;
 }
}

class ListNode<T> {
 private T data = null;
 private ListNode<T> next = null;

 public ListNode(T data) {
    this.data = data;
 }

 public ListNode<T> next(ListNode<T> next) {
    this.next = next;
    return this.next;
 }

 public ListNode<T> nextNode() {
    return this.next;
 }

 public T readData() {
    return data;
 }
}

Your reference variables temp & next are assigned to new Objects during each iteration and you loose track of your next pointers. You could have figured out this problem using debugger as others suggested. Here is the working example.

public class Test {

    public static void main(String args[]) {
        String map = "ABBACBCCA";
        char[] charArray = map.toCharArray();
        ListNode<Character> head = null, temp = null;
        for (int i = 0; i < charArray.length; i++) {
            ListNode<Character> obj = new ListNode<Character>(charArray[i]);
            if (temp != null) {
                temp.next = obj;
            } else {
                head = obj;
            }
            temp = obj;
        }
        // Print the list
        while (head != null) {
             System.out.println(head.data);
             head = head.next;
        }
    }
}

class ListNode<T> {
    public T data = null;
    public ListNode<T> next;
    public ListNode(T data) {
        this.data = data;
        this.next = null;
    }
}

This is probably one of the simpler ways to build your linked list:

String map = "ABBACBCCA";

ListNode<Character> head = null;
ListNode<Character> tail = null;

for (char c:map.toCharArray()) {
  final ListNode<Character> node = new ListNode<>(c);
  if (head == null) {
    head = node;
  } else {
    tail.next = node;
  }
  tail = node;
}

While taking care of your type parameters everywhere

class ListNode<T> {
  public T data = null;
  ListNode<T> next = null;

  public ListNode(T data) {
    this.data = data;
  }
}

Not to mention that you can fully leverage Java api's as well:

LinkedList<Character> ll =
  "ABBACBCCA".chars()
    .mapToObj(i->(char)i) // takes care of boxing char
    .collect(Collectors.toCollection(LinkedList<Character>::new));

Also to loop through your ListNode's, you could consider adding:

class ListNodeIterator<T> implements Iterator<T> {
  private ListNode<T> current;

  public ListNodeIterator<T> ListNodeIterator(ListNode<T> node) {
    current = node;
  }

  public boolean hasNext() {
    return current.next != null;
  }

  public T next() {
    current = current.next;
    return current.data;
  }
}

With following modification:

class ListNode<T> implements Iterable<T> {
  public T data = null;
  public ListNode<T> next = null;

  public ListNode(T data) {
    this.data = data;
  }

  public Iterator<T> iterator() {
    return new ListNodeIterator<>(this);
  }
}

So you can use it as follows:

for (char c:head) {
  System.out.println("Character: "+c);
}

or even

head.forEach(c->{System.out.println("Character: "+c);});

Well ... wasn't that a nice trip through Javaland?