code-refactor-master

Use this Skill when:

• Refactoring existing code for better quality
• Eliminating code smells
• Improving code readability and maintainability
• Optimizing performance without changing behavior
• Applying design patterns
• Reducing complexity
• Cleaning up technical debt

1. Core Rules

Golden Rule: Make code changes that improve internal structure without altering external behavior

Key Principles:

• One refactoring at a time
• Run tests after each refactoring
• Commit frequently with clear messages
• Keep refactoring separate from feature work
• Maintain backwards compatibility unless explicitly changing API

Red Flags to Refactor:

• Code duplication (DRY principle)
• Long methods (>20-30 lines)
• Large classes (>300-500 lines)
• Long parameter lists (>3-4 parameters)
• Deeply nested conditionals (>3 levels)
• Comments explaining what code does (code should be self-explanatory)

2. Common Code Smells

Bloaters:

• Long Method
• Large Class
• Primitive Obsession
• Long Parameter List
• Data Clumps

Object-Orientation Abusers:

• Switch Statements (consider polymorphism)
• Temporary Field
• Refused Bequest
• Alternative Classes with Different Interfaces

Change Preventers:

• Divergent Change (one class changes for many reasons)
• Shotgun Surgery (one change requires many small changes)
• Parallel Inheritance Hierarchies

Dispensables:

• Comments (where code should be self-explanatory)
• Duplicate Code
• Lazy Class
• Dead Code
• Speculative Generality

Couplers:

• Feature Envy
• Inappropriate Intimacy
• Message Chains
• Middle Man

3. Refactoring Catalog

Method-Level Refactorings:

Extract Method

```java

// Before

void printOwing() {

printBanner();

// print details

System.out.println("name: " + name);

System.out.println("amount: " + getOutstanding());

}

// After

void printOwing() {

printBanner();

printDetails(getOutstanding());

}

void printDetails(double outstanding) {

System.out.println("name: " + name);

System.out.println("amount: " + outstanding);

}

```

Inline Method

```java

// Before - method too simple

int getRating() {

return moreThanFiveLateDeliveries() ? 2 : 1;

}

boolean moreThanFiveLateDeliveries() {

return numberOfLateDeliveries > 5;

}

// After

int getRating() {

return numberOfLateDeliveries > 5 ? 2 : 1;

}

```

Replace Temp with Query

```java

// Before

double calculateTotal() {

double basePrice = quantity * itemPrice;

if (basePrice > 1000) {

return basePrice * 0.95;

}

return basePrice * 0.98;

}

// After

double calculateTotal() {

if (basePrice() > 1000) {

return basePrice() * 0.95;

}

return basePrice() * 0.98;

}

double basePrice() {

return quantity * itemPrice;

}

```

Variable-Level Refactorings:

Rename Variable

```python

# Before

d = 10 # elapsed time in days

# After

elapsed_time_in_days = 10

```

Split Temporary Variable

```java

// Before

double temp = 2 * (height + width);

System.out.println(temp);

temp = height * width;

System.out.println(temp);

// After

double perimeter = 2 * (height + width);

System.out.println(perimeter);

double area = height * width;

System.out.println(area);

```

Class-Level Refactorings:

Extract Class

```java

// Before

class Person {

String name;

String officeAreaCode;

String officeNumber;

String getTelephoneNumber() {

return "(" + officeAreaCode + ") " + officeNumber;

}

}

// After

class Person {

String name;

TelephoneNumber officeTelephone = new TelephoneNumber();

String getTelephoneNumber() {

return officeTelephone.getTelephoneNumber();

}

}

class TelephoneNumber {

String areaCode;

String number;

String getTelephoneNumber() {

return "(" + areaCode + ") " + number;

}

}

```

Replace Conditional with Polymorphism

