Java的int数组的简单工具类IntArrayUtil2.0

这个功能偏于单一类型，不过，想通用的话，改为泛型就好了，有些比较的方法就要有所牺牲（引用对象的比较用不了比较符）。

 

  1 package cn.util;
  2 
  3 /**
  4  * 整数数组工具类：
  5  *  如果想改为通用类，需要设置
  6  *  比版本1多了行设置，矩形设置值，圆形设置值，替换。
  7  * 
  8  * @author JXLYS
  9  * @version 2.0
 10  */
 11 public class IntArrayUtil {
 12 
 13     /**
 14      * 二维数组设置一个圆形状的值。
 15      * 
 16      * @param iarr
 17      *            原数组
 18      * @param cX
 19      *            圆心x
 20      * @param cY
 21      *            圆心y
 22      * @param r
 23      *            半径
 24      * @param value
 25      *            值
 26      */
 27     public static void fillCircular(int[][] iarr, int cX, int cY, int r, int value) {
 28         for (int i = 0; i <= r * 2; i++) {
 29             for (int j = 0; j <= r * 2; j++) {
 30                 int x = cX + j - r - cX;
 31                 int y = cY + i - r - cY;
 32                 if (x * x + y * y <= r * r) {
 33                     set(iarr, cX + j - r, cY + i - r, value);
 34                 }
 35             }
 36         }
 37     }
 38 
 39     /**
 40      * 一维数组查找第一次出现值的索引。
 41      * 
 42      * @param iarr
 43      * @param value
 44      * @return
 45      */
 46     public static int findValue(int[] iarr, int value) {
 47         for (int i = 0; i < iarr.length; i++) {
 48             if (iarr[i] == i)
 49                 return i;
 50         }
 51         return -1;
 52     }
 53 
 54     /**
 55      * 二维数组查找第一次出现指定数值的位置。[x,y]
 56      * 
 57      * @param iarr
 58      *            原数组
 59      * @param value
 60      *            值
 61      * @return
 62      */
 63     public static int[] findValue(int[][] iarr, int value) {
 64         for (int i = 0; i < iarr.length; i++) {
 65             for (int j = 0; j < iarr[i].length; j++) {
 66                 if (iarr[i][j] == value) {
 67                     return new int[] { j, i };
 68                 }
 69             }
 70         }
 71         return null;
 72     }
 73 
 74     /**
 75      * 获得一维数组指定位置的值。查询出错则返回-1。
 76      * 
 77      * @param iarr
 78      *            原数组
 79      * @param index
 80      *            索引
 81      * @return
 82      */
 83     public static int get(int[] iarr, int index) {
 84         return noArrayIndexOutOfBounds(iarr.length, index) ? iarr[index] : -1;
 85 
 86     }
 87 
 88     /**
 89      * 获得指定位置的值
 90      * 
 91      * @param iarr
 92      *            原数组
 93      * @param x
 94      *            位置x
 95      * @param y
 96      *            位置y
 97      */
 98     public static int get(int[][] iarr, int x, int y) {
 99         return noArrayIndexOutOfBounds(iarr.length, y) && noArrayIndexOutOfBounds(iarr[y].length, x) ? iarr[y][x] : -1;
100     }
101 
102     /**
103      * 创建一个一维数组，参数是顺序的输入值。 参数可变（有多少个参数就有多少个值）
104      * 
105      */
106     public static int[] newOne(int... values) {
107         return values;
108     }
109 
110     /**
111      * 创建指定长度的一维数组，长度不大于0则返回null。
112      * 
113      * @param length
114      *            数组长度。
115      */
116     public static int[] newOneLength(int length) {
117         return length > 0 ? new int[length] : null;
118     }
119 
120     /**
121      * 创建一个指定一维数组的个数为y，一维数组的长度为x的二维数组。
122      * 
123      * @param x
124      *            一维数组的长度
125      * @param y
126      *            一维数组的个数。
127      */
128     public static int[][] newTwoLength(int x, int y) {
129         return x > 0 && y > 0 ? new int[y][x] : null;
130     }
131 
132     private static boolean noArrayIndexOutOfBounds(int length, int index) {// 检测数组是否越界
133         return index >= 0 && index < length ? true : false;
134     }
135 
136     /**
137      * 替换一维数组中指定的值。
138      * 
139      * @param iarr
140      *            原数组
141      * @param regex
142      *            符合条件的值
143      * @param value
144      *            目标值
145      */
146     public static void replaceAll(int[] iarr, int regex, int value) {
147         for (int i = 0; i < iarr.length; i++) {
148             if (iarr[i] == regex) {
149                 iarr[i] = value;
150             }
151         }
152     }
153 
154     /**
155      * 替换二维数组中指定的值。
156      * 
157      * @param iarr
158      *            原数组
159      * @param regex
160      *            符合条件的值
161      * @param value
162      *            目标值
163      */
164     public static void replaceAll(int[][] iarr, int regex, int value) {
165         for (int i = 0; i < iarr.length; i++) {
166             replaceAll(iarr[i], regex, value);
167         }
168     }
169 
170     /**
171      * 修改一维数组的指定索引的值，如果索引越界则不修改。
172      * 
173      * @param iarr
174      *            原数组
175      * @param index
176      *            索引
177      * @param value
178      *            值
179      */
180     public static void set(int[] iarr, int index, int value) {
181         if (noArrayIndexOutOfBounds(iarr.length, index))
182             iarr[index] = value;
183     }
184 
185     /**
186      * 设置二维数组的指定索引的值。
187      * 
188      * @param iarr
189      *            二维数组
190      * @param x
191      *            一维数组里的索引
192      * @param y
193      *            二维数组的索引
194      * @param value
195      *            值
196      */
197     public static void set(int[][] iarr, int x, int y, int value) {
198         if (noArrayIndexOutOfBounds(iarr.length, y) && noArrayIndexOutOfBounds(iarr[y].length, x)) {
199             iarr[y][x] = value;
200         }
201     }
202 
203     /**
204      * 设置数组的所有值。
205      * 
206      * @param iarr
207      *            原数组
208      * @param value
209      *            值
210      */
211     public static void setAll(int[] iarr, int value) {
212         for (int i = 0; i < iarr.length; i++) {
213             iarr[i] = value;
214         }
215     }
216 
217     /**
218      * 二维数组设置一个圆圈形状的值。
219      * 
220      * @param iarr
221      *            原数组
222      * @param cX
223      *            圆心x
224      * @param cY
225      *            圆心y
226      * @param r
227      *            半径
228      * @param value
229      *            值
230      */
231     public static void setCircular(int[][] iarr, int cX, int cY, int r, int value) {
232         for (int i = 0; i <= r * 2; i++) {
233             for (int j = 0; j <= r * 2; j++) {
234                 int x = cX + j - r - cX;
235                 int y = cY + i - r - cY;
236                 if (x * x + y * y == r * r) {
237                     set(iarr, cX + j - r, cY + i - r, value);
238                 }
239             }
240         }
241     }
242 
243     /**
244      * 一维数组设置一行的数据，可检测越界。
245      * 
246      * @param iarr
247      * @param x1
248      * @param x2
249      * @param value
250      */
251     public static void setLine(int[] iarr, int x1, int x2, int value) {
252         int n = x1 > x2 ? -1 : 1;// 检测大小
253         for (int i = 0, x = Math.abs(x2 - x1); i <= x; i++) {
254             set(iarr, x1 + i * n, value);
255         }
256     }
257 
258     /**
259      * 二维数组设置一行的数据，可检测越界
260      * 
261      * @param iarr
262      *            原数组
263      * @param x1
264      *            位置1的x
265      * @param y1
266      *            位置1的y
267      * @param x2
268      *            位置2的x
269      * @param y2
270      *            位置2的y
271      * @param value
272      *            值
273      */
274     public static void setLine(int[][] iarr, int x1, int y1, int x2, int y2, int value) {
275         int n1 = y1 > y2 ? -1 : 1;
276         int n2 = x1 > x2 ? -1 : 1;
277         for (int i = 0, y = Math.abs(y2 - y1); i < y; i++) {
278             for (int j = 0, x = Math.abs(x2 - x1); j < x; j++) {
279                 set(iarr, x + j * n2, y + i * n1, value);
280             }
281         }
282     }
283 
284     /**
285      * 二维数组设置矩形，可检测越界。
286      * 
287      * @param iarr
288      *            原数组
289      * @param x
290      *            位置x
291      * @param y
292      *            位置y
293      * @param w
294      *            宽度
295      * @param h
296      *            高度
297      * @param value
298      *            值
299      */
300     public static void fillRect(int[][] iarr, int x, int y, int w, int h, int value) {
301         for (int i = 0; i < h; i++) {
302             for (int j = 0; j < w; j++) {
303                 set(iarr, x + j, y + i, value);
304             }
305         }
306     }
307 
308     /**
309      * 二维数组设置矩形，可检测越界。
310      * 
311      * @param iarr
312      *            原数组
313      * @param x
314      *            位置x
315      * @param y
316      *            位置y
317      * @param w
318      *            宽度
319      * @param h
320      *            高度
321      * @param value
322      *            值
323      */
324     public static void setRect(int[][] iarr, int x, int y, int w, int h, int value) {
325         for (int i = 0; i < h; i++) {
326             for (int j = 0; j < w; j++) {
327                 if (i == 0 || j == 0 || i == w - 1 || j == h - 1)
328                     set(iarr, x + j, y + i, value);
329             }
330         }
331     }
332 
333     /**
334      * 便捷输出一维数组到控制台。
335      * 
336      * @param iarr
337      */
338     public static void show(int[] iarr) {
339         System.out.print("数组：");
340         for (int i = 0; i < iarr.length; i++) {
341             if (i != iarr.length - 1)
342                 System.out.print(iarr[i] + ",");
343             else
344                 System.out.println(iarr[i]);
345         }
346     }
347 
348     /**
349      * 便捷输出二维数组到控制台。
350      * 
351      * @param iarr
352      */
353     public static void show(int[][] iarr) {
354         for (int i = 0; i < iarr.length; i++) {
355             System.out.print("第" + i + "行");
356             show(iarr[i]);
357         }
358     }
359 
360     private IntArrayUtil() {// 私有化构造方法
361         throw new RuntimeException();
362     }
363 }

 

转载于:https://www.cnblogs.com/jxlys/p/8031499.html