设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

实例讲解Java编程中数组反射的使用方法

2016-7-29 15:37| 发布者: zhangjf| 查看: 587| 评论: 0

摘要: 什么是反射 “反射（Reflection）能够让运行于JVM中的程序检测和修改运行时的行为。”这个概念常常会和内省（Introspection）混淆，以下是这两个术语在Wikipedia中的解释： 内省用于在运行时检测某个对象的类型和 ...

什么是反射
“反射（Reflection）能够让运行于JVM中的程序检测和修改运行时的行为。”这个概念常常会和内省（Introspection）混淆，以下是这两个术语在Wikipedia中的解释：

  • 内省用于在运行时检测某个对象的类型和其包含的属性；
  • 反射用于在运行时检测和修改某个对象的结构及其行为。
  • 从它们的定义可以看出，内省是反射的一个子集。有些语言支持内省，但并不支持反射，如C++。

内省示例：instanceof 运算符用于检测某个对象是否属于特定的类。

  2. if (obj instanceof Dog) {
  3. Dog d = (Dog) obj;
  4. d.bark();
  5. }
复制代码

反射示例：Class.forName()方法可以通过类或接口的名称（一个字符串或完全限定名）来获取对应的Class对象。forName方法会触发类的初始化。

  2. // 使用反射
  3. Class<?> c = Class.forName("classpath.and.classname");
  4. Object dog = c.newInstance();
  5. Method m = c.getDeclaredMethod("bark", new Class<?>[0]);
  6. m.invoke(dog);
复制代码

在Java中，反射更接近于内省，因为你无法改变一个对象的结构。虽然一些API可以用来修改方法和属性的可见性，但并不能修改结构。

数组的反射
数组的反射有什么用呢？何时需要使用数组的反射呢？先来看下下面的代码：

  2. Integer[] nums = {1, 2, 3, 4};
  3. Object[] objs = nums; //这里能自动的将Integer[]转成Object[]
  4. Object obj = nums; //Integer[]当然是一个Object
  5. int[] ids = {1, 2, 3, 4};
  6. //Object[] objs2 = ids; //这里不能将int[]转换成Object[]
  7. Object obj2 = ids; //int[] 是一个Object
复制代码

上面的例子表明：基本类型的一维数组只能当做Object，而不能当作Object[]。

  2. int[][] intArray = {{1, 2}, {3, 4}};
  3. Object[] oa = intArray;
  4. Object obj = intArray;
  5. //Integer[][] integerArray = intArray; int[][] 不是 Integer[][]
  6. Integer[][] integerArray2 = new Integer[][]{{1, 2}, {3, 4}};
  7. Object[][] oa2 = integerArray2;
  8. Object[] oa3 = integerArray2;
  9. Object obj2 = integerArray2;
复制代码

从上面的例子可以看出java的二位数组是数组的数组。下面来看下对数组进行反射的例子：

  2. package cn.zq.array.reflect;
  4. import java.lang.reflect.Array;
  5. import java.util.Arrays;
  6. import java.util.Random;
  8. public class ArrayReflect {
  9. public static void main(String[] args) {
  10. Random rand = new Random(47);
  11. int[] is = new int[10];
  12. for(int i = 0; i < is.length; i++) {
  13. is[i] = rand.nextInt(100);
  14. }
  15. System.out.println(is);
  16. System.out.println(Arrays.asList(is));
  17. /*以上的2个输出都是输出类似"[[I@14318bb]"的字符串，
  18. 不能显示数组内存放的内容,当然我们采用遍历的方式来输出数组内的内容*/
  19. System.out.println("--1.通过常规方式遍历数组对数组进行打印--");
  20. for(int i = 0; i < is.length; i++) {
  21. System.out.print(is[i] + " ");
  22. }
  23. System.out.println();
  24. System.out.println("--2.通过数组反射的方式遍历数组对数组进行打印--");
  25. Object obj = is; //将一维的int数组向上转为Object
  26. System.out.println("obj isArray:" + obj.getClass().isArray());
  27. for(int i = 0; i < Array.getLength(obj); i++) {
  28. int num = Array.getInt(obj, i);
  29. //也能通过这个常用的方法来获取对应索引位置的值
  30. //Object value = Array.get(obj, i); //如果数组存放的是基本类型，那么返回的是基本类型对应的包装类型
  31. System.out.print(num + " ");
  32. }
  33. }
  34. }
