Клас колекции в Java

здрасти През последните няколко урока постигнахме голям напредък в овладяването на ArrayList. Досега обаче извършихме само най-простите операции: премахване, вмъкване и показване. Разбира се, това не покрива пълния списък от задачи, които разработчиците трябва да изпълняват, когато работят с ArrayList. Помните ли урока за масивите и Arraysкласа? Създателите на Java специално са проектирали този клас, за да се справи с най-честите задачи, пред които са изпequalsи програмистите, когато работят с масиви. И Howво заArrayList? Със сигурност има няHowъв списък с често срещани задачи, които трябва да бъдат изпълнени с него. Всички ли са имплементирани в конкретен клас or трябва да пишем собствена реализация всеки път? Разбира се, не е нужно да пишете всичко сами. Най-често срещаните операции, включващи колекции, вече са имплементирани в специалния статичен Collectionsклас. В Java група от структури от данни обикновено се нарича колекция . Данните могат да се съхраняват по много различни начини. Досега сме изучавали само ArrayListкласа, където данните се съхраняват в масив. С други колекции ще се запознаем по-късно. Засега е достатъчно просто да разберете, че Collectionsкласът е предназначен да работи не само сArrayList, но и с други видове колекции (оттук и името му). И така, с Howви задачи Collectionsвсъщност помага класът при работа с ArrayList? Първият и най-очевиден е сортирането. В урока за масивите разгледахме пример с числа. Сега ще разгледаме пример с низове. Класът Collectionsимплементира sort()метода за сортиране на съдържанието на колекции:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       System.out.println(solarSystem);

   }
}

Изход: [Земя, Юпитер, Марс, Меркурий, Нептун, Сатурн, Уран, Венера] Низовете са сортирани по азбучен ред! Но защо по азбучен ред? Класът Stringвсъщност прилага логиката, която управлява начина, по който низовете се сравняват (което се случва по азбучен ред). За класове, които създавате сами, можете да приложите своя собствена логика за сравнение, но ще говорим за това в други уроци. Класът Collectionsсъщо ви помага да намерите минималния и максималния елемент в ArrayList. Това се прави с помощта на методите min()и max():

public static void main(java.lang.String[] args) {

   ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7));
   System.out.println(Collections.max(numbers));
   System.out.println(Collections.min(numbers));

}

Резултат: 7 1 Естествено, това е много по-удобно от ръчното писане на codeа, за да обходите всички елементи и да намерите най-големия/най-малкия елемент :) Друг много полезен метод е reverse(). Ако трябва да "обърнем" списъка, така че елементите да вървят в обратен ред, How ще го направим? Вероятно няма да е толкова лесно да напишете такъв алгоритъм сам :) За щастие, методът reverse()вече знае How. Да предположим, че не харесваме факта, че sort()методът сортира нашите планети по азбучен ред и искаме да обърнем техния ред: от Я към А:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       Collections.reverse(solarSystem);
       System.out.println(solarSystem);

   }
}

Резултат: [Венера, Уран, Сатурн, Нептун, Меркурий, Марс, Юпитер, Земя] Говорихме много за сортирането, реда на елементите и т.н. Но Howво, ако имахме противоположната цел? Да предположим например, че се опитваме да внедрим бинго игра. Добавяме 100 числа към барабана. Те трябва да се появяват на екрана един по един. Първият играч, който задраска всички числа на билета си, печели. Това е лесно за изпълнение с помощта на shuffle()метода:

public class Main {

   public static void main(java.lang.String[] args) {

       ArrayList<Integer> bingoDrum = new ArrayList<>(100);
       for (int i = 1; i <= 100; i++) {

           bingoDrum.add(i);// add the numbers 1 to 100 to the drum
       }

       Collections.shuffle(bingoDrum);// Mix it up
       System.out.println ("Your attention, please! Here are the first 10 numbers from the drum!");
       for (int i = 0; i < 10; i++) {

           System.out.println(bingoDrum.get(i));
       }

   }
}

Изход: Вашето внимание, моля! Ето и първите 10 числа от барабана! 32 61 4 81 25 8 66 35 42 71 Толкова е лесно! Проблемът е решен и нашата част от играта е написана :) Сега нека си представим различна ситуация. Преди това създадохме solarSystemсписък, който съдържаше планетите. И изглежда, че ни подхожда по всяHowъв начин, освен по един: можете да изтривате елементи от него и да добавяте нови ! Това очевидно не е поведението, което очакваме: Слънчевата система трябва да бъде непроменлива в нашата програма. Класът Collectionsима много интересен метод: unmodifiableList(). Той създава неизменен списък от списъка, подаден като аргумент. Не можете да добавяте or изтривате елементи от този списък. Когато имаме работа със списъка на планетите в Слънчевата система, това е точно това, което искаме!

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       List<String> solarSystem = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune)));
       solarSystem.add("Pluto");// Try to add a new element
   }
}

Изход: Изключение в нишката "main" java.lang.UnsupportedOperationException в java.util.Collections$UnmodifiableCollection.add(Collections.java:1075) в Main.main(Main.java:21) Това е грешка: не можете добавете нещо към solarSystem! Единственото нещо, което трябва да обърнете внимание тук, е фактът, че този метод връща List<>(не ArrayList<>), тъй като този тип е общ за всички видове списъци. Друга често срещана ситуация, която лесно може да се случи, е програмистът да добави елементи в грешен ред. Ако това се случи и установим, че Меркурий и Нептун са смесени, можем да коригираме тази грешка, като използваме swap()метода:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(neptune, venus, earth, mars
       , jupiter, saturn, uranus, mercury));// The planets are in the wrong order
       System.out.println(solarSystem);

       Collections.swap(solarSystem, solarSystem.indexOf(mercury), solarSystem.indexOf(neptune));
       System.out.println(solarSystem);

   }
}

Предаваме на swap()метода нашия списък и индексите на двата елемента, които трябва да бъдат разменени. Имайте предвид, че методът работи с индекси, а не с препратки. И така, тук трябваше да използваме ArrayList.indexOf()метода. Резултат: [Нептун, Венера, Земя, Марс, Юпитер, Сатурн, Уран, Меркурий] [Меркурий, Венера, Земя, Марс, Юпитер, Сатурн, Уран, Нептун] Накрая ще се запознаем с един много интересен метод: disjoint(). Проверява дали две колекции се пресичат, т.е. дали имат поне един идентичен елемент . Ако не го направят, връща true. Ако го направят, тогава се връща false

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystemPart1 = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars));
       ArrayList<String> solarSystemPart2 = new ArrayList<>(Arrays.asList(jupiter, saturn, uranus, neptune));

       System.out.println(Collections.disjoint(solarSystemPart1, solarSystemPart2));

   }
}

Както можете да видите, нашите два списъка имат напълно различни елементи, така че програмата извежда true . Това е интересен и много полезен клас. Като Arrays, той върши много рутинна, досадна работа instead of нас, позволявайки ни да се съсредоточим върху други неща.