Delete an error in a Map
package part;
import ;
import ;
public class Java01 {
public static void main(String[] args) {
// Why do you need to use the packaging type Integer instead of int HashMap<String, Integer> map = new HashMap();
("a", 1);
("b", 2);
("c", 3);
// Get the set of all key names, the return type is Set type Set<String> Keys = ();
// Enhanced for loop for (String keyName : Keys) {
// If the key names are equal, delete it, causing the program to report an error. Will report an error if(keyName == "b"){
// (keyName); Delete will report an error ("n",11); // New additions will also report errors (keyName, 200); // OK, but we'd better use iterator to operate }
}
}
}Why do I need to use the packaging type Integer instead of int
Because: The keys and values of HashMap must be object types and cannot be basic data types.
Java provides automatic boxing (int to Integer) and unboxing (Integer to int) functions.
Integer after the int type is automatically packed
Will you report an error for Haha?
When we are in the middle of the cycle, we will not only delete it, but also report an error if we add it.
Because: When you loop through the HashMap key collection using for-each
The underlying layer for-each is implemented through Iterator
Iterator checks whether the set is modified (by a modCount variable) to determine
If you find that the collection is modified (for example, adding or deleting elements), a ConcurrentModificationException will be thrown
Why can't an error be reported when deleting it when traversing the last item?
package part;
import ;
import ;
public class Java01 {
public static void main(String[] args) {
// The keys and values of HashMap must be object types and cannot be basic data types. Integer after the int type is automatically packed HashMap<String, Integer> map = new HashMap();
("a", 1);
("b", 2);
("c", 3);
// Get the set of all key names, the return type is Set type Set<String> Keys = ();
// Enhanced for loop for (String keyName : Keys) {
// When traversing the last item, you will not report an error when deleting it if(keyName == "c"){
(keyName);
}
}
}
}Explanation: Why does it not report an error when deleting the last item?
This (ConcurrentModificationException) trigger mechanism
(ConcurrentModificationException) is used to detect whether the set is modified through the modCount variable.
When iterating through the collection, Iterator checks whether modCount is consistent with the expected value. If it is inconsistent (i.e., the set is modified), an exception will be thrown.
When you delete the last item, the Iterator may have completed the traversal, so the check for modCount is not triggered.
Therefore, there will be no error
It is best to use an iterator to modify the data.
package part;
import ;
import ;
import ;
public class Java01 {
public static void main(String[] args) {
// Why do you need to use the packaging type Integer instead of int HashMap<String, Integer> map = new HashMap();
("a", 1);
("b", 2);
("c", 3);
Set<String> keys = ();
// Iterator Iterator<String> it =();
// hasNext method is used to make sure whether the next data exists while (()) {
// Get the next data String key = ();
// Delete the key name is b if("b".equals(key)){
();
}
// 1 null 3
((key));
}
// {a=1, c=3}
(map);
}
}Iterate using removeIf() method (Java 8+)
HashMap<String, Integer> map = new HashMap<>();
("a", 1);
("b", 2);
("c", 3);
Set<String> keys = ();
(keyName -> ("c")); // Use removeIf(map); // Output: {a=1, b=2}Can other items be deleted using an iterator?
That is to say: when we loop through the item a, can we delete the data of the item b?
No.
Because: Only this item in the current loop can be deleted. Again: Only this item in the current loop can be deleted
Convert an array to a string ()
package part;
import ;
public class Java01 {
public static void main(String[] args) {
// Declare and initialize an int array int[] is= {1, 2, 3, 4, 5};
// Convert to string [1, 2, 3, 4, 5] String str = (is);
(str);
// [I@28d93b30 is the memory address of hashCode (is);
}
}Convert arrays into collections and ascending order
package part;
import ;
import ;
public class Java01 {
public static void main(String[] args) {
// Convert arrays into collections List<Integer> list = (1, 2, 3, 4, 5);
int[] arr = {4,1,-3,10 };
// The default is ascending order, which will affect the original array, which is different from js (arr);
// [-3, 1, 4, 10]
((arr));
}
}The binary search method is to find the sorted position
package part;
import ;
import ;
public class Java01 {
public static void main(String[] args) {
int[] arr = {4,1,-3,10 };
(arr);
// [-3, 1, 4, 10]
((arr));
// Query the location of 4 int index = (arr, 4);
// 2
(index);
}
}Comparison of 2 array items
package part;
import ;
import ;
public class Java01 {
public static void main(String[] args) {
int[] arr1 = {4,1,-3,10 };
int[] arr2 = {4,1,10, -3};
// Will compare whether the two arrays are equal, and will compare one-to-one. -3 of item 2 and 10 of item 2 are not equal, return flase ((arr1,arr2)); // false
}
}package part;
import ;
import ;
public class Java01 {
public static void main(String[] args) {
int[] arr1 = {4, 1, -3, 10};
int[] arr2 = {4, 1, 10, -3};
//arr1, 0, 2 means to take the first 2 from the arr1 array, starting from 0. arr2, 0, 2 means to start from the arr2 array, take the first 2 // One thing that needs to be noted is: It was introduced in JDK 9. If you are using JDK 8 or earlier, this method will report an error. ((arr1, 0, 2, arr2, 0, 2)); // Output: true }
}ArrayList The default length of the collection is 10. You set the container size must be greater than or equal to 0. If it is negative, it will report an error
package part;
import ;
public class Java01 {
public static void main(String[] args) {
ArrayList<String > list2 = new ArrayList<String>(0);
(list2); // []
ArrayList<String> list1 = new ArrayList<String>(-1);
(list1); // Illegal parameter exception }
}The access range of ArrayList is [0, length -1]
package part;
import ;
import ;
import ;
public class Java01 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
("A");
("B");
("C");
// The access range is [0, length -1] ((2));
// IndexOutOfBoundsException Index exceeds exception ((3));
}
}The length of LinkedList is 0, and use get(0) and getFirst to access the error
package part;
import ;
public class Java01 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<String>();
//Report an error IndexOutOfBoundsException ((0));
// The length of the list is 0. Now you get the first item. This operation is similar to the index cross-border. There will be an error as well //
(());
}
}JAVA Copy Full Screen
HashMap is deleted during looping, and new data will be reported as an error.
package part;
import ;
import ;
public class Java01 {
public static void main(String[] args) {
HashMap map = new HashMap();
("a",1);
("b",2);
("c",3);
// Once HashMap starts looping, if you delete and add new data, an error will occur for (Object key : ()) {
if(("b")){
// (key); Delete data error // ("d",4); New data error (key,4); // Change the data and will not report an error }
}
// We can use iterators to solve this problem. (map);
}
}This is the article about the built-in methods of iterator and arrays in Java collections and common errors. For more related contents of iterator and arrays, please search for my previous articles or continue browsing the related articles below. I hope you can support me more in the future!