Răspuns scurt: Da, boolean[] poate fi folosit ca tip de retur într-o metodă Java.

În acest articol vom explora în detaliu regulile privind tipurile de retur în Java, cu focus special pe array-uri de primitive precum boolean[].

Regula generală în Java

În Java, orice tip valid poate fi folosit ca tip de retur al unei metode. Aceasta include:

• Tipuri primitive: int, boolean, double, char, etc.
• Array-uri de primitive: boolean[], int[], double[]
• Array-uri de obiecte: String[], Object[]
• Clase: String, ArrayList, clase custom
• Interfețe: List, Comparable, interfețe custom
• Enum-uri: orice tip enum definit
• void: când metoda nu returnează nimic

Exemplu concret cu boolean[]

Iată o metodă simplă care returnează un array de boolean:

public boolean[] getFlags() {
    return new boolean[] { true, false, true };
}

Sau, folosind o variabilă intermediară:

public boolean[] getFlags() {
    boolean[] flags = { true, false, true };
    return flags;
}

Ambele variante sunt perfect valide în Java.

De ce funcționează?

În Java, boolean[] este un tip de referință, nu un tip primitiv. Când scriem boolean[], definim un array — iar toate array-urile în Java sunt obiecte.

Astfel:

• Metoda returnează o referință către array, nu o copie a conținutului
• Această referință poate fi stocată, transmisă sau folosită ca orice alt obiect

public class FlagManager {
    
    public boolean[] getDefaultFlags() {
        return new boolean[] { true, false, true };
    }
    
    public static void main(String[] args) {
        FlagManager manager = new FlagManager();
        boolean[] flags = manager.getDefaultFlags();
        
        System.out.println("Primul flag: " + flags[0]);  // true
        System.out.println("Lungime: " + flags.length);  // 3
    }
}

Capcană importantă: mutabilitatea array-urilor

Când returnezi un array, returnezi referința către acel array. Aceasta înseamnă că apelantul poate modifica conținutul original:

public class FlagManager {
    private boolean[] internalFlags = { true, false, true };
    
    // ATENȚIE: expune array-ul intern!
    public boolean[] getFlags() {
        return internalFlags;
    }
}

Problema apare astfel:

FlagManager manager = new FlagManager();
boolean[] flags = manager.getFlags();

// Modificăm array-ul primit
flags[0] = false;

// Acum și internalFlags[0] este false!
// Am modificat starea internă a obiectului fără să ne dăm seama

Soluții pentru protejarea datelor interne

Soluția 1: Defensive Copy (copie defensivă)

Returnează o copie a array-ului, nu originalul:

public boolean[] getFlags() {
    return internalFlags.clone();
}

Sau manual:

public boolean[] getFlags() {
    boolean[] copy = new boolean[internalFlags.length];
    System.arraycopy(internalFlags, 0, copy, 0, internalFlags.length);
    return copy;
}

Soluția 2: Folosește o colecție imutabilă

În loc de array, folosește List<Boolean> imutabilă:

import java.util.Collections;
import java.util.List;
import java.util.Arrays;

public class FlagManager {
    private final List<Boolean> flags = Arrays.asList(true, false, true);
    
    public List<Boolean> getFlags() {
        return Collections.unmodifiableList(flags);
    }
}

Soluția 3: BitSet pentru eficiență

Pentru seturi mari de flag-uri, BitSet este mai eficient:

import java.util.BitSet;

public class FlagManager {
    private BitSet flags = new BitSet();
    
    public FlagManager() {
        flags.set(0);  // true
        flags.clear(1); // false
        flags.set(2);  // true
    }
    
    public BitSet getFlags() {
        return (BitSet) flags.clone();
    }
}

Comparație: Array vs. Alternative

Rezumat

Da, boolean[] poate fi folosit ca tip de retur în Java. Este un tip de referință valid, iar metoda va returna o referință către array.

Puncte cheie de reținut:

1. Orice tip valid Java poate fi tip de retur
2. Array-urile sunt tipuri de referință, nu primitive
3. Atenție la mutabilitate — caller-ul poate modifica array-ul
4. Folosește clone() sau colecții imutabile pentru protecție
5. Pentru seturi mari de boolean, consideră BitSet

Articol publicat pe blogul IUCOSOFT — cursuri și resurse pentru programatori Java.