숫자(Number) 0x01

자, 이제 실제로 유틸리티 클래스를 만들어 보자.
단순히 웹 어플리케이션 개발을 할 경우 실제적으로 많이 쓰이는 것은 문자열을 숫자형으로 변환하는 것이다.
문자열을 입력받아 자바 기본 숫자형으로 변환하는 클래스를 만들어보자

	/**
	 * 문자열을 숫자(short)형으로 변환한다.
	 * 
	 * <pre>
	 * NumberUtils.toShort(null, 0)   = 0
	 * NumberUtils.toShort("NaN", 0)  = 0
	 * NumberUtils.toShort("1234", 0) = 1234
	 * </pre>
	 * 
	 * @param value
	 * @param defaultValue 기본값
	 * @return
	 */
	public static short toShort(String value, short defaultValue) {
		if (value == null) {
			return defaultValue;
		}
		short result = defaultValue;
		try {
			result = Short.parseShort(value);
		} catch (NumberFormatException e) {
			// ignore
		}
		
		return result;
	}
	
	/**
	 * 문자열을 숫자(Short)형으로 변환한다.
	 * 
	 * <pre>
	 * NumberUtils.toShortObject(null)   		= null
	 * NumberUtils.toShortObject("NaN")  		= null
	 * NumberUtils.toShortObject("1234") 		= 1234
	 * </pre>
	 * 
	 * @param value
	 * @return
	 */
	public static Short toShortObject(String value) {
		if (value == null) {
			return null;
		}
		Short result = null;
		try {
			result = new Short(Short.parseShort(value));
		} catch (NumberFormatException e) {
			// ignore
		}	
		return result;
	}

	/**
	 * 문자열을 숫자(Short)형으로 변환한다.
	 * 단, 문자열은 패턴(pattern)과 일치해야한다.
	 * 패턴과 일치하지 않을 경우에는 null을 반환한다.
	 * 
	 * <pre>
	 * NumberUtils.toShortObject(null, *)          = null
	 * NumberUtils.toShortObject("NaN", *)         = null
	 * NumberUtils.toShortObject("1,234", "#,###") = 1234
	 * NumberUtils.toShortObject("1234", "#,###")  = null
	 * NumberUtils.toShortObject("1234", null)     = 1234
	 * </pre>
	 * 
	 * @param value
	 * @param pattern 패턴
	 * @return
	 */
	public static Short toShortObject(String value, String pattern) {
		if (value == null) {
			return null;
		}
		
		Short result = null;
		if (pattern != null) {
			DecimalFormat dFormat = new DecimalFormat(pattern);
			try {
				result = new Short(dFormat.parse(value).shortValue());
				
				if (value.equals(dFormat.format(result)) == false) {
					result = null;
				}
			} catch (ParseException e) {
				// ignore
			}
		} else {
			try {
				result = new Short(Short.parseShort(value));
			} catch (NumberFormatException e) {
				// ignore
			}
		}
		
		return result;
	}
	
	/**
	 * 문자열을 숫자(int)형으로 변환한다.
	 * 
	 * <pre>
	 * NumberUtils.toInteger(null, 0)   = 0
	 * NumberUtils.toInteger("NaN", 0)  = 0
	 * NumberUtils.toInteger("1234", 0) = 1234
	 * </pre>
	 * 
	 * @param value
	 * @param defaultValue 기본값
	 * @return
	 */
	public static int toInteger(String value, int defaultValue) {
		if (value == null) {
			return defaultValue;
		}
		int result = defaultValue;
		try {
			result = Integer.parseInt(value);
		} catch (NumberFormatException e) {
			// ignore
		}
		
		return result;
	}
	
	/**
	 * 문자열을 숫자(Integer)형으로 변환한다.
	 * 
	 * <pre>
	 * NumberUtils.toIntegerObject(null)          = null
	 * NumberUtils.toIntegerObject("NaN")         = null
	 * NumberUtils.toIntegerObject("1234")        = 1234
	 * NumberUtils.toIntegerObject("-2147483649") = null
	 * NumberUtils.toIntegerObject("-2147483648") = -2147483648
	 * NumberUtils.toIntegerObject("2147483647")  = 2147483647
	 * NumberUtils.toIntegerObject("2147483648")  = null
	 * </pre>
	 * 
	 * @param value
	 * @return
	 */
	public static Integer toIntegerObject(String value) {
		if (value == null) {
			return null;
		}
		Integer result = null;
		try {
			result = new Integer(Integer.parseInt(value));
		} catch (NumberFormatException e) {
			// ignore
		}	
		return result;
	}

	/**
	 * 문자열을 숫자(Integer)형으로 변환한다.
	 * 단, 문자열은 패턴(pattern)과 일치해야한다.
	 * 패턴과 일치하지 않을 경우에는 null을 반환한다.
	 * 
	 * <pre>
	 * NumberUtils.toIntegerObject(null, *)          = null
	 * NumberUtils.toIntegerObject("NaN", *)         = null
	 * NumberUtils.toIntegerObject("1,234", "#,###") = 1234
	 * NumberUtils.toIntegerObject("1234", "#,###")  = null
	 * NumberUtils.toIntegerObject("1234", null)     = 1234
	 * </pre>
	 * 
	 * @param value
	 * @param pattern 패턴
	 * @return
	 */
	public static Integer toIntegerObject(String value, String pattern) {
		if (value == null) {
			return null;
		}
		
		Integer result = null;
		if (pattern != null) {
			DecimalFormat dFormat = new DecimalFormat(pattern);
			try {
				result = new Integer(dFormat.parse(value).intValue());
				
				if (value.equals(dFormat.format(result)) == false) {
					result = null;
				}
			} catch (ParseException e) {
				// ignore
			}
		} else {
			try {
				result = new Integer(Integer.parseInt(value));
			} catch (NumberFormatException e) {
				// ignore
			}
		}
		
		return result;
	}
	
	/**
	 * 문자열을 숫자(long)형으로 변환한다.
	 * 
	 * <pre>
	 * NumberUtils.toLong(null, 0)   = 0
	 * NumberUtils.toLong("NaN", 0)  = 0
	 * NumberUtils.toLong("1234", 0) = 1234
	 * </pre>
	 * 
	 * @param value
	 * @param defaultValue 기본값
	 * @return
	 */
	public static long toLong(String value, long defaultValue) {
		long result = defaultValue;

		try {
			result = Long.parseLong(value);
		} catch (NumberFormatException e) {
			// ignore
		}
		
		return result;
	}
	
	/**
	 * 문자열을 숫자(Long)형으로 변환한다.
	 * 
	 * <pre>
	 * NumberUtils.toLongObject(null)   = null
	 * NumberUtils.toLongObject("NaN")  = null
	 * NumberUtils.toLongObject("1234") = 1234
	 * </pre>
	 * 
	 * @param value
	 * @return
	 */
	public static Long toLongObject(String value) {
		Long result = null;
		try {
			result = new Long(Long.parseLong(value));
		} catch (NumberFormatException e) {
			// ignore
		}	
		return result;
	}
	
	/**
	 * 문자열을 숫자(Long)형으로 변환한다.
	 * 단, 문자열은 패턴(pattern)과 일치해야한다.
	 * 패턴과 일치하지 않을 경우에는 null을 반환한다.
	 * 
	 * <pre>
	 * NumberUtils.toLongObject(null, *)            = null
	 * NumberUtils.toLongObject("NaN", *)           = null
	 * NumberUtils.toLongObject("1,234", "#,###")   = 1234
	 * NumberUtils.toLongObject("1234", "#,###")    = null
	 * NumberUtils.toLongObject("1234", null)       = 1234
	 * </pre>
	 * 
	 * @param value
	 * @param pattern 패턴
	 * @return
	 */
	public static Long toLongObject(String value, String pattern) {
		if (value == null) {
			return null;
		}
		
		Long result = null;
		if (pattern != null) {
			DecimalFormat dFormat = new DecimalFormat(pattern);
			try {
				result = new Long(dFormat.parse(value).longValue());
				
				if (value.equals(dFormat.format(result)) == false) {
					result = null;
				}
			} catch (ParseException e) {
				// ignore
			}
		} else {
			try {
				result = new Long(Long.parseLong(value));
			} catch (NumberFormatException e) {
				// ignore
			}
		}
		
		return result;
	}
	
	/**
	 * 문자열을 숫자(float)형으로 변환한다.
	 * 
	 * <pre>
	 * NumberUtils.toFloat(null, 0)     = 0.0
	 * NumberUtils.toFloat("NaN", 0)    = 0.0
	 * NumberUtils.toFloat("1234.5", 0) = 1234.5
	 * </pre>
	 * 
	 * @param value
	 * @param defaultValue 기본값
	 * @return
	 */
	public static float toFloat(String value, float defaultValue) {
		if (value == null) {
			return defaultValue;
		}
		try {
			return Float.parseFloat(value);
		} catch (NumberFormatException e) {
			return defaultValue;
		}
	}

	/**
	 * 문자열을 숫자(Float)형으로 변환한다.
	 * 
	 * <pre>
	 * NumberUtils.toFloatObject(null)     = null
	 * NumberUtils.toFloatObject("AAA")    = null
	 * NumberUtils.toFloatObject("NaN")    = Float.NAN
	 * NumberUtils.toFloatObject("1234.5") = 1234.5
	 * </pre>
	 * 
	 * @param value
	 * @return
	 */
	public static Float toFloatObject(String value) {
		if (value == null) {
			return null;
		}
		try {
			return new Float(Float.parseFloat(value));
		} catch (NumberFormatException e) {
			return null;
		}	
	}
	

	/**
	 * 문자열을 숫자(Float)형으로 변환한다.
	 * 단, 문자열은 패턴(pattern)과 일치해야한다.
	 * 패턴과 일치하지 않을 경우에는 null을 반환한다.
	 * 
	 * <pre>
	 * NumberUtils.toFloatObject(null, *)              = null
	 * NumberUtils.toFloatObject("AAA", *)             = null
	 * NumberUtils.toFloatObject("NaN", *)             = Float.NAN
	 * NumberUtils.toFloatObject("1,234", "#,###.#")   = 1234.0
	 * NumberUtils.toFloatObject("1,234.5", "#,###.#") = 1234.5
	 * NumberUtils.toFloatObject("1234.5", "#,###")    = null
	 * NumberUtils.toFloatObject("1234.5", null)       = 1234.5
	 * </pre>
	 * 
	 * @param value
	 * @param pattern 패턴
	 * @return
	 */
	public static Float toFloatObject(String value, String pattern) {
		if (value == null) {
			return null;
		}
		
		Float result = null;
		if (pattern != null) {
			DecimalFormat dFormat = new DecimalFormat(pattern);
			try {
				result = new Float(dFormat.parse(value).floatValue());
				
				if (value.equals(dFormat.format(result)) == false) {
					result = null;
				}
			} catch (ParseException e) {
				// ignore
			}
		} else {
			try {
				result = new Float(Float.parseFloat(value));
			} catch (NumberFormatException e) {
				// ignore
			}
		}
		
		return result;
	}
	
	/**
	 * 문자열을 숫자(double)형으로 변환한다.
	 * 
	 * <pre>
	 * NumberUtils.toDouble(null, 0)   = 0.0
	 * NumberUtils.toDouble("AAA", 0)  = 0.0
	 * NumberUtils.toDouble("NaN", 0)  = 0.0
	 * NumberUtils.toDouble("1234.5", 0) = 1234.5
	 * </pre>
	 * 
	 * @param value
	 * @param defaultValue 기본값
	 * @return
	 */
	public static double toDouble(String value, double defaultValue) {
		if (value == null) {
			return defaultValue;
		}

		try {
			return Double.parseDouble(value);
		} catch (NumberFormatException e) {
			return defaultValue;
		}
	}

	/**
	 * 문자열을 숫자(Double)형으로 변환한다.
	 * 
	 * <pre>
	 * NumberUtils.toDoubleObject(null)     = null
	 * NumberUtils.toDoubleObject("NaN")    = null
	 * NumberUtils.toDoubleObject("1234.5") = 1234.5
	 * </pre>
	 * 
	 * @param value
	 * @return
	 */
	public static Double toDoubleObject(String value) {
		if (value == null) {
			return null;
		}
		try {
			return new Double(Double.parseDouble(value));
		} catch (NumberFormatException e) {
			return null;
		}	
	}
	

	/**
	 * 문자열을 숫자(Double)형으로 변환한다.
	 * 단, 문자열은 패턴(pattern)과 일치해야한다.
	 * 패턴과 일치하지 않을 경우에는 null을 반환한다.
	 * 
	 * <pre>
	 * NumberUtils.toDoubleObject(null, *)                  = null
	 * NumberUtils.toDoubleObject("NaN", *)                 = null
	 * NumberUtils.toDoubleObject("1,234", "#,###.#")       = 1234.0
	 * NumberUtils.toDoubleObject("1,234.5", "#,###.#")     = 1234.5
	 * NumberUtils.toDoubleObject("1234.5", "#,###")        = null
	 * NumberUtils.toDoubleObject("1234.5", null)           = 1234.5
	 * </pre>
	 * 
	 * @param value
	 * @param pattern 패턴
	 * @return
	 */
	public static Double toDoubleObject(String value, String pattern) {
		if (value == null) {
			return null;
		}
		
		Double result = null;
		if (pattern != null) {
			DecimalFormat dFormat = new DecimalFormat(pattern);
			try {
				result = new Double(dFormat.parse(value).doubleValue());
				
				if (value.equals(dFormat.format(result)) == false) {
					result = null;
				}
			} catch (ParseException e) {
				// ignore
			}
		} else {
			try {
				result = new Double(Double.parseDouble(value));
			} catch (NumberFormatException e) {
				// ignore
			}
		}
		
		return result;
	}