复制代码

输出：

  2. [I@14318bb
  3. [[I@14318bb]
  4. --1.通过常规方式遍历数组对数组进行打印--
  5. 58 55 93 61 61 29 68 0 22 7
  6. --2.通过数组反射的方式遍历数组对数组进行打印--
  7. obj isArray:true
  8. 58 55 93 61 61 29 68 0 22 7
复制代码

上面的例子首先创建了一个int的一维数组，然后随机的像里面填充0~100的整数，接着通过System.out.println()方法直接对数组输出或者用Arrays.asList方法（如果不是基本类型的一维数组此方法能按照期望转成List，如果是二维数组也不能按照我们期望转成List）将数组转成List再输出，通过都不是我们期望的输出结果。接下来以常规的数组的遍历方式来输出数组内的内容，然后将int[]看成是一个Object，利用反射来遍历其内容。Class.isArray()可以用来判断是对象是否为一个数组，假如是一个数组，那么在通过java.lang.reflect.Array这个对数组反射的工具类来获取数组的相关信息，这个类通过了一些get方法，可以用来获取数组的长度，各个版本的用来获取基本类型的一维数组的对应索引的值，通用获取值的方法get(Object array, int index)，设置值的方法，还有2个用来创建数组实例的方法。通过数组反射工具类，可以很方便的利用数组反射写出通用的代码，而不用再去判断给定的数组到底是那种基本类型的数组。

  2. package cn.zq.array.reflect;
  4. import java.lang.reflect.Array;
  6. public class NewArrayInstance {
  7. public static void main(String[] args) {
  8. Object o = Array.newInstance(int.class, 20);
  9. int[] is = (int[]) o;
  10. System.out.println("is.length = " + is.length);
  11. Object o2 = Array.newInstance(int.class, 10, 8);
  12. int[][] iss = (int[][]) o2;
  13. System.out.println("iss.length = " + iss.length
  14. + ", iss[0].lenght = " + iss[0].length);
  15. }
  16. }
  18. is.length = 20
  19. iss.length = 10, iss[0].lenght = 8
复制代码

Array总共通过了2个方法来创建数组
Object newInstance(Class componentType, int length)，根据提供的class来创建一个指定长度的数组，如果像上面那样提供int.class，长度为10，相当于new int[10];
Object newInstance(Class componentType, int... dimensions)，根据提供的class和维度来创建数组，可变参数dimensions用来指定数组的每一维的长度，像上面的例子那样相当于创建了一个new int[10][8]的二维数组，但是不能创建每一维长度都不同的多维数组。通过第一种创建数组的方法，可以像这样创建数组Object o = Array.newInstance(int[].class, 20)可以用来创建二维数组，这里相当于Object o = new int[20][];
当然通过上面例子那样来创建数组的用法是很少见的，其实也是多余的，为什么不直接通过new来创建数组呢？反射创建数组不仅速度没有new快，而且写的程序也不易读，还不如new来的直接。事实上通过反射创建数组确实很少见，是有何种变态的需求需要用反射来创建数组呢！
由于前面对基本类型的数组进行输出时遇到一些障碍，下面将利用数组反射来实现一个工具类来实现期望的输出：

  2. package cn.zq.util;
  4. import java.io.ByteArrayOutputStream;
  5. import java.io.PrintStream;
  6. import java.lang.reflect.Array;
  8. public class Print {
  9. public static void print(Object obj) {
  10. print(obj, System.out);
  11. }
  12. public static void print(Object obj, PrintStream out) {
  13. out.println(getPrintString(obj));
  14. }
  15. public static void println() {
  16. print(System.out);
  17. }
  18. public static void println(PrintStream out) {
  19. out.println();
  20. }
  21. public static void printnb(Object obj) {
  22. printnb(obj, System.out);
  23. }
  24. public static void printnb(Object obj, PrintStream out) {
  25. out.print(getPrintString(obj));
  26. }
  27. public static PrintStream format(String format, Object ... objects) {
  28. return format(System.out, format, objects);
  29. }
  30. public static PrintStream format(PrintStream out, String format, Object ... objects) {
  31. Object[] handleObjects = new Object[objects.length];
  32. for(int i = 0; i < objects.length; i++) {
  33. Object object = objects[i];
  34. if(object == null || isPrimitiveWrapper(object)) {
  35. handleObjects[i] = object;
  36. } else {
  37. ByteArrayOutputStream bos = new ByteArrayOutputStream();
  38. PrintStream ps = new PrintStream(bos);
  39. printnb(object, ps);
  40. ps.close();
  41. handleObjects[i] = new String(bos.toByteArray());
  42. }
  43. }
  44. out.format(format, handleObjects);
  45. return out;
  46. }
  47. /**
  48. * 判断给定对象是否为基本类型的包装类。
  49. * @param o 给定的Object对象
  50. * @return 如果是基本类型的包装类，则返回是，否则返回否。
  51. */
  52. private static boolean isPrimitiveWrapper(Object o) {
  53. return o instanceof Void || o instanceof Boolean
  54. || o instanceof Character || o instanceof Byte
  55. || o instanceof Short || o instanceof Integer
  56. || o instanceof Long || o instanceof Float
  57. || o instanceof Double;
  58. }
  59. public static String getPrintString(Object obj) {
  60. StringBuilder result = new StringBuilder();
  61. if(obj != null && obj.getClass().isArray()) {
  62. result.append("[");
  63. int len = Array.getLength(obj);
  64. for(int i = 0; i < len; i++) {
  65. Object value = Array.get(obj, i);
  66. result.append(getPrintString(value));
  67. if(i != len - 1) {
  68. result.append(", ");
  69. }
  70. }
  71. result.append("]");
  72. } else {
  73. result.append(String.valueOf(obj));
  74. }
  75. return result.toString();
  76. }
  77. }
复制代码

上面的Print工具类提供了一些实用的进行输出的静态方法，并且提供了一些重载版本，可以根据个人的喜欢自己编写一些重载的版本，支持基本类型的一维数组的打印以及多维数组的打印，看下下面的Print工具进行测试的示例：

  2. package cn.zq.array.reflect;
  4. import static cn.zq.util.Print.print;
  6. import java.io.PrintStream;
  8. import static cn.zq.util.Print.*;
  10. public class PrintTest {
  11. static class Person {
  12. private static int counter;
  13. private final int id = counter ++;
  14. public String toString() {
  15. return getClass().getSimpleName() + id;
  16. }
  17. }
  19. public static void main(String[] args) throws Exception {
  20. print("--打印非数组--");
  21. print(new Object());
  22. print("--打印基本类型的一维数组--");
  23. int[] is = new int[]{1, 22, 31, 44, 21, 33, 65};
  24. print(is);
  25. print("--打印基本类型的二维数组--");
  26. int[][] iss = new int[][]{
  27. {11, 12, 13, 14},
  28. {21, 22,},
  29. {31, 32, 33}
  30. };
  31. print(iss);
  32. print("--打印非基本类型的一维数组--");
  33. Person[] persons = new Person[10];
  34. for(int i = 0; i < persons.length; i++) {
  35. persons[i] = new Person();
  36. }
  37. print(persons);
  38. print("--打印非基本类型的二维数组--");
  39. Person[][] persons2 = new Person[][]{
  40. {new Person()},
  41. {new Person(), new Person()},
  42. {new Person(), new Person(), new Person(),},
  43. };
  44. print(persons2);
  45. print("--打印empty数组--");
  46. print(new int[]{});
  47. print("--打印含有null值的数组--");
  48. Object[] objects = new Object[]{
  49. new Person(), null, new Object(), new Integer(100)
  50. };
  51. print(objects);
  52. print("--打印特殊情况的二维数组--");
  53. Object[][] objects2 = new Object[3][];
  54. objects2[0] = new Object[]{};
  55. objects2[2] = objects;
  56. print(objects2);
  57. print("--将一维数组的结果输出到文件--");
  58. PrintStream out = new PrintStream("out.c");
  59. try {
  60. print(iss, out);
  61. } finally {
  62. out.close();
  63. }
  64. print("--格式化输出--");
  65. format("%-6d%s %B %s", 10086, "is", true, iss);
  66. /**
  67. * 上面列出了一些Print工具类的一些常用的方法，
  68. * 还有一些未列出的方法，请自行查看。
  69. */
  70. }
  71. }
复制代码

输出：

  2. --打印非数组--
  3. java.lang.Object@61de33
  4. --打印基本类型的一维数组--
  5. [1, 22, 31, 44, 21, 33, 65]
  6. --打印基本类型的二维数组--
  7. [[11, 12, 13, 14], [21, 22], [31, 32, 33]]
  8. --打印非基本类型的一维数组--
  9. [Person0, Person1, Person2, Person3, Person4, Person5, Person6, Person7, Person8, Person9]
  10. --打印非基本类型的二维数组--
  11. [[Person10], [Person11, Person12], [Person13, Person14, Person15]]
  12. --打印empty数组--
  13. []
  14. --打印含有null值的数组--
  15. [Person16, null, java.lang.Object@ca0b6, 100]
  16. --打印特殊情况的二维数组--
  17. [[], null, [Person16, null, java.lang.Object@ca0b6, 100]]
  18. --将一维数组的结果输出到文件--
  19. --格式化输出--
  20. 10086 is TRUE [[11, 12, 13, 14], [21, 22], [31, 32, 33]]
复制代码

输出文件：

2016425142151040.png (1111×352)

可见Print工具类已经具备打印基本类型的一维数组以及多维数组的能力了，总体来说上面的工具类还是挺实用的，免得每次想要看数组里面的内容都有手动的去编写代码，那样是在是太麻烦了，以后直接把Print工具类拿过去用就行了，多么的方便啊。
上面的工具类确实能很好的工作，但是假如有这样一个需求：给你一个数组（也有可能是其他的容器），你给我整出一个List。那么我们应该怎样做呢？事实上Arrays.asList不总是能得到我们所期望的结果，java5虽然添加了泛型，但是是有限制的，并不能像c++的模板那样通用，正是因为java中存在基本类型，即使有自动包装的机制，与泛型一起并不能使用，参数类型必须是某种类型，而不能是基本类型。下面给出一种自己的解决办法：

  2. package cn.zq.util;
  4. import java.lang.reflect.Array;
  5. import java.util.ArrayList;
  6. import java.util.Arrays;
  7. import java.util.Enumeration;
  8. import java.util.Iterator;
  9. import java.util.List;
  10. import java.util.Map;
  12. public class CollectionUtils {
  14. public static List<?> asList(Object obj) {
  15. return convertToList(
  16. makeIterator(obj));
  17. }
  18. public static <T>List<T> convertToList(Iterator<T> iterator) {
  19. if(iterator == null) {
  20. return null;
  21. }
  22. List<T> list = new ArrayList<T>();
  23. while(iterator.hasNext()) {
  24. list.add(iterator.next());
  25. }
  26. return list;
  27. }
  28. @SuppressWarnings({ "rawtypes", "unchecked" })
  29. public static Iterator<?> makeIterator(Object obj) {
  30. if(obj instanceof Iterator) {
  31. return (Iterator<?>) obj;
  32. }
  33. if(obj == null) {
  34. return null;
  35. }
  36. if(obj instanceof Map) {
  37. obj = ((Map<?, ?>)obj).entrySet();
  38. }
  40. Iterator<?> iterator = null;
  41. if(obj instanceof Iterable) {
  42. iterator = ((Iterable<?>)obj).iterator();
  43. } else if(obj.getClass().isArray()) {
  44. //Object[] objs = (Object[]) obj; //原始类型的一位数组不能这样转换
  45. ArrayList list = new ArrayList(Array.getLength(obj));
  46. for(int i = 0; i < Array.getLength(obj); i++) {
  47. list.add(Array.get(obj, i));
  48. }
  49. iterator = list.iterator();
  50. } else if(obj instanceof Enumeration) {
  51. iterator = new EnumerationIterator((Enumeration) obj);
  52. } else {
  53. iterator = Arrays.asList(obj).iterator();
  54. }
  55. return iterator;
  56. }
  58. public static class EnumerationIterator<T> implements Iterator<T> {
  59. private Enumeration<T> enumeration;
  60. public EnumerationIterator(Enumeration<T> enumeration) {
  61. this.enumeration = enumeration;
  62. }
  63. public boolean hasNext() {
  64. return enumeration.hasMoreElements();
  65. }
  66. public T next() {
  67. return enumeration.nextElement();
  68. }
  69. public void remove() {
  70. throw new UnsupportedOperationException();
  71. }
  72. }
  73. }
复制代码

测试代码：

  2. package cn.zq.array.reflect;
  4. import java.util.Iterator;
  5. import java.util.List;
  7. import cn.zq.array.reflect.PrintTest.Person;
  8. import cn.zq.util.CollectionUtils;
  10. public class CollectionUtilsTest {
  11. public static void main(String[] args) {
  12. System.out.println("--基本类型一维数组--");
  13. int[] nums = {1, 3, 5, 7, 9};
  14. List<?> list = CollectionUtils.asList(nums);
  15. System.out.println(list);
  16. System.out.println("--非基本类型一维数组--");
  17. Person[] persons = new Person[]{
  18. new Person(),
  19. new Person(),
  20. new Person(),
  21. };
  22. List<Person> personList = (List<Person>) CollectionUtils.asList(persons);
  23. System.out.println(personList);
  24. System.out.println("--Iterator--");
  25. Iterator<Person> iterator = personList.iterator();
  26. List<Person> personList2 = (List<Person>) CollectionUtils.asList(iterator);
  27. System.out.println(personList2);
  29. }
  30. }
复制代码

输出：

  2. --基本类型一维数组--
  3. [1, 3, 5, 7, 9]
  4. --非基本类型一维数组--
  5. [Person0, Person1, Person2]
  6. --Iterator--
  7. [Person0, Person1, Person2]
复制代码

在java的容器类库中可以分为Collection，Map，数组，由于Iterator(以及早期的遗留接口Enumeration)是所有容器的通用接口并且Collection接口从Iterable(该接口的iterator将返回一个Iterator)，所以在makeIterator方法中对这些情形进行了一一的处理，对Map类型，只需要调用其entrySet()方法，对于实现了Iterable接口的类(Collection包含在内)，调用iterator()直接得到Iterator对象，对于Enumeration类型，利用适配器EnumerationIterator进行适配，对于数组，利用数组反射遍历数组放入ArrayList中，对于其他的类型调用Arrays.asList()方法创建一个List。CollectionUtils还提供了一些其他的方法来进行转换，可以根据需要添加自己需要的方法。

总结：数组的反射对于那些可能出现数组的设计中提供更方便、更灵活的方法，以免写那些比较麻烦的判断语句，这种灵活性付出的就是性能的代价，对于那些根本不需要数组反射的情况下用数组的反射实在是不应该。是否使用数组的反射，在实际的开发中仁者见仁智者见智，根据需要来选择是否使用数组的反射，最好的方式就是用实践来探路，先按照自己想到的方式去写，在实践中不断的完善。

收藏 邀请
上一篇：Java设计模式开发中使用观察者模式的实例教程下一篇：Java设计模式编程之解释器模式的简单讲解

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-5-6 09:37

Copyright 2015-2025 djqfx

返回顶部