org.apache.commons.lang3.ArrayUtils 学习笔记

package com.nihaorz.model;

/**
 * @作者 王睿
 * @时间 2016-5-17 上午10:05:17
 *
 */
public class Person {
	private String id;
	private String name;
	private Integer age;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";
	}

}

import java.util.Iterator;
import java.util.Map;

import org.apache.commons.lang3.ArrayUtils;
import org.junit.Test;

import com.nihaorz.model.Person;

/**
 * @作者 王睿
 * @时间 2016-5-17 上午9:30:36 ArrayUtilsTest 使用 org.apache.commons.lang3.ArrayUtils
 *     对象完成数组的打印、克隆、查找、删除、倒序、分割以及值型/对象数组集合之间的转换等常用操作
 */
public class ArrayUtilsTest {

	/**
	 * 测试类统一获取Person数组方法
	 * @return
	 */
	private Person[] getPP(){
		Person p = new Person();
		p.setId("1001");
		p.setName("王睿");
		p.setAge(27);
		Person p1 = new Person();
		p1.setId("1002");
		p1.setName("钱青芝");
		p1.setAge(27);
		Person p2 = new Person();
		p2.setId("1003");
		p2.setName("王啸");
		p2.setAge(30);
		Person p3 = new Person();
		p3.setId("1004");
		p3.setName("胡曼琪");
		p3.setAge(10);
		Person[] pp = new Person[]{p,p1,p2,p3};
		return pp;
	}

	/**
	 * 测试类统一打印方法
	 * @param objs
	 */
	private void printArray(Object objs){
		System.out.println(ArrayUtils.toString(objs));
	}

	/**
	 * ArrayUtils.toString
	 * POJO对象数组直接toString
	 * 二维数组toString
	 */
	@Test
	public void _toString(){
		Person[] pp = getPP();
		printArray(pp[0]);
		printArray(pp);
		int[][] intArray2 = { { 1, 2 }, { 2, 4 }, { 3, 8 }, { 4, 16 } };
		printArray(intArray2);
		Object[][] notAMap = { { "A", new Double(100) },
				{ "B", new Double(80) }, { "C", new Double(60) },
				{ "D", new Double(40) }, { "E", new Double(20) } };
		printArray(notAMap);
	}

	/**
	 * ArrayUtils.clone
	 * 数组对象克隆方法
	 */
	@Test
	public void _clone(){
		Person[] pp = getPP();
		Person[] pp1 = ArrayUtils.clone(pp);
		printArray(pp1);
	}

	/**
	 * ArrayUtils.indexOf
	 * 返回元素在数组中第一次出现的位置，如果未找到或查询的参数是null即返回-1
	 */
	@Test
	public void indexOf(){
		double[] arr = {1.23,2.34,3.45,4.56,5.67,6.78,7.89,8.90,4.56};
		int result = ArrayUtils.indexOf(arr, 4.56);
		System.out.println(result);
		String[] arr2 = {"wangrui", "wangcheng", "钱青芝","钱青芝"};
		System.out.println(ArrayUtils.indexOf(arr2, "钱青芝"));
	}

	/**
	 * ArrayUtils.lastIndexOf
	 * 返回元素在数组中最后一次出现的位置，如果未找到或查询的参数是null即返回-1
	 */
	@Test
	public void lastIndexOf(){
		double[] arr = {1.23,2.34,3.45,4.56,5.67,6.78,7.89,8.90,4.56};
		int result = ArrayUtils.lastIndexOf(arr, 4.56);
		System.out.println(result);
		String[] arr2 = {"wangrui", "wangcheng", "钱青芝","钱青芝"};
		System.out.println(ArrayUtils.lastIndexOf(arr2, "钱青芝"));
		System.out.println(ArrayUtils.lastIndexOf(arr2, null));
	}

	/**
	 * ArrayUtils.contains
	 * 指定数组中是否存在指定元素
	 */
	@Test
	public void contains(){
		double[] arr = {1.23,2.34,3.45,4.56,5.67,6.78,7.89,8.90,4.56};
		System.out.println(ArrayUtils.contains(arr, 6.78));
		System.out.println(ArrayUtils.contains(arr, 6.77));
	}

	/**
	 * ArrayUtils.remove
	 * 删除数组指定下标的元素返回新的数组对象
	 */
	@Test
	public void remove(){
		Person[] pp = getPP();
		pp = ArrayUtils.remove(pp, 1);
		printArray(pp);
	}

	/**
	 * ArrayUtils.removeAll
	 * 批量删除数组指定下标的元素返回新的数组对象
	 */
	@Test
	public void removeAll(){
		Person[] pp = getPP();
		pp = ArrayUtils.removeAll(pp, 1, 2);
		printArray(pp);
	}

	/**
	 * ArrayUtils.removeElement
	 * 删除数组指定元素（仅删除第一个）返回新的数组对象
	 */
	@Test
	public void removeElement(){
		Person p = new Person();
		p.setId("1001");
		p.setName("王睿");
		p.setAge(27);
		Person p1 = new Person();
		p1.setId("1002");
		p1.setName("钱青芝");
		p1.setAge(27);
		Person p2 = new Person();
		p2.setId("1003");
		p2.setName("王啸");
		p2.setAge(30);
		Person p3 = new Person();
		p3.setId("1004");
		p3.setName("胡曼琪");
		p3.setAge(10);
		Person[] pp = new Person[]{p,p,p,p1,p2,p3};
		pp = ArrayUtils.removeElement(pp, p);
		printArray(pp);
	}

