Apache Commons

Kategória: Java külső könyvtárak.

Áttekintés

Az Apache Commons egy igen terjedelmes könyvtár halmaz, melynek kiinduló pontja az alábbi oldal: https://commons.apache.org/. Ezek igen sok területet érintenek; néhány közülük:

És még jó néhány.

Talán a legelterjedtebb közülük az Apache Commons Lang, ebből szemezgetünk ebben a részben. Ehhez az alábbi függőségre van szükségünk:

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>

Az alábbi példákat nagyobbrészt a https://www.baeldung.com/java-commons-lang-3, https://www.baeldung.com/string-processing-commons-lang és https://www.baeldung.com/array-processing-commons-lang leírások alapján készítettem el.

String műveletek

A standard Java String osztály is igen gazdag, de számos művelet létezik, melyek gyakran előfordulnak, és az alapból hiányoznak. Íme néhány példa:

import org.apache.commons.lang3.StringUtils;

StringUtils.containsAny("abcdefghijk", "jkl"); // true
StringUtils.containsAny("abcdefghijk", "xyz"); // false
StringUtils.containsIgnoreCase("Faragó Csaba", "cs"); // true
StringUtils.countMatches("abacabadabaeabaf", "ab"); // 4
StringUtils.prependIfMissing("google.com", "www."); // www.google.com
StringUtils.prependIfMissing("www.google.com", "www."); // www.google.com
StringUtils.reverse("123456789"); // 987654321
StringUtils.rotate("123456789", 3); // 789123456
StringUtils.difference("apple 123", "apple 456"); // 456

És még természetesen számos egyéb.

Tömb műveletek

A Java Collection API kicsit háttérbe szorította a tömböket, így valójában az alap tömbökön eléggé foghíjas a rendszer által nyújtott lehetőségek. Az Apache Commons Lang igen gazdag művelet halmazt nyújt:

import org.apache.commons.lang3.ArrayUtils;

int[] array = {1, 2, 3, 4, 5};
System.out.println(ArrayUtils.toString(array));
ArrayUtils.insert(3, array, 1, 2, 3); // -> {1,2,3,1,2,3,4,5}, új tömb
ArrayUtils.removeAll(array, 1, 3); // -> {1,3,5}, új tömb
ArrayUtils.removeElements(array, 1, 3, 6); // -> {2,4,5}, új tömb
ArrayUtils.subarray(array, 1, 4); // -> {2,3,4}, új tömb
ArrayUtils.contains(array, 4); // true
ArrayUtils.reverse(array, 1, 4); // {1,2,3,4,5} -> {1,4,3,2,5}, helyben
ArrayUtils.swap(array, 0, 3, 2); // {1,4,3,2,5} -> {2,5,3,1,4}, helyben

Bizonyos műveletek (pl. reverse vagy swap) helyben történnek, mások (a példában az összes többi) új tömböt hoz létre.

Törtek

A tizedes tört nem létezik a standard Java-ban, pedig előfordulhat, hogy szükség van rá. A lebegőpontos aritmetika csak közelítése annak. Az Apache Commons Lang megvalósítása egyszerűsítést is tartalmaz:

import org.apache.commons.lang3.math.Fraction;

Fraction.getFraction(1, 6).add(Fraction.getFraction(1, 6)).toString(); // 1/3

Reflection

Az Apache Commons Lang reflection megvalósítására egy példa:

class Salute {
    public String name;

    public Salute(String name) {
        this.name = name;
    }

    public String sayHello() {
        return "Hello, " + name + "!";
    }
}

import org.apache.commons.lang3.reflect.ConstructorUtils;
import org.apache.commons.lang3.reflect.FieldUtils;
import org.apache.commons.lang3.reflect.MethodUtils;

Salute instance = ConstructorUtils.invokeConstructor(Salute.class, "Csaba");
System.out.println(FieldUtils.readField(instance, "name")); // Csaba
System.out.println((String)MethodUtils.invokeMethod(instance, "sayHello")); // Hello, Csaba!

Párok, hármasok

Tartja magát az elv, hogy az elem kettesek, elem hármasok stb. nem jók, helyette hozzunk létre osztályt, és nevesítsük a mezőket. Ez igaz is meg nem is. Ha ez alapból nyelvi elem lenne, akkor a Java-ban (ahol egy struktúra eléggé bőbeszédű) túl nagy enne a kísértés, hogy mindenre azt használjuk, ami a kód olvashatóságának rovására menne. Ugyanakkor azzal, hogy nincs, az gyakran tényleg feleslegesen kényszeríti a fejlesztőt felesleges osztályok létrehozására.

Az Apache Commons Lang tartalmaz elem ketteseket és elem hármasokat is. Mivel kell hozzá a megfelelő külső könyvtár, olyan könnyen azért nem fog elburjánozni a használata, de azért igen hasznos. Az elem kettesekből ráadásul módosítható és nem módosítható változat is létezik. A lenti példában egy módosítható elem kettesre és egy elem hármasra látunk példát:

import org.apache.commons.lang3.tuple.MutablePair;
import org.apache.commons.lang3.tuple.Triple;
 
MutablePair<String, Integer> pair = new MutablePair<String, Integer>("apple", 5);
pair.setRight(6);
System.out.println(pair.getLeft());
 
Triple<String, Integer, String> triple = Triple.of("apple", 5, "good");
System.out.println(triple.getLeft() + ", " + triple.getMiddle() + ",  " + triple.getRight());
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License