在通过反射列出一个对象的所有域的字符串形式的测试中,在对结果的比较过程中,遇到了这个关键词修饰的域,有时间再好好研究一下:
public class ObjectAnalyzer {
private ArrayList<Object> visited = new ArrayList<>();
/**
* 将对象转换为 列出所有域的字符串形式
* @param obj 一个对象
* @return 包含对象的类名和所有域名和值 的字符串
*/
public String toString(Object obj)
{
if(obj == null)
return "null";
if(visited.contains(obj))
return "...";
visited.add(obj);
Class c1 = obj.getClass();
if(c1 == String.class)
return (String)obj;
if(c1.isArray())
{
//component--n:组成部分; 成分; 部件;adj:成分的; 组成的; 合成的; 构成的;
//getComponentType()返回数组中元素的Class对象,如果不是Class对象那么返回null
String r = "falg" + c1.getComponentType() + "[]{ArrayList中的object数组:";
for(int i = 0;i < Array.getLength(obj); i++) {
if(i > 0)
r += ",";
Object val = Array.get(obj, i);
if(c1.getComponentType().isPrimitive())
r += val;
else
r += toString(val);
}
return r + "数组遍历完毕}";
}
String r = c1.getName();
do {
r += "[";
Field[] fields = c1.getDeclaredFields();
AccessibleObject.setAccessible(fields, true);//获得访问控制权限,否则下面的get方法将会抛出一个illegalAccessException
//获取所有域的名字和值(即属性名和属性值)
for(Field field : fields)
{
if(!Modifier.isStatic(field.getModifiers())) {//如果域不是静态的——————多打的两个空是父类的域,但是是空的
if(!r.endsWith("[")) //不是刚开始,加分隔符“,”
r += ",";
r += field.getName() + "=";
try {
Class t = field.getType(); //获取域的类型
Object val = field.get(obj); //获取拥有这个域的对象的值
if(t.isPrimitive()) //如果域的类型是基本数据类型(八大基本类型)
r += val;
else
r += toString(val); //基本数据类型需要强转
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}
if(r.endsWith("["))
r += "父类被过滤的静态域";
r += "]";
c1 = c1.getSuperclass(); //再获取父类的域信息
}while(c1 != null);
return r;
}
public static void main(String[] args) {
ReflectionTest test = new ReflectionTest();
ArrayList<Integer> squares = new ArrayList<>();
for(int i = 1; i <= 5; i++) {
squares.add(i * i);
}
//System.out.println(Object.class.getSuperclass().getName());
String str = "hello world!";
Object aObject = str;
System.out.println(aObject.getClass().getComponentType());
System.out.println(new ObjectAnalyzer().toString(squares));
}
}
null
java.util.ArrayList[elementData=falgclass java.lang.Object[]{ArrayList中的object数组:java.lang.Integer[value=1][父类被过滤的静态域][父类被过滤的静态域],java.lang.Integer[value=4][父类被过滤的静态域][父类被过滤的静态域],java.lang.Integer[value=9][父类被过滤的静态域][父类被过滤的静态域],java.lang.Integer[value=16][父类被过滤的静态域][父类被过滤的静态域],java.lang.Integer[value=25][父类被过滤的静态域][父类被过滤的静态域],null,null,null,null,null数组遍历完毕},size=5][modCount=5][父类被过滤的静态域][父类被过滤的静态域]
ArrayList中
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
* will be expanded to DEFAULT_CAPACITY when the first element is added.
*/
transient Object[] elementData; // non-private to simplify nested class access
在抽象类AbstractList中发现
/**
* The number of times this list has been <i>structurally modified</i>.
* Structural modifications are those that change the size of the
* list, or otherwise perturb it in such a fashion that iterations in
* progress may yield incorrect results.
*
* <p>This field is used by the iterator and list iterator implementation
* returned by the {@code iterator} and {@code listIterator} methods.
* If the value of this field changes unexpectedly, the iterator (or list
* iterator) will throw a {@code ConcurrentModificationException} in
* response to the {@code next}, {@code remove}, {@code previous},
* {@code set} or {@code add} operations. This provides
* <i>fail-fast</i> behavior, rather than non-deterministic behavior in
* the face of concurrent modification during iteration.
*
* <p><b>Use of this field by subclasses is optional.</b> If a subclass
* wishes to provide fail-fast iterators (and list iterators), then it
* merely has to increment this field in its {@code add(int, E)} and
* {@code remove(int)} methods (and any other methods that it overrides
* that result in structural modifications to the list). A single call to
* {@code add(int, E)} or {@code remove(int)} must add no more than
* one to this field, or the iterators (and list iterators) will throw
* bogus {@code ConcurrentModificationExceptions}. If an implementation
* does not wish to provide fail-fast iterators, this field may be
* ignored.
*/
protected transient int modCount = 0;
后记:这个关键字是为了不被序列化定义的,在序列化反序列化传输的时候,不会序列化它。