Java String.split() метод

Нека поговорим за метода String.split на Java : Howво прави и защо е необходим. Не е трудно да се досетите, че той разделя Java низ, но How работи това на практика? Нека се потопим дълбоко в действието на метода и да обсъдим някои неочевидни подробности. В същото време ще научим колко метода за разделяне всъщност има String . Да тръгваме!

Описание и подпис за String.split на Java

В Java методът split разделя низ на поднизове с помощта на разделител, дефиниран с помощта на регулярен израз. Нека представим сигнатурата на метода и да започнем нашето гмуркане:

String[] split(String regex)

От подписа стават ясни две неща:

1. Методът връща масив от низове.
2. Методът има параметър за въвеждане на низ, наречен regex .

Нека анализираме всяко от тях поотделно, докато разбиваме описанието, дадено по-горе.

1. Методът връща масив от низове.

   Декларацията съдържа следните думи: "В Java методът split разделя низ на поднизове." Методът събира тези поднизове в масив, който става върнатата стойност.

2. Методът има параметър за въвеждане на низ, наречен regex .

   Отново си припомнете описанието: "разделя низ на поднизове с помощта на разделител, дефиниран с помощта на регулярен израз." Параметърът за въвеждане на regex е регулярен израз, който се прилага към оригиналния низ. Когато знакът or комбинацията от знаци съвпадат, те се третират като разделител.

Разделянето на Java на практика

Сега нека се доближим до същината. Нека си представим, че имаме низ от думи. Например така: Трябва да разделим низа на думи. Виждаме, че думите в този низ са разделени една от друга с интервали. В този случай знакът за интервал е идеалният кандидат за нашия разделител. Кодът за решаване на нашата задача би изглеждал така:

public class Main {
    public static void main(String[] args) {
        String str = "I love Java";
        String[] words = str.split(" ");
        for (String word : words) {
            System.out.println(word);
        }
    }
}

Резултатът от основния метод ще бъде следните редове: Нека видим още няколко примера за това How ще работи методът на разделяне : Забележете разликите между последните два реда в tableта по-горе. Във втория до последния ред като разделител се използва запетая. В резултат на това, когато низът е разделен, някои от думите имат водещи интервали. В последния ред използвахме запетая и интервал като наш разделител. Ето защо в получения масив нямаше поднизове с водещи интервали. Това е само тънък детайл, който показва колко е важно внимателно да изберете правилния разделител.

Водещ разделител