	/**
	 * ArrayUtils.removeElements
	 * 删除数组指定元素（传多个删多个）返回新的数组对象
	 */
	@Test
	public void removeElements(){
		Person p = new Person();
		p.setId("1001");
		p.setName("王睿");
		p.setAge(27);
		Person p1 = new Person();
		p1.setId("1002");
		p1.setName("钱青芝");
		p1.setAge(27);
		Person p2 = new Person();
		p2.setId("1003");
		p2.setName("王啸");
		p2.setAge(30);
		Person p3 = new Person();
		p3.setId("1004");
		p3.setName("胡曼琪");
		p3.setAge(10);
		Person[] pp = new Person[]{p,p,p,p1,p2,p3};
		pp = ArrayUtils.removeElements(pp, p);
		printArray(pp);
		pp = new Person[]{p,p,p,p1,p2,p3};
		pp = ArrayUtils.removeElements(pp, p, p);
		printArray(pp);

		String[] strs = new String[]{"1", "1", "1", "2", "3", "4"};
		strs = ArrayUtils.removeElements(strs, "1", "1");
		printArray(strs);
	}

	/**
	 * ArrayUtils.reverse
	 * 数组反转
	 */
	@Test
	public void reverse(){
		Person[] pp = getPP();
		printArray(pp);
		/**
		 * 数组整个直接反转
		 */
		ArrayUtils.reverse(pp);
		printArray(pp);
		/**
		 * 只反转第0到第2（不包含第2个元素）个元素
		 */
		ArrayUtils.reverse(pp, 0, 2);
		printArray(pp);
	}

	/**
	 * ArrayUtils.subarray
	 * 数组对象切割，返回新的数组对象
	 */
	@Test
	public void subarray(){
		Person[] pp = getPP();
		printArray(pp);
		pp = ArrayUtils.subarray(pp, 2, 3);
		printArray(pp);
	}

	/**
	 * ArrayUtils.toObject
	 * 将8种基本类型数组转换为包装类型数组
	 */
	@Test
	public void toObject(){
		int[] arr = new int[]{};
		System.out.println(arr.getClass().getSimpleName());
		System.out.println(ArrayUtils.toObject(arr).getClass().getSimpleName());
		char[] arr1 = new char[]{};
		System.out.println(arr1.getClass().getSimpleName());
		System.out.println(ArrayUtils.toObject(arr1).getClass().getSimpleName());
		double[] arr2 = new double[]{1.1,2.2,3.3,4.4};
		Double[] arr3 = ArrayUtils.toObject(arr2);
		printArray(arr3);
		for (Double d : arr3) {
			System.out.println(d.getClass().getSimpleName());
		}
	}

	/**
	 * ArrayUtils.toPrimitive
	 * 将8中包装类型数组转换为基本类型数组
	 */
	@Test
	public void toPrimitive(){
		Integer[] arr = new Integer[]{};
		System.out.println(arr.getClass().getSimpleName());
		System.out.println(ArrayUtils.toPrimitive(arr).getClass().getSimpleName());
		Character[] arr1 = new Character[]{};
		System.out.println(arr1.getClass().getSimpleName());
		System.out.println(ArrayUtils.toPrimitive(arr1).getClass().getSimpleName());
		Double[] arr2 = new Double[]{1.1,2.2,3.3,4.4};
		/**
		 * 直接转换，不处理null值，出现null值即报空指针异常
		 */
		double[] arr3 = ArrayUtils.toPrimitive(arr2);
		printArray(arr3);
		arr2 = ArrayUtils.add(arr2, null);
		/**
		 * 处理null值，如果遇到null值直接替换为0.123456
		 */
		printArray(ArrayUtils.toPrimitive(arr2, 0.123456));
		/**
		 * 不处理null值，报空指针异常
		 */
		printArray(ArrayUtils.toPrimitive(arr2));
	}

	/**
	 * ArrayUtils.toArray
	 * 将一组对象转换为数组
	 */
	@Test
	public void toArray(){
		String[] arr = ArrayUtils.toArray("112", "223", "445", "556");
		printArray(arr);
	}

	/**
	 * ArrayUtils.toMap
	 * 将二维数组转换为map对象
	 */
	@Test
	public void toMap(){
		String[] arr1 = ArrayUtils.toArray("112", "223", "445", "556");
		String[] arr2 = ArrayUtils.toArray("556", "778", "889", "900");
		String[][] arr3 = ArrayUtils.toArray(arr1, arr2);
		Map map = ArrayUtils.toMap(arr3);
		String[][] arr4 = new String[][] {{"RED", "#FF0000"},{"GREEN", "#00FF00"},{"BLUE", "#0000FF"}};
		map = ArrayUtils.toMap(arr4);
		Iterator it = map.keySet().iterator();
		while(it.hasNext()) {
			String key = (String) it.next();
			System.out.println("key:" + key + ", value:" + map.get(key));
		}
		Object[][] notAMap = { { "A", new Double(100) },
				{ "B", new Double(80) }, { "C", new Double(60) },
				{ "D", new Double(40) }, { "E", new Double(20) } };
		Map map1 = ArrayUtils.toMap(notAMap);
		Double res = (Double) map1.get("C");
		System.out.println("get 'C' from map1: " + res);
	}

}