LineArray: line primitive drawning class

Hello, I’m relatively new to programming (especially 3d graphics programming with Java and jMonkey) and I need some help.
In my project I had to draw some line primitives and (using Custom Mesh tutorial) put together a small line manager class. I know it’s unsafe and somewhat have not obvious interface. So, please, could some of experienced programmers made a code review on it and give me a couple of advices?

package MeshMakers;

import com.jme3.math.Vector3f;
import com.jme3.math.ColorRGBA;
import com.jme3.scene.Mesh;
import com.jme3.scene.VertexBuffer;

import java.nio.FloatBuffer;
import java.util.ArrayList;

/**
 * Creates and stores line buffer, which could been converted into mesh.
 */
public class LineArray
{
  private ArrayList<Vector3f> vcPositionStartList;
  private ArrayList<Vector3f> vcPositionEndList;
  private ArrayList<ColorRGBA> clColorStartList;
  private ArrayList<ColorRGBA> clColorEndList;

  private Mesh msMesh;
  private FloatBuffer fbPositionBuffer;
  private FloatBuffer fbColorBuffer;

  public LineArray()
  {
    this.vcPositionStartList = new ArrayList<>();
    this.vcPositionEndList = new ArrayList<>();
    this.clColorStartList = new ArrayList<>();
    this.clColorEndList = new ArrayList<>();

    this.msMesh = new Mesh();
    this.msMesh.setMode(Mesh.Mode.Lines);

    MeshUpdate();
  }

  /**
   * Adds new line to line buffer.
   */
  public void BufferLinesAdd(Vector3f vcPositionStart, Vector3f vcPositionEnd, ColorRGBA clColorStart, ColorRGBA clColorEnd)
  {
    if (vcPositionStart != null && vcPositionEnd != null) {
      this.vcPositionStartList.add(vcPositionStart);
      this.vcPositionEndList.add(vcPositionEnd);

      if (clColorStart != null)
        this.clColorStartList.add(clColorStart);
      else
        this.clColorStartList.add(ColorRGBA.White);

      if (clColorEnd != null)
        this.clColorEndList.add(clColorEnd);
      else
        this.clColorEndList.add(clColorStartList.get(clColorStartList.size() - 1).clone());
    }
  }

  /**
   * Get references to given element in line buffer.
   */
  public void BufferLinesGet(int nIndex, Vector3f vcVectorStartOut, Vector3f vcVectorEndOut, ColorRGBA clColorStartOut, ColorRGBA clColorEndOut)
  {
    if (nIndex >= 0 && nIndex < this.vcPositionStartList.size())
    {
      vcVectorStartOut = this.vcPositionStartList.get(nIndex);
      vcVectorEndOut = this.vcPositionEndList.get(nIndex);
      clColorStartOut = this.clColorStartList.get(nIndex);
      clColorEndOut = this.clColorEndList.get(nIndex);
    }
  }

  /**
   * Removes given element in line buffer.
   */
  public void BufferLinesRemove(int nIndex)
  {
    if (nIndex >= 0 && nIndex < this.vcPositionStartList.size())
    {
      this.vcPositionStartList.remove(nIndex);
      this.vcPositionEndList.remove(nIndex);
      this.clColorStartList.remove(nIndex);
      this.clColorEndList.remove(nIndex);
    }
  }

  /**
   * Completely clears line buffer.
   */
  public void BufferLinesClear()
  {
    this.vcPositionStartList.clear();
    this.vcPositionEndList.clear();
    this.clColorStartList.clear();
    this.clColorEndList.clear();
  }

  /**
   * Get values of line in generated mesh
   * @param nIndex Index of line in generated mesh
   */
  public void MeshLineGet(int nIndex, Vector3f vcVectorStartOut, Vector3f vcVectorEndOut, ColorRGBA clColorStartOut, ColorRGBA clColorEndOut)
  {
    if
    (
      nIndex >= 0 &&
      nIndex * 7 <= this.fbPositionBuffer.capacity() &&
      nIndex * 9 <= this.fbColorBuffer.capacity()
    )
    {
      int i;

      i = nIndex * 6;
      if (vcVectorStartOut == null) vcVectorStartOut = new Vector3f();
      vcVectorStartOut.x = this.fbPositionBuffer.get(i++);
      vcVectorStartOut.y = this.fbPositionBuffer.get(i++);
      vcVectorStartOut.z = this.fbPositionBuffer.get(i++);

      if (vcVectorEndOut == null) vcVectorEndOut = new Vector3f();
      vcVectorEndOut.x = this.fbPositionBuffer.get(i++);
      vcVectorEndOut.y = this.fbPositionBuffer.get(i++);
      vcVectorEndOut.z = this.fbPositionBuffer.get(i);

      i = nIndex * 8;
      if (clColorStartOut == null) clColorStartOut = new ColorRGBA();
      clColorStartOut.r = this.fbColorBuffer.get(i++);
      clColorStartOut.g = this.fbColorBuffer.get(i++);
      clColorStartOut.b = this.fbColorBuffer.get(i++);
      clColorStartOut.a = this.fbColorBuffer.get(i++);

      if (clColorEndOut == null) clColorEndOut = new ColorRGBA();
      clColorEndOut.r = this.fbColorBuffer.get(i++);
      clColorEndOut.g = this.fbColorBuffer.get(i++);
      clColorEndOut.b = this.fbColorBuffer.get(i++);
      clColorEndOut.a = this.fbColorBuffer.get(i);
    }
    else
    {
      vcVectorStartOut = null;
      vcVectorEndOut = null;
      clColorStartOut = null;
      clColorEndOut = null;
    }
  }

