Example of Moving Code Around

Invoking Rearrange Code on a Class and Viewing the results

A Before and After Example of Code Rearrangement

Let's modify the code arrangement settings for this example. Specifically we want to create a new rule that puts private methods at the bottom of each class.

Modifying the Existing Rule Arrangement

You can change your rule arrangement preferences with ⌘, (macOS), Ctrl+Alt+S (Windows/Linux) and then searching for arrangement. Select Editor > Code Style > Java from the filtered list and then the Arrangement tab.

Arrangement Settings/Preferences

To change your code arrangement settings, use ⌘, (macOS), Ctrl+Shift+S (Windows/Linux), to bring up the Preferences/Settings dialog. This dialog is searchable, so you can type in arrangement. This filters the dialog to Code Style. You can then select the language you're working with. In this tutorial we will use Java. Alternatively, you can navigate to Editor > Code Style > Java.

The Arrangement tab is grouped into two areas:

Grouping Rules

IntelliJ IDEA allows you to group these three code elements:

Getters and Setters is fairly self-explanatory. When this checkbox is selected, and you invoke rearrange code, your getters and setters will be grouped together in your class. This is enabled by default.

Override methods is similar to Getters and Setters in that it will group your Override methods together in your class. You also have the option to order them by the order they are defined in the super class or interface, or to order them by name. For our example let's select this checkbox.

Dependent methods has a drop-down that allows you to select breadth-first or depth-first for method coupling. You may have a use-case for this option, but for most Java code bases that have evolved over time, trying to keep related methods together is not usually what you want to do. If you do choose to use this option then it will take priority over Matching Rules. We suggest you use this option or Matching Rules, not both. In our example we're going to use Matching Rules defined in the next section as this is a more common real-world scenario.

Matching Rules

This is where you can define how you'd like your classes to be ordered when you invoke rearrange code. You can select any line and move it up or down as required with the arrows in the top-right. You can also click the pencil icon to the right of each row to alter the rule and select a finer level of granularity.

Adding a New Arrangement Rule

To add our new rule, go down to rule 22 and press the + button. This will place the new rule below 22. Select Type: method and Modifier: private. You can give it a name if required but both the type and modifier are displayed so that may not be necessary for this example.

New rule for private methods

Now we've modified our code arrangement let's take a look at what it looks like. Note our specific rule here that puts private methods at the bottom of the class which can be very useful. You can see this in rule 23.

Given you can't scroll a screenshot, here is the order in text form, so you can see what's happening:

1fieldpublicstaticfinal
2fieldprotectedstaticfinal
3fieldpackage privatestaticfinal
4fieldprivatestaticfinal
5fieldpublicstatic
6fieldprotectedstatic
7fieldpackage privatestatic
8fieldprivatestatic
9initializer blockstatic
10fieldpublicfinal
11fieldprotectedfinal
12fieldpackage privatefinal
13fieldprivatefinal
14fieldpublic
15fieldprotected
16fieldpackage private
17fieldprivate
18field
19initializer block
20constructor
21methodstatic
22method
23methodprivate
24enum
25interface
26classstatic
27class

Here's the code that we're going to rearrange. As you can see, the getter and setter methods are not together, private methods are in the middle of the class and override methods are also scattered throughout the class.

public class RearrangeCode {
private int id;
public int getId() {
return id;
}
@Override
public String toString() {
return "RearrangeCode{" +
"id=" + id +
", firstName='" + firstName + '\'' +
", middleName='" + middleName + '\'' +
", lastName='" + lastName + '\'' +
", phone='" + phone + '\'' +
", notes='" + notes + '\'' +
", ordersById=" + ordersById +
'}';
}
private String firstName;
private void privateHelperMethod() {
// does something in here
}
public void setId(int id) {
int newID = 1;
System.out.println(newID);
this.id = id;
}
private String middleName;
public String getMiddleName() {
return middleName;
}
public void setMiddleName(String middleName) {
this.middleName = middleName;
}
private String lastName;
public void setLastName(String lastName) {
this.lastName = lastName;
}
private String phone;
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
private String notes;
public String getNotes() {
return notes;
}
public void setNotes(String notes) {
this.notes = notes;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
RearrangeCode that = (RearrangeCode) o;
return id == that.id &&
Objects.equals(firstName, that.firstName) &&
Objects.equals(middleName, that.middleName) &&
Objects.equals(lastName, that.lastName) &&
Objects.equals(phone, that.phone) &&
Objects.equals(notes, that.notes) &&
Objects.equals(ordersById, that.ordersById);
}
@Override
public int hashCode() {
return Objects.hash(id, firstName, middleName, lastName, phone, notes, ordersById);
}
private Collection<Order> ordersById;
public Collection<Order> getOrdersById() {
return ordersById;
}
public void setOrdersById(Collection<Order> ordersById) {
this.ordersById = ordersById;
}
}

Let's invoke rearrange code with ⌘⇧A (macOS), or Ctrl+Shift+A (Windows/Linux). In the Find Actions dialog you can type in Rearrange Code:

Rearrange Code

Press Enter on Rearrange Code option to apply the settings to the whole class.

When you do this, the code will be rearranged (see below). Here is a list of changes:

  • All the fields have moved to the top of the class because that's what we specified in our grouping rows 1-8.
  • The getter and setter methods are grouped because IntelliJ IDEA has grouped them together from the grouping rules.
  • The Override methods have been grouped together because we specified we wanted to keep them together in the grouping rules). The Override methods are also implemented in the order they appear in the Object super class.
  • Next are the remaining two public methods, which are obeying line 22 of our matching rules.
  • Finally, there's the private method which is obeying line 23 of our matching rules.
public class RearrangeCode {
private int id;
private String firstName;
private String middleName;
private String lastName;
private String phone;
private String notes;
private Collection<Order> ordersById;
public int getId() {
return id;
}
public void setId(int id) {
int newID = 1;
System.out.println(newID);
this.id = id;
}
public String getMiddleName() {
return middleName;
}
public void setMiddleName(String middleName) {
this.middleName = middleName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getNotes() {
return notes;
}
public void setNotes(String notes) {
this.notes = notes;
}
@Override
public int hashCode() {
return Objects.hash(id, firstName, middleName, lastName, phone, notes, ordersById);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
RearrangeCode that = (RearrangeCode) o;
return id == that.id &&
Objects.equals(firstName, that.firstName) &&
Objects.equals(middleName, that.middleName) &&
Objects.equals(lastName, that.lastName) &&
Objects.equals(phone, that.phone) &&
Objects.equals(notes, that.notes) &&
Objects.equals(ordersById, that.ordersById);
}
@Override
public String toString() {
return "RearrangeCode{" +
"id=" + id +
", firstName='" + firstName + '\'' +
", middleName='" + middleName + '\'' +
", lastName='" + lastName + '\'' +
", phone='" + phone + '\'' +
", notes='" + notes + '\'' +
", ordersById=" + ordersById +
'}';
}
public Collection<Order> getOrdersById() {
return ordersById;
}
public void setOrdersById(Collection<Order> ordersById) {
this.ordersById = ordersById;
}
private void privateHelperMethod() {
// does something in here
}
}

Rearranging Just Code You've Changed

Now you've seen a worked example of rearranging a whole class, let's take a look at the use-case for only rearranging code that you've edited rather than the whole class.