for (int i = 0 ; i < size; i++)
    for(int j = 0 ; j < size ; j++)
    {
         if ( arr[i][j] == 88)
         {
              `save this 2 indexes`
              break;
         }
    }

By converting your 2D Array int[][] to List<List<Integer>>, you can take advantage of indexOf to find the index of your max:

List<List<Integer>> triangle = new ArrayList<List<Integer>>();
    triangle.add(Arrays.asList(75));
    triangle.add(Arrays.asList(95, 64));

    for (List<Integer> row : triangle) {
        // you can also ask for row.indexOf(max);
        System.out.println("At row: " + triangle.indexOf(row) + " is: " + row.indexOf(64));         
    }

You might want to try using a HashMap<Integer, Integer> instead if you want the code to scale and stay performant.

    public class MobScene {
        private HashMap<Integer, Integer> mobs = new HashMap<Integer, Integer>(10);
        // Note that '10' is the initial capacity of the Collection.
        // I only use it as I already know the given capacity and avoid extra memory being reserved.

        public MobScene() {
            mobs.put(9300127,2);
            mobs.put(9300128,2);
            mobs.put(9300129,2);
            mobs.put(9300130,3);
            mobs.put(9300131,3);
            mobs.put(9300132,3);
            mobs.put(9300133,4);
            mobs.put(9300134,4);
            mobs.put(9300135,5);
            mobs.put(9300136,6);
        }

        public void addPoints(int mobid) {
            if(mobs.contains(mobid)) {
                mobs.put(mobs.get(mobid) + 1);
            }
        }
    }

If list is your list, you should be able to find the value "res" with:

list.get(0).get(0)

For a reference a[row][col] to an element of a 2d array, the equivalent reference to an ArrayList of ArrayLists (or really any List of Lists) will be list.get(row).get(col)

As long as the comparison operator (equals() method) of your Square is suitable for you, then any of these method would work :

• Converting to ArrayList and unsing indexOf and get
• Using java.util.Arrays.binarySearch
• Do a foreach loop and search manually
• etc.

You only need a valid comparison operator, if the default Object.equals()(comparison of object instances) is suitable for your need, then you don't have much to do :

Point getObject(Square s){
{
    for(int i = 0; i<n; i++){
        for(int j = 0; j<n; j++){
            if( squares[i][j].equals(s) ) {
                return Point(i, j);
            }
        }
    }
    return null;
}

Note that if your array is large, it's not the fastest way to do it.

You can't directly retrieve the index just because the index is used to access elements in map but they are not contained in the object. The object itself has no clue of being inside an array.

A better approach would be to store the index inside the object itself:

class MyObject {
  final public int x, y;

  MyObject(int x, int y) {
    this.x = x;
    this.y = y;
  }
}

public place(MyObject o) {
  map[o.x][o.y] = object;
}

You can even have a wrapper class which works as a generic holder:

class ObjectHolder<T> {
  public T data;
  public final int x, y;

  ObjectHolder(int x, int y, T data) {
    this.data = data;
    this.x = x;
    this.y = y;
  }
}

and then just pass this around instead that the original object.

But, if you don't need to have them logically in a 2D array, at this point you can just use the wrapper without any 2D array.

Right now, you should consistently get 2 * arr.length as the final value. That isn't what you are probably looking for. It looks like you want to know the coordinates for the max value. To do this, you'll need to cache the values of the indexes and then use them later:

public static void main(String[] args) {
    int[][] arr = {{4, 44, 5, 7, 63, 1}, {7, 88, 31, 95, 9, 6}, {88, 99, 6, 5, 77, 4}};
    int tmpI = 0;
    int tmpJ = 0;
    double max = arr[0][0];
    // there are some changes here. in addition to the caching
    for (int i = 0; i < arr.length; i++) {
        int[] inner = arr[i];
        // caches inner variable so that it does not have to be looked up
        // as often, and it also tests based on the inner loop's length in
        // case the inner loop has a different length from the outer loop.
        for (int j = 0; j < inner.length; j++) {
            if (inner[j] > max) {
                max = inner[j];
                // store the coordinates of max
                tmpI = i; tmpJ = j;
            }
        }
    }
    System.out.println(max);
    // convert to string before outputting:
    System.out.println("The (x,y) is: ("+tmpI+","+tmpJ+")");

My Java is a bit rusty but I'm not seeing any logical issues with the code doing what you want it to.

Since you return just the row or column index, the caller can't tell from that if the match was a row or a column.

If you really want to not return an array nor string with both integers, you could create a class with two attributes (x,y), and return an instance of that class. But I don't see why you would do this

Class be looking like:

public class MyIndex{
    int x;
    int y;

    public MyIndex(int x, int y){
       this.x=x;
       this.y=y;
    }

    public int getX() {return x;}
    public void setX(int x) {this.x = x;}
    public int getY() {return y;}
    public void setY(int y) {this.y = y;}
}

Or use Point class from package java.awt

/ and % operations can help you

int getByPosition(int[][] arr, int pos) {
    return arr[pos / arr.length][pos % arr.length];
}

Update: to get position by indexes:

int getPosByIndex(int[][] arr, int i, int j) {
    return arr.length * i + j;
}