精华内容
下载资源
问答
  • #re: xstream 解析xml 别名 注解 list集合 boolean 数组 converter Pom.xml设置回复更多评论2013-03-27 17:30 by hello_kittyCALCULATEcaihongcheng10truefalsefalsefalsefalsefalsefalsefalsefalsefalse一开始有一...

    # re: xstream 解析xml 别名 注解 list集合 boolean 数组 converter Pom.xml设置  回复  更多评论

    2013-03-27 17:30 by hello_kitty

    CALCULATE

    caihongcheng

    10

    true

    false

    false

    false

    false

    false

    false

    false

    false

    false

    一开始有一个boolean类型的数组,我把它添加到一个list里面,想通过xstream遍历成xml。(源代码:

    ArrayList list = new ArrayList();

    list.add("CALCULATE");

    list.add("caihongcheng");

    list.add(10);

    list.add(status);//status为boolean数组

    )

    求大神给写段代码让上面的数组变成下面那样的,可以把代码发给我邮箱:513110286@qq.com,不胜感谢!

    CALCULATE

    caihongcheng

    20

    true

    false

    false

    false

    false

    false

    false

    false

    false

    false

    展开全文
  • 根据CopyModel对未完成的Java文件(class类)添加包名、import、extends、implements、注解等** @param oldFile* @param classDecorateModel** 组件名* 文件名* 包名* 父类全名(包括包名)* 方法字符串* String[] 接口...

    /**

    * 根据CopyModel对未完成的Java文件(class类)添加包名、import、extends、implements、注解等

    *

    * @param oldFile

    * @param classDecorateModel

    *

    * 组件名

    * 文件名

    * 包名

    * 父类全名(包括包名)

    * 方法字符串

    * String[] 接口全名(包括包名)数组

    * String[] import 全名(包括包名)数组

    *

    * Map>

    * Map>

    * Map>

    *

    * @return

    */

    public static File decorateFileByCopyModel(File oldFile, ClassDecorateModel classDecorateModel){

    String oldFileName = oldFile.getName().replace(".java", "");

    // 新建文件的名

    String tempFileName = oldFileName + System.currentTimeMillis();

    String absolutePath = oldFile.getAbsolutePath();

    absolutePath = absolutePath.substring(0, absolutePath.lastIndexOf("\\"));

    File newFile = new File(absolutePath + "\\" + tempFileName);

    try {

    newFile.createNewFile();

    // 读取文件到FileInputStream中

    FileInputStream fileInputStream = new FileInputStream(oldFile);

    // 读取FileInputStream到InputStreamReader中,然后再读取到BufferedReader中

    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(fileInputStream));

    // 新建的文件绑定到FileOutputStream上

    FileOutputStream fileOutputStream = new FileOutputStream(newFile);

    // 把FileOutputStream绑定到PrintWriter上

    PrintWriter printWriter = new PrintWriter(fileOutputStream);

    String packageName = classDecorateModel.getPackageName(), fileName;

    if(packageName == null || "".equals(packageName)){

    // 按行从BufferedReader中读取代码

    String thisLine, packageLine;

    while((thisLine = bufferedReader.readLine()) != null){

    // 输出包名和导入项

    if(thisLine.startsWith("package ")){

    packageLine = thisLine.substring(0, thisLine.indexOf(";"));

    packageName = packageLine.replace("package ", "");

    break;

    }

    }

    }

    bufferedReader.close();

    // 获取源文件的class对象

    fileName = oldFile.getName().substring(0, oldFile.getName().indexOf("."));

    Class> classFile = Class.forName(packageName + "." + fileName);

    // 文件中所有注解 Map>>

    Map>> existsNameAnnotationMap = ClassAnnotationParse.generateAnnotationParse((Class>)classFile);

    fileInputStream = new FileInputStream(oldFile);

    BufferedReader inputBufferedReader = new BufferedReader(new InputStreamReader(fileInputStream));

    // 导入语句

    List importStrList = new ArrayList();

    String[] importArray = classDecorateModel.getImportArray();

    if(importArray != null){

    for(String importStr : importArray){

    importStrList.add(importStr);

    }

    }

    // 父类名

    String parentClassName = classDecorateModel.getParentFullClassName();

    String simpleParentName = null;

    if(parentClassName != null && !"".equals(parentClassName)){

    // 添加到import语句

    if(!importStrList.contains("import " + parentClassName + ";")){

    importStrList.add("import " + parentClassName + ";");

    }

    simpleParentName = parentClassName.substring(parentClassName.lastIndexOf(".") + 1, parentClassName.length());

    }

    // 接口名

    String[] interfaceNameArray = classDecorateModel.getImplementsArray();

    StringBuffer interfaceBuffer = null;

    if(interfaceNameArray != null){

    interfaceBuffer = new StringBuffer();

    String simpleInterfaceName;

    for(String interfaceName : interfaceNameArray){

    simpleInterfaceName = interfaceName.substring(interfaceName.lastIndexOf(".") + 1, interfaceName.length());

    if(!interfaceBuffer.equals("")){

    interfaceBuffer.append(",");

    }

    interfaceBuffer.append(simpleInterfaceName);

    // 添加到import语句

    if(!importStrList.contains("import " + interfaceName + ";")){

    importStrList.add("import " + interfaceName + ";");

    }

    }

    }

    // Map

    // Map

    // Map

    Map toAddAnnotationModelMap = classDecorateModel.getAnnotationMap();

    Map toAddAttrMap = null;

    AnnotationModel[] toAddAnnotationArray = null;

    Map> existsAnnotationMap = null, newAnnotationMap = null;

    Map existsAnnoAttrMap = null, newMap = null;

    boolean existsAnnoFlag = false, existsAnnoAttrFlag = false;

    String toAddSimpleAnnoName, methodNamePara = null, attributeName, packClassName;

    if(toAddAnnotationModelMap != null){

    String toAddKey;

    for(Entry toAddAnnotationModelEntry : toAddAnnotationModelMap.entrySet()){

    // 本类所有要添加的注解

    toAddAnnotationArray = toAddAnnotationModelEntry.getValue();

    // 循环注解

    for(AnnotationModel annotationModel : toAddAnnotationArray){

    // 添加到import列表中

    if(!importStrList.contains("import " + annotationModel.getAnnotationFullName() + ";")){

    String fa = annotationModel.getAnnotationFullName();

    fa = "import " + fa + ";";

    importStrList.add(fa);

    }

    }

    // key 属性 方法 或类本身

    toAddKey = toAddAnnotationModelEntry.getKey();

    // Map

    if(toAddKey.contains("Method-")){

    // 方法名##参数类型,参数名-参数类型,参数名

    methodNamePara = toAddKey.split("-")[1];

    // 获取类中该方法本来就有的注解 Map>

    existsAnnotationMap = existsNameAnnotationMap.get(methodNamePara);

    for(AnnotationModel toAddAnnotationModel : toAddAnnotationArray){

    // 类中是否已经含有要添加的注解类

    existsAnnoFlag = false;

    existsAnnoAttrFlag = false;

    if(existsAnnotationMap != null){

    for(Entry> existsAnnotationEntry : existsAnnotationMap.entrySet()){

    // 类中已经存在该注解类

    if(toAddAnnotationModel.getAnnotationFullName().equals(existsAnnotationEntry.getKey())){

    // 已存在注解类的所有属性 Map

    existsAnnoAttrMap = existsAnnotationEntry.getValue();

    // 要添加的该注解类的属性 Map

    toAddAttrMap = toAddAnnotationModel.getAttrMap();

    for(Entry toAddAttrEntry : toAddAttrMap.entrySet()){

    existsAnnoAttrFlag = false;

    for(Entry existsAnnoAttrEntry : existsAnnoAttrMap.entrySet()){

    // 已经存在该属性

    if(existsAnnoAttrEntry.getKey().equals(toAddAttrEntry.getKey())){

    existsAnnoAttrEntry.setValue(toAddAttrEntry.getValue());

    existsAnnoAttrFlag = true;

    break;

    }

    }

    // 不存在该属性

    if(!existsAnnoAttrFlag){

    existsAnnoAttrMap.put(toAddAttrEntry.getKey(), toAddAttrEntry.getValue());

    }

    }

    existsAnnoFlag = true;

    break;

    }

    }

    }

    // 不含有要添加的注解类

    if(!existsAnnoFlag){

    // Map>

    newAnnotationMap = new HashMap>();

    // 注解类的属性

    if(toAddAnnotationModel.getAttrMap() != null && toAddAnnotationModel.getAttrMap().size() > 0){

    // Map

    newMap = new HashMap();

    for(Entry toAddAttrEntry : toAddAnnotationModel.getAttrMap().entrySet()){

    newMap.put(toAddAttrEntry.getKey(), toAddAttrEntry.getValue());

    }

    newAnnotationMap.put(toAddAnnotationModel.getAnnotationFullName(), newMap);

    }

    if(existsAnnotationMap != null){

    // 添加以前就存在的注解

    for(Entry> entry : existsAnnotationMap.entrySet()){

    newAnnotationMap.put(entry.getKey(), entry.getValue());

    }

    }

    existsNameAnnotationMap.put(methodNamePara, newAnnotationMap);

    }

    }

    // TODO 由Map改为Map

    // Map

    } else if(toAddKey.contains("Attribute-") || toAddKey.contains("Collection-")){

    // 方法名##参数类型,参数名-参数类型,参数名

    attributeName = toAddKey.split("-")[1];

    // 获取类中该属性本来就有的注解 Map>

    existsAnnotationMap = existsNameAnnotationMap.get(attributeName);

    for(AnnotationModel toAddAnnotationModel : toAddAnnotationArray){

    // 类中是否已经含有要添加的注解类

    existsAnnoFlag = false;

    existsAnnoAttrFlag = false;

    toAddSimpleAnnoName = toAddAnnotationModel.getAnnotationFullName().substring(toAddAnnotationModel.getAnnotationFullName().lastIndexOf(".")+1, toAddAnnotationModel.getAnnotationFullName().length());

    if(existsAnnotationMap != null){

    for(Entry> existsAnnotationEntry : existsAnnotationMap.entrySet()){

    // 类中已经存在该注解类

    if(toAddAnnotationModel.getAnnotationFullName().equals(existsAnnotationEntry.getKey())){

    // 已存在注解类的所有属性 Map

    existsAnnoAttrMap = existsAnnotationEntry.getValue();

    // 要添加的该注解类的属性 Map

    toAddAttrMap = toAddAnnotationModel.getAttrMap();

    for(Entry toAddAttrEntry : toAddAttrMap.entrySet()){

    existsAnnoAttrFlag = false;

    for(Entry existsAnnoAttrEntry : existsAnnoAttrMap.entrySet()){

    // 已经存在该属性

    if(existsAnnoAttrEntry.getKey().equals(toAddAttrEntry.getKey())){

    existsAnnoAttrEntry.setValue(toAddAttrEntry.getValue());

    existsAnnoAttrFlag = true;

    break;

    }

    }

    // 不存在该属性

    if(!existsAnnoAttrFlag){

    existsAnnoAttrMap.put(toAddAttrEntry.getKey(), toAddAttrEntry.getValue());

    }

    }

    existsAnnoFlag = true;

    break;

    }

    }

    }

    // 不含有要添加的注解类

    if(!existsAnnoFlag){

    // Map>

    newAnnotationMap = new HashMap>();

    // 注解类的属性

    if(toAddAnnotationModel.getAttrMap() != null && toAddAnnotationModel.getAttrMap().size() > 0){

    // Map

    newMap = new HashMap();

    for(Entry toAddAttrEntry : toAddAnnotationModel.getAttrMap().entrySet()){

    newMap.put(toAddAttrEntry.getKey(), toAddAttrEntry.getValue());

    }

    newAnnotationMap.put(toAddAnnotationModel.getAnnotationFullName(), newMap);

    }

    if(existsAnnotationMap != null){

    // 添加以前就存在的注解

    for(Entry> entry : existsAnnotationMap.entrySet()){

    newAnnotationMap.put(entry.getKey(), entry.getValue());

    }

    }

    existsNameAnnotationMap.put(attributeName, newAnnotationMap);

    }

    }

    // TODO 由Map改为Map

    // Map

    } else if(toAddKey.contains("ClassName-")){

    // 包名.类名

    packClassName = toAddKey.split("-")[1];

    // 获取类本身本来就有的注解 Map>

    existsAnnotationMap = existsNameAnnotationMap.get(packClassName);

    for(AnnotationModel toAddAnnotationModel : toAddAnnotationArray){

    // 类中是否已经含有要添加的注解类

    existsAnnoFlag = false;

    existsAnnoAttrFlag = false;

    toAddSimpleAnnoName = toAddAnnotationModel.getAnnotationFullName().substring(toAddAnnotationModel.getAnnotationFullName().indexOf(".")+1, toAddAnnotationModel.getAnnotationFullName().length());

    if(existsAnnotationMap != null){

    for(Entry> existsAnnotationEntry : existsAnnotationMap.entrySet()){

    // 类中已经存在该注解类

    if(toAddAnnotationModel.getAnnotationFullName().equals(existsAnnotationEntry.getKey())){

    // 已存在注解类的所有属性 Map

    existsAnnoAttrMap = existsAnnotationEntry.getValue();

    // 要添加的该注解类的属性 Map

    toAddAttrMap = toAddAnnotationModel.getAttrMap();

    for(Entry toAddAttrEntry : toAddAttrMap.entrySet()){

    existsAnnoAttrFlag = false;

    for(Entry existsAnnoAttrEntry : existsAnnoAttrMap.entrySet()){

    // 已经存在该属性

    if(existsAnnoAttrEntry.getKey().equals(toAddAttrEntry.getKey())){

    existsAnnoAttrEntry.setValue(toAddAttrEntry.getValue());

    existsAnnoAttrFlag = true;

    break;

    }

    }

    // 不存在该属性

    if(!existsAnnoAttrFlag){

    existsAnnoAttrMap.put(toAddAttrEntry.getKey(), toAddAttrEntry.getValue());

    }

    }

    existsAnnoFlag = true;

    break;

    }

    }

    }

    // 不含有要添加的注解类

    if(!existsAnnoFlag){

    // Map>

    newAnnotationMap = new HashMap>();

    // 注解类的属性

    if(toAddAnnotationModel.getAttrMap() != null && toAddAnnotationModel.getAttrMap().size() > 0){

    // Map

    newMap = new HashMap();

    for(Entry toAddAttrEntry : toAddAnnotationModel.getAttrMap().entrySet()){

    newMap.put(toAddAttrEntry.getKey(), toAddAttrEntry.getValue());

    }

    newAnnotationMap.put(toAddSimpleAnnoName, newMap);

    }

    if(existsAnnotationMap != null){

    // 添加以前就存在的注解

    for(Entry> entry : existsAnnotationMap.entrySet()){

    newAnnotationMap.put(entry.getKey(), entry.getValue());

    }

    }

    existsNameAnnotationMap.put(packClassName, newAnnotationMap);

    }

    }

    }

    }

    }

    // Map>>

    Map>> allNameAnnotationMap = new HashMap>>();

    Map> oldAllAnnoMap = new HashMap>();

    Map> allAnnoMap = null;

    Map newSubMap = new HashMap();

    String annoFullName, annoSimpleName, annoAttrValueName, annoAttrValueSimpleName;

    // Map>>

    for(Entry>> entry : existsNameAnnotationMap.entrySet()){

    oldAllAnnoMap = entry.getValue();

    allAnnoMap = new HashMap>();

    for(Entry> subEntry : oldAllAnnoMap.entrySet()){

    annoFullName = subEntry.getKey();

    if(!importStrList.contains("import " + annoFullName + ";")){

    importStrList.add("import " + annoFullName + ";");

    }

    Map subMap = subEntry.getValue();

    newSubMap = new HashMap();

    for(Entry subSubEntry : subMap.entrySet()){

    // 属性值枚举类型

    if(subSubEntry.getKey().split("-").length == 3 && (subSubEntry.getKey().split("-")[2]).equals("Enum")){

    annoAttrValueName = ((String)subSubEntry.getValue()).substring(0, ((String)subSubEntry.getValue()).lastIndexOf("."));

    if(!importStrList.contains("import " + annoAttrValueName + ";")){

    importStrList.add("import " + annoAttrValueName + ";");

    }

    annoAttrValueSimpleName = ((String)subSubEntry.getValue()).replace(annoAttrValueName.substring(0, annoAttrValueName.lastIndexOf(".")) + ".", "");

    newSubMap.put(subSubEntry.getKey(), annoAttrValueSimpleName);

    } else {

    newSubMap.put(subSubEntry.getKey(), subSubEntry.getValue());

    }

    }

    annoSimpleName = annoFullName.substring(annoFullName.lastIndexOf(".") + 1, annoFullName.length());

    allAnnoMap.put(annoSimpleName, newSubMap);

    }

    allNameAnnotationMap.put(entry.getKey(), allAnnoMap);

    }

    String thisLine, tempStr, oldParentName = null, oldInterfaceNameStr = null, componentName, importStr;

    String[] decorateArray, keyStrArray = null, keyParaArray;

    boolean annotationFlag = false, bracketCloseFlag = true;

    StringBuffer fileAnnoBuffer = new StringBuffer(), paraBuffer, keyBuffer = null;

    Map> classAnnotationMap = null, annoMap;

    int leftBarckets = 0, rightBarckets = 0, accessModifierIndex, transientIndex, staticIndex, finalIndex, nameIndex, typeIndex, volatileIndex, synchronizedIndex, abstractIndex, nativeIndex, strictIndex;

    Map classAnnoAttrMap = null;

    Class>[] paraClassArray = null;

    Class> paraClass = null;

    Field[] fieldArray;

    Method[] methodArray;

    // 按行从BufferedReader中读取代码

    while((thisLine = inputBufferedReader.readLine()) != null){

    // 输出包名和导入项

    if(thisLine.startsWith("package ")){

    // 把包名输出到PrintWriter中

    componentName = classDecorateModel.getComponentName();

    if(componentName != null && !"".equals(componentName)){

    printWriter.println("package " + componentName + "." + packageName + ";");

    } else if(componentName == null || !"".equals(componentName)){

    printWriter.println("package " + packageName + ";");

    }

    printWriter.println("");

    // 把importStrList中所有import语句输出到PrintWriter中

    for(int i=0;i

    importStr = importStrList.get(i);

    if(i == importStrList.size() - 1){

    printWriter.print(importStr);

    } else {

    printWriter.println(importStr);

    }

    }

    // 如果该行不是空行

    } else if(!"".equals(thisLine.trim())){

    // 注解里面

    if(!bracketCloseFlag){

    fileAnnoBuffer.append(thisLine.trim());

    leftBarckets = leftBarckets + CommonUtility.stringNumbers(thisLine, "(");

    rightBarckets = rightBarckets + CommonUtility.stringNumbers(thisLine, ")");

    if(rightBarckets == leftBarckets){

    bracketCloseFlag = true;

    rightBarckets = 0;

    leftBarckets = 0;

    }

    // 该行是注解

    } else if(thisLine.trim().startsWith("@")){

    // 第一行注解

    if(!annotationFlag){

    annotationFlag = true;

    }

    leftBarckets = CommonUtility.stringNumbers(thisLine, "(");

    rightBarckets = CommonUtility.stringNumbers(thisLine, ")");

    if(leftBarckets != rightBarckets){

    bracketCloseFlag = false;

    }

    } else {

    // 如果该行是类名行,添加该行上的所有注解

    if(thisLine.contains(" class " + oldFileName)){

    printWriter.println("");

    // 获取本身的注解 Map>

    classAnnotationMap = allNameAnnotationMap.get(packageName + "." + oldFileName);

    // Map 输出

    if(classAnnotationMap != null && classAnnotationMap.size() > 0){

    for(Entry> classAnnotationEntry : classAnnotationMap.entrySet()){

    printWriter.println("@"+ classAnnotationEntry.getKey() + "(");

    classAnnoAttrMap = classAnnotationEntry.getValue();

    // 输出注解属性和属性值

    printAnnotationAttrValue(classAnnoAttrMap, printWriter);

    printWriter.println(")");

    }

    }

    // 把类名行解析成字符串数组

    decorateArray = thisLine.split(" ");

    if(simpleParentName != null && !"".equals(simpleParentName)){

    // 该类有父类

    if(thisLine.contains(" extends ")){

    for(int i=0;i

    tempStr = decorateArray[i];

    if("extends".equals(tempStr)){

    oldParentName = decorateArray[i+1];

    break;

    }

    }

    thisLine = thisLine.replace(oldParentName, simpleParentName);

    // 该类没有父类

    } else {

    thisLine = thisLine.replace(oldFileName, oldFileName + " extends " + simpleParentName);

    }

    }

    // 接口

    if(interfaceBuffer != null){

    // 该类有接口

    if(thisLine.contains(" implements ")){

    for(int i=0;i

    tempStr = decorateArray[i];

    if("implements".equals(tempStr)){

    oldInterfaceNameStr = decorateArray[i+1];

    break;

    }

    }

    thisLine = thisLine.replace(oldInterfaceNameStr, oldInterfaceNameStr + ", " + interfaceBuffer.toString());

    // 该类没有接口

    } else {

    thisLine = thisLine.replace("{", oldFileName + " implements " + interfaceBuffer.toString() + " {");

    }

    }

    // 把该行代码输出到PrintWriter中

    printWriter.println(thisLine);

    // 添加方法

    if(classDecorateModel.getMethodStr() != null && !"".equals(classDecorateModel.getMethodStr())){

    printWriter.println("");

    printWriter.println(classDecorateModel.getMethodStr());

    printWriter.println("");

    }

    // 该行是import行

    } else if(thisLine.startsWith("import ")){

    // 如果importStrList中不包含该import行

    if(!importStrList.contains(thisLine)){

    printWriter.println(thisLine);

    }

    // 该行是空行

    } else if(thisLine.trim().equals("")){

    printWriter.println("");

    // 该行不是类名行、导入行、package行、空行、注解行

    } else {

    // 获取并输出源文件的所有字段

    fieldArray = classFile.getDeclaredFields();

    for(Field field : fieldArray){

    field.setAccessible(true);

    nameIndex = thisLine.indexOf(field.getName());

    typeIndex = thisLine.indexOf(field.getType().getSimpleName());

    if(nameIndex != -1 && typeIndex != -1 && typeIndex < nameIndex){

    // 访问权限

    if(field.getModifiers() == 2){// private

    accessModifierIndex = thisLine.indexOf("private ");

    if(accessModifierIndex == -1 || accessModifierIndex > typeIndex){

    continue;

    }

    } else if(field.getModifiers() == 4){// protected

    accessModifierIndex = thisLine.indexOf("protected ");

    if(accessModifierIndex == -1 || accessModifierIndex > typeIndex){

    continue;

    }

    } else if(field.getModifiers() == 1){// public

    accessModifierIndex = thisLine.indexOf("public ");

    if(accessModifierIndex == -1 || accessModifierIndex > typeIndex){

    continue;

    }

    }

    // 修饰符

    if(field.getModifiers() == 128){// transient

    transientIndex = thisLine.indexOf("transient ");

    if(transientIndex == -1 || transientIndex > typeIndex){

    continue;

    }

    }

    if(field.getModifiers() == 8){// static

    staticIndex = thisLine.indexOf("static ");

    if(staticIndex == -1 || staticIndex > typeIndex){

    continue;

    }

    }

    if(field.getModifiers() == 16){// final

    finalIndex = thisLine.indexOf("final ");

    if(finalIndex == -1 || finalIndex > typeIndex){

    continue;

    }

    } else if(field.getModifiers() == 64){// volatile

    volatileIndex = thisLine.indexOf("volatile ");

    if(volatileIndex == -1 || volatileIndex > typeIndex){

    continue;

    }

    }

    // 该行是field行

    // Map>>

    //Map>>

    for(Entry>> entry : allNameAnnotationMap.entrySet()){

    // 不是属性的注解

    if(!entry.getKey().equals(field.getName())){

    continue;

    }

    // Map>

    annoMap = entry.getValue();

    for(Entry> subEntry : annoMap.entrySet()){

    printWriter.println("@"+ subEntry.getKey() + "(");

    classAnnoAttrMap = subEntry.getValue();

    // 输出注解属性和属性值

    printAnnotationAttrValue(classAnnoAttrMap, printWriter);

    printWriter.println(")");

    }

    }

    }

    }

    // 获取并输出源文件的所有方法

    methodArray = classFile.getDeclaredMethods();

    for(Method method : methodArray){

    method.setAccessible(true);

    nameIndex = thisLine.indexOf(method.getName());

    typeIndex = thisLine.indexOf(method.getReturnType().getSimpleName());

    if(nameIndex != -1 && typeIndex != -1 && typeIndex < nameIndex){

    // 访问权限

    if(method.getModifiers() == 2){// private

    accessModifierIndex = thisLine.indexOf("private ");

    if(accessModifierIndex == -1 || accessModifierIndex > typeIndex){

    continue;

    }

    } else if(method.getModifiers() == 4){// protected

    accessModifierIndex = thisLine.indexOf("protected ");

    if(accessModifierIndex == -1 || accessModifierIndex > typeIndex){

    continue;

    }

    } else if(method.getModifiers() == 1){// public

    accessModifierIndex = thisLine.indexOf("public ");

    if(accessModifierIndex == -1 || accessModifierIndex > typeIndex){

    continue;

    }

    }

    // 修饰符

    if(method.getModifiers() == 1024){// abstract

    abstractIndex = thisLine.indexOf("abstract ");

    if(abstractIndex == -1 || abstractIndex > typeIndex){

    continue;

    }

    }

    if(method.getModifiers() == 8){// static

    staticIndex = thisLine.indexOf("static ");

    if(staticIndex == -1 || staticIndex > typeIndex){

    continue;

    }

    }

    if(method.getModifiers() == 16){// final

    finalIndex = thisLine.indexOf("final ");

    if(finalIndex == -1 || finalIndex > typeIndex){

    continue;

    }

    }

    if(method.getModifiers() == 32){// synchronized

    synchronizedIndex = thisLine.indexOf("synchronized ");

    if(synchronizedIndex == -1 || synchronizedIndex > typeIndex){

    continue;

    }

    }

    if(method.getModifiers() == 256){// native

    nativeIndex = thisLine.indexOf("native ");

    if(nativeIndex == -1 || nativeIndex > typeIndex){

    continue;

    }

    } else if(method.getModifiers() == 2048){// strictfp

    strictIndex = thisLine.indexOf("strictfp ");

    if(strictIndex == -1 || strictIndex > typeIndex){

    continue;

    }

    }

    // 拼接方法参数 参数类型-参数类型-参数类型

    paraClassArray = method.getParameterTypes();

    paraBuffer = new StringBuffer();

    for(int i=0;i

    paraClass = paraClassArray[i];

    if(i > 0){

    paraBuffer.append("-");

    }

    paraBuffer.append(paraClass.getSimpleName());

    }

    // 该行是Method行

    // Map>>

    //Map>>

    for(Entry>> entry : allNameAnnotationMap.entrySet()){

    // 不是属性的注解

    // 方法名##参数类型,参数名

    // 参数类型,参数名

    // 参数类型,参数名

    keyStrArray = entry.getKey().split("-");

    // 方法名##参数类型-参数类型-参数类型

    keyBuffer = new StringBuffer();

    for(String keyStr : keyStrArray){

    keyParaArray = keyStr.split("\\,");

    if(!keyBuffer.toString().equals("")){

    keyBuffer.append("-");

    }

    keyBuffer.append(keyParaArray[0]);

    }

    if(!keyBuffer.toString().equals(method.getName() + "##" + paraBuffer.toString())){

    continue;

    }

    // Map>

    annoMap = entry.getValue();

    for(Entry> subEntry : annoMap.entrySet()){

    printWriter.println("@"+ subEntry.getKey() + "(");

    classAnnoAttrMap = subEntry.getValue();

    // 输出注解属性和属性值

    printAnnotationAttrValue(classAnnoAttrMap, printWriter);

    printWriter.println(")");

    }

    }

    }

    }

    // 类所有的构造函数

    //Constructor>[] constructorArray = classFile.getDeclaredConstructors();

    //for(Constructor> constructor : constructorArray){

    //

    //constructor.setAccessible(true);

    //

    //nameIndex = thisLine.indexOf(constructor.getName());

    //if(nameIndex != -1 && typeIndex != -1 && typeIndex < nameIndex){

    //

    访问权限

    //if(constructor.getModifiers() == 2){// private

    //accessModifierIndex = thisLine.indexOf("private ");

    //if(accessModifierIndex == -1 || accessModifierIndex > nameIndex){

    //continue;

    //}

    //} else if(constructor.getModifiers() == 4){// protected

    //accessModifierIndex = thisLine.indexOf("protected ");

    //if(accessModifierIndex == -1 || accessModifierIndex > nameIndex){

    //continue;

    //}

    //} else if(constructor.getModifiers() == 1){// public

    //accessModifierIndex = thisLine.indexOf("public ");

    //if(accessModifierIndex == -1 || accessModifierIndex > nameIndex){

    //continue;

    //}

    //}

    //

    该行是Method行

    Map>>

    Map>>

    //for(Entry>> entry : existsNameAnnotationMap.entrySet()){

    //

    不是属性的注解

    //if(!entry.getKey().equals(method.getName() + "##" + paraBuffer.toString())){

    //continue;

    //}

    //

    Map>

    //Map> annoMap = entry.getValue();

    //for(Entry> subEntry : annoMap.entrySet()){

    //

    //printWriter.println("@"+ subEntry.getKey() + "(");

    //

    //Map classAnnoAttrMap = subEntry.getValue();

    //

    输出注解属性和属性值

    //printAnnotationAttrValue(classAnnoAttrMap, printWriter);

    //

    //printWriter.println(")");

    //}

    //}

    //}

    //

    //printWriter.println(thisLine);

    //}

    printWriter.println(thisLine);

    }

    }

    }

    }

    // 把PrintWriter刷新

    printWriter.flush();

    // 关闭PrintWriter

    printWriter.close();

    // 关闭BufferedReader

    inputBufferedReader.close();

    // 把文件删除

    oldFile.delete();

    // 把新文件名改为源文件名

    newFile.renameTo(oldFile);

    } catch (FileNotFoundException e) {

    e.printStackTrace();

    } catch (IOException e) {

    e.printStackTrace();

    } catch (ClassNotFoundException e) {

    e.printStackTrace();

    } catch (IllegalArgumentException e) {

    e.printStackTrace();

    }

    return newFile;

    }

    展开全文
  • (二)注解添加属性 (三)注解的创建 (四)反射注解 (一)元注解的使用 元注解是用来修饰注解声明的注解,可以控制被修饰的注解的特性。 【1】@Target 用来声明被修饰的注解可以用在什么位置。可以在@...

    目录

     

    (一)元注解的使用

    (二)注解添加属性

    (三)注解的创建

    (四)反射注解


    (一)元注解的使用

    元注解是用来修饰注解声明的注解,可以控制被修饰的注解的特性。

    【1】@Target

    用来声明被修饰的注解可以用在什么位置。可以在@Target的属性中设置ElementType类型的数组来指定可以使用的位置。如果不用此元注解修饰,默认注解可以用在任意位置。

    @Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})

    补充:TYPE表示类,FIELD表示属性

    【2】@Retention

    用来声明被修饰的注解会被保留到什么阶段。

    名称 解释 备注
    RetentionPolicy.SOURCE

    此注解将会被保留到源码阶段.java中,.java中。

    在编译过程中被删除。

    这种类型的注解通常是给编译器看的。
    RetentionPolicy.CLASS 此注解将会被保留在源码阶段和编译阶段,.java和.class中。在类加载的过程中被删除。 这种类型的注解通常是给类加载器看的。
    RetentionPolicy.RUNTIME 

    此注解将会被保留在源码阶段 、编译阶段 和 运行段。

    .java .class和内存中的字节码中都会存在

    这种类型的注解通常用来在运行阶段进行反射,控制程序运行过程。

    补充:只有RUNTIME级别的注解才可以通过反射技术进行反射

    【3】@Documented

    用来声明被修饰注解是否要被文档提取工具提取到文档中。默认不提取。

    【4】@Inherited

    被修饰的注解是否具有继承性,默认没有继承性。

    (二)注解添加属性

    注解中的所有的属性必须是public的,可以显式声明,也可以不声明,不声明默认就是public的。

    注解中的属性只能是八种基本数据类型String类型、Class类型、枚举类型、其他注解类型及以上类型的一维数组。

    注解类声明属性的过程非常类似于为接口定义方法。String name();定义name变量

    注解中声明的属性,需要在使用注解时,为其赋值,赋值的方式就是使用注解时,在注解后跟一对小括号 在其中通过属性名=属性值的方式指定属性的值。

    声明属性的默认值,在声明注解时 在注解的属性后 通过default关键字,声明属性的默认值,声明过默认值的属性 可以在使用注解时不赋值,则默认采用默认值,也可以手动赋值覆盖默认值如果属性是一维数组类型 而 在传入的数组中只有一个值,则包括数组的大括号可以省略,如果注解的属性,只有一个需要赋值 且该属性的名称叫做value 则在使用注解时 value=可以不写

    (三)注解的创建

    1. 创建注解,使用@interface关键字创建
    2. 添加元注解,设置保存阶段与放置位置
    3. 添加属性
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    
    @Target({ElementType.TYPE,ElementType.METHOD})	//设置注解放置在类上和方法上
    @Retention(RetentionPolicy.RUNTIME)				//设置注解保存阶段为RUNTIME
    public @interface MyAnno {
    	int age();									//定义age变量,属性为int类型
    	String[] addr();							//定义addr变量,属性为String一维数组类型
    	String name() default "zs";					//定义name变量,默认值为“zs”	
    }

    以上便是配置注解的步骤。

    (四)反射注解

    在方法、属性、类等等的字节码文件上有以下三个方法。通过以下三个方法,可以指定利用注解,执行工作。

    判断指定注解是否存在该元素上。

     isAnnotationPresent(Class<? extends Annotation> annotationClass)

    根据指定注解的Class字节码文件,获取注解信息。

    getAnnotation(Class<A> annotationClass)

    返回此元素上存在的所有注解。

    getAnnotations()

    案例:

    import java.util.Arrays;
    
    @MyAnno(age=18,addr= {"北京","上海"},value="程序猿")
    public class AnnoTest{
    	
    	public static void main(String args[]) {
    		Class<AnnoTest> clz = AnnoTest.class;
    		//isAnnotationPresent表示该MyAnno.class是否存在AnnoTest类上
    		boolean flag = clz.isAnnotationPresent(MyAnno.class);
    		if(flag) {
    			//getAnnotation获取指定注解
    			MyAnno myAnno = clz.getAnnotation(MyAnno.class);
    			//获取注解中的属性
    			String name = myAnno.name();
    			String[] addr = myAnno.addr();
    			int age = myAnno.age();
    			String value = myAnno.value();
    			System.out.println("姓名:"+name);
    			System.out.println("年龄:"+age);
    			System.out.println("地址:"+Arrays.toString(addr));
    			System.out.println("职业:"+value);
    			
    		}else {
    			System.out.println("..........");
    			throw new RuntimeException("您没有指定注解");
    		}
    	}
    	
    	
    }

     

     

     

     

    展开全文
  • 注解是一种能被添加java代码中的元数据,类、方法、变量、参数和包都可以用注解来修饰。注解对于它所修饰的代码并没有直接的影响。 通过官方描述得出以下结论: 注解是一种元数据形式。即注解是属于java的一种...

    1、注解

    什么是注解

    注解是一种能被添加到java代码中的元数据,类、方法、变量、参数和包都可以用注解来修饰。注解对于它所修饰的代码并没有直接的影响。

    通过官方描述得出以下结论:

    1. 注解是一种元数据形式。即注解是属于java的一种数据类型,和类、接口、数组、枚举类似。
    2. 注解用来修饰,类、方法、变量、参数、包。
    3. 注解不会对所修饰的代码产生直接的影响。

    注解的分类:内置注解、元注解、自定义注解

    内置注解:重写、废弃、镇压警告等。

    元注解:元注解的作用就是负责解释其他的注解。

    1、@target:用来描述当前注解的作用范围

    2、@document :用来产生当前注解的文档信息

    3、@inherited:表明子类可以继承父类的该注解

    4、@retention:表明需要在什么级别保存该注解,用于描述注解的生命周期

    如何使用注解

    ​ 可以在程序代码中的关键节点(类、方法、变量、参数、包)上打上这些标记,然后程序在编译时或运行时可以检测到这些标记从而执行一些特殊操作。因此可以得出自定义注解使用的基本流程:

    第一步,定义注解——相当于定义标记;
    第二步,配置注解——把标记打在需要用到的程序代码中;
    第三步,解析注解——在编译期或运行时检测到标记,并进行特殊操作。

    2、自定义注解

    基本语法

    1、使用关键字 @interface

    2、格式:

    public @interface{ }

    3、可以带有参数, 只有一个参数的时候, 建议名为 : value

    自定义注解

    // 标记运行时候的注解
    @Retention(value = RetentionPolicy.RUNTIME)
    // 标记产生文档
    @Documented
    // 标记作用的范围
    @Target({ElementType.METHOD, ElementType.TYPE, ElementType.FIELD})
    
    @interface my1 {
        // 使用 value的时候, 注解的参数可以直接写
        String value() default "value";
    
        int age();
    
        // 可以设置默认值
        int id() default 1;
    
        // 数组类型
        String[] school() default {"洛阳师范学院", "北大"};
    }
    
    

    3、使用反射来获取注解的信息

    测试类

    @my1(age = 1, id = 15)
    public class TestAnnotation {
        @my1(age = 2)
        public int age;
    
        @my1(age = 2, id = 8)
        public int id;
    
        @SuppressWarnings("all")
        @my1(value = "1", age = 2, id = 9)
        public void testmethod() {
            System.out.println(id + age);
        }
      
        public static void main(String[] args)  {
                
        }
    }
    

    测试获得字段上的注解信息

        public static void main(String[] args)  {
            TestAnnotation test = new TestAnnotation();
            Class<? extends TestAnnotation> aClass = test.getClass();
            System.out.println("得到字段上的注解  =========================");
            //得到字段上的注解  =========================
    
            Field age = aClass.getField("id");
            System.out.println(age);
    
            my1 annotation2 = age.getAnnotation(my1.class);
            System.out.println(annotation2.id());
        }
    
    

    在这里插入图片描述

    测试获得方法上的注解信息

        public static void main(String[] args)  {
            TestAnnotation test = new TestAnnotation();
            Class<? extends TestAnnotation> aClass = test.getClass();
            System.out.println("得到 方法上的注解  =========================");
            // 得到 方法上的注解  =========================
            Method testmethod = aClass.getMethod("testmethod");
            System.out.println(testmethod);
    
            my1 annotation1 = testmethod.getAnnotation(my1.class);
            System.out.println(annotation1.school()[0]);
    
            System.out.println(annotation1.value());
    
            System.out.println(annotation1.id());
        }
    

    在这里插入图片描述

    测试获得类上的注解信息

        public static void main(String[] args)  {
            TestAnnotation test = new TestAnnotation();
            Class<? extends TestAnnotation> aClass = test.getClass();
    
            System.out.println("得到类上的注解  =========================");
            // 得到类上的注解  =========================
    
            my1 annotation = aClass.getAnnotation(my1.class);
    
            String value = annotation.value();
            String[] school = annotation.school();
    
            System.out.println(school[0]);
            System.out.println(annotation.value());
        }
    

    在这里插入图片描述

    4、完整程序

    @SuppressWarnings("all")
    @my1(age = 1, id = 15)
    public class TestAnnotation {
        @my1(age = 2)
        public int age;
    
        @my1(age = 2, id = 8)
        public int id;
    
        @SuppressWarnings("all")
        @my1(value = "1", age = 2, id = 9)
        public void testmethod() {
            System.out.println(id + age);
        }
    
        public static void main(String[] args) throws NoSuchMethodException, NoSuchFieldException {
            /*   new TestAnnotation().testmethod();*/
            TestAnnotation test = new TestAnnotation();
            Class<? extends TestAnnotation> aClass = test.getClass();
            System.out.println("得到字段上的注解  =========================");
            //得到字段上的注解  =========================
    
            Field age = aClass.getField("id");
            System.out.println(age);
    
            my1 annotation2 = age.getAnnotation(my1.class);
            System.out.println(annotation2.id());
    
    
            System.out.println("得到 方法上的注解  =========================");
            // 得到 方法上的注解  =========================
            Method testmethod = aClass.getMethod("testmethod");
            System.out.println(testmethod);
    
            my1 annotation1 = testmethod.getAnnotation(my1.class);
            System.out.println(annotation1.school()[0]);
    
            System.out.println(annotation1.value());
    
            System.out.println(annotation1.id());
            System.out.println("得到类上的注解  =========================");
            // 得到类上的注解  =========================
    
            my1 annotation = aClass.getAnnotation(my1.class);
    
            String value = annotation.value();
            String[] school = annotation.school();
    
            System.out.println(school[0]);
            System.out.println(annotation.value());
        }
    }
    
    /**
     * @author Administrator
     */
    
    // 标记运行时候的注解
    @Retention(value = RetentionPolicy.RUNTIME)
    // 标记产生文档
    @Documented
    // 标记作用的范围
    @Target({ElementType.METHOD, ElementType.TYPE, ElementType.FIELD})
    @interface my1 {
        // 使用 value的时候, 注解的参数可以直接写
        String value() default "value";
    
        int age();
    
        // 可以设置默认值
        int id() default 1;
    
        // 数组类型
        String[] school() default {"洛阳师范学院", "北大"};
    }
    
    

    5、反射的更多叙述

    反射详解

    展开全文
  • 官方给出的定义是:注解是一种能被添加java 代码中的元数据,类、方法、变量、参数和包都可以用注解来修饰,注解对于它所修饰的代码并没有直接的影响。 所以我可以知道: 注解是一种元数据形式,即注解是属于 ...
  • 参考 Robert.S 的《Algorithm》/*** 编译:* 执行:* 所依赖的库:StdOut.java* 简介:找出最大元素的优先队列,使用二叉堆实现(以数组表示的完全二叉树作为data stru)* ------------------------------------------...
  • javapoet 中 添加注解代码为 AnnotationSpec.Builder(注解类).addMember(String name, String format, Object... args) 导致如下问题 如果注解的属性值是数组类型 生成 如:method(@AnnotationName(value=...
  • 注解是一种能被添加java代码中的元数据,类、方法、变量、参数和包都可以用注解来修饰。注解对于它所修饰的代码并没有直接的影响。 通过官方描述得出以下结论: 1、注解是一种元数据形式。即注解是属于java的...
  • Java 8 角度看注解类型

    2015-04-10 10:35:54
    1、除了在继承关系上的限制(不能添加泛型声明也不能添加extends继承另外的接口),声明时用@interface而不是interface以外,注解类型和普通接口没有区别 2、注解类型中可以包含多个元素,通过方法声明形式来定义,...
  • scala简要:注解

    千次阅读 2015-01-02 14:55:38
    可以对是scala类使用java注解,也可以使用scala特有的注解。 在scala中,可为类,方法,字段,局部变量和参数添加注解。Java注解的参数类型只能是: 1)数值型变量 2)字符串 3)类变量 4)java枚举 5)其他注解 6...
  • @interface 注解详述

    千次阅读 2017-01-11 15:53:51
    Java中,定义注解其实和定义接口差多不,只需要在interface前添加一个@符号就可以,即 @interface Zhujie{ },这就表明我们定义了一个名为 @Zhujie 的注解注解中的每一个方法定义了这个注解类型的一个元素,特别...
  • 自定义注解

    2021-01-21 17:15:39
    注解是一种能被添加java代码中的元数据,类、方法、变量、参数和包都可以用注解来修饰。注解对于它所修饰的代码并没有直接的影响。 二、通过官方描述得出以下结论: 注解是一种元数据形式。即注解是属于java的一...
  • java8新特性简略介绍

    2016-11-30 23:55:07
    lambda表达式—-java8最大的亮点,使得java提供了对函数式编程的支持 ...扩展注解的支持—–java8现在能几乎为任何类型添加注解 反射的部分增强—–能获取的基础信息更多 Java8增加的类库Optional,Stream,Date/Time,j
  • enum的values()方法可以返回enum实例的数组,而且该数组的元素严格保持其在enum中声明时的顺序。但是我们查看Enum类的API会发现并没有values()方法,那么为什么还可以使用呢?是因为values()方法是编译器添加的...
  • 这里先引入来自于博客Java注解——Repeatable对于@Repeatable 的用法: 首先创建一个APersons注解,再创建一个APerson注解,最后编写一个Man类来作为测试: 创建一个APersons注解,里面包含一个Aperson类型的数组 ...
  • java前后端分离以后,后端常常返回给前端以下的内容:如果遇到某个字段的内容为空的时候会出现这样的情况:图中红色箭头的情况是一个数组集合,但是该集合为空,所以就返回null,但是我们如果想对于这样的数组如果...
  • java前后端分离以后,后端常常返回给前端以下的内容:如果遇到某个字段的内容为空的时候会出现这样的情况:图中红色箭头的情况是一个数组集合,但是该集合为空,所以就返回null,但是我们如果想对于这样的数组如果...
  • Java 8引入了JSR-308,它为Java语言添加了新的注释功能。 最重要的是:键入注释。 现在可以像下面这样设计怪物了: 比注解更疯狂的是类型注解。 在数组上。 谁认为这是有效的Java代码? pic.twitter....
  • Java 8引入了JSR-308,它为Java语言添加了新的注释功能。 最重要的是:键入注释。 现在可以像下面这样设计怪物了: 比注解更疯狂的是类型注解。 在数组上。 谁认为这是有效的Java代码? pic.twitter....
  • 归并排序—Java

    2017-06-14 20:33:49
    一开始做算法的时候,感觉递归算法很绕,所以我就在阅读别人代码的基础上,对代码每一步都添加自己的注解,方便我以后的学习。 public class MergeSort { /** * 归并排序 * @param nums 待排序数组 * @param...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
     util实现Java图片水印添加功能,有添加图片水印和文字水印,可以设置水印位置,透明度、设置对线段锯齿状边缘处理、水印图片的路径,水印一般格式是gif,png,这种图片可以设置透明度、水印旋转等,可以参考代码...
  • Java数组倒置 简单 Java图片加水印,支持旋转和透明度设置 摘要:Java源码,文件操作,图片水印 util实现Java图片水印添加功能,有添加图片水印和文字水印,可以设置水印位置,透明度、设置对线段锯齿状边缘处理、水印...
  • 后台Control接受前端传来的数组时,需要添加注解才能接收到。 @RequestMapping(value = "/testJava", produces = "text/html;charset=UTF-8") @ResponseBody private String testJava(HttpServletRequest request,...
  • 数组边界检查消除 方法内联 逃逸分析 如果对象不会逃逸到方法或线程外,可以做什么优化? Java与C/C++的编译器对比 物理机如何处理并发问题? Java内存模型 什么是Java内存模型? Java内存模型的目标? 主内存与工作内存...
  • 添加 @RabbitListener 注解来指定某方法作为消息消费的方法,例如监听某 Queue 里面的消息MessageConvert涉及网络传输的应用序列化不可避免,发送端以某种规则将消息转成 byte 数组进行发送,接收端则以约定的规则...
  • 8.4.1 集合类中添加的方法 170 8.4.2 比较器 171 8.4.3 Collections类 173 8.5 使用文件 173 8.5.1 读取文件行的流 173 8.5.2 遍历目录项的流 175 8.5.3 Base64编码 176 8.6 注解 177 8.6.1 可重复的注解 177 8.6.2 ...
  • Spring和SpringBoot中配置Properties 文章目录Spring和SpringBoot中配置Properties1通过 **@PropertySource** ...(2)注意:java8以上支持重复使用该注解数组的样式 官网:https://docs.oracle.com/javase/tutoria

空空如也

空空如也

1 2 3 4
收藏数 74
精华内容 29
关键字:

java注解添加数组

java 订阅