단순히 null 체크나, 변환 실패할 경우만 체크하고 나머지는 자바에서 기본적으로 제공해주는 parserXXX를 사용해서 어려운 부분이 없으니, 설명은 생략하도록하겠다.

 별로 쓸 일은 없겠지만 unsigned int 형을 다뤄보자. 자바에는 unsigned 형이 없다. 그래서 int형을 unsigned int 형 처럼 사용할려면 i & 0xfffffffL; 연산을 이용해서 long형에 담으면 부호없는 int 형 처럼 보인다.

	/**
	 * 입력한 i값을 unsigned int로 변환한다.
	 * 자바는 unsinged int가 없기때문에 long형으로 반환한다.
	 * 
	 * <pre>
	 * NumberUtils.unsignedInt(1) 	= 1
	 * NumberUtils.unsignedInt(0) 	= 0
	 * NumberUtils.unsignedInt(-1) 	= 4294967295
	 * </pre>
	 * 
	 * @param i signed int
	 * @return unsigned int
	 */
	public static long unsignedInt(int i) {
		return i & 0xFFFFFFFFL;
	}

테스트 케이스를 만들어보자.

	@Test
	public void testUnsignedInt() {
		Assert.assertEquals(NumberUtils.unsignedInt(0xFFFFFFF0), 0xFFFFFFF0L);
		Assert.assertEquals(NumberUtils.unsignedInt(0xFFFFFFFF), 0xFFFFFFFFL);
	}