Това е друг важен нюанс. Ако оригиналният низ започва с разделителя, тогава първият елемент от резултантния масив ще бъде празен низ. Например, това би изглеждало така: Оригинален низ: " I love Java" Разделител: " " Получен масив: { "", "I", "love", "Java" } Но ако оригиналният низ завършва с разделител по-скоро отколкото да започне с едно, тогава резултатът ще бъде различен: Оригинален низ: "I love Java " Delimiter: " " Получен масив: { "I", "love", "Java"

public class Main {
    public static void main(String[] args) {
        print("I love Java".split(" "));
        print(" I love Java".split(" "));
        print("I love Java ".split(" "));
        print(" I love Java ".split(" "));
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

Резултатът от главния метод ще бъде така: Отново обърнете внимание на факта, че когато първият знак в оригиналния низ е разделителен знак, тогава резултатът е, че първият елемент в масива ще бъде празен низ.

Претоварен брат or сестра

Класът String има друг разделен метод със следния подпис:

String[] split(String regex, int limit)

Този метод има допълнителен ограничителен параметър: той определя колко пъти моделът на регулярен израз ще бъде приложен към оригиналния низ. Вижте обясненията по-долу:

лимит > 0

Моделът се прилага лимит -1 пъти. Нещо повече, дължината на върнатия масив няма да надвишава стойността на параметъра limit . Последният елемент от масива ще бъде частта от низа, която следва последното място, където е намерен разделителят. Пример:

public class Main {
    public static void main(String[] args) {
        print("I love Java".split(" ", 1));
        print("I love Java".split(" ", 2));
        /*
         Output:
         [I love Java]
         [I, love Java]
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

граница < 0

Регулярният израз на разделителя се прилага към низа възможно най-много пъти. Полученият масив може да има произволна дължина. Пример:

public class Main {
    public static void main(String[] args) {
        // Note the space at the end of the string
        print("I love Java ".split(" ", -1));
        print("I love Java ".split(" ", -2));
        print("I love Java ".split(" ", -12));
        /*
         Output:
        [I, love, Java, ]
        [I, love, Java, ]
        [I, love, Java, ]

        Please note that the last element of the array is
        an empty string. This is caused by the whitespace
        at the end of the original string.
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

лимит = 0

Както в случая, когато limit < 0, моделът на разделителя се прилага към низа възможно най-много пъти. Крайният масив може да има произволна дължина. Ако последните елементи са празни низове, те се изхвърлят от крайния масив. Пример:

public class Main {
    public static void main(String[] args) {
        // Note the space at the end of the string
        print("I love Java ".split(" ", 0));
        print("I love Java ".split(" ", 0));
        print("I love Java ".split(" ", 0));
        /*
         Output:
        [I, love, Java]
        [I, love, Java]
        [I, love, Java]
        Note the absence of empty strings at the end of the arrays
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

Ако надникнем в реализацията на еднопараметърната version на метода split , тогава можем да видим, че тя е като своя претоварен брат, но с втория аргумент, зададен на нула:

public String[] split(String regex) {
    return split(regex, 0);
}

Различни примери

В реалната практика понякога се случва да имаме низове, които се генерират според определени правила. Такъв низ може да влезе в нашата програма отвсякъде:

• от услуга на трета страна;
• от заявка, изпратена до нашия сървър;
• от конфигурационен файл;
• и така нататък.

В тези ситуации програмистът обикновено знае "правилата на играта". Да кажем, че програмист знае, че той or тя работи с потребителска информация, съхранена според този модел: Да вземем някои конкретни стойности като пример: Да предположим, че задачата на програмиста е да напише метод, който изпраща имейл до потребителя. Програмистът има достъп до потребителските данни, които се записват във формата, даден по-горе. Подзадачата, която сега ще продължим да анализираме, е How да изолираме имейл address от останалите потребителски данни. Това е един пример, в който методът на разделяне може да бъде полезен. В края на краищата, ако погледнем шаблона за потребителски данни, разбираме, че извличането на имейл address на потребителя от останалите е просто като извикване на метода split за разделяне на низа. Тогава имейл addressът ще бъде в последния елемент на получения масив. Ето пример за метод, който взема низ, съдържащ потребителски данни, и връща имейл address на потребителя. За простота, нека кажем, че низът с данни винаги е във формата, който искаме:

public class Main {
    public static void main(String[] args) {
        String userInfo = "135|bender|bender@gmail.com";
        System.out.println(getUserEmail(userInfo));
        // Output: bender@gmail.com
    }

    static String getUserEmail(String userInfo) {
        String[] data = userInfo.split("\\|");
        return data[2]; // or data[data.length - 1]
    }
}

Обърнете внимание на разделителя: "\\|" . В регулярни изрази, "|" е специален знак със специално meaning, така че ако искаме да го използваме като обикновен знак (т.е. това, което искаме да намерим в оригиналния низ), тогава трябва да екранираме знака с две обратни наклонени черти. Помислете за друг пример. Да приемем, че имаме информация за поръчка, която е структурирана така: Или дори можем да приемем някои специфични стойности: Нашата задача е да изчислим общата стойност на поръчката. Тук ще трябва да приложим метода на разделяне няколко пъти. Първата стъпка е да разделите низа с помощта на ";" като разделител, за да го разделите на съставните му части. Тогава всеки получен подниз ще съдържа информация за отделен продукт, който можем да обработим по-късно. След това за всеки продукт ще разделим съответната информация с помощта на символа ",". Ще вземем елемент със специфичен индекс (този, в който се съхранява цената на продукта) от резултантния низов масив, ще го преобразуваме в числова форма и ще пресметнем общата цена на поръчката. Нека напишем метод, който ще направи всички тези изчисления:

public class Main {
    public static void main(String[] args) {
        String orderInfo = "1,cucumbers,2.39;2,tomatoes,1.89;3,bacon,4.99";
        System.out.println(getTotalOrderAmount(orderInfo));
        // Output: 9.27
    }

    static double getTotalOrderAmount(String orderInfo) {
        double totalAmount = 0d;
        final String[] items = orderInfo.split(";");

        for (String item : items) {
            final String[] itemInfo = item.split(",");
            totalAmount += Double.parseDouble(itemInfo[2]);
        }

        return totalAmount;
    }
}

Вижте дали можете сами да разберете How работи този метод. Въз основа на тези примери можем да кажем, че методът на разделяне се използва, когато имаме някои данни, форматирани като низ, и трябва да извлечем определена по-конкретна информация от тях.

Резюме

Разгледахме метода split на класа String . Това е точно това, от което се нуждаете, когато трябва да разделите низ на съставните му части с помощта на специален разделител. Методът връща масив от низове (поднизовете, които съставят оригиналния низ). Той приема регулярен израз, чиито съвпадения представляват символа(ите) на разделителя. Разгледахме различни тънкости на този метод:

• водещ разделител;
• неговият претоварен брат с два параметъра.

Също така се опитахме да моделираме някои ситуации от реалния живот, където използвахме метода на разделяне , за да разрешим хипотетични, но доста реалистични проблеми.