Set集合
Set接口继承了Collection接口，集合中元素是不能重复的。如果有相关的元素重复内容，就保留原来的元素，添加的元素取消，不能随机读取元素，没有顺序。
Set<Integer> set1 = new HashSet<>();
//添加元素
set1.add(1);
set1.addAll(List.of(2, 3, 4, 5, 6, 1, 9));
System.out.println(set1);
//判断有没有元素
System.out.println(set1.contains(5));
System.out.println(set1.contains(7));
System.out.println(set1.containsAll(List.of(1, 23, 3, 4)));
System.out.println("=========================================");
//删除元素
System.out.println(set1.remove(9));
System.out.println(set1);
set1.clear();
System.out.println(set1);
HashSet集合，中的对象必须重写如下两个方法:equals() hashCode(),可以使用高级工具自动生成。
public class StudentsA1 implements Comparable
@Override
public int compareTo(StudentsA1 o) {
return id - o.id;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
StudentsA1 that = (StudentsA1) o;
return id == that.id;
}
Set集合遍历，不能随机读取其中的一个，要么全读取完。
for (int i : set1) {
System.out.println(i);
}
TreeSet
是一个有序，可排序的，不可重复元素的集合工具类。
TreeSet<Integer> tree = new TreeSet<>();
//加入的时候会自动排序
tree.addAll(List.of(1, 2, 3, 44, 66, 44, 1, 2, 6, 5, 4));
System.out.println(tree.size());
System.out.println(tree);
TreeSet<String> trees = new TreeSet<>();
trees.addAll(List.of("java", "python", "c", "c++", "javascript", "book", "java"));
System.out.println(trees.size());
System.out.println(trees);
可以修改排序规则。
TreeSet<String> trees = new TreeSet<>((a, b) -> b.compareTo(a));
trees.addAll(List.of("java", "python", "c", "c++", "javascript", "book", "java"));
System.out.println(trees.size());
System.out.println(trees);
Collections接口的工具类
java.util.Collections工具类，相当于数组对象的工具类Arrays工具类
排序操作
reverse(List)：反转List中元素的顺序shuffle(List)：对List集合元素进行随机排序sort(List)：根据元素的自然顺序对指定List集合元素按升序排序sort(List,Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序替换 和 查找操作
扫描二维码关注公众号，回复： 15458631 查看本文章
swap(List, int ,int )：将指定List集合中的 i 处元素 和 j 处元素进行交换Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素Object max(Collection, Comparator)：根据Comparator指定的顺序，返回给集合中的最大元素Object min(Collection)：根据元素的自然顺序，返回给定集合中的最小元素Object min(Collection, Comparator)：根据Comparator指定的顺序，返回给集合中的最大元素int frequency(Collection,Object)：返回指定集合中指定元素的出现次数void copy(List dest,List src)：将src中的内容复制到dest中 注意复制的目标集合的长度必须大于源集合，否则会抛出空指针异常boolean replaceAll(List list,Object oldVal,Object newVal)：使用新值替换List对象的所有旧值
List<Integer> list = new ArrayList<>(List.of(10,20,30,40,50,10));
System.out.println(list);
//洗牌
Collections.shuffle(list);
System.out.println(list);
//升序
Collections.sort(list);
System.out.println(list);
//降序
Collections.sort(list,(a,b)->b-a);
System.out.println(list);
//集合位置交换，倒序
Collections.reverse(list);
System.out.println(list);
Map接口
public interface Map<K, V> {
}
Map<K,V> 实现类为 HashMap<K,V>，HashMap 实例化，添加，判断，清空，删除，替换
在添加元素的时候当K重复时将新的值写入覆盖。
K不重复值一样不会被覆盖。
Map<String, String> map = new HashMap<>();
map.put("bj", "北京");
map.put("tj", "天津");
map.put("hn", "河南");
map.put("sh", "上海");
//第一种遍历方式 keySet()方法返回Set集合
Set<String> keys = map.keySet();
for (String k : keys) {
System.out.printf("map[\"%s\"] = %s%n", k, map.get(k));
}
System.out.println("1111111111111111111111111");
//第二种遍历方式 values() 返回Collection<String> 集合
Collection<String> values = map.values();
for (String v : values) {
System.out.println(v);
}
System.out.println("2222222222222222222222222222");
//第三种遍历方式 entrySet() 返回一个Set<Map.Entry<String,String>> 集合
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> e : entries) {
System.out.println(e.getKey());
System.out.println(e.getValue());
}
System.out.println("333333333333333333333333333333");
//第四种遍历方式 使用迭代器接口Iterator 接口
Iterator<String> iterator = map.values().iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println("44444444444444444444444444444");
Iterator<String> iterator1 = map.keySet().iterator();
while (iterator1.hasNext()) {
String key = iterator1.next();
System.out.println(key);
System.out.println(map.get(key));
}
Map<String, String> map = new HashMap<>();
map.put("bj", "北京");
map.put("tj", "天津");
map.put("hn", "河南");
map.put("sh", "上海");
System.out.println(map.size());
//获取值
System.out.println(map.get("hn"));
//判断有没有值
System.out.println(map.containsKey("hn"));
//获取值
if (map.containsKey("hn")) {
System.out.println(map.get("hn"));
}
HashMap不是线程同步，如果需要使用线程并发，可以使用HashTable对象。
Hashtable<K,V> implements Map<K,V>
Hashtable：底层也是哈希表，是同步的，是一个单线程结合，是线程安全的集合，速度慢
HashMap：底层也是哈希表，但是线程不安全的集合，是多线程集合，速度快
HashMap（还有之前学的所有集合）：都可以存储null键，null值
Hashtable：不能存储null键，null值
TreeMap
TreeMap是非线程同步的。
-
是一个有序的key-value集合，它是通过红黑树实现的。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
-
是继承了AbstractMap，也是以key-value集合存储。实现了NavigableMap接口，可以支持一系列的导航方法。
比如返回有序的key集合。实现了Cloneable克隆接口。
TreeMap<Integer, String> tm = new TreeMap<>();
tm.put(1, "hello1");
tm.put(2, "hello22");
tm.put(3, "hello333");
tm.put(10, "hello10");
tm.put(4, "hello4444");
System.out.println(tm);
//.descendingMap() 返回一个Map 根据key降序，对原来的TreeMap没有改变
Map<Integer, String> t2 = tm.descendingMap();
System.out.println(tm);
System.out.println(t2);
| 方法 | 说明 |
|---|---|
| put(K key, V value) | 将指定值与此映射中的指定键进行关联 |
| int size() | 返回此集合元素的个数 |
| V remove(Object key) | |
| putAll(Map map) | 将指定映射中的所有映射关系复制到此映射中 |
| Collection values() | |
| Set keySet() | 本质是TreeSet |
| Map.Entry<K,V> entrySet() | 返回Set<Map.Entry<K,V>> |
| get(Object key) | |
| containsKey(Object key) | |
| firstEntry() | 返回集合第一个Map.Entry<K,V> |
| lastEntry() | |
| firstKey() | 返回集合第一个元素的Key |
| lastKey() | |
| boolean remove(Object key, Object value) | |
| containsValue() |
集合接口及工具类总结：
Collection 接口
List 接口
ArrayList 动态数组，有序 插入删除速度慢，读取速度
LinkedList 双向链表，插入删除速度快，读取速度慢
Vector 动态数组，线程安全
Set 接口
HashSet 唯一集合，无序
TreeSet 唯一集合，是有序
Map 接口
HashMap K,V键值对集合，双列集合
TreeMap 根据key有序的map集合
Hashtable 和 HashMap一样，双列集合，线程安全