0xFFFFFFFF는 int형일 경우 -1이다. 근데 잘 보면 비교값이 0xFFFFFFFFL 이다. 'L'이란 문자가 붙는다. 이 'L'은 long 타입의 숫자란 뜻이다. 그래서 0xFFFFFFFFL = 4294967295임으로 원하는 결과가 나오게 되는것이다.

이번에 비트(bit) 연산을 한번 해볼까.
'&'(AND) 연산은 두 값이 다 1일때만 1을, 아니면 0을 나타낸다.
 예) 1011 & 1101 = 1001
'|'(OR) 연산은 두 값중 하나라도 1일때 1을, 둘다 0이면 면 0을 나타낸다.
 예) 1011 & 1101 = 1111
shift 연산
'<<' 은 비트단위만큼 왼쪽으로 이동을 한다는 뜻이다. 오른쪽은 0으로 채운다.
 예) 10111010 << 4 = 10100000
'>>' 은 비트단위만큼 오른쪽으로 이동을 한다는 뜻이다. 만일 최상위 비트가 1인 경우 왼쪽을 1로 채우고 아닐 경우 0으로 채운다.
 예) 10111010 >> 4 = 11111011
     00111010 >> 4 = 00000011
'>>>'은 비트단위만큼 오른쪽으로 이동을 한다는 뜻이다. 단, 무조건 왼쪽을 0으로 채운다.
 예) 10111010 >>> 4 = 00001011
     00111010 >>> 4 = 00000011
