CellPosition.java

  1. package com.gh.mygreen.xlsmapper.util;

  3. import java.awt.Point;
  4. import java.io.Serializable;
  5. import java.util.regex.Matcher;
  6. import java.util.regex.Pattern;

  8. import org.apache.poi.ss.usermodel.Cell;
  9. import org.apache.poi.ss.util.CellAddress;
  10. import org.apache.poi.ss.util.CellReference;

  12. /**
  13.  * 単一のセルのアドレスを表現するクラス。
  14.  * <p>{@link java.awt.Point}だと、行、列の表現がわかりづらくmutableなので、、その代わりに使用する。
  15.  * <p>{@link CellReference}との違いは、セルのアドレスの絶対一致を表現するためのもの。
  16.  * <p>POIに同じ用途のクラス{@link CellAddress}が存在するが、
  17.  *    こちらは{@link Serializable}や{@link Cloneable}が実装されておらず、使い勝手が悪い。</p>
  18.  *
  19.  * @since 1.4
  20.  * @author T.TSUCHIE
  21.  *
  22.  */
  23. public class CellPosition implements Serializable, Comparable<CellPosition>, Cloneable {

  25.     /** serialVersionUID */
  26.     private static final long serialVersionUID = 8579701754512731611L;

  28.     /**
  29.      * シート上の先頭の位置を表現するための定数。
  30.      */
  31.     public static final CellPosition A1 = new CellPosition(0, 0);

  33.     private final int row;

  35.     private final int column;

  37.     private final String toStringText;

  39.     /**
  40.      * CellAddressのインスタンスを作成する。
  41.      *
  42.      * @param row 行番号 (0から始まる)
  43.      * @param column 列番号 (0から始まる)
  44.      * @throws IllegalArgumentException {@literal row < 0 || column < 0}
  45.      */
  46.     private CellPosition(int row, int column) {
  47.         ArgUtils.notMin(row, 0, "row");
  48.         ArgUtils.notMin(column, 0, "column");
  49.         this.row = row;
  50.         this.column = column;
  51.         this.toStringText = CellReference.convertNumToColString(column) + (row + 1);
  52.     }

  54.     /**
  55.      * CellAddressのインスタンスを作成する。
  56.      *
  57.      * @param row 行番号 (0から始まる)
  58.      * @param column 列番号 (0から始まる)
  59.      * @return {@link CellPosition}のインスタンス
  60.      * @throws IllegalArgumentException {@literal row < 0 || column < 0}
  61.      */
  62.     public static CellPosition of(int row, int column) {
  63.         ArgUtils.notMin(row, 0, "row");
  64.         ArgUtils.notMin(column, 0, "column");

  66.         return new CellPosition(row, column);
  67.     }

  69.     /**
  70.      * CellAddressのインスタンスを作成する。
  71.      * @param cell セルのインスタンス。
  72.      * @return {@link CellPosition}のインスタンス
  73.      * @throws IllegalArgumentException {@literal cell == null.}
  74.      */
  75.     public static CellPosition of(final Cell cell) {
  76.         ArgUtils.notNull(cell, "cell");

  78.         return of(cell.getRowIndex(), cell.getColumnIndex());
  79.     }

  81.     /**
  82.      * CellAddressのインスタンスを作成する。
  83.      * @param reference セルの参照形式。
  84.      * @return {@link CellPosition}のインスタンス
  85.      * @throws IllegalArgumentException {@literal reference == null.}
  86.      */
  87.     public static CellPosition of(final CellReference reference) {
  88.         ArgUtils.notNull(reference, "reference");

  90.         return of(reference.getRow(), reference.getCol());
  91.     }

  93.     /**
  94.      * CellAddressのインスタンスを作成する。
  95.      * @param address セルのアドレス
  96.      * @return {@link CellPosition}のインスタンス
  97.      * @throws IllegalArgumentException {@literal address == null.}
  98.      */
  99.     public static CellPosition of(final CellAddress address) {
  100.         ArgUtils.notNull(address, "address");

  102.         return of(address.getRow(), address.getColumn());
  103.     }

  105.     /**
  106.      * CellAddressのインスタンスを作成する。
  107.      * @param address 'A1'の形式のセルのアドレス
  108.      * @return {@link CellPosition}のインスタンス
  109.      * @throws IllegalArgumentException {@literal address == null || address.length() == 0 || アドレスの書式として不正}
  110.      */
  111.     public static CellPosition of(final String address) {
  112.         ArgUtils.notEmpty(address, "address");

  114.         if(!matchedCellAddress(address)) {
  115.             throw new IllegalArgumentException(address + " is wrong cell address pattern.");
  116.         }

  118.         return of(new CellReference(address));
  119.     }

  121.     private static final Pattern PATTERN_CELL_ADREESS = Pattern.compile("^([a-zA-Z]+)([0-9]+)$");

  123.     private static boolean matchedCellAddress(final String address) {
  124.         final Matcher matcher = PATTERN_CELL_ADREESS.matcher(address);
  125.         return matcher.matches();
  126.     }

  128.     /**
  129.      * CellAddressのインスタンスを作成する。
  130.      * @param point セルの座標
  131.      * @return {@link CellPosition}のインスタンス
  132.      * @throws IllegalArgumentException {@literal point == null.}
  133.      */
  134.     public static CellPosition of(final Point point) {
  135.         ArgUtils.notNull(point, "point");
  136.         return of(point.y, point.x);
  137.     }

  139.     @Override
  140.     public int compareTo(final CellPosition other) {
  141.         ArgUtils.notNull(other, "other");

  143.         int r = this.row - other.row;
  144.         if (r != 0) {
  145.             return r;
  146.         }

  148.         int c = this.column - other.column;
  149.         if (c != 0) {
  150.             return c;
  151.         }

  153.         return 0;
  154.     }

  156.     @Override
  157.     public int hashCode() {
  158.         final int prime = 31;
  159.         int result = 1;
  160.         result = prime * result + column;
  161.         result = prime * result + row;
  162.         return result;
  163.     }

  165.     @Override
  166.     public boolean equals(final Object obj) {
  167.         if(this == obj) {
  168.             return true;
  169.         }
  170.         if(obj == null) {
  171.             return false;
  172.         }
  173.         if(!(obj instanceof CellPosition)) {
  174.             return false;
  175.         }
  176.         CellPosition other = (CellPosition) obj;
  177.         if(column != other.column) {
  178.             return false;
  179.         }
  180.         if(row != other.row) {
  181.             return false;
  182.         }
  183.         return true;
  184.     }

  186.     @Override
  187.     public CellPosition clone() {
  188.         return new CellPosition(row, column);
  189.     }

  191.     /**
  192.      * 行番号を取得する。
  193.      * @return 行番号 (0から始まる)
  194.      */
  195.     public int getRow() {
  196.         return row;
  197.     }

  199.     /**
  200.      * 列番号を取得する。
  201.      * @return 列番号 (0から始まる)
  202.      */
  203.     public int getColumn() {
  204.         return column;
  205.     }

  207.     /**
  208.      * {@link Point}の形式に変換します。
  209.      * @return {@link Point}のインスタンス。
  210.      *          x座標が列番号（column index）、y座標が行番号(row index)なります。
  211.      */
  212.     public Point toPoint() {
  213.         return new Point(column, row);
  214.     }

  216.     /**
  217.      * POIの{@link CellAddress}の形式に変換します。
  218.      * @return {@link CellAddress}のインスタンス。
  219.      */
  220.     public CellAddress toCellAddress() {
  221.         return new CellAddress(row, column);
  222.     }

  224.     /**
  225.      * セルのアドレスを取得する。
  226.      * @return 'A1'の形式で、セルノアドレスを文字列として表現する。
  227.      */
  228.     public String formatAsString() {
  229.         return toStringText;
  230.     }

  232.     /**
  233.      * 行番号に指定した値を加算する。
  234.      * @param value 加算する値
  235.      * @return 加算したインスタンス
  236.      */
  237.     public CellPosition addRow(int value) {
  238.         return new CellPosition(row + value, column);
  239.     }

  241.     /**
  242.      * 列番号に指定した値を加算する。
  243.      * @param value 加算する値
  244.      * @return 加算したインスタンス
  245.      */
  246.     public CellPosition addColumn(int value) {
  247.         return new CellPosition(row, column + value);
  248.     }

  250.     /**
  251.      * {@link #formatAsString()}の値を返します。
  252.      */
  253.     @Override
  254.     public String toString() {
  255.         return formatAsString();
  256.     }

  258. }
Created with JaCoCo 0.8.5.201910111838