  /**
   * Edit values of line in generated mesh
   * @param nIndex Index of line in generated mesh
   */
  public void MeshLineEdit(int nIndex, Vector3f vcVectorStart, Vector3f vcVectorEnd, ColorRGBA clColorStart, ColorRGBA clColorEnd)
  {
    if
    (
      nIndex >= 0 &&
      nIndex * 7 <= this.fbPositionBuffer.capacity() &&
      nIndex * 9 <= this.fbColorBuffer.capacity() &&
      vcVectorStart != null && vcVectorEnd != null
    )
    {
      int i;

      i = nIndex * 6;
      this.fbPositionBuffer.put(i++, vcVectorStart.x);
      this.fbPositionBuffer.put(i++, vcVectorStart.y);
      this.fbPositionBuffer.put(i++, vcVectorStart.z);

      this.fbPositionBuffer.put(i++, vcVectorEnd.x);
      this.fbPositionBuffer.put(i++, vcVectorEnd.y);
      this.fbPositionBuffer.put(i, vcVectorEnd.z);

      i = nIndex * 8;
      if (clColorStart != null) {
        this.fbColorBuffer.put(i++, clColorStart.r);
        this.fbColorBuffer.put(i++, clColorStart.g);
        this.fbColorBuffer.put(i++, clColorStart.b);
        this.fbColorBuffer.put(i++, clColorStart.a);
      }
      else
        i+=4;

      if (clColorEnd != null) {
        this.fbColorBuffer.put(i++, clColorEnd.r);
        this.fbColorBuffer.put(i++, clColorEnd.g);
        this.fbColorBuffer.put(i++, clColorEnd.b);
        this.fbColorBuffer.put(i, clColorEnd.a);
      }

      msMesh.updateBound();
    }
  }

  /**
   * Updates mesh with data stored in line buffer
   */
  public void MeshUpdate()
  {
    float[] fPositionArray = new float[this.vcPositionStartList.size() * 6];
    float[] fColorArray = new float[this.clColorStartList.size() * 8];

    int p = 0;
    int c = 0;

    Vector3f vcVector;
    ColorRGBA clColor;

    for (int i = 0; i < vcPositionStartList.size(); i++)
    {
      vcVector = this.vcPositionStartList.get(i);
      fPositionArray[p++] = vcVector.x;
      fPositionArray[p++] = vcVector.y;
      fPositionArray[p++] = vcVector.z;

      vcVector = this.vcPositionEndList.get(i);
      fPositionArray[p++] = vcVector.x;
      fPositionArray[p++] = vcVector.y;
      fPositionArray[p++] = vcVector.z;

      clColor = this.clColorStartList.get(i);
      fColorArray[c++] = clColor.r;
      fColorArray[c++] = clColor.g;
      fColorArray[c++] = clColor.b;
      fColorArray[c++] = clColor.a;

      clColor = this.clColorEndList.get(i);
      fColorArray[c++] = clColor.r;
      fColorArray[c++] = clColor.g;
      fColorArray[c++] = clColor.b;
      fColorArray[c++] = clColor.a;
    }

    msMesh.setBuffer(VertexBuffer.Type.Position, 3, fPositionArray);
    msMesh.setBuffer(VertexBuffer.Type.Color, 4, fColorArray);

    msMesh.updateCounts();
    msMesh.updateBound();

    this.fbPositionBuffer = this.msMesh.getFloatBuffer(VertexBuffer.Type.Position);
    this.fbColorBuffer = this.msMesh.getFloatBuffer(VertexBuffer.Type.Color);
  }

  /**
   * Get amount of elements in line buffer
   */
  public int BufferSizeGet()
  {
    return this.vcPositionStartList.size();
  }

  /**
   * Returns mesh, generated out of line buffer
   */
  public Mesh MeshGet()
  {
    return this.msMesh;
  }
}

P.S: I’m very sorry if analog of that class already existed in jMonkey engine or posted on forum.