```python

# Before

class Bird:

def get_speed(self):

if self.type == "EUROPEAN":

return self.get_base_speed()

elif self.type == "AFRICAN":

return self.get_base_speed() - self.get_load_factor()

elif self.type == "NORWEGIAN_BLUE":

return 0 if self.is_nailed else self.get_base_speed()

# After

class Bird:

def get_speed(self):

pass # Abstract

class European(Bird):

def get_speed(self):

return self.get_base_speed()

class African(Bird):

def get_speed(self):

return self.get_base_speed() - self.get_load_factor()

class NorwegianBlue(Bird):

def get_speed(self):

return 0 if self.is_nailed else self.get_base_speed()

```

4. Java-Specific Refactorings

Use Modern Java Features:

Replace Anonymous Class with Lambda

```java

// Before

list.sort(new Comparator() {

@Override

public int compare(String a, String b) {

return a.compareTo(b);

}

});

// After

list.sort((a, b) -> a.compareTo(b));

// Or even better

list.sort(String::compareTo);

```

Use Streams API

```java

// Before

List result = new ArrayList<>();

for (String s : list) {

if (s.length() > 3) {

result.add(s.toUpperCase());

}

}

// After

List result = list.stream()

.filter(s -> s.length() > 3)

.map(String::toUpperCase)

.collect(Collectors.toList());

```

Replace String Concatenation

```java

// Before - inefficient in loops

String result = "";

for (String s : list) {

result += s + ", ";

}

// After

StringBuilder result = new StringBuilder();

for (String s : list) {

result.append(s).append(", ");

}

// Or better

String result = String.join(", ", list);

```

Use Optional

```java

// Before

public User findUser(int id) {

User user = database.getUser(id);

return user != null ? user : new User();

}

// After

public Optional findUser(int id) {

return Optional.ofNullable(database.getUser(id));

}

```

Replace Type Code with Enum

```java

// Before

public static final int TYPE_A = 1;

public static final int TYPE_B = 2;

// After

public enum Type {

A, B

}

```

5. Python-Specific Refactorings

Use List Comprehensions

```python

# Before

result = []

for item in items:

if item > 0:

result.append(item * 2)

# After

result = [item * 2 for item in items if item > 0]

```

Use Collections Module

```python

# Before

counts = {}

for item in items:

if item in counts:

counts[item] += 1

else:

counts[item] = 1

# After

from collections import Counter

counts = Counter(items)

```

Use Context Managers

```python

# Before

file = open('file.txt')

data = file.read()

file.close()

# After

with open('file.txt') as file:

data = file.read()

```

Use f-strings

```python

# Before

message = "Hello, %s! You are %d years old." % (name, age)

# After

message = f"Hello, {name}! You are {age} years old."

```

Use Type Hints

```python

# Before

def process(data):

return [x * 2 for x in data]

# After

def process(data: list[int]) -> list[int]:

return [x * 2 for x in data]

```

Use Dataclasses

```python

# Before

class Point:

def __init__(self, x, y):

self.x = x

self.y = y

def __repr__(self):

return f"Point(x={self.x}, y={self.y})"

# After

from dataclasses import dataclass

@dataclass

class Point:

x: int

y: int

```

6. Clean Code Principles

Naming:

```java

// Bad

int d; // elapsed time in days

// Good

int elapsedTimeInDays;

// Bad

public List getThem() {

List list1 = new ArrayList<>();

for (int[] x : theList) {

if (x[0] == 4) {

list1.add(x);

}

}

return list1;

}

// Good

public List getFlaggedCells() {

List flaggedCells = new ArrayList<>();

for (Cell cell : gameBoard) {

if (cell.isFlagged()) {

flaggedCells.add(cell);

}

}

return flaggedCells;

}

```

Functions:

• Small (20-30 lines max)
• Do one thing
• One level of abstraction
• Descriptive names
• Few arguments (0-3 ideal)

Comments:

```java

// Bad - comment explains what code does

// Check to see if employee is eligible for full benefits

if ((employee.flags & HOURLY_FLAG) && (employee.age > 65))

// Good - code is self-explanatory

if (employee.isEligibleForFullBenefits())

```

7. Performance Refactorings

Algorithm Optimization:

```python

# Before - O(n²)

def has_duplicates(arr):

for i in range(len(arr)):

for j in range(i + 1, len(arr)):

if arr[i] == arr[j]:

return True

return False

# After - O(n)

def has_duplicates(arr):

return len(arr) != len(set(arr))

```

