数组集合+反射

package javase.gaoxin.jishu;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Array_Reflect_Test {

    /*数组的4种初始化方式*/
    public static void main(String[] args) {
       
    int [] i = new int[]{1,2,3,4,5};//注意这种方式new Object[]中“[]”内不能写任何东西
    String [] s = {"a","b","c","d","e"};
    Object [] o1 = new Object[5];
    Object [] o2 = new Object[5];
    o2[0] = 1;
    o2[1] = 2;
    o2[2] = 3;
    o2[3] = 4;
    o2[4] = 5;
   
    String s1="aa";
   
    /*‘原始类型’的‘数组’【不能】‘转换’成‘Object类型’的【数组】*/
    //o1 = i;
   
    /*元素类型的值可以转成Object类型的，这是因为元素类型会自动转换成起包转类型，而包装类型为应用类型*/
    Object o = 8;
   
    /*而‘引用类型’的都可以转换成‘Object类型’的‘数组’，这跟引用类型都是Object的子类型道理是一样的*/
    o1 = s;
   
    //看控制台，直接打印数组时看不到数组中的内容的
    System.out.println(i);
   
    //★★★★★想【直接】就可以看到‘数组’中的元素的方法：
    System.out.println(Arrays.toString(i));
   
    //‘集合’是可以通过‘打印’【直接】就可以看到里面元素的，故‘数组’可以通过‘转换’成‘集合’，
    //然后打印集合就可以看到原来数组的元素了;
    //★★★数组转集合的方法：Arrays.asList(Object[] o)
    //★★★但是，‘原始类型（基本类型）’的数组转换成‘集合’后再打印时‘看不到’其中的元素的
    //这是因为：asList(Object[] o)需要传一个Object类型的数组，而基本类型的数组时无法转成Object数组的
    System.out.println(Arrays.asList(s));
   
    System.out.println(Arrays.asList(i));
   
   
    getObjectInfo(i);
   
    getObjectInfo(s);
   
    getObjectInfo(s1);

    }
   
    /*如何利用反射获取数组的信息？这就要用到'java.lang.reflect.Array'这个类*/
    public static void getObjectInfo(Object o){
   
    Class c = o.getClass();
   
    if(o.getClass().isArray()){
       
        int in = Array.getLength(o);
             
        for(int i1=0;i1<in;i1++){
       
            Object k = Array.get(o, i1);
           
            System.out.print(k+",");
        }
       
        System.out.println();
       
    }else{
        System.out.println(o);
    }
   
    }

}

 

package javase.gaoxin.jishu;

import java.lang.reflect.Field;

public class ReflectTest {
      
    public static void main(String[] args) {
   
    /*获得一个类的‘字节码实例'（即'类名.Class',它代表一个‘类’型在电脑中一个‘唯一’标识的字节码，注意：每个‘类’只有‘唯一’的一个这样的字节码实例）
     * 有3中方法：
     * 1)类名.Class
     * 2)类的实例.getClass()
     * 3)Class.forName(String className)
     */   
    ReflectTest1 rt = new ReflectTest1(2,3);
    Class c = rt.getClass();
    Field [] fields = c.getFields();
   
   
    for(Field field:fields){
       
        if(field.getType()==String.class){
       
        try {
            String oldV = (String)field.get(rt);
            String newV = oldV.replaceAll("b", "a");
            System.out.println(newV);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        }
        else {
        if(field.getModifiers()==1){
           
            try {
            String name = field.getName();
            Field f = c.getDeclaredField(name);//获得访问修饰符是private的’成员名‘的方法
            System.out.println(name);
            f.setAccessible(true);
            Integer y =(Integer)f.get(rt);
            System.out.println(y);//看控制台，为什么没有打印出y的值，原因是：前面用for(field:fields)这个地方就不会遍历访问修饰符为private的成员
            } catch (IllegalArgumentException e) {
            e.printStackTrace();
            } catch (SecurityException e) {
            e.printStackTrace();
            } catch (IllegalAccessException e) {
            e.printStackTrace();
            } catch (NoSuchFieldException e) {
            e.printStackTrace();
            }
           
        }
        else{
            try {
            System.out.println(field.get(rt));
            } catch (IllegalArgumentException e) {
            e.printStackTrace();
            } catch (IllegalAccessException e) {
            e.printStackTrace();
            }

        }
        }
    }
    }
   
}

 

package javase.gaoxin.jishu;

public class ReflectTest1 {
   
    public int x=0;
   
    private int y=0;
   
    public String s1="ball";
    public String s2="basketball";
    public String s3="string";
   
    public ReflectTest1(int x,int y){
    super();
    this.x=x;
    this.y=y;
    }
}