java map interface tutorial with implementation examples
Този изчерпателен урок на Java Map обхваща как да създавате, инициализирате и итерирате чрез Карти. Също така ще научите за методите за карти и примери за изпълнение:
Ще се запознаете с основите на интерфейса на картата, методите, поддържани от интерфейса на картата, и други специфични термини, свързани с интерфейса на картата.
Събирането на карти в Java е колекция, която съпоставя ключ към стойност. Това е колекция, състояща се от ключове и стойности. Всеки запис в картата се състои от ключ със съответната стойност. Клавишите са уникални в картите. Картите могат да се използват обикновено, когато трябва да модифицираме колекция въз основа на ключова стойност.
=> Проверете ВСИЧКИ уроци за Java тук.
Какво ще научите:
- Карти в Java
- Методи на картите
- Внедряване на Java Map
- Заключение
Карти в Java
Картата в Java е част от интерфейса java.util.map. Интерфейсът на картата не е част от интерфейса за събиране и това е причината, поради която картите се различават от другите колекции.
Общата йерархия на интерфейса на картата е показана по-долу.
Както е показано по-горе, има два интерфейса за внедряване на карта, т.е.интерфейс на картата и интерфейс sortedMap. Има три класа, а именно HashMap, TreeMap и LinkedHashMap.
Тези типове карти са описани по-долу:
| Клас | Описание | |
|---|---|---|
| Премахване | V премахване (Object key) | Изтрийте запис на картата за дадения ключ |
| LinkedHashMap | Разширява се от класа HashMap. Тази карта поддържа реда за вмъкване | |
| HashMap | Внедрете интерфейс на картата. HashMap не поддържа реда. | |
| TreeMap | Внедрява както интерфейс map, така и sortedMap. TreeMap поддържа възходящ ред. |
Точки, които трябва да запомните за Карти.
- В картите всеки ключ може да съответства на най-много една стойност. Също така, не може да има дублиращи се ключове в картите.
- Реализации на карти като HashMap и LinkedHashMap позволяват нулеви ключови и нулеви стойности. TreeMap обаче не го позволява.
- Карта не може да бъде обходена такава, каквато е. Следователно за обхождане трябва да се преобразува, за да се използва с помощта на метода keyset () или entrySet ().
Създайте карта в Java
За да създадем карта в Java, първо трябва да включим интерфейса в нашата програма. Можем да използваме едно от следните изявления в програмата, за да импортираме функционалността на картата.
import java.util.*; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.TreeMap; Трябва да създадем конкретна реализация на картата, тъй като тя е интерфейс.
Следните изявления създават карта в Java.
Map hash_map = new HashMap(); Map tree_map = new TreeMap(); Горните изявления ще създадат карти със спецификации по подразбиране.
Можем също така да създадем общи карти, указващи типовете както за ключ, така и за стойност.
Map myMap = new HashMap(); Горната дефиниция ще има ключове от тип string и обекти като стойности.
Инициализирайте карта в Java
Той може да бъде инициализиран чрез следните методи:
# 1) Използване на колекции
Класът Java Collections има фабрични методи, които могат да се използват за инициализиране на колекции, включително карти.
Някои методи, използвани за инициализиране на картата, са както следва:
(1) Колекции.EmptyMap ()
Collections.EmptyMap () връща сериализуема и неизменяема карта, която е празна. Например, следния ред код,
Map myMap = Collections.EMPTY_MAP; Това ще създаде празна карта. Горният метод може да изхвърли „непроверено предупреждение за присвояване“ и по този начин можем също да използваме формуляра за безопасен тип, както следва.
Map myMap = Collections.emptyMap (); (2) Collections.unModifiableMap ()
Методът unModifiableMap () приема друга карта като аргумент и създава немодифицируем изглед на оригиналната карта.
Map myMap = Collections.EMPTY_MAP; Map map_unmodifiable = Collections.unmodifiableMap (myMap); (3) Collections.singletonMap ()
Класът Collections също осигурява фабричен метод ‘singletonMap ()’, който създава неизменяема единична карта, имаща само един запис.
Map singleton_map = Collections.singletonMap('CHN', 'Beijing'); # 2) Използване на Java 8
Можем да получим поток от данни от Java 8 поточни API методи и да конструираме карти, използвайки Collectors.
Някои от методите за изграждане на карти са:
(1) Collectors.toMap ()
Събираме поток и след това използваме метода Collectors.toMap (), за да изградим карта.
Map map = Stream.of(new String()(){{'USA', 'Washington'}, {'United Kingdom', 'London'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); Горното изявление създава карта от поток Java 8.
(2) Collectors.collectingAndThen ()
В това ние адаптираме метода toMap (), който позволява на колекционера да произвежда неизменяема карта, използвайки метода collectionAndThen ().
Map immutableMap = Stream.of(new String()(){ {'USA', 'Washington'}, {'United Kingdom', 'London”} }).collect(Collectors.collectingAndThen(Collectors.toMap(p -> p (0), p -> p(1)), Collections::unmodifiableMap)); # 3) Използване на метода put на интерфейса на картата
Методът put () на интерфейса на картата може да се използва за присвояване на начални стойности на картите.
# 4) Използване на Double Brace Initialization
Техниката „двойна скоба инициализация“ създава вътрешен клас. Този клас е анонимен и има инициализатор на екземпляр в него. Това не е предпочитана техника и трябва да се избягва, тъй като може да доведе до изтичане на памет или проблеми със сериализацията.
Програмата по-долу показва различните методи за инициализиране на карта, обсъдени по-горе.
import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //using Collections //create an empty map Map emptymap = Collections.EMPTY_MAP; //create unmodifiable map using Collections Map unmodifiableMap = Collections.unmodifiableMap(emptymap); System.out.println('unmodifiableMap map values:' + unmodifiableMap); //singleton map Map singleton_map = Collections.singletonMap(10, ' TEN'); System.out.println('
singleton_map Map values:' + singleton_map); //using Java 8 //1. toMap method of collectors class Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); System.out.println('
map_cities values: ' + map_cities); //2. collectingAndThen method Map capitals_Map = Stream.of(new String()(){ {'MAH', 'Mumbai'}, {'GOA', 'Panaji'}, {'KAR', 'Bangaluru'} }).collect(Collectors.collectingAndThen (Collectors.toMap(p -> p(0), p -> p(1)), Collections::unmodifiableMap)); System.out.println('
capitals_Map values: ' + capitals_Map); //double brace initialization Map country_map = new HashMap(); country_map.put('USA', 'Washington'); country_map.put('UK', 'London'); country_map.put('IND', 'Delhi'); country_map.put('GER', 'Berlin'); System.out.println('
Map values:' + country_map); } }Изход:
unmodifiableMap стойности на картата: {}
singleton_map Стойности на картата: {10 = TEN}
Стойности на map_cities: {CH = Ченай, DL = Ню Делхи, MH = Мумбай}
capitals_Map стойности: {MAH = Мумбай, GOA = Panaji, KAR = Бангалур}
Стойности на картата: {САЩ = Вашингтон, GER = Берлин, Великобритания = Лондон, IND = Делхи}
Итерирайте върху картата в Java и отпечатайте картата
Можем да обходим картата точно по същия начин, по който обхождаме останалите колекции. В допълнение към обхождането на записите в картата, ние също можем да обходим само ключовете или само стойностите в картата. Имайте предвид, че за да прекосите карта, тя трябва да бъде преобразувана, за да се зададе първо.
Следните методи се използват за пресичане на записите в картата.
Използване на Entre Iterator
При този метод получаваме итератор на запис от набор от записи. След това, използвайки методите getKey и getValue, извличаме двойката ключ-стойност за всяко въвеждане на карта.
Следващата програма показва използването на итератор на запис.
import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //use toMap method of collectors class to populate the map Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); //transform map to set Set entries = map_cities.entrySet(); //declare an iterator Iterator iterator = entries.iterator(); System.out.println('The map entries are:'); System.out.println(' KEY VALUE'); //iterate and print key and value pairs. while(iterator.hasNext()) { Map.Entry entry = iterator.next(); System.out.println(' ' + entry.getKey() + ' ' +entry.getValue()); } } } Изход:
Записите на картата са:
КЛЮЧОВА СТОЙНОСТ
CH Ченай
DL Ню Делхи
MH Мумбай
В горната програма получаваме итератор на запис от картата, използвайки метода entrySet. След това обхождаме картата, използвайки метода hasNext () на итератора за въвеждане и отпечатваме двойката ключ-стойност.
Използване на запис за всеки цикъл
Тук обхождаме entrySet, като използваме за всеки цикъл и изпълнението е показано по-долу.
import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //use toMap method of collectors class to populate the map Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); System.out.println('The map entries are:'); System.out.println(' KEY VALUE'); //iterate using for each over entry set and print key and value pairs. for(Map.Entry entry : map_cities.entrySet()){ System.out.println(' ' + entry.getKey() + ' ' +entry.getValue()); } } } Изход:
Записите на картата са:
КЛЮЧОВА СТОЙНОСТ
CH Ченай
DL Ню Делхи
MH Мумбай
Методи на картите
Интерфейсът на картата в Java поддържа различни операции, подобни на тези, поддържани от други колекции. В този раздел ще обсъдим различните методи, предоставени от Map API в Java. Тъй като обхватът на този урок е ограничен до въвеждане на интерфейс на карта като цяло, няма да описваме тези методи.
Ще обсъдим подробно тези методи, докато обсъждаме класовете на интерфейса на картата.
Следващата таблица изброява всички методи, предоставени от API на картата.
| Име на метода | Прототип на метода | Описание |
|---|---|---|
| вземете | V get (Object key) | Връща обекта или стойността за дадения ключ |
| слагам | V put (Object key, Object value) | Вмъкване на запис ключ-стойност в картата |
| putAll | void putAll (Карта на картата) | Поставете дадени записи на картата в картата. С други думи копира или клонира карта. |
| keySet | Set keySet () | Връща зададения изглед на картата. |
| entrySet | Комплект | Връща задава изгледа за дадена карта |
| стойности | Стойности на колекцията () | Връща колекционен изглед на стойностите в картата. |
| размер | размер int () | Връща броя на записите в картата |
| ясно | празно ясно () | Изчиства картата |
| празно е | boolean isEmpty () | Проверява дали картата е празна и връща вярно, ако да. |
| съдържа стойност | boolean containsValue (стойност на обекта) | Връща true, ако картата съдържа стойността, равна на дадената стойност |
| съдържаКлюч | boolean containsKey (Object key) | Връща true, ако даден ключ съществува в картата |
| равно на | булево равно (Обект o) | Сравнява посочения обект o с картата |
| хеш код | int hashCode () | връща хеш кода за Картата |
| за всеки | void forEach (действие на BiConsumer) | Извършва дадено действие за всеки запис в картата |
| getOrDefault | V getOrDefault (Object key, V defaultValue) | Връща определена стойност за дадения ключ или стойността му по подразбиране, ако ключът не присъства |
| Премахване | булево премахване (Object key, Object value) | Премахва определени ключове и стойности |
| замени | V заместване (ключ K, стойност V) | Заменя дадения ключ с посочената стойност |
| замени | булева замяна (ключ K, V oldValue, V newValue) | Заменя старата стойност с нова стойност за даден ключ |
| replaceAll | void replaceAll (функция BiFunction) | Извиква дадена функция за заместване на всички записи на картата |
| putIfAbsent | V putIfAbsent (ключ K, стойност V) | Вмъква дадения ключ, стойност само ако вече не е налице |
| изчисли | V изчисление (ключ K, BiFunction remappingFunction) | Изчислява картографиране за посочен ключ и стойност, дадени на функцията за картографиране. |
| computeIfAbsent | V computeIfAbsent (клавиш K, Функция mappingFunction) | Изчислете стойността за дадения ключ, като използвате функцията за картографиране, ако вече не присъства. |
| computeIfPresent | V computeIfPresent (ключ K, BiFunction remappingFunction) | Изчислява ново картографиране за дадения ключ с дадената функция за пренасочване, ако стойността на ключа вече е налице |
| отивам | V сливане (K ключ, V стойност, BiFunction remappingFunction) | Свързва даден ключ със стойността, ако той вече не е свързан или е свързан с нулевата стойност. |
Всички горепосочени методи се поддържат от интерфейса на картата. Имайте предвид, че методите, които изглеждат засенчени, са новите методи, включени в Java 8.
Внедряване на Java Map
Следващата програма реализира пример на карта в Java. Тук използваме повечето от методите, разгледани по-горе.
Примерът демонстрира различни операции за получаване, пут и набор операции.
import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.Set; public class Main { public static void main(String() args) { //create a map Map country_map = new HashMap(); //assign values to the map country_map.put('IND', 'India'); country_map.put('SL', 'Srilanka'); country_map.put('CHN', 'China'); country_map.put('KOR', 'Korea'); country_map.put(null, 'Z'); // null key country_map.put('XX', null); // null value String value = country_map.get('CHN'); // get System.out.println('Key = CHN, Value : ' + value); value = country_map.getOrDefault('XX', 'Default Value'); //getOrDefault System.out.println('
Key = XX, Value : ' + value); boolean keyExists = country_map.containsKey(null); //containsKey boolean valueExists = country_map.containsValue('Z'); //containsValue System.out.println('
null keyExists : ' + keyExists + ', null valueExists= ' + valueExists); Set entrySet = country_map.entrySet(); //entrySet System.out.println('
entry set for the country_map: ' + entrySet); System.out.println('
Size of country_map : ' + country_map.size()); //size Map data_map = new HashMap(); data_map.putAll(country_map); //putAll System.out.println('
data_map mapped to country_map : ' + data_map); String nullKeyValue = data_map.remove(null); //remove System.out.println('
null key value for data_map : ' + nullKeyValue); System.out.println('
data_map after removing null key = ' + data_map); Set keySet = country_map.keySet(); //keySet System.out.println('
data map keys : ' + keySet); Collection values = country_map.values(); //values System.out.println('
data map values : ' + values); country_map.clear(); //clear System.out.println('
data map after clear operation, is empty :' + country_map.isEmpty()); } } Изход:
Ключ = CHN, Стойност: Китай
Ключ = XX, Стойност: нула
null keyExists: true, null valueExists = true
запис за страна_карта: (null = Z, XX = null, CHN = Китай, SL = Srilanka, IND = Индия, KOR = Корея)
Размер на country_map: 6
data_map картографирана на country_map: {null = Z, XX = null, CHN = Китай, SL = Srilanka, IND = Индия, KOR = Kore
да се}
нулева ключова стойност за data_map: Z
data_map след премахване на нулев ключ = {XX = null, CHN = Китай, SL = Srilanka, IND = Индия, KOR = Корея}
ключове на картата с данни: (нула, XX, CHN, SL, IND, KOR)
стойности на картата с данни: (Z, нула, Китай, Шриланка, Индия, Корея)
карта с данни след ясна работа, е празна: true
Сортиране на карта в Java
Тъй като картата се състои от двойки ключ-стойност, можем да сортираме картата по ключове или стойности.
В този раздел ще сортираме карта както на ключовете, така и на стойностите.
Сортирай по ключ
За да сортираме карта по клавиши, можем да използваме дървесна карта. Картата на дървото сортира ключовете автоматично. Долната програма Java преобразува карта в дървовидна карта и показва сортираните ключове.
import java.util.HashMap; import java.util.Map; import java.util.TreeMap; public class Main { public static void main(String() args) { //declare and initialize a map Map country_map = new HashMap(); country_map.put('I', 'India'); country_map.put('C', 'China'); country_map.put('A', 'America'); country_map.put('D', 'Denmark'); country_map.put('X', 'Hongkong'); //print original map System.out.println('Original Unsorted Map: '); display_map(country_map); System.out.println('
Map sorted by Key: '); //convert map to treemap and display it in which keys are auto sorted Map treecountry = new TreeMap(country_map); display_map(treecountry); } public static void display_map(Map map) { //obtain entry iterator and display key value pairs of map for (Map.Entry entry : map.entrySet()) { System.out.println(' ' + entry.getKey() + ' ' + entry.getValue()); } } }Изход:
Оригинална несортирана карта:
Америка
С Китай
D Дания
X Хонконг
Аз Индия
Карта, сортирана по ключ:
Америка
С Китай
D Дания
Аз Индия
X Хонконг
Горната програма създава карта, състояща се от един азбучен код като ключове и имена на държави като стойности. Първо, показваме оригиналната карта, която не е сортирана. След това преобразуваме картата в дървовидна карта, която автоматично сортира ключовете. И накрая, показваме сортираната дървесна карта на клавишите.
Сортирай по стойност
За да сортираме карта въз основа на стойности, първо преобразуваме картата в списък. След това сортираме този списък, използвайки метода Collections.sort (), който използва сравнител за сравняване на стойностите и подреждането им в определен ред.
След като списъкът бъде сортиран, свързаните записи в списъка отново се копират на карта, която ни дава сортираната карта.
Следващата Java програма демонстрира сортирането на карта въз основа на стойност. Програмата използва LinkedHashMap, която се предава на функцията за сортиране. Във функцията за сортиране тя се преобразува в свързан списък и се сортира. След сортирането се преобразува обратно в LinkedHashMap.
какво е .eps файл
import java.util.*; public class Main { public static void main(String() args) { //define and initialize a map LinkedHashMap capitals_map = new LinkedHashMap(); capitals_map.put('NEP', 'Kathmandu'); capitals_map.put('IND', 'New Delhi'); capitals_map.put('USA', 'Washington'); capitals_map.put('UK', 'London'); capitals_map.put('AUS', 'Canberra'); //print original map System.out.println('Original unsorted map: '); System.out.println(capitals_map); //call sortMap method Map sorted_Map = sortMap(capitals_map); //print the sorted map System.out.println('
Map sorted on value : '); System.out.println(' Key Value '); for (Map.Entry entry : sorted_Map.entrySet()) { System.out.println(' ' + entry.getKey()+ ' ' + entry.getValue()); } } public static LinkedHashMap sortMap(LinkedHashMap linked_map) { //create a linkedlist from LinkedHashMap List capital_List = new LinkedList(linked_map.entrySet()); //sort the LinkedList Collections.sort(capital_List, (o1, o2) -> o1.getValue().compareTo(o2.getValue())); //Create LinkedHashMap from linkedlist and return it LinkedHashMap finalMap = new LinkedHashMap(); for (Map.Entry entry : capital_List) { finalMap.put(entry.getKey(), entry.getValue()); } return finalMap; } } Изход:
Оригинална несортирана карта:
{NEP = Катманду, IND = Ню Делхи, САЩ = Вашингтон, Великобритания = Лондон, AUS = Канбера
Карта, сортирана по стойност:
Ключова стойност
ОТ Канбера
NEP Катманду
Великобритания Лондон
IND Ню Делхи
САЩ Вашингтон
Едновременна карта в Java
ConcurrentMap е интерфейс, който наследява от интерфейса java.util.map. Интерфейсът concurrentMap е представен за първи път в JDK 1.5 и предоставя карта, която обработва едновременния достъп.
Интерфейсът concurrentMap е част от пакета java.util.concurrent.
Следващата Java програма демонстрира concurrentMap в Java.
import java.util.concurrent.*; class Main { public static void main(String() args) { //create and initialize concurrentHashMap ConcurrentHashMap m = new ConcurrentHashMap(); m.put(100, 'Red'); m.put(101, 'Green'); m.put(102, 'Blue'); System.out.println('
Initial Concurrent Map : ' + m); //add a key using putIfAbsent method; key=103 is absent so its added m.putIfAbsent(103, 'Purple'); System.out.println('
After adding absent key 103 : ' + m); m.remove(101, 'Green'); // remove key = 101 System.out.println('
Concurrent Map after removing 101:' + m); m.putIfAbsent(101, 'Brown'); // again add key = 101 since its absent System.out.println('
Add absent key 101:' + m); m.replace(101, 'Brown', 'Green'); // replace value for key = 101 with 'Green' System.out.println('
Replace value at key 101:' + m); } } import java.util.concurrent.*; class Main { public static void main(String() args) { //create and initialize concurrentHashMap ConcurrentHashMap m = new ConcurrentHashMap(); m.put(100, 'Red'); m.put(101, 'Green'); m.put(102, 'Blue'); System.out.println('
Initial Concurrent Map : ' + m); //add a key using putIfAbsent method; key=103 is absent so its added m.putIfAbsent(103, 'Purple'); System.out.println('
After adding absent key 103 : ' + m); m.remove(101, 'Green'); // remove key = 101 System.out.println('
Concurrent Map after removing 101:' + m); m.putIfAbsent(101, 'Brown'); // again add key = 101 since its absent System.out.println('
Add absent key 101:' + m); m.replace(101, 'Brown', 'Green'); // replace value for key = 101 with 'Green' System.out.println('
Replace value at key 101:' + m); } }Изход:
Първоначална едновременна карта: {100 = червено, 101 = зелено, 102 = синьо}
След добавяне на отсъстващ ключ 103: {100 = червен, 101 = зелен, 102 = син, 103 = лилав}
Едновременна карта след премахване на 101: {100 = червено, 102 = синьо, 103 = лилаво}
Добавете липсващ ключ 101: {100 = червен, 101 = кафяв, 102 = син, 103 = лилав}
Заменете стойността при ключ 101: {100 = червено, 101 = зелено, 102 = синьо, 103 = лилаво}
Синхронизирана карта в Java
Синхронизираната карта е карта, която е безопасна за нишки и е подкрепена от дадена карта. В Java синхронизираната карта се получава чрез използване на метода synchronizedMap () на класа java.util.Collections. Този метод връща синхронизирана карта за дадена карта.
Тази върната синхронизирана карта се използва за достъп до резервната карта за постигане на сериен достъп.
Общата декларация на метода synchronizedMap () е:
public static Map synchronizedMap(Map m) където m => е подкрепената карта.
Както вече споменахме, този метод връща синхронизирания изглед на карта m.
Долната програма Java е пример за синхронизирана карта.
import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a map Map int_map = new HashMap(); int_map.put(1, 10); int_map.put(2, 20); int_map.put(3, 30); int_map.put(4, 40); int_map.put(5, 50); //print the map System.out.println('Original (backed) Map: ' + int_map); //obtain synchronized map Map sync_map = Collections.synchronizedMap(int_map); //remove an element from the map int_map.remove(3, 30); //print the altered map System.out.println('
Synchronized map after remove(3, 30):' + sync_map); } } Изход:
Оригинална (подкрепена) карта: {1 = 10, 2 = 20, 3 = 30, 4 = 40, 5 = 50}
Синхронизирана карта след премахване (3, 30): {1 = 10, 2 = 20, 4 = 40, 5 = 50}
Статична карта в Java
Статичната карта в Java е карта, която е обявена за статична точно като статична променлива. Чрез деклариране на карта за статична, тя се превръща в достъпна променлива на класа, без да използва обекта.
Има два подхода за създаване и инициализиране на статична карта в Java.
# 1) Използване на статична променлива
Тук създаваме статична променлива на картата и я създаваме с инстанция заедно с декларацията.
Този подход е демонстриран в следващата Java програма.
import java.util.*; class Main { //declare a static map variable and initialize it with declaration private static final Map myMap = new HashMap(){ { put(1, 'India'); put(2, 'Portugal'); put(3, 'Germany'); } }; public static void main(String() args) { //print the map System.out.println('Static map using static map variable:'); System.out.println(myMap); } }Изход:
Статична карта, използваща статична променлива на картата:
{1 = Индия, 2 = Португалия, 3 = Германия}
# 2) Използване на статичен блок
В това създаваме статична променлива на картата. След това създаваме статичен блок и вътре в този статичен блок инициализираме променливата на картата.
Програмата по-долу демонстрира това.
import java.util.*; class Main { // Declare the static map private static Map map; // declare a static block and initialize static map static { map = new HashMap(); map.put(1, 'Red'); map.put(2, 'Green'); map.put(3, 'Blue'); } public static void main(String() args) { System.out.println('Static Map using static block:'); System.out.println(map); } } Изход:
как да използвам торент файл
Статична карта, използваща статичен блок:
{1 = червено, 2 = зелено, 3 = синьо}
Преобразуване на списъка в карта
В този раздел ще обсъдим методите за преобразуване на списъка в карта.
Двата метода включват:
Традиционен метод
В традиционния метод всеки елемент от списъка се копира в карта, използвайки цикъл за всеки.
Това изпълнение е показано по-долу:
import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a list List colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Brown'); colorsList.add('White'); System.out.println('The given list: ' + colorsList); //declare a map Map map = new HashMap(); //initial Id(key) int i=1; //assign each list element to the map for (String color : colorsList) { map.put(i, color); i++; } //print the map System.out.println('Map generated from List:' + map); } } Изход:
Даденият списък: (Червено, зелено, синьо, кафяво, бяло)
Карта, генерирана от списъка: {1 = червен, 2 = зелен, 3 = син, 4 = кафяв, 5 = бял}
Списък за картографиране в Java 8
Можем да използваме и метода Java 8 Collectors.mapOf (), който ще преобразува дадения списък в карта.
Програмата по-долу демонстрира това.
import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.stream.Collectors; // class for list class Subject { //sub_id => map key private Integer sub_id; // sub_name => map value private String sub_name; // Subject constructor public Subject(Integer sub_id, String sub_name) { // initialize sub_id and sub_name this.sub_id = sub_id; this.sub_name = sub_name; } // return sub_id public Integer getSub_Id() { return sub_id; } // return sub_name public String getSub_Name() { return sub_name; } } public class Main { public static void main(String() args) { // create a list and add values to the list List sub_list = new ArrayList(); sub_list.add(new Subject(1, 'Abacus')); sub_list.add(new Subject(2, 'Maths')); sub_list.add(new Subject(3, 'Physics')); sub_list.add(new Subject(3, 'Chemistry')); //use Java 8 Collectors.toMap() method to create a map and assign list elements to it LinkedHashMap sub_map = sub_list.stream() .collect( Collectors.toMap(Subject::getSub_Id, Subject::getSub_Name,(x, y) -> x + ', ' + y, LinkedHashMap::new)); //print the map System.out.println('Map obtained from list : ' + sub_map); } } Изход:
Карта, получена от списъка: {1 = Абакус, 2 = Математика, 3 = Физика, Химия}
В тази програма имаме клас Subject, който действа като списъчен клас. Класът Subject има две полета, т.е. sub_id и sub_name. Имаме методи за четене на стойностите на полето от класа. В основната функция създаваме обекти от този клас и изграждаме списък.
След това този списък се преобразува в картата с помощта на метода Collectors.MapOf, който взема елементите един по един. Той също така взема sub_Id като ключ към картата. Накрая се генерира картата, която има sub_Id като ключ и Sub_Name като стойност.
Конвертиране на карта в низ в Java
Колекцията от карти може да бъде преобразувана в низ, като се използват два подхода:
Използване на StringBuilder
Тук създаваме обект StringBuilder и след това копираме двойките ключ-стойност на картата в обекта StringBuilder. След това преобразуваме обекта StringBuilder в низ.
Програмата по-долу показва Java кода за преобразуване на картата в низа.
import java.util.*; import java.util.stream.Collectors; public class Main { public static void main(String() args) { //create and initialize a map Map numberNames = new HashMap(); numberNames.put(10, 'Ten'); numberNames.put(20, 'Twenty'); numberNames.put(30, 'Thirty'); numberNames.put(40, 'Forty'); //print the given map System.out.println('The given map: ' + numberNames); //create a StringBuilder object to store string StringBuilder map_String = new StringBuilder('{'); //append key-value pair of map to StringBuilder object for (Integer key : numberNames.keySet()) { map_String.append(key + '=' + numberNames.get(key) + ', '); } map_String.delete(map_String.length()-2, map_String.length()).append('}'); //print the string from StringBuilder System.out.println('
The string representation of map:'); System.out.println(map_String.toString()); } }Изход:
Дадената карта: {20 = двадесет, 40 = четиридесет, 10 = десет, 30 = тридесет}
Низовото представяне на map:
{20 = Двадесет, 40 = Четиридесет, 10 = Десет, 30 = Тридесет}
Използване на Java 8 Streams
В този метод ние създаваме поток от ключовете на картата и след това го преобразуваме в низа.
Дадената по-долу програма показва преобразуването на картата в низ с помощта на потоци.
import java.util.*; import java.util.stream.Collectors; public class Main{ public static void main(String() args) { //create and initialize a map Map numberNames = new HashMap(); numberNames.put(10, 'Ten'); numberNames.put(20, 'Twenty'); numberNames.put(30, 'Thirty'); numberNames.put(40, 'Forty'); //print the given map System.out.println('The given map: ' + numberNames); String map_String = numberNames.keySet().stream() .map(key -> key + '=' + numberNames.get(key)) .collect(Collectors.joining(', ', '{', '}')); //print the string System.out.println('
The string representation of map:'); System.out.println(map_String); } }Изход:
Дадената карта: {20 = двадесет, 40 = четиридесет, 10 = десет, 30 = тридесет}
Низовото представяне на map:
{20 = Двадесет, 40 = Четиридесет, 10 = Десет, 30 = Тридесет}
Преобразуване на карта в списък в Java
Картата се състои от ключове и стойности, докато списъкът е последователност от отделни елементи. Когато преобразуваме картата в списък, обикновено превръщаме ключовете в списък с ключове и стойности в списък със стойности.
Следната програма Java показва това преобразуване.
import java.util.*; public class Main { public static void main(String() args) { //declare a map and initialize it Map color_map = new HashMap(); color_map.put(10, 'red'); color_map.put(20, 'green'); color_map.put(30, 'blue'); color_map.put(40, 'cyan'); color_map.put(50, 'magenta'); //print the list of keys using map.keySet() method System.out.println('List of keys from the given map:'); List key_list = new ArrayList(color_map.keySet()); System.out.println(key_list); //print the list of values using map.values() method System.out.println('
List of values from the given map:'); List val_list = new ArrayList(color_map.values()); System.out.println(val_list); } }Изход:
Списък с ключове от дадената карта:
(50, 20, 40, 10, 30)
Списък на стойностите от дадената карта:
(пурпурно, зелено, циан, червено, синьо)
Речник Vs. Карта в Java
Нека обсъдим някои от основните разлики между речник и карта в Java.
| Речник | Карта |
|---|---|
| Речникът е абстрактен клас. | Картата е интерфейс. |
| Класове и методи, използвани от речниковия клас предшестват колекцията. | Класовете и методите, използвани от класовете на картата, са част от рамката за събиране. |
| Ако клас разширява речника, той не може да разшири нито един друг клас, тъй като Java поддържа само едно наследяване | Картата е интерфейс, така че клас може да наследява от картата и други интерфейси |
| Старо изпълнение. Почти остарял в по-новите версии на Java. | Интерфейсът на картата е заменил изпълнението на речника. |
често задавани въпроси
В # 1) Защо използваме интерфейс на картата в Java?
Отговор: Картата е интерфейс в Java, който се реализира от класове, съхраняващи данни като двойки ключ-стойност. Интерфейсът на картата предоставя операции / методи, които могат да се извършват върху двойки ключ-стойност като вмъкване, актуализиране, изтриване и т.н.
Q # 2)Какво означава MAP в Java?
Отговор: Карта в Java представлява картографиране на ключ със специфична стойност. Карта на Java съхранява тези двойки ключ-стойност в карта. Можем да търсим и да извлечем стойността, свързана с ключ, само като използваме ключа в картата.
В Java е внедрена карта, използваща интерфейс, който не е част от интерфейса за събиране. Но картата е колекция.
Q # 3)Какво получава MAP?
Отговор: Get () е метод, предоставен от интерфейс на картата в Java, който се използва за извличане на стойността, свързана с определен ключ, предоставен като аргумент на метода get (). Ако стойността не присъства, се връща нула.
Q # 4)Картата колекция ли е?
Отговор: Въпреки че картата се разглежда като колекция като цяло, тя не реализира интерфейса на колекция. Някои от реализациите на map, като treemap, не поддържа нулеви стойности или ключове.
Q # 5)Каква е разликата между набор и карта?
Отговор: Set е колекция само от ключове, докато картата е колекция от двойки ключ-стойност. Въпреки че наборът не позволява нулеви стойности, някои от реализациите на картата позволяват нулеви стойности.
Set не позволява дублиращи се ключове. Картата може да позволява дублирани стойности, но ключовете трябва да са уникални. Комплектът обикновено се използва, когато искаме да съхраним колекция от уникални елементи. Картата може да се използва, когато трябва да съхраняваме данни под формата на двойки ключ-стойност.
Заключение
В този урок обсъдихме основите на интерфейса на картата. Виждали сме и различните методи и всички други подробности, свързани с интерфейса на картата в Java. Разбрахме, че има различни реализации на интерфейси на карти, включително treemap, hashmap и т.н.
В предстоящите ни уроци ще обсъдим по-подробно изпълнението на тази карта.
=> Посетете тук, за да научите Java от нулата.
Препоръчително четене
- Какво представлява HashMap в Java?
- TreeMap в Java - Урок с примери за TreeMap на Java
- LinkedHashMap в Java - Пример и изпълнение на LinkedHashMap
- Задаване на интерфейс в Java: Урок за задаване на Java с примери
- Урок за JAVA за начинаещи: 100+ практически ръководства за Java видео
- Урок за стека на Java: Внедряване на клас на стека с примери
- Урок за отражение на Java с примери
- Назъбен масив в Java - урок с примери