Класс 2D массива в Java с обтеканием по краям

Question

Я делаю 2D-класс массива в Java с обтеканием по краям.Таким образом, в массиве 10x20 запись (2, -1) будет такой же, как (2,19), а (4,22) будет такой же, как (4,2).Я также хочу иметь возможность доступа к этой структуре как к «выровненному массиву», поэтому я буду использовать 1-мерную массивоподобную структуру для хранения объектов.Я бы использовал одномерный массив, но тогда я не могу использовать универсальные типы, поэтому вместо этого я использую ArrayList.Класс еще не закончен, но я разместил код ниже.

Мой первый вопрос - алгоритмический: в приведенном ниже коде я обращаюсь к элементам (i, j), используя функции modRow (i) и modCol (j).Это работает нормально, но мне интересно, если кто-нибудь может придумать лучший способ сделать это.Эти функции затем вызываются функцией get (i, j).Я хочу иметь возможность получить доступ к элементам как можно быстрее.

Мой второй вопрос касается Java: я довольно новичок в Java и перенес этот код из проекта на C ++.У меня есть функция set (), которая позволяет мне установить элемент в позиции i в массиве (хранится в ArrayList).Однако функция set будет работать только в том случае, если функция add () уже была вызвана и установит элемент в положение i в выровненном массиве.Если у кого-то есть какие-либо предложения относительно того, как я могу сделать этот класс лучше, я буду рад их видеть.

import java.util.*;

public class Grid<T> {

    ArrayList<T> array; // holds objects in grid - would rather use an array
                        // but that won't support generics
    int rows;  // number of rows in grid
    int cols;  // number of cols in grid
    int length; // total number of objects in grid - maybe just get this from ArrayList
    int conNum; // number of connections for each point on grid (either 4 or 8) 
                // used for determining distances between points on the grid

    // constructor
    Grid(int row, int col, int numCon) {
        rows = row;
        cols = col;
        length = rows * cols;
        conNum = numCon;
        array = new ArrayList<T>(length);
    }

    // returns total size of grid
    public int len() {
        return length;
    }

    // returns number of rows
    public int row() {
        return rows;
    }

    // returns number of columns
    public int col() {
        return cols;
    }

    // wish I didn't have to use this 
    // would be nice to just be able to use set(int i, T t)
    public void add(T t) {
        array.add(t);
    }

    // sets object i in flattened out array
    public void set(int i, T t) {
        array.set(i, t);
    }

    // returns object i in flattened out array
    // for faster access when user just needs to iterate through all objects 
    // in grid without respect to position in 2D grid
    public T get(int i) {
        return array.get(i);
    }

    // returns the row position of i in grid - adjusted for warp around edges 
    // is there a better way to do this?  
    private int modRow(int i) {
        if(i >=0) {
            if(i < rows) {
                return i;
            } else { // i >= rows
                return i % rows;
            }
        } else { // i < 0
            return (i % rows + rows) % rows;
        }
    }

    // returns the column position of j in grid - adjusted for warp around edges 
    // is there a better way to do this? 
    private int modCol(int j) {
        if(j >=0) {
            if(j < cols) {
                return j;
            } else { // j >= cols
                return j % cols;
            }
        } else { // j < 0
            return (j % cols + cols) % cols;
        }
    }

    // sets object at (i,j) value from store adjusted for wrap around edges 
    public void set(int i, int j, T t) {
        array.set(modRow(i) * cols + modCol(j), t);
    }

    // gets object at (i,j) value from store adjusted for wrap around edges 
    public T get(int i, int j) {
        return array.get(modRow(i) * cols + modCol(j));
    }

    // returns distance on the grid between two objects at (y1,x1) and (y2,x2)
    public int dist(int y1, int x1, int y2, int x2) {
        int y = distFirst(y1, y2);
        int x = distSecond(x1, x2);
        if (conNum == 4) // taxicab distance
        {
            return y + x;
        } else { //if(conNum == 8) supremum distance
            return Math.max(y, x);
        }
    }

    // returns distance on the grid between the first coordinates y1 & y2 of two objects
    public int distFirst(int y1, int y2) {
        int dist = Math.abs(modRow(y2) - modRow(y1));
        return Math.min(dist, rows - dist);
    }

    // returns distance on the grid between the second coordinates x1 & x2 of two objects
    public int distSecond(int x1, int x2) {
        int dist = Math.abs(modCol(x2) - modCol(x1));
        return Math.min(dist, cols - dist);
    }
}

Answer 1

Не уверен, что привело вас к тому, что вы не можете использовать дженерики с массивами, потому что вы можете.Поэтому измените определение своего внутреннего хранилища и вызовите набор для своего сердца.

Ваши функции modRows / modCols могут быть (немного) более эффективными.Индекс будет выходить за пределы только в одном направлении, поэтому вы можете избавиться от вложенных проверок.

if(index < 0) return index + max_size;
else if(index >= max_size) return index % max_size;
else return index;

Answer 2

@ Восприятие: что не так с оригинальным index < 0 чеком?

if(index < 0) return (index % max_size + max_size) % max_size;    // <-- like that
else if(index >= max_size) return index % max_size;
else return index;