内容持续更新中。。。
目录
Arrays.toString()---转换数组为String，可以直接打印数组内容
Arrays.mismatch()---比较数组相同的元素，不匹配返回索引值
List类---有序列表集合（也称为序列或列表）允许重复元素
contains()---判断元素是否在集合中，在则返回true，不在则返回false
containsAll()---判断传入的集合或元素是否包含在list中，包含则返回true，不包含在则返回false
indexOf()---查找传入的元素是否存在；存在则返回元素在列表中第一次找到的索引值，不存在则返回-1
lastIndexOf()---返回指定元素在列表集合里最后出现的索引值，没有则返回-1
isEmpty()---判断列表集合是否为空，为空则返回true,不为空返回false
removeAll()---传入列表对象，移除该对象中包含的元素
retainAll()---原列表保留传入列表中的元素，其余的元素丢弃
compute()---计算指定键及其当前映射值满足表达式时，对值做修改，不满足则返回null
computeIfAbsent()---如果键未关联或值为空，将新值赋值给其值；不为空则原值不变
computeIfPresent()---指定的键，若不为空，则修改其值
containsKey()---判断查找的映射键是否存在，存在返回true，反之返回false
containsValue()---判断映射中要查找的映射值是否在映射中，在则返回true，反之返回false
entrySet()---将映射的键值对内容成对取出来，生成列表集合元素
isEmpty()---判断映射是否元素为空，空则返回true
merge()---如果指定的键尚未与值关联或与null关联，则将其与给定的非空值关联。
remove()---根据键删除此映射的键值对，返回的为映射键对应的值
String字符串类
charAt()---通过索引获取字符串字符
解释：传入int类型索引值，返回操作此字符串中对应索引值的char字符类型数据；
用法：
String s = "abcd";
char a = s.charAt(2);
length()---获取字符串长度
解释：返回操作此字符串int类型的长度
用法：
String s = "abcd";
int a = s.length();
split()---根据条件切割字符串为数组
解释：根据正则表达式条件（即对应条件），将字符串拆分为含多个元素的字符串数组，元素为原字符串的一部分。
可以传一个参数或两个参数；一个参数时s.split("正则表达式");两个参数时s.split("正则表达式",3)即按正则表达式找到的内容，将字符串分割为3部分，当不填第二个参数时，则一直分割，直到结束；
用法：
String s = "a-b-c-d";
String[] arr = s.split("-");
分割后的arr数组内容为{"a","b","c","d"}
valueOf()---将其他类型转为字符串
解释：将其他类型转换为字符串类型
用法：
char[] arr1 = {'a','b','c'};
String s = String.valueOf(arr1);
System.out.println(s);
输出：abc
trim()---去除字符串前后的空格
解释：去除字符串前后的空格，返回新的字符串
使用：
String s = " dfdsfsdf cba ";
String x = s.trim();
System.out.println(x);
输出结果:"dfdsfsdf cba"
replace()---字符串替换
解释：将字符串的某些字符替换为其他字符，也可以是字符串的替换，返回字符串值
用法：
String s = "你叫什么？";
String x = s.replace("你","他");
System.out.println(x);
repeat()---返回字符串重复n次拼接的新字符串
解释：返回字符串重复n次拼接的新字符串
用法：
String s = "aaa fghhhhh eee";
String x = s.repeat(2);
System.out.println(x);
Arrays数组类
Arrays.toString()---转换数组为String，可以直接打印数组内容
解释：使用时传入任意类型的数组，返回后是String的类型字符串形如[a, b, c]
后续也可以人为重写toString()方法，自定义内容输出格式
用法：
String[] arr = {"a","b","c"};
String s = Arrays.toString(arr);
System.out.println(s);
程序输出结果为：[a, b, c]
Arrays.sort()---升序排序
解释：传入任意类型数组对象，对数组内的元素按升序排序，无返回值，只需传入数组，调用方法即可。
还可以指定数组索引范围进行升序排序，需传入3个参数
Arrays.sort(数组对象,起始索引,结束索引);
用法：
int[] arr = {14,25,78,11,0,100,23};
Arrays.sort(arr); //给数组按升序排序
String x = Arrays.toString(arr);
System.out.println(x);输出结果如下：
[0, 11, 14, 23, 25, 78, 100]
Arrays.parallelSort()---升序排序
解释：与Arrays.sort()等同的数组升序排序方法
传入任意类型数组对象，对数组内的元素按升序排序，无返回值，只需传入数组，调用方法即可。
还可以指定数组索引范围进行升序排序，需传入3个参数
用法：
int[] arr = {14,25,78,11,0,100,23};
Arrays.parallelSort(arr);
String x = Arrays.toString(arr);
System.out.println(x);输出结果如下：
[0, 11, 14, 23, 25, 78, 100]
两者区别：
根据性能结果，我们可以得出结论，当需要对大型数据集进行排序时，parallelSort()可能是更好的选择。但是，对于较小大小的数组，最好使用sort()，因为它提供了更好的性能。
详细请看如下链接：
https://blog.csdn.net/weixin_39946657/article/details/110612876
Arrays.equals()---比较数组
解释：比较任意同类型的数组arr1和数组arr2的元素成员是否相等，返回布尔类型的值，相等返回true,不相等返回false.
用法：
int[] arr1 = {14,25,78,11,0,100,23};
int[] arr2 = {14,25,78,11,0,100,2};
int[] arr3 = {14,25,78,11,0,100,23};
boolean x1 = Arrays.equals(arr1,arr2);
boolean x2 = Arrays.equals(arr1,arr3);
System.out.println(x1);
System.out.println(x2);
程序运行结果为：
false
true
Arrays.copyOf()---复制数组
解释：将任意类型数组，复制指定长度，并返回一个新数组对象；可以看作截断数组或复制数组（当设置的长度等于原数组长度时）的作用。
用法：
import java.util.Arrays;
public class Demo1 {
public static void main(String[] args){
int[] arr1 = {14,25,78,11,0,100,23};
int[] arr2 = Arrays.copyOf(arr1,3); //设置长度小于arr1时，复制并截取数组arr1
int[] arr3 = Arrays.copyOf(arr1,7); //设置长度与arr1相等时，完全复制数组arr1
int[] arr4 = Arrays.copyOf(arr1,10); //设置长度大于arr1时，复制数组arr1，并扩容
System.out.println(Arrays.toString(arr2));
System.out.println(Arrays.toString(arr3));
System.out.println(Arrays.toString(arr4));
}
}程序运行结果如下：
Arrays.copyOfRange()---复制数组
解释：将任意类型数组，复制指定长度，并返回一个新数组对象；可以看作截断数组或复制数组（当设置的长度等于原数组长度时）的作用。与Arrays.copyOf()用法等同。
Arrays.fill()---初始化数组元素
解释：为任意数组的每个元素设置一个初始值；无返回值，只需调用方法即可使用；格式：Arrays.fill(数组,初始值);
用法：
import java.util.Arrays;
public class Demo1 {
public static void main(String[] args){
int[] arr1 = new int[5];
Arrays.fill(arr1,89);
System.out.println(Arrays.toString(arr1));
}
}程序运行结果如图：
Arrays.setAll()---待定。。。
Arrays.mismatch()---比较数组相同的元素，不匹配返回索引值
解释：比较两个数组的元素，返回数组第一个不配的元素的索引值，若返回-1，可以认为两个数组元素完全相同（因为元素都匹配了）；
格式：int x = Arrays.mismatch(arr1,arr2);
也可以设置两个数组的任意范围的元素的匹配情况格式：int x = Arrays.mismatch(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)，返回相对索引值
用法：
package day02;
import java.util.Arrays;
public class Demo1 {
public static void main(String[] args){
String[] arr1 = {"a","b","er"};
String[] arr2 = {"a","b","er","kk"};
int x = Arrays.mismatch(arr1,arr2);
System.out.println(x);
}
}程序运行结果如下：
Collection集合类集
集合类库继承、父子关系图
Iterator---集合的迭代器
方法如下图：
1.hasNext()：方法返回true或false；判断迭代器是否有元素需要迭代
2.next()：方法返回一个对象元素
3.remove()：移除最后一次next()方法返回的那个元素
解释代码如下：
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class Demo4 {
public static void main(String[] args) {
List<String> list = new LinkedList<>();
list.add("aa");
list.add("bb");
list.add("cc");
list.add("dd");
list.add("eee");
list.add("fff");
System.out.println(list.toString());
ListIterator<String> li = list.listIterator();
System.out.println(li.next()); //aa
System.out.println(li.next()); //bb
li.remove(); //移除了bb
System.out.println("-------------------------------------------------");
System.out.println(list.toString());
while (li.hasNext()){
System.out.println(li.next()); //打印cc dd eee fff
}
}
}运行结果如下：
List类---有序列表集合（也称为序列或列表）允许重复元素
创建字符串类型的有序集合：List<String> list = new LinkedList<>();
add()---添加元素方法
两种方式
1.list.add("fff");直接添加元素
2.list.add(0,"hello");通过索引添加元素（注意索引不能超过集合容量范围）
addAll()---
1.list.addAll(list1);可以将整个集合直接添加
2.list.addAll(0,list1);通过索引将整个集合直接添加
package day02;
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("bb");
list1.add("cc");
list1.add("dd");
list1.add("eee");
list1.add("fff");
list1.add(1,"hello");
List<String> list = new LinkedList<>();
//将list1加到list中
list.addAll(list1);
//指定索引再将list1添加到list中
list.addAll(1,list1);
System.out.println(list.toString());
}
}输出打印list内容如下：
圈起处为第二次添加的内容
clear()---删除集合的所有元素
list.clear()清空集合的所有元素
contains()---判断元素是否在集合中，在则返回true，不在则返回false
如下图：
containsAll()---判断传入的集合或元素是否包含在list中，包含则返回true，不包含在则返回false
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("bb");
list1.add("cc");
list1.add("dd");
list1.add("eee");
list1.add("fff");
list1.add(1,"hello");
List<String> list = new LinkedList<>();
list.addAll(list1);
list.addAll(1,list1);
System.out.println(list.toString());
System.out.println("----------------------------------------");
List<String> list2 = new LinkedList<>();
list2.add("aa");
list2.add("eee");
List<String> list3 = new LinkedList<>();
list3.add("hgk");
list3.add("eee");
System.out.println(list.containsAll(list2));
System.out.println(list.containsAll(list3));
}
}运行结果：
equals()---判断列表集合是否相同
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list2 = new LinkedList<>();
list2.add("aa");
list2.add("eee");
List<String> list3 = new LinkedList<>();
list3.add("hgk");
list3.add("eee");
System.out.println("list2:"+list2);
System.out.println("list3:"+list3);
//打印list2和list3比较结果
System.out.println(list2.equals(list3));
System.out.println("----------------------------------------");
list2 = List.copyOf(list3);
System.out.println("list2:"+list2);
System.out.println("list3:"+list3);
//打印list2和list3比较结果
System.out.println(list2.equals(list3));
}
}运行结果：
copyOf()---复制集合元素，返回一个新集合
使用方式：List.copyOf(对象);
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list2 = new LinkedList<>();
list2.add("aa");
list2.add("eee");
List<String> list3 = new LinkedList<>();
list3.add("hgk");
list3.add("eee");
System.out.println("list2:"+list2);
System.out.println("list3:"+list3);
System.out.println("----------------------------------------");
//使用copyOf()方法复制list3集合内容,生成的新集合给到list2，list2最后的结果将和list3一致
list2 = List.copyOf(list3);
System.out.println("list2:"+list2);
System.out.println("list3:"+list3);
}
}打印结果如下：
get()---返回列表集合指定位置的元素
使用方式：返回的数据类型 a = list1.get(3);
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("eee");
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("student");
String a = list1.get(3);
System.out.println(a);
}
} 
hashCode()---返回此列表集合的哈希码值(对象在内存中的地址值)
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("eee");
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("student");
int a = list1.hashCode();
List<String> list2 = new LinkedList<>();
list2.add("tttt");
int b = list2.hashCode();
System.out.println("list1.code:"+a);
System.out.println("list2.code:"+b);
}
} 
indexOf()---查找传入的元素是否存在；存在则返回元素在列表中第一次找到的索引值，不存在则返回-1
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("eee");
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("student");
list1.add("hello");
System.out.println(list1);
int a = list1.indexOf("hello");
System.out.println(a);
int b = list1.indexOf("dd");
System.out.println(b);
}
} 
lastIndexOf()---返回指定元素在列表集合里最后出现的索引值，没有则返回-1
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("eee");
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hello");
list1.add("student");
System.out.println("list1:"+list1);
//找列表中第一次出现的"hello"
int a = list1.indexOf("hello");
System.out.println(a);
//找列表中最后一次出现的"hello"
int b = list1.lastIndexOf("hello");
System.out.println(b);
//找列表中第一次出现的"kkkk"
int c = list1.indexOf("kkkk");
System.out.println(c);
//找列表中最后一次出现的"kkkk"
int d = list1.lastIndexOf("kkkk");
System.out.println(d);
}
} 
isEmpty()---判断列表集合是否为空，为空则返回true,不为空返回false
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("eee");
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("student");
System.out.println("list1:"+list1);
//清空列表元素
list1.clear();
System.out.println("列表元素为空？"+list1.isEmpty());
}
} 
listIterator()---列表集合迭代器
1.list.listIterator();默认从0索引位置开始的迭代器
2.list.listIterator(3);默认从3索引位置开始的迭代器；（列表集合不能为空，最大索引不能小于3）
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class Demo4 {
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("eee");
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hello");
list1.add("student");
System.out.println("list1:"+list1);
System.out.println("----------------------------------------");
//li为生成的list1的迭代器
ListIterator<String> li1 = list1.listIterator();
//迭代打印元素
System.out.println("li1迭代器开始");
System.out.println(li1.next());
System.out.println(li1.next());
//li为生成的list1的迭代器
System.out.println("---------------------------------------");
ListIterator<String> li2 = list1.listIterator(4); //迭代器从索引为4的元素开始
//迭代打印元素
System.out.println("li2迭代器开始");
System.out.println(li2.next());
System.out.println(li2.next());
}
} 
of()---返回固定长度的列表集合
remove()---移除列表集合中的元素
1.list.remov(1);通过索引下标移除元素
2.list.remove("hello");通过具体元素对象进行移除
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("eee");
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hello");
list1.add("student");
System.out.println("list1:"+list1);
System.out.println("----------------------------------------");
list1.remove(1);
System.out.println("移除下标为1的元素");
System.out.println("list1:"+list1);
System.out.println("----------------------------------------");
System.out.println("移除为'java'的元素");
list1.remove("java");
System.out.println("list1:"+list1);
}
} 
removeAll()---传入列表对象，移除该对象中包含的元素
格式：list.remove(list1);
移除自身：list.remove(list);等同于list.clear();
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("eee");
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hello");
list1.add("student");
System.out.println("list1:"+list1);
System.out.println("----------------------------------------");
List<String> list2 = new LinkedList<>();
list2.add("hello");
list2.add("world");
list2.add("java");
System.out.println("list2:"+list2);
//移除list1里面含在list2中的元素
list1.removeAll(list2);
System.out.println("list1:"+list1+"移除后结果.");
}
}
replaceAll()---待更新。。。
retainAll()---原列表保留传入列表中的元素，其余的元素丢弃
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("eee");
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hello");
list1.add("student");
System.out.println("list1:"+list1);
System.out.println("----------------------------------------");
List<String> list2 = new LinkedList<>();
list2.add("hello");
list2.add("world");
list2.add("java");
System.out.println("list2:"+list2);
list1.retainAll(list2);
System.out.println("list1:"+list1);
}
} 
set()---替换列表集合中的元素
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("eee");
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hello");
list1.add("student");
System.out.println("list1:"+list1);
System.out.println("----------------------------------------");
list1.set(1,"python");
System.out.println("list1:"+list1);
}
} 
size()---返回列表集合的元素个数，返回值为int
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("eee");
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hello");
list1.add("student");
System.out.println("list1:"+list1);
System.out.println("----------------------------------------");
System.out.println(list1.size());
}
} 
sort()---给元素排序
列表集合有自己的默认排序规则，有Comparable和Comparator两个接口，在自定义对象比较时需要重写这两个接口，这里不展开说；
使用方式：Collections.sort(list1);
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
private static Object String;
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("eee");
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hello");
list1.add("student");
System.out.println("list1:"+list1);
List<Integer> list2 = new LinkedList<Integer>();
list2.add(54);
list2.add(33);
list2.add(66);
list2.add(12);
list2.add(88);
list2.add(36);
System.out.println("list2:"+list2);
System.out.println("----------------------------------------");
Collections.sort(list1);
System.out.println("list1:"+list1);
Collections.sort(list2);
System.out.println("list2:"+list2);
}
}字符串按字母顺序排，数字按大小排
spliterator()---待更新。。。
subList()---返回列表集合的指定范围的元素
返回的元素为[2,6)的索引下标的值：list1.subList(2,6);
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
private static Object String;
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("eee");
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hello");
list1.add("student");
System.out.println("list1:"+list1);
System.out.println("----------------------------------------");
Collections.sort(list1);
//返回的元素为[2,6)的索引下标的值
List<String> L = list1.subList(2,6);
System.out.println("list1:"+list1);
System.out.println("L:"+L);
}
} 
toArray()---返回列表集合元素组成的数组
用法：Object[] a = list1.toArray();
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
public class Demo4 {
private static Object String;
public static void main(String[] args) {
System.out.println("----------------------------------------");
List<String> list1 = new LinkedList<>();
list1.add("aa");
list1.add("eee");
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("hello");
list1.add("student");
System.out.println("list1:"+list1);
List<Integer> list2 = new LinkedList<Integer>();
list2.add(54);
list2.add(33);
list2.add(66);
list2.add(12);
list2.add(88);
list2.add(36);
System.out.println("list2:"+list2);
System.out.println("----------------------------------------");
Object[] a = list1.toArray();
Object[] b = list2.toArray();
System.out.println("a:"+ Arrays.toString(a));
System.out.println("b:"+Arrays.toString(b));
}
} 
HashMap类
构造方法有4种如下：
类方法：
clear()---删除所有键值对映射
用法：hm.clear();
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo4 {
public static void main(String[] args) {
HashMap<Integer, Student1> hm1 = new HashMap<>();
Student1 s1 = new Student1("薛宝钗",19,96);
Student1 s2 = new Student1("贾宝玉",18,81.5);
Student1 s3 = new Student1("林黛玉",17,96);
Student1 s4 = new Student1("王熙凤",23,95);
Student1 s5 = new Student1("史湘云",18,90);
Student1 s6 = new Student1("贾迎春",20,80);
//添加元素
hm1.put(1,s1);
hm1.put(2,s2);
hm1.put(3,s3);
hm1.put(4,s4);
hm1.put(5,s5);
hm1.put(6,s6);
//创建映射键值对视图
Set<Map.Entry<Integer, Student1>> st = hm1.entrySet();
//生成映射迭代器
Iterator<Map.Entry<Integer, Student1>> it = st.iterator();
//打印每个元素
while (it.hasNext()){
System.out.println(it.next());
}
System.out.println("---------------------------------------------------");
//清空映射里的元素
hm1.clear();
//创建映射键值对视图
st = hm1.entrySet();
//打印映射键值对视图
System.out.println(st);
}
}
clone()---浅复制映射
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo4 {
public static void main(String[] args) {
HashMap<Integer, Student1> hm1 = new HashMap<>();
Student1 s1 = new Student1("薛宝钗",19,96);
Student1 s2 = new Student1("贾宝玉",18,81.5);
Student1 s3 = new Student1("林黛玉",17,96);
Student1 s4 = new Student1("王熙凤",23,95);
Student1 s5 = new Student1("史湘云",18,90);
Student1 s6 = new Student1("贾迎春",20,80);
//添加元素
hm1.put(1,s1);
hm1.put(2,s2);
hm1.put(3,s3);
hm1.put(4,s4);
hm1.put(5,s5);
hm1.put(6,s6);
//创建映射键值对视图
Set<Map.Entry<Integer, Student1>> st1 = hm1.entrySet();
//生成映射迭代器
Iterator<Map.Entry<Integer, Student1>> it1 = st1.iterator();
//打印每个元素
while (it1.hasNext()){
System.out.println(it1.next());
}
int a = hm1.hashCode();
//打印后面hm1的哈希码
System.out.println(a);
System.out.println("---------------------------------------------------");
//hm1.clone()返回Object对象
Object hm2 = hm1.clone();
//打印hm2
System.out.println(hm2);
int b = hm2.hashCode();
//打印后面hm2的哈希码
System.out.println(b);
}
}
hm1和hm2的哈希码相同；浅复制了hm1对象的内容
compute()---计算指定键及其当前映射值满足表达式时，对值做修改，不满足则返回null
compute API简单介绍：
//表达式为三目运算
map.compute(key, (k, v) -> (v == null) ? msg : v.concat(msg))import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo4 {
public static void main(String[] args) {
HashMap<Integer, Student1> hm1 = new HashMap<>();
Student1 s1 = new Student1("薛宝钗",19,96);
Student1 s2 = new Student1("贾宝玉",18,81.5);
Student1 s3 = new Student1("林黛玉",17,96);
Student1 s4 = new Student1("王熙凤",23,95);
Student1 s5 = new Student1("史湘云",18,90);
Student1 s6 = new Student1("贾迎春",20,80);
//添加元素
hm1.put(1,s1);
hm1.put(2,s2);
hm1.put(3,s3);
hm1.put(4,s4);
hm1.put(5,s5);
hm1.put(6,s6);
//创建映射键值对视图
Set<Map.Entry<Integer, Student1>> st = hm1.entrySet();
//生成映射迭代器
Iterator<Map.Entry<Integer, Student1>> it1 = st.iterator();
//打印每个元素
while (it1.hasNext()){
System.out.println(it1.next());
}
System.out.println("---------------------------------------------------");
//表达式为三目运算
hm1.compute(3,(k,v) -> (v != null)? new Student1("林黛玉",16,96):null);
//生成映射迭代器
Iterator<Map.Entry<Integer, Student1>> it2 = st.iterator();
//打印每个元素
while (it2.hasNext()){
System.out.println(it2.next());
}
}
}如下图对值进行了修改：
computeIfAbsent()---如果键未关联或值为空，将新值赋值给其值；不为空则原值不变
用法：
map.computeIfAbsent(键值对键的值，k -> 键值对的值);
用法
map.computeIfAbsent(key, k -> value);值为空时：
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo4 {
public static void main(String[] args) {
HashMap<Integer, Student1> hm1 = new HashMap<>();
Student1 s1 = new Student1("薛宝钗",19,96);
Student1 s2 = new Student1("贾宝玉",18,81.5);
Student1 s3 = new Student1("林黛玉",17,96);
Student1 s4 = new Student1("王熙凤",23,95);
Student1 s5 = new Student1("史湘云",18,90);
Student1 s6 = new Student1("贾迎春",20,80);
Student1 s7 = new Student1("贾探春", 14, 82.5);
//添加元素
hm1.put(1,s1);
hm1.put(2,s2);
hm1.put(3,s3);
hm1.put(4,s4);
hm1.put(5,s5);
//值为空时
hm1.put(7,null);
hm1.put(6,s6);
//创建映射键值对视图
Set<Map.Entry<Integer, Student1>> st = hm1.entrySet();
//生成映射迭代器
Iterator<Map.Entry<Integer, Student1>> it1 = st.iterator();
//打印每个元素
while (it1.hasNext()){
System.out.println(it1.next());
}
System.out.println("---------------------------------------------------");
hm1.computeIfAbsent(7, k -> new Student1("贾探春", 15, 82.5));
//生成映射迭代器
Iterator<Map.Entry<Integer, Student1>> it2 = st.iterator();
//打印每个元素
while (it2.hasNext()){
System.out.println(it2.next());
}
}
}
值不为空时：
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo4 {
public static void main(String[] args) {
HashMap<Integer, Student1> hm1 = new HashMap<>();
Student1 s1 = new Student1("薛宝钗",19,96);
Student1 s2 = new Student1("贾宝玉",18,81.5);
Student1 s3 = new Student1("林黛玉",17,96);
Student1 s4 = new Student1("王熙凤",23,95);
Student1 s5 = new Student1("史湘云",18,90);
Student1 s6 = new Student1("贾迎春",20,80);
Student1 s7 = new Student1("贾探春", 14, 82.5);
//添加元素
hm1.put(1,s1);
hm1.put(2,s2);
hm1.put(3,s3);
hm1.put(4,s4);
hm1.put(5,s5);
//值不为空时
hm1.put(7,s7);
hm1.put(6,s6);
//创建映射键值对视图
Set<Map.Entry<Integer, Student1>> st = hm1.entrySet();
//生成映射迭代器
Iterator<Map.Entry<Integer, Student1>> it1 = st.iterator();
//打印每个元素
while (it1.hasNext()){
System.out.println(it1.next());
}
System.out.println("---------------------------------------------------");
hm1.computeIfAbsent(7, k -> new Student1("贾探春", 15, 82.5));
//生成映射迭代器
Iterator<Map.Entry<Integer, Student1>> it2 = st.iterator();
//打印每个元素
while (it2.hasNext()){
System.out.println(it2.next());
}
}
}值的结果不变：
computeIfPresent()---指定的键，若不为空，则修改其值
用法：
map.computeIfPresent(键值对键的值，(k,v) -> 键值对的值);
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo4 {
public static void main(String[] args) {
HashMap<Integer, Student1> hm1 = new HashMap<>();
Student1 s1 = new Student1("薛宝钗",19,96);
Student1 s2 = new Student1("贾宝玉",18,81.5);
Student1 s3 = new Student1("林黛玉",17,96);
Student1 s4 = new Student1("王熙凤",23,95);
Student1 s5 = new Student1("史湘云",18,90);
Student1 s6 = new Student1("贾迎春",20,80);
Student1 s7 = new Student1("贾探春", 14, 82.5);
//添加元素
hm1.put(1,s1);
hm1.put(2,s2);
hm1.put(3,s3);
hm1.put(4,s4);
hm1.put(5,s5);
hm1.put(7,s7);
hm1.put(6,s6);
//创建映射键值对视图
Set<Map.Entry<Integer, Student1>> st = hm1.entrySet();
//生成映射迭代器
Iterator<Map.Entry<Integer, Student1>> it1 = st.iterator();
//打印每个元素
while (it1.hasNext()){
System.out.println(it1.next());
}
System.out.println("---------------------------------------------------");
hm1.computeIfPresent(7,(k,v) -> new Student1("贾惜春", 16, 100));
//生成映射迭代器
Iterator<Map.Entry<Integer, Student1>> it2 = st.iterator();
//打印每个元素
while (it2.hasNext()){
System.out.println(it2.next());
}
}
}
containsKey()---判断查找的映射键是否存在，存在返回true，反之返回false
boolean a = map.containsKey(键)；
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo4 {
public static void main(String[] args) {
HashMap<Integer, Student1> hm1 = new HashMap<>();
Student1 s1 = new Student1("薛宝钗",19,96);
Student1 s2 = new Student1("贾宝玉",18,81.5);
Student1 s3 = new Student1("林黛玉",17,96);
Student1 s4 = new Student1("王熙凤",23,95);
Student1 s5 = new Student1("史湘云",18,90);
Student1 s6 = new Student1("贾迎春",20,80);
Student1 s7 = new Student1("贾探春", 14, 82.5);
//添加元素
hm1.put(1,s1);
hm1.put(2,s2);
hm1.put(3,s3);
hm1.put(4,s4);
hm1.put(5,s5);
hm1.put(7,s7);
hm1.put(6,s6);
//创建映射键值对视图
Set<Map.Entry<Integer, Student1>> st = hm1.entrySet();
//生成映射迭代器
Iterator<Map.Entry<Integer, Student1>> it1 = st.iterator();
//打印每个元素
while (it1.hasNext()){
System.out.println(it1.next());
}
System.out.println("---------------------------------------------------");
boolean a = hm1.containsKey(8);
System.out.println(a);
boolean b = hm1.containsKey(6);
System.out.println(b);
}
} 
containsValue()---判断映射中要查找的映射值是否在映射中，在则返回true，反之返回false
boolean a = map.containsValue(映射的值)；
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo4 {
public static void main(String[] args) {
HashMap<Integer, Student1> hm1 = new HashMap<>();
Student1 s1 = new Student1("薛宝钗",19,96);
Student1 s2 = new Student1("贾宝玉",18,81.5);
Student1 s3 = new Student1("林黛玉",17,96);
Student1 s4 = new Student1("王熙凤",23,95);
Student1 s5 = new Student1("史湘云",18,90);
Student1 s6 = new Student1("贾迎春",20,80);
Student1 s7 = new Student1("贾探春", 14, 82.5);
Student1 s8 = new Student1("尤二姐", 13, 81.5);
//添加元素
hm1.put(1,s1);
hm1.put(2,s2);
hm1.put(3,s3);
hm1.put(4,s4);
hm1.put(5,s5);
hm1.put(7,s7);
hm1.put(6,s6);
//创建映射键值对视图
Set<Map.Entry<Integer, Student1>> st = hm1.entrySet();
//生成映射迭代器
Iterator<Map.Entry<Integer, Student1>> it1 = st.iterator();
//打印每个元素
while (it1.hasNext()){
System.out.println(it1.next());
}
System.out.println("---------------------------------------------------");
boolean a = hm1.containsValue(s8);
System.out.println(a);
boolean b = hm1.containsValue(s5);
System.out.println(b);
}
}
entrySet()---将映射的键值对内容成对取出来，生成列表集合元素
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo4 {
public static void main(String[] args) {
HashMap<Integer, Student1> hm1 = new HashMap<>();
Student1 s1 = new Student1("薛宝钗",19,96);
Student1 s2 = new Student1("贾宝玉",18,81.5);
Student1 s3 = new Student1("林黛玉",17,96);
Student1 s4 = new Student1("王熙凤",23,95);
Student1 s5 = new Student1("史湘云",18,90);
Student1 s6 = new Student1("贾迎春",20,80);
Student1 s7 = new Student1("贾探春", 14, 82.5);
Student1 s8 = new Student1("尤二姐", 13, 81.5);
//添加元素
hm1.put(1,s1);
hm1.put(2,s2);
hm1.put(3,s3);
hm1.put(4,s4);
hm1.put(5,s5);
hm1.put(7,s7);
hm1.put(6,s6);
//创建映射键值对视图
Set<Map.Entry<Integer, Student1>> st = hm1.entrySet();
System.out.println("打印键值对视图："+st);
}
}返回的为键值对集合：
get()---返回指定键映射到的值，若无值则返回null
import java.util.HashMap;
public class Demo4 {
public static void main(String[] args) {
HashMap<Integer, Student1> hm1 = new HashMap<>();
Student1 s1 = new Student1("薛宝钗",19,96);
Student1 s2 = new Student1("贾宝玉",18,81.5);
Student1 s3 = new Student1("林黛玉",17,96);
Student1 s4 = new Student1("王熙凤",23,95);
Student1 s5 = new Student1("史湘云",18,90);
Student1 s6 = new Student1("贾迎春",20,80);
Student1 s7 = new Student1("贾探春", 14, 82.5);
Student1 s8 = new Student1("尤二姐", 13, 81.5);
//添加元素
hm1.put(1,s1);
hm1.put(2,s2);
hm1.put(3,s3);
hm1.put(4,s4);
hm1.put(5,s5);
hm1.put(7,s7);
hm1.put(6,s6);
Student1 s = hm1.get(6);
System.out.println(s);
}
} 
isEmpty()---判断映射是否元素为空，空则返回true
import java.util.HashMap;
public class Demo4 {
public static void main(String[] args) {
HashMap<Integer, Student1> hm1 = new HashMap<>();
Student1 s1 = new Student1("薛宝钗",19,96);
Student1 s2 = new Student1("贾宝玉",18,81.5);
Student1 s3 = new Student1("林黛玉",17,96);
Student1 s4 = new Student1("王熙凤",23,95);
Student1 s5 = new Student1("史湘云",18,90);
Student1 s6 = new Student1("贾迎春",20,80);
Student1 s7 = new Student1("贾探春", 14, 82.5);
Student1 s8 = new Student1("尤二姐", 13, 81.5);
//添加元素
hm1.put(1,s1);
hm1.put(2,s2);
hm1.put(3,s3);
hm1.put(4,s4);
hm1.put(5,s5);
hm1.put(7,s7);
hm1.put(6,s6);
boolean a = hm1.isEmpty();
System.out.println(a);
}
}
keySet()---返回映射键的列表集合
import java.util.HashMap;
import java.util.Set;
public class Demo4 {
public static void main(String[] args) {
HashMap<Integer, Student1> hm1 = new HashMap<>();
Student1 s1 = new Student1("薛宝钗",19,96);
Student1 s2 = new Student1("贾宝玉",18,81.5);
Student1 s3 = new Student1("林黛玉",17,96);
Student1 s4 = new Student1("王熙凤",23,95);
Student1 s5 = new Student1("史湘云",18,90);
Student1 s6 = new Student1("贾迎春",20,80);
Student1 s7 = new Student1("贾探春", 14, 82.5);
Student1 s8 = new Student1("尤二姐", 13, 81.5);
//添加元素
hm1.put(1,s1);
hm1.put(2,s2);
hm1.put(3,s3);
hm1.put(4,s4);
hm1.put(5,s5);
hm1.put(7,s7);
hm1.put(6,s6);
//映射键的列表集合
Set<Integer> ks = hm1.keySet();
System.out.println(ks);
}
}
merge()---如果指定的键尚未与值关联或与null关联，则将其与给定的非空值关联。
用法：
map.merge(传入键, 传入值, (oldValue, newValue) -> oldValue+newValue);返回计算后映射的值
import java.util.HashMap;
public class Demo4 {
public static void main(String[] args) {
//创建一个HashMap
HashMap<String, Integer> prices = new HashMap<>();
// 往 HashMap 插入映射
prices.put("Shoes", 200);
prices.put("Bag", 300);
prices.put("Pant", 150);
prices.put("Shirt", 150);
System.out.println("HashMap: " + prices);
int returnedValue = prices.merge("Shirt", 100, (oldValue, newValue) -> oldValue+newValue);
System.out.println("Price of Shirt: " + returnedValue);
// 输出更新后的 HashMap
System.out.println("Updated HashMap: " + prices);
}
} 
put()---新增映射键值对
map.(传入键，传入值)；
import java.util.HashMap;
public class Demo4 {
public static void main(String[] args) {
//创建一个HashMap
HashMap<String, Integer> prices = new HashMap<>();
// 往 HashMap 插入映射
prices.put("Shoes", 200);
prices.put("Bag", 300);
prices.put("Pant", 150);
prices.put("Shirt", 150);
System.out.println("HashMap: " + prices);
}
}
putAll()---将另一个映射元素添加到当前映射里
map1.putAll(map2);
import java.util.HashMap;
public class Demo4 {
public static void main(String[] args) {
//创建一个HashMap
HashMap<String, Integer> prices1 = new HashMap<>();
HashMap<String, Integer> prices2 = new HashMap<>();
// 往 HashMap 插入映射
prices1.put("Shoes", 200);
prices2.put("Bag", 300);
prices2.put("Pant", 150);
prices2.put("Shirt", 150);
prices1.putAll(prices2);
System.out.println("HashMap: " + prices1);
}
} 
remove()---根据键删除此映射的键值对，返回的为映射键对应的值
import java.util.HashMap;
public class Demo4 {
public static void main(String[] args) {
//创建一个HashMap
HashMap<String, Integer> prices2 = new HashMap<>();
// 往 HashMap 插入映射
prices2.put("Shoes", 200);
prices2.put("Bag", 300);
prices2.put("Pant", 150);
prices2.put("Shirt", 210);
//打印最初的prices2
System.out.println("HashMap: " + prices2);
System.out.println("-------------------------------------");
//删除Shirt:150键值对
int re = prices2.remove("Shirt");
//打印之后的prices2
System.out.println("HashMap: " + prices2);
//打印删除的键值对的值
System.out.println(re);
}
}
size()---返回键值对的数量
import java.util.HashMap;
public class Demo4 {
public static void main(String[] args) {
//创建一个HashMap
HashMap<String, Integer> prices2 = new HashMap<>();
// 往 HashMap 插入映射
prices2.put("Shoes", 200);
prices2.put("Bag", 300);
prices2.put("Pant", 150);
prices2.put("Shirt", 210);
int a = prices2.size();
System.out.println(a);
//打印最初的prices2
System.out.println("HashMap: " + prices2);
System.out.println("-------------------------------------");
//删除Shirt:150键值对
int re = prices2.remove("Shirt");
int b = prices2.size();
System.out.println(b);
//打印之后的prices2
System.out.println("HashMap: " + prices2);
//打印删除的键值对的值
System.out.println(re);
}
} 
values()---返回映射中包含的值的集合
import java.util.Collection;
import java.util.HashMap;
public class Demo4 {
public static void main(String[] args) {
//创建一个HashMap
HashMap<String, Integer> prices2 = new HashMap<>();
// 往 HashMap 插入映射
prices2.put("Shoes", 200);
prices2.put("Bag", 300);
prices2.put("Pant", 150);
prices2.put("Shirt", 210);
//映射键值对中值的集合
Collection<Integer> c = prices2.values();
//打印值的集合
System.out.println(c);
//打印最初的prices2
System.out.println("HashMap: " + prices2);
System.out.println("-------------------------------------");
}
}
泛型
泛型，即不确定的类型；
应有场景：当设计某个类前期不明确是用什么数据类型时，可使用泛型；
泛型类
public class ClassName<T> {
private T data;
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}泛型接口
public interface IntercaceName<T>{
T getData();
}
实现接口时，可以选择指定泛型类型，也可以选择不指定，如下：
指定类型：
public class Interface1 implements IntercaceName<String> {
private String text; @Override public String getData() {
return text;
}
}
不指定类型：
public class Interface1<T> implements IntercaceName<T> {
private T data; @Override public T getData() {
return data;
}
}泛型方法
private static <T> T 方法名(T a, T b) {
}泛型限制类型
在使用泛型时， 可以指定泛型的限定区域
例如： 必须是某某类的子类或 某某接口的实现类，格式：
<T extends 类或接口1 & 接口2>泛型中的通配符？
类型通配符是使用？代替方法具体的类型实参。
1 <? extends Parent> 指定了泛型类型的上届
2 <? super Child> 指定了泛型类型的下届
3 <?> 指定了没有限制的泛型类型作用
1.提高代码复用率
2.泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）
注意
在编译之后程序会采取去泛型化的措施。
也就是说Java中的泛型，只在编译阶段有效。
在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加
类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
