How to use

JavaCodeStyleManager

in

com.intellij.psi.codeStyle

protected void formatJavCode(PsiClass cls) {
  if (cls == null) {
    return;
  }
  JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(cls.getProject());
  styleManager.optimizeImports(cls.getContainingFile());
  styleManager.shortenClassReferences(cls);
}

filedPrefix = Config.getInstant().getFiledNamePreFixStr();
if (TextUtils.isEmpty(filedPrefix)) {
  JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(project);
  filedPrefix = styleManager.getPrefixByVariableKind(VariableKind.FIELD
  );

public void addAnnotation(@NotNull PsiModifierListOwner parameter, @NotNull Annotation annotation) {
 PsiModifierList modifierList = parameter.getModifierList();
 if (JavaUtils.isAnnotationPresent(parameter, annotation) || null == modifierList) {
  return;
 }
 JavaService.getInstance(parameter.getProject()).importClazz((PsiJavaFile) parameter.getContainingFile(), annotation.getQualifiedName());
 
 PsiElementFactory elementFactory = JavaPsiFacade.getInstance(project).getElementFactory();
 PsiAnnotation psiAnnotation = elementFactory.createAnnotationFromText(annotation.toString(), parameter);
 modifierList.add(psiAnnotation);
 JavaCodeStyleManager.getInstance(project).shortenClassReferences(psiAnnotation.getParent());
}

@Nonnull
@Provides
@Singleton
public JavaCodeStyleManager provideCodeStyleManager(@Nonnull Project project) {
  return JavaCodeStyleManager.getInstance(project);
}

public static PsiMethod generateSetterPrototype(PsiField field, final PsiClass containingClass, boolean returnSelf) {
 Project project = field.getProject();
 JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(project);
 PsiElementFactory factory = JavaPsiFacade.getInstance(field.getProject()).getElementFactory();
 VariableKind kind = codeStyleManager.getVariableKind(field);
 String propertyName = codeStyleManager.variableNameToPropertyName(name, kind);
 String setName = suggestSetterName(field);
 try {
   .createMethodFromText(factory.createMethod(setName, returnSelf ? factory.createType(containingClass) : PsiType.VOID).getText(),
              field);
  String parameterName = codeStyleManager.propertyNameToVariableName(propertyName, VariableKind.PARAMETER);
  PsiParameter param = factory.createParameter(parameterName, field.getType());

  @Override
  protected void run(@NotNull Result<PsiFile> result) throws Throwable {
    final PsiPackage packageElement = directoryService.getPackage(directory);
    if (packageElement == null) {
      throw new InvalidDirectoryException("Target directory does not provide a package");
    }

    final String fileName = Extensions.append(name, StdFileTypes.JAVA);
    final PsiFile found = directory.findFile(fileName);
    if (found != null) {
      throw new ClassAlreadyExistsException("Class '" + name + "'already exists in " + packageElement.getName());
    }

    final String packageName = packageElement.getQualifiedName();
    final String className = Extensions.remove(this.name, StdFileTypes.JAVA);
    try {
      final String java = converter.convert(packageName, className, json);
      final PsiFile classFile = fileFactory.createFileFromText(fileName, JavaFileType.INSTANCE, java);
      CodeStyleManager.getInstance(classFile.getProject()).reformat(classFile);
      JavaCodeStyleManager.getInstance(classFile.getProject()).optimizeImports(classFile);
      final PsiFile created = (PsiFile) directory.add(classFile);
      result.setResult(created);
    } catch (IOException e) {
      throw new ClassCreationException("Failed to create new class from JSON", e);
    }
  }
}

public static String suggestPropertyName(@NotNull PsiField field, @NotNull String fieldName) {
 JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(field.getProject());
 VariableKind kind = codeStyleManager.getVariableKind(field);
 String name = codeStyleManager.variableNameToPropertyName(fieldName, kind);
 if (!field.hasModifierProperty(PsiModifier.STATIC) && isBoolean(field.getType())) {
  if (name.startsWith(IS_PREFIX) && name.length() > IS_PREFIX.length() && Character.isUpperCase(name.charAt(IS_PREFIX.length()))) {
   name = Introspector.decapitalize(name.substring(IS_PREFIX.length()));
  }
 }
 return name;
}

try {
 final Project project = operand.getProject();
 final String uniqueVariableName = JavaCodeStyleManager.getInstance(project).suggestUniqueVariableName("l", parent, false);
 final PsiDeclarationStatement declarationStatement =
  (PsiDeclarationStatement)JavaPsiFacade.getElementFactory(project).createStatementFromText(

@Nonnull
@Override
public String convert(@Nonnull String name, @Nonnull TypeName type) {
  final String propertyName = DefaultNamePolicy.format(name, CaseFormat.LOWER_CAMEL);
  final String fieldName = codeStyleManager.propertyNameToVariableName(propertyName, VariableKind.FIELD);
  if (Strings.isNullOrEmpty(fieldName)) {
    throw new IllegalArgumentException("Cannot convert '" + name + "' to a field name");
  }
  return fieldName;
}

    mappingMethod.getModifierList()
  );
  JavaCodeStyleManager.getInstance( project ).shortenClassReferences( inserted );
}, containingFile );

@Before
@Override
public void setUp() throws Exception {
  super.setUp();
  final Project project = getProject();
  final JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(project);
  underTest = new ParameterNamePolicy(codeStyleManager);
}

  @Nonnull
  @Override
  public String convert(@Nonnull String name, @Nonnull TypeName type) {
    final String propertyName = DefaultNamePolicy.format(name, CaseFormat.LOWER_CAMEL);
    final String parameterName = codeStyleManager.propertyNameToVariableName(propertyName, VariableKind.PARAMETER);
    if (Strings.isNullOrEmpty(parameterName)) {
      throw new IllegalArgumentException("Cannot convert '" + name + "' to a parameter name");
    }
    return parameterName;
  }
}

protected PsiFile createFile(Project project, @NotNull PsiDirectory psiDirectory, String fileName, String context, LanguageFileType fileType) {
  //+        final String simpleContent = XmlSorterUtil.replaceAllByRegex(content, ">" + lineSeparator + "*\\s+?<", "><");
  String replace = context.replaceAll("\r\n", "\n");
  PsiFile file = psiDirectory.findFile(fileName);
  if (file!=null){
    file.delete();
  }
  PsiFile psiFile = PsiFileFactory.getInstance(project).createFileFromText(fileName, fileType, replace);
  // reformat class
  CodeStyleManager.getInstance(project).reformat(psiFile);
  if (psiFile instanceof PsiJavaFile) {
    JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(project);
    styleManager.optimizeImports(psiFile);
    styleManager.shortenClassReferences(psiFile);
  }
  //加载到磁盘中
  psiDirectory.add(psiFile);
  return psiFile;
}

JavaCodeStyleManager.getInstance(project).shortenClassReferences(psiGetterAnnotation);
PsiAnnotation psiGetterAnnotation = elementFactory.createAnnotationFromText(Annotation.SETTER.toString(), clazz);
clazz.addBefore(psiGetterAnnotation,JavaUtils.findNealModifierElement(clazz.getFirstChild()).getFirstChild());
JavaCodeStyleManager.getInstance(project).shortenClassReferences(psiGetterAnnotation);

@Before
@Override
public void setUp() throws Exception {
  super.setUp();
  final Project project = getProject();
  final JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(project);
  underTest = new FieldNamePolicy(codeStyleManager);
}