Thread: How to use this 2d ArrayList class?

In Java, you can fake 2D ArrayLists by making an ArrayList of ArrayLists of some type (it's not as confusing at it sounds).

I wrote that class as an example of how to utilize this, but it's really not necessary to use that class at all. You can use this idea the same way vector<vector<type>> is used.

For example, say your C++ code looked something like this:

// really C++ code
// I know that by using references/pointers this could be more efficient, but that's beyond the scope of this example
vector<vector<int>> v;
v.push_back(vector<int>());
v.push_back(vector<int>());
v.push_back(vector<int>());
v[0].push_back(1);
v[0].push_back(2);
v[1].push_back(3);
v[1].push_back(4);
v[1].push_back(0);
v[2].push_back(5);
// now have the following contents:
// row 0: 1, 2
// row 1: 3, 4, 0
// row 2: 5
// get the element at row 1 and column 2
int number = v[1][2];

The Java-equivalent code would be (it's very similar to the above code, though there are a few differences):

// Create an ArrayList of ArrayLists of Integers
ArrayList<ArrayList<Integer>> my2DArrayList = new ArrayList<ArrayList<Integer>>();
// add in a few ArrayLists. These contain the "rows" of the 2D ArrayList
my2DArrayList.add(new ArrayList<Integer>());
my2DArrayList.add(new ArrayList<Integer>());
my2DArrayList.add(new ArrayList<Integer>());
// you can retrieve rows using get(), then treat that 1D arrayList as the column.
my2DArrayList.get(0).add(1);
my2DArrayList.get(0).add(2);
my2DArrayList.get(1).add(3);
my2DArrayList.get(1).add(4);
my2DArrayList.get(1).add(0);
my2DArrayList.get(2).add(5);
// my2DArrayList now contains this:
// row 0: 1, 2
// row 1: 3, 4, 0
// row 2: 5
// to retrieve a specific element, you need to first get the ArrayList of the row you want, then retrieve the column from that arraylist you want
// get element at row 1 and column 2
int number = my2DArrayList.get(1).get(2);

If you do want to use my "wrapper class", you're more than welcome to. I fixed it recently (at the time I posted this, actually) because I actually never really tested it in the past (how embarrassing). It basically embodies this idea into short and concise methods of how you would perform common operations such as getting an element at a specific row and column.

Thank you. This is what I needed.

... one last thing, how would I go about reassigning a new value to an existing element?

myArrayList2D.get(row).set(col, value);

Do you mean a deep copy? Java works via references so it's a rather big pain to perform a deep copy.

Your code simply gets a reference to the ArrayList at row s. You can copy that ArrayList, but any changes you make to objects inside that ArrayList will effect those inside vfrequency.

vlinefreq = vfrequency.get(s).clone(); // creates a shallow copy of row s

If you need a deep copy, you could go through and call clone on every element inside of vlinefreq. However, this is not guaranteed to work or give you a deep copy since implementation of Clonable is rather sporadic.

Yeah, in that case I need a deep copy.

Meh, no need to use clone but still a pain to cycle through every element.

vlinefreq.clear();
int x;
for (x=0; x < vfrequency.get(s).size(); x++)
{
	vlinefreq.add(vfrequency.get(s).get(x));
}

Wait, wait, wait.

Are you trying to create an independent copy of an ArrayList? That is very simple, just use the ArrayList(Collection<? extends E> c) constructor.

Here is some sample code that shows its implementation:

import java.util.ArrayList;
 
public class MainClassTest 
{
    public static void main(String args[]) 
    {
    	ArrayList<String> values = new ArrayList<String>();
    	values.add("Test");
    	values.add("Test1");
    	values.add("Test2");
    	values.add("Test3");
    	values.add("Test4");
    	ArrayList<String> valuesDuo = new ArrayList<String>(values);
    	valuesDuo.add("Test5");
    	valuesDuo.set(2,"Test200");
 
    	System.out.println(values);
    	System.out.println(valuesDuo);
    }
}

That still produces a soft copy. Java makes it rather cumbersome to get a good deep copy because it functions using references/pointers for objects. Even Cloneable objects sometimes return only shallow copy. If you're using your own classes, you can implement Clonable to provide a true deep copy. However, if you're mixing in other API's (including the standard API) you're going to have a lot of custom code just to provide a deep copy.

// knowing that we have Points which take int x and int y, we can clone them manually.
Point p1 = new Point(1,2);
// a manual clone of p1. It's guaranteed to be a deep-copy
Point p2 = new Point(p1.x, p1.y);

But doesn't a soft copy keep the references? The constructor I used above allows you to edit values of one array without changing the values of the other array. Wouldn't that mean it isn't a soft copy? Maybe I missed something.

Originally Posted by aussiemcgr

The constructor I used above allows you to edit values of one array without changing the values of the other array. Wouldn't that mean it isn't a soft copy?

The changes made in the code you posted changes the references, so all it is doing is reassigning the references to something else - this is only reflected in the List where the change occurred (all other references still refer to the previous object). In more complex scenarios, change the variables of an object within the array and the effect will be reflected in every reference. Here's a modification of the code you posted to demonstrate, printing the arrays will show that the values of both arrays are identical

public class Test {
 
	String string;
	public Test(String s){
		string = s;
	}
 
	public static void main(String args[])
    {
        ArrayList<Test> values = new ArrayList<Test>();
        values.add(new Test("Test"));
        values.add(new Test("Test1"));
        values.add(new Test("Test2"));
        values.add(new Test("Test3"));
        values.add(new Test("Test4"));
        ArrayList<Test> valuesDuo = new ArrayList<Test>(values);
        valuesDuo.get(2).string = "Test200";
 
 
        System.out.println(values);
        System.out.println(valuesDuo);
    }
	@Override
	public String toString(){
		return string;
	}
}