'~'은 보수로서 0을 1로, 1을 0으로 바꾼다.
자바에서는 shift 연산은 지원하는데, rotate 연산은 지원하지 않는다.(아마도..) 그래서 위의 연산을 가지고 roate를 구현해보자
덤으로 long형의 앞 워드(word)와 뒷 워드(word)를 추출하는것도 만들어보자.

	/**
	 * <p>
	 * long 형의 앞 워드(word=4byte)를 추출한다.
	 * </p>
	 * 
	 * @param l
	 * @return
	 */
	public static int extractW0(long l) {
		return (int) (l >> 32);
	}

	/**
	 * <p>
	 * long 형의 뒤 워드(word=4byte)를 추출한다.
	 * </p>
	 * 
	 * @param l
	 * @return
	 */
	public static int extractW1(long l) {
		return (int) l;
	}

	/**
	 * <p>
	 * 지정한 거리만큼 왼쪽으로 로테이트(rotate)한다.
	 * </p>
	 * 
	 * @param i
	 * @param distance
	 *            로테이트 할 비트 수
	 * @return
	 */
	public static int rotateLeft(int i, int distance) {
		return (i << distance) | (i >>> -distance);
	}

	/**
	 * <p>
	 * 지정한 거리만큼 오른쪽으로 로테이트(rotate)한다.
	 * </p>
	 * 
	 * @param i
	 * @param distance
	 *            로테이트 할 비트 수
	 * @return
	 */
	public static int rotateRight(int i, int distance) {
		return (i >>> distance) | (i << -distance);
	}

	/**
	 * <p>
	 * 지정한 거리만큼 왼쪽으로 로테이트(rotate)한다.
	 * </p>
	 * 
	 * 
	 * @param i
	 * @param distance
	 *            로테이트 할 비트 수
	 * @return
	 */
	public static long rotateLeft(long i, int distance) {
		return (i << distance) | (i >>> -distance);
	}

	/**
	 * <p>
	 * 지정한 거리만큼 오른쪽으로 로테이트(rotate)한다.
	 * </p>
	 * 
	 * @param i
	 * @param distance
	 *            로테이트 할 비트 수
	 * @return
	 */
	public static long rotateRight(long i, int distance) {
		return (i >>> distance) | (i << -distance);
	}

	@Test
	public void testExtractW0() {
		Assert.assertEquals(NumberUtils.extractW0(0xFFFFFFFF00000000L), 0xFFFFFFFF);
		Assert.assertEquals(NumberUtils.extractW0(0x00000001FFFFFFFFL), 0x00000001);
		Assert.assertEquals(NumberUtils.extractW0(0x00000000FFFFFFFFL), 0x00000000);
	}

	@Test
	public void testExtractW1() {
		Assert.assertEquals(NumberUtils.extractW1(0x00000000FFFFFFFFL), 0xFFFFFFFF);
		Assert.assertEquals(NumberUtils.extractW1(0xFFFFFFFF00000000L), 0x00000000);
		Assert.assertEquals(NumberUtils.extractW1(0xFFFFFFFF00000001L), 0x00000001);
	}

	@Test
	public void testRotateLeftIntInt() {
		Assert.assertEquals(NumberUtils.rotateLeft(0xF2AB34CD, 4), 0x2AB34CDF);
		Assert.assertEquals(NumberUtils.rotateLeft(0xF2AB34CD, 8), 0xAB34CDF2);
		Assert.assertEquals(NumberUtils.rotateLeft(0xF2AB34CD, 16), 0x34CDF2AB);
		Assert.assertEquals(NumberUtils.rotateLeft(0x02AB34CD, 4), 0x2AB34CD0);
	}

	@Test
	public void testRotateRightIntInt() {
		Assert.assertEquals(NumberUtils.rotateRight(0xF2AB34CD, 4), 0xDF2AB34C);
		Assert.assertEquals(NumberUtils.rotateRight(0xF2AB34CD, 8), 0xCDF2AB34);
		Assert.assertEquals(NumberUtils.rotateRight(0xF2AB34CD, 16), 0x34CDF2AB);
		Assert.assertEquals(NumberUtils.rotateRight(0x02AB34CD, 4), 0xD02AB34C);
	}

	@Test
	public void testRotateLeftLongInt() {
		Assert.assertEquals(NumberUtils.rotateLeft(0xF2AB34CD00000000L, 4), 0x2AB34CD00000000FL);
		Assert.assertEquals(NumberUtils.rotateLeft(0xF2AB34CD00000000L, 8), 0xAB34CD00000000F2L);
		Assert.assertEquals(NumberUtils.rotateLeft(0xF2AB34CD00000000L, 16), 0x34CD00000000F2ABL);
		Assert.assertEquals(NumberUtils.rotateLeft(0x02AB34CD00000000L, 4), 0x2AB34CD000000000L);
	}

	@Test
	public void testRotateRightLongInt() {
		Assert.assertEquals(NumberUtils.rotateRight(0xF2AB34CD00000000L, 4), 0x0F2AB34CD0000000L);
		Assert.assertEquals(NumberUtils.rotateRight(0xF2AB34CD00000000L, 8), 0x00F2AB34CD000000L);
		Assert.assertEquals(NumberUtils.rotateRight(0xF2AB34CD00000000L, 16), 0x0000F2AB34CD0000L);
		Assert.assertEquals(NumberUtils.rotateRight(0x02AB34CD00000000L, 4), 0x002AB34CD0000000L);
	}

NumberUtils.java

NumberUtilsTests.java