Lazy Evaluation:

```java

// Before - computes all values

List results = list.stream()

.map(this::expensiveOperation)

.collect(Collectors.toList());

return results.get(0);

// After - computes only what's needed

return list.stream()

.map(this::expensiveOperation)

.findFirst()

.orElse(null);

```

Memoization:

```python

# Before

def fibonacci(n):

if n <= 1:

return n

return fibonacci(n-1) + fibonacci(n-2)

# After

from functools import lru_cache

@lru_cache(maxsize=None)

def fibonacci(n):

if n <= 1:

return n

return fibonacci(n-1) + fibonacci(n-2)

```

8. Refactoring Workflow

Step-by-step process:

1. Identify: Find code smell or improvement opportunity
2. Plan: Decide which refactoring to apply
3. Test: Ensure tests exist and pass
4. Refactor: Make one small change
5. Test: Run tests again
6. Commit: Save working state
7. Repeat: Continue with next refactoring

Example workflow:

```bash

# 1. Create feature branch

git checkout -b refactor/improve-user-service

# 2. Identify issue (e.g., long method)

# Read code, find UserService.processUser() is 150 lines

# 3. Run existing tests

mvn test # or pytest

# 4. Extract method

# Break processUser into smaller methods

# 5. Run tests

mvn test # Ensure still passing

# 6. Commit

git commit -m "refactor: extract validateUser method"

# 7. Continue

# Extract next method, repeat

```

9. Refactoring Checklist

Before refactoring:

• [ ] Tests exist and pass
• [ ] Understand the code behavior
• [ ] Have a clear goal
• [ ] Know which refactoring to apply

During refactoring:

• [ ] Make small, incremental changes
• [ ] Run tests after each change
• [ ] Keep code working at all times
• [ ] Commit frequently

After refactoring:

• [ ] All tests pass
• [ ] Code is more readable
• [ ] Complexity reduced
• [ ] No behavioral changes
• [ ] Documentation updated if needed

10. LeetCode-Specific Refactoring

Optimize brute force:

```java

// Before - Brute force O(n²)

public int[] twoSum(int[] nums, int target) {

for (int i = 0; i < nums.length; i++) {

for (int j = i + 1; j < nums.length; j++) {

if (nums[i] + nums[j] == target) {

return new int[]{i, j};

}

}

}

return new int[]{};

}

// After - Hash map O(n)

public int[] twoSum(int[] nums, int target) {

Map map = new HashMap<>();

for (int i = 0; i < nums.length; i++) {

int complement = target - nums[i];

if (map.containsKey(complement)) {

return new int[]{map.get(complement), i};

}

map.put(nums[i], i);

}

return new int[]{};

}

```

Extract helper methods:

```python

# Before - monolithic

def solve(self, grid):

# 50 lines of code mixing concerns

# After - modular

def solve(self, grid):

if not self.is_valid(grid):

return []

processed = self.preprocess(grid)

result = self.compute(processed)

return self.format_output(result)

def is_valid(self, grid):

# validation logic

def preprocess(self, grid):

# preprocessing logic

def compute(self, data):

# core algorithm

def format_output(self, result):

# formatting logic

```

Don't:

• Refactor without tests
• Change behavior during refactoring
• Make multiple changes at once
• Refactor and add features simultaneously
• Over-engineer simple code
• Prematurely optimize

For CS_basics repository:

• Refactor solutions in leetcode_java/ and leetcode_python/
• Maintain consistency across language implementations
• Keep algorithm explanations updated
• Follow project conventions
• Test refactored code with example inputs
• Document complexity improvements

IDE Refactoring Tools:

• IntelliJ IDEA: Refactor menu (Ctrl+Alt+Shift+T)
• VS Code: Python refactoring extensions
• PyCharm: Refactoring actions

Use automated refactoring when available:

• Rename: Safe renaming across project
• Extract method/variable: Automatic extraction
• Inline: Safe inlining with preview
• Move: Restructure packages/modules