在里面 散列 有一个哈希函数可以将键映射到某些值。但这些散列函数可能会导致冲突，即两个或多个键映射到同一个值。 链式散列 避免碰撞。其思想是使哈希表的每个单元格指向具有相同哈希函数值的记录的链表。 让我们创建一个散列函数，这样我们的散列表就有N个存储桶。 要将节点插入哈希表，我们需要找到给定键的哈希索引。它可以用散列函数来计算。 示例：hashIndex=key%noOfBuckets 插入 ：移动到与上面计算的哈希索引相对应的bucket，并在列表末尾插入新节点。 删去 ：要从哈希表中删除节点，请计算键的哈希索引，移动到与计算出的哈希索引相对应的bucket，搜索当前bucket中的列表以查找并删除具有给定键（如果找到）的节点。
null
![图片[1]-Java中的哈希-yiteyi-C++库](https://www.yiteyi.com/wp-content/uploads/geeks/geeks_chain-hashing-1.png)
请参考 散列|集2（单独链接） 详细信息。
在Java中实现哈希的方法
- 借助 散列表 （哈希的同步实现）
JAVA
// Java program to demonstrate working of HashTable import java.util.*; class GFG { public static void main(String args[]) { // Create a HashTable to store // String values corresponding to integer keys Hashtable<Integer, String> hm = new Hashtable<Integer, String>(); // Input the values hm.put( 1 , "Geeks" ); hm.put( 12 , "forGeeks" ); hm.put( 15 , "A computer" ); hm.put( 3 , "Portal" ); // Printing the Hashtable System.out.println(hm); } } |
输出：
{15=A computer, 3=Portal, 12=forGeeks, 1=Geeks}
- 借助于 哈希图 （散列的非同步更快实现）
JAVA
// Java program to create HashMap from an array // by taking the elements as Keys and // the frequencies as the Values import java.util.*; class GFG { // Function to create HashMap from array static void createHashMap( int arr[]) { // Creates an empty HashMap HashMap<Integer, Integer> hmap = new HashMap<Integer, Integer>(); // Traverse through the given array for ( int i = 0 ; i < arr.length; i++) { // Get if the element is present Integer c = hmap.get(arr[i]); // If this is first occurrence of element // Insert the element if (hmap.get(arr[i]) == null ) { hmap.put(arr[i], 1 ); } // If elements already exists in hash map // Increment the count of element by 1 else { hmap.put(arr[i], ++c); } } // Print HashMap System.out.println(hmap); } // Driver method to test above method public static void main(String[] args) { int arr[] = { 10 , 34 , 5 , 10 , 3 , 5 , 10 }; createHashMap(arr); } } |
输出：
{34=1, 3=1, 5=2, 10=3}
- 借助于 LinkedHashMap （与HashMap类似，但保持元素的顺序）
JAVA
// Java program to demonstrate working of LinkedHashMap import java.util.*; public class BasicLinkedHashMap { public static void main(String a[]) { LinkedHashMap<String, String> lhm = new LinkedHashMap<String, String>(); lhm.put( "one" , "practice.geeksforgeeks.org" ); lhm.put( "two" , "code.geeksforgeeks.org" ); lhm.put( "four" , "quiz.geeksforgeeks.org" ); // It prints the elements in same order // as they were inserted System.out.println(lhm); System.out.println( "Getting value for key 'one': " + lhm.get( "one" )); System.out.println( "Size of the map: " + lhm.size()); System.out.println( "Is map empty? " + lhm.isEmpty()); System.out.println( "Contains key 'two'? " + lhm.containsKey( "two" )); System.out.println( "Contains value 'practice.geeks" + "forgeeks.org'? " + lhm.containsValue( "practice" + ".geeksforgeeks.org" )); System.out.println( "delete element 'one': " + lhm.remove( "one" )); System.out.println(lhm); } } |
输出：
{one=practice.geeksforgeeks.org, two=code.geeksforgeeks.org, four=quiz.geeksforgeeks.org}Getting value for key 'one': practice.geeksforgeeks.orgSize of the map: 3Is map empty? falseContains key 'two'? trueContains value 'practice.geeksforgeeks.org'? truedelete element 'one': practice.geeksforgeeks.org{two=code.geeksforgeeks.org, four=quiz.geeksforgeeks.org}
- 借助于 ConcurretHashMap （与哈希表类似，同步，但使用多个锁时速度更快）
JAVA
// Java program to demonstrate working of ConcurrentHashMap import java.util.concurrent.*; class ConcurrentHashMapDemo { public static void main(String[] args) { ConcurrentHashMap<Integer, String> m = new ConcurrentHashMap<Integer, String>(); m.put( 100 , "Hello" ); m.put( 101 , "Geeks" ); m.put( 102 , "Geeks" ); // Printing the ConcurrentHashMap System.out.println( "ConcurentHashMap: " + m); // Adding Hello at 101 key // This is already present in ConcurrentHashMap object // Therefore its better to use putIfAbsent for such cases m.putIfAbsent( 101 , "Hello" ); // Printing the ConcurrentHashMap System.out.println( "ConcurentHashMap: " + m); // Trying to remove entry for 101 key // since it is present m.remove( 101 , "Geeks" ); // Printing the ConcurrentHashMap System.out.println( "ConcurentHashMap: " + m); // replacing the value for key 101 // from "Hello" to "For" m.replace( 100 , "Hello" , "For" ); // Printing the ConcurrentHashMap System.out.println( "ConcurentHashMap: " + m); } } |
输出：
ConcurentHashMap: {100=Hello, 101=Geeks, 102=Geeks}ConcurentHashMap: {100=Hello, 101=Geeks, 102=Geeks}ConcurentHashMap: {100=Hello, 102=Geeks}ConcurentHashMap: {100=For, 102=Geeks}
- 借助于 哈希集 （与HashMap类似，但只维护密钥，不维护密钥对）
JAVA
// Java program to demonstrate working of HashSet import java.util.*; class Test { public static void main(String[] args) { HashSet<String> h = new HashSet<String>(); // Adding elements into HashSet using add() h.add( "India" ); h.add( "Australia" ); h.add( "South Africa" ); h.add( "India" ); // adding duplicate elements // Displaying the HashSet System.out.println(h); // Checking if India is present or not System.out.println( "HashSet contains India or not:" + h.contains( "India" )); // Removing items from HashSet using remove() h.remove( "Australia" ); // Printing the HashSet System.out.println( "List after removing Australia:" + h); // Iterating over hash set items System.out.println( "Iterating over list:" ); Iterator<String> i = h.iterator(); while (i.hasNext()) System.out.println(i.next()); } } |
输出：
[South Africa, Australia, India]HashSet contains India or not:trueList after removing Australia:[South Africa, India]Iterating over list:South AfricaIndia
借助于 LinkedHashSet （与LinkedHashMap类似，但只维护密钥，不维护配对）
JAVA
// Java program to demonstrate working of LinkedHashSet import java.util.LinkedHashSet; public class Demo { public static void main(String[] args) { LinkedHashSet<String> linkedset = new LinkedHashSet<String>(); // Adding element to LinkedHashSet linkedset.add( "A" ); linkedset.add( "B" ); linkedset.add( "C" ); linkedset.add( "D" ); // This will not add new element as A already exists linkedset.add( "A" ); linkedset.add( "E" ); System.out.println( "Size of LinkedHashSet = " + linkedset.size()); System.out.println( "Original LinkedHashSet:" + linkedset); System.out.println( "Removing D from LinkedHashSet: " + linkedset.remove( "D" )); System.out.println( "Trying to Remove Z which is not " + "present: " + linkedset.remove( "Z" )); System.out.println( "Checking if A is present=" + linkedset.contains( "A" )); System.out.println( "Updated LinkedHashSet: " + linkedset); } } |
输出：
Size of LinkedHashSet = 5Original LinkedHashSet:[A, B, C, D, E]Removing D from LinkedHashSet: trueTrying to Remove Z which is not present: falseChecking if A is present=trueUpdated LinkedHashSet: [A, B, C, E]
- 借助于 有序树 （实现SortedSet接口，对象按排序和升序存储）。
JAVA
// Java program to demonstrate working of TreeSet import java.util.*; class TreeSetDemo { public static void main(String[] args) { TreeSet<String> ts1 = new TreeSet<String>(); // Elements are added using add() method ts1.add( "A" ); ts1.add( "B" ); ts1.add( "C" ); // Duplicates will not get insert ts1.add( "C" ); // Elements get stored in default natural // Sorting Order(Ascending) System.out.println( "TreeSet: " + ts1); // Checking if A is present or not System.out.println( "TreeSet contains A or not:" + ts1.contains( "A" )); // Removing items from TreeSet using remove() ts1.remove( "A" ); // Printing the TreeSet System.out.println( "TreeSet after removing A:" + ts1); // Iterating over TreeSet items System.out.println( "Iterating over TreeSet:" ); Iterator<String> i = ts1.iterator(); while (i.hasNext()) System.out.println(i.next()); } } |
输出：
TreeSet: [A, B, C]TreeSet contains A or not:trueTreeSet after removing A:[B, C]Iterating over TreeSet:BC
© 版权声明
文章版权归作者所有，未经允许请勿转载。
THE END
![关于”PostgreSQL错误：关系[表]不存在“问题的原因和解决方案-yiteyi-C++库](https://www.yiteyi.com/wp-content/themes/zibll/img/thumbnail.svg)
