什么是集合

在数学中，集合是由一些确定的对象组成的整体。这些对象称为集合的元素，

在Java中，集合（Collection）是一种用来存储和操作一组对象的容器。Java提供了多个集合类和接口，位于java.util包中，用于处理不同类型的集合需求。

Java中的集合主要分为两大类：Collection和Map。

Collection：是存储一组对象的集合接口，它的子接口包括List、Set和Queue。
- List：有序、可重复的集合，允许通过索引访问元素。常见的实现类有ArrayList和LinkedList。
- Set：无序、不重复的集合，不允许存储相同的元素。常见的实现类有HashSet和TreeSet。
- Queue：队列集合，按照先进先出（FIFO）的原则进行元素的添加和删除。常见的实现类有LinkedList和PriorityQueue。
Map：是一种键值对（Key-Value）映射的数据结构，它的实现类有HashMap、TreeMap、LinkedHashMap等。

这些集合类提供了丰富的方法，用于添加、删除、查询、遍历等操作。通过使用集合，可以方便地管理和操作一组对象，并提供了更高效的数据存取方式。

ArrayList:

动态数组它实现了 List 接口相比于传统的数组，ArrayList 具有更便利的方法和更灵活的大小调整。

ArrayList 的扩容是自动进行的，当元素数量超过当前容量时，会自动增加容量以容纳更多的元素

所有操作：

package come;import java.util.*;/*** @author cqh* @date 2024/1/6* @Description*/
public class MyList {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();// 添加一个元素 小明list.add("小明");// list = [小明]// 在第一个位置加入元素 小花list.add(0,"小花");// list = [小花, 小明]// 获取元素个数int i= list.size();// i = 2// 获取第一个元素String s = list.get(0);// s = 小花// 修改元素list.set(1, "王强");// list = [小花, 王强]// 删除元素list.remove("小花");// 或者 list.remove(0);// list = [王强]ArrayList<String> list1 = new ArrayList<>();list1.add("小王");list1.add("小强");// list1 = [小王, 小强]// 判断是否包含某个元素boolean contains = list.contains("小明");// contains = falseboolean b = list.containsAll(list1);// b = false// 将第二个列表中的所有元素添加到第一个列表中list.addAll(list1);// list = [王强, 小王, 小强]// list1 =[小王, 小强]list1.addAll(1,list);//list1 = [小王, 王强, 小王, 小强, 小强]// 遍历集合list.forEach(item-> System.out.println("item = " + item));//item = 王强//item = 小王//item = 小强// 获取迭代器对象Iterator<String> iterator = list.iterator();// 使用迭代器遍历列表并打印元素while (iterator.hasNext()) {String fruit = iterator.next();System.out.println(fruit);}// 王强// 小王// 小强// 将列表转换为数组Object[] array = list.toArray();// 遍历数组并打印元素for (Object fruit : array) {System.out.println(fruit);}// 王强// 小王// 小强// 从list1中移除与list相同的元素// list = [王强, 小王, 小强]// list1 = [小王, 王强, 小王, 小强, 小强]list1.removeAll(list);// list1 = []//清空元素//list = [王强, 小王, 小强]list.clear();// list = []List<Integer> list2 = new ArrayList<>();// 添加元素list2.add(5);list2.add(2);list2.add(8);list2.add(1);//list2 = [5, 2, 8, 1]// 排序 正序Collections.sort(list2);// list2 = [1, 2, 5, 8]// 倒叙Collections.reverse(list2);// list2 = [8, 5, 2, 1]// 删除小于等于 3 的元素list2.removeIf(number -> number <= 3);// list2 = [8, 5]// 可以方便地根据指定的条件删除列表中的元素，实现灵活的元素过滤和删除操作// 创建两个ArrayList对象List<Integer> list3 = new ArrayList<>();List<Integer> list4 = new ArrayList<>();// 添加元素list3.add(1);list3.add(2);list3.add(3);list4.add(1);list4.add(2);list4.add(3);// 判断两个列表是否相等// list3 = [1,2,3]// list4 = [1,2,3]boolean isEqual = list3.equals(list4);// isEqual = true// 可以方便地比较两个列表是否相等，用于进行列表的相等性判断。// 获取列表的哈希码int i1 = list2.hashCode();// i1 = 1214// 可以方便地获取列表的哈希码，用于进行对象的存储和查找等操作。// list2 = [8,5]// 查找元素在列表中的索引位置int index = list2.indexOf(8);// index = 0// 可以方便地查找元素在列表中的索引位置，用于进行元素的定位和操作list2.add(5);list2.add(2);list2.add(8);list2.add(1);list2.add(8);list2.add(3);// 查找元素在列表中最后一次出现的索引位置// list2 = [8, 5, 5, 2, 8, 1, 8, 3]int index2 = list2.lastIndexOf(8);// index2 = 6// 可以方便地查找元素在列表中最后一次出现的索引位置，用于进行元素的定位和操作。// 获取列表迭代器ListIterator<Integer> iterator1 = list2.listIterator();// 遍历列表System.out.println("正向遍历:");while (iterator1.hasNext()) {int element = iterator1.next();System.out.println(element);}// 8// 5// 5// 2// 8// 1// 8// 3// 逆向遍历列表System.out.println("逆向遍历:");while (iterator1.hasPrevious()) {int element = iterator1.previous();System.out.println(element);}// 3// 8// 1// 8// 2// 5// 5// 8// 可以方便地对列表进行遍历、修改和定位操作。// 获取列表 SpliteratorSpliterator<Integer> spliterator = list2.spliterator();// 遍历列表System.out.println("使用 forEachRemaining 遍历列表:");spliterator.forEachRemaining(System.out::println);// 8// 5// 5// 2// 8// 1// 8// 3// 可以方便地对列表进行并行处理和优化。// 使用replaceAll方法替换列表中的所有元素list2.replaceAll(n -> n * 2);// list2 = [16, 10, 10, 4, 16, 2, 16, 6]// 可以方便地对列表中的所有元素进行替换操作// 获取列表的流并对流进行操作list2.stream().forEach(System.out::println);// 16// 10// 10// 4// 16// 2// 16// 6// 我们可以方便地获取列表的流，从而利用流式操作对列表进行各种处理。Stream 提供了丰富的中间操作和终端操作，可以灵活地进行数据处理// 获取列表的并行流list2.parallelStream().forEach(System.out::println);// 2// 16// 6// 16// 10// 4// 16// 10// 与普通的顺序流（Sequential Stream）不同，通过使用并行流，我们可以实现对列表中的元素进行并行处理，从而提高处理的效率。// 获取列表的字符串表示形式String str = list2.toString();// str = [16, 10, 10, 4, 16, 2, 16, 6]// 该方法返回一个包含列表中所有元素的字符串，每个元素之间用逗号分隔，并使用方括号括起来}}

常用操作：

创建 ArrayList 对象：

ArrayList<String> arrayList = new ArrayList<>();

添加元素到列表的末尾：
```
arrayList.add("Apple");
```
在指定位置插入元素：
```
arrayList.add(index, "Orange");
```
获取列表的大小（元素个数）：
```
int size = arrayList.size();
```
获取指定位置的元素：
```
String element = arrayList.get(index);
```
更新指定位置的元素：
```
arrayList.set(index, newValue);
```
删除指定位置的元素：
```
arrayList.remove(index);
```
删除指定元素的第一个匹配项：
```
arrayList.remove(element);
```

检查列表是否包含指定元素：

boolean containsElement = arrayList.contains(element);

检查列表是否为空：
```
boolean isEmpty = arrayList.isEmpty();
```
清空列表中的所有元素：
```
arrayList.clear();
```

迭代遍历列表的元素：

for (String element : arrayList) {System.out.println(element); }

LinkedList：

双向链表数据结构它实现了 List 接口和 Deque 接口与 ArrayList 相比，LinkedList 在插入和删除元素时更高效，但在访问和搜索元素时性能较低。

package come;import java.util.LinkedList;/*** @author cqh* @date 2024/1/6* @Description*/
public class MyLinkedListTest {public static void main(String[] args) {// 创建 LinkedList 对象LinkedList<String> linkedList  = new LinkedList<>();// 添加元素到列表的末尾linkedList.add("Apple");linkedList.addLast("Banana");// linkedList = [Apple, Banana]// 在列表的开头添加元素linkedList.addFirst("Orange");// linkedList = [Orange, Apple, Banana]// 获取列表的第一个和最后一个元素String first = linkedList.getFirst();String last = linkedList.getLast();// first = Orange// last = Banana// 获取列表的大小（元素个数）int size = linkedList.size();// size = 3// 获取指定位置的元素String s = linkedList.get(1);// s = Apple// 更新指定位置的元素// linkedList = [Orange, Apple, Banana]linkedList.set(1,"watermelon");// linkedList = [Orange, watermelon, Banana]// 删除指定位置的元素linkedList.remove(1);// linkedList = [Orange, Banana]// 删除指定元素的第一个匹配项linkedList.remove("Orange");// linkedList = [Banana]// 检查列表是否包含指定元素boolean banana = linkedList.contains("Banana");// banana = true// 迭代遍历列表的元素for (String element : linkedList) {System.out.println(element);}// Banana// 清空列表中的所有元素linkedList.clear();// linkedList = []// 检查列表是否为空boolean empty = linkedList.isEmpty();// empty = truelinkedList.add("Apple");linkedList.add("Banana");linkedList.add("watermelon");linkedList.add("Orange");// linkedList = [Apple, Banana, watermelon, Orange]// 删除第一个元素linkedList.removeFirst();// linkedList = [Banana, watermelon, Orange]// 删除最后一个元素linkedList.removeLast();// linkedList = [Banana, watermelon]}
}

HashSet：

它实现了 Set 接口用于存储不重复的元素

HashSet 使用哈希表来存储元素，具有快速查找和插入的特性。它不保证元素的顺序。

package come;import java.util.HashSet;
import java.util.SortedSet;/*** @author cqh* @date 2024/1/6* @Description*/
public class MyHashSet {public static void main(String[] args) {// 创建 HashSet 对象：HashSet<String> hashSet = new HashSet<>();// 添加元素到集合中：hashSet.add("Apple");hashSet.add("Banana");hashSet.add("watermelon");// hashSet = [Apple, watermelon, Banana]// 检查集合是否包含指定元素：boolean containsElement = hashSet.contains("watermelon");// containsElement = true// 删除指定元素：hashSet.remove("watermelon");// hashSet = [Apple, Banana]// 获取集合的大小（元素个数）：int size = hashSet.size();// size = 2// 检查集合是否为空：boolean isEmpty = hashSet.isEmpty();// isEmpty = false//迭代遍历集合的元素：for (String element : hashSet) {System.out.println(element);}// Apple// Banana// 将集合转换为数组Object[] objects = hashSet.toArray();// 遍历输出 Object 数组中的元素for (Object obj : objects) {System.out.println(obj);}// Apple// Banana//清空集合中的所有元素：hashSet.clear();// hashSet = []}
}

TreeSet:

它实现了 SortedSet 接口，用于存储有序的、不重复的元素

与 HashSet 不同，TreeSet 使用红黑树（一种自平衡二叉查找树）来存储元素，因此可以保持元素的有序性。

package come;import java.util.TreeSet;/*** @author cqh* @date 2024/1/6* @Description*/
public class MyTreeSetTest {public static void main(String[] args) {// 创建 TreeSet 对象：TreeSet<String> treeSet = new TreeSet<>();// 添加元素到集合中：treeSet.add("Apple");treeSet.add("Banana");treeSet.add("watermelon");// treeSet = [Apple, Banana, watermelon]// 检查集合是否包含指定元素：boolean containsElement = treeSet.contains("Banana");// containsElement = true// 删除指定元素：treeSet.remove("Banana");// treeSet = [Apple, watermelon]// 获取集合的大小（元素个数）：int size = treeSet.size();// size = 2// 检查集合是否为空：boolean isEmpty = treeSet.isEmpty();// isEmpty = false// 迭代遍历集合的元素：for (String element : treeSet) {System.out.println(element);}// Apple// watermelon// 清空集合中的所有元素：treeSet.clear();// treeSet = []}
}

Queue:

队列遵循先进先出（FIFO）的原则

package come;import java.util.LinkedList;
import java.util.Queue;/*** @author cqh* @date 2024/1/6* @Description*/
public class MyQueueTest {public static void main(String[] args) {Queue<String> queue = new LinkedList<>();// 添加元素到队列尾部queue.add("Apple");queue.add("Orange");queue.add("Banana");// 获取并移除队列头部元素String element = queue.poll();System.out.println(element);// 输出: "Apple"// 获取队列头部元素String peekElement = queue.peek();System.out.println(peekElement);// 输出: "Orange"// 获取队列的大小int size = queue.size();System.out.println(size);// 输出: 2// 检查队列是否为空boolean isEmpty = queue.isEmpty();System.out.println(isEmpty);// 输出: false}
}

HashMap:

实现了 Map 接口，并基于哈希表实现

它允许存储键值对，并且可以通过键来快速访问对应的值。

HashMap 的特点是根据键的哈希值来存储和访问元素，因此可以快速地查找、插入和删除元素。但是，HashMap 不保证元素的顺序，如果需要有序性，可以考虑使用 LinkedHashMap。

package come;import java.util.*;/*** @author cqh* @date 2024/1/6* @Description*/
public class MyHashMap {public static void main(String[] args) {// 创建 HashMap 对象：HashMap<String, Object> hashMap = new HashMap<>();// 添加键值对到 HashMap：hashMap.put("姓名", "小明");hashMap.put("年龄",18);hashMap.put("性别","男");// hashMap = {姓名=小明, 年龄=18, 性别=男}// 获取指定键对应的值：String xinMin = (String) hashMap.get("姓名");// xinMin = 小明// 检查是否包含指定的键：boolean containsKey = hashMap.containsKey("姓名");// containsKey = true// 检查是否包含指定的值：boolean containsValue = hashMap.containsValue("小明");// containsValue = trueSystem.out.println("hashMap = " + hashMap);// 删除指定键对应的键值对：hashMap.remove("姓名");// hashMap = {年龄=18, 性别=男}// 获取 HashMap 的大小（键值对的个数）：int size = hashMap.size();// size = 2// 迭代遍历 HashMap 的键或值：// 遍历键for (String key : hashMap.keySet()) {System.out.println(key);}// 年龄// 性别// 遍历值for (Object value : hashMap.values()) {System.out.println(value);}// 18// 男// 替换指定键所对应的值hashMap.replace("性别","女");// hashMap = {年龄=18, 性别=女}// replace() 方法只能替换已经存在的键值对，如果指定的键不存在，则不会执行替换操作HashMap<String, Object> map = new HashMap<>();map.put("爱好","羽毛球");hashMap.putAll(map);// hashMap = {爱好=羽毛球, 年龄=18, 性别=女}Set<Map.Entry<String, Object>> entries = hashMap.entrySet();for (Map.Entry<String, Object> entry : entries) {String key = entry.getKey();Object value = entry.getValue();System.out.println(key + " -> " + value);}// 爱好 -> 羽毛球//年龄 -> 18//性别 -> 女//拷贝HashMap<String, Object> clone = (HashMap<String, Object>) hashMap.clone();// clone = {爱好=羽毛球, 年龄=18, 性别=女}// 如果该键不存在，则使用指定的函数计算值并将其存储在 Map 中。如果存在，则返回当前值。Map<String, List<Integer>> map2 = new HashMap<>();// 计算一个键的值List<Integer> values1 = map2.computeIfAbsent("key1", k -> new ArrayList<>());values1.add(1);values1.add(2);System.out.println(map2);// 输出：{key1=[1, 2]}// 再次计算相同的键的值List<Integer> values2 = map2.computeIfAbsent("key1", k -> new ArrayList<>());values2.add(3);System.out.println(map2);// 输出：{key1=[1, 2, 3]}// 根据指定的键和当前值计算新值，并将其存储在 Map 中。如果该键存在且其值不为 null，则使用指定的 BiFunction 函数计算新值；否则，不执行计算操作。Map<String, Integer> map3 = new HashMap<>();map3.put("key1", 1);// 计算一个键的新值map3.computeIfPresent("key1", (k, v) -> v + 1);System.out.println(map3);// 输出：{key1=2}// 再次计算相同的键的新值map3.computeIfPresent("key1", (k, v) -> v * 2);System.out.println(map3);// 输出：{key1=4}// 删除键和值对应的映射关系map3.computeIfPresent("key1", (k, v) -> null);System.out.println(map3); // 输出：{}System.out.println("clone = " + clone);System.out.println("hashMap = " + hashMap);// 用于获取指定键对应的值，如果该键不存在，则返回指定的默认值。Map<String, Integer> map4 = new HashMap<>();map4.put("key1", 1);int value1 = map4.getOrDefault("key1", 0);System.out.println(value1); // 输出：1int value2 = map4.getOrDefault("key2", 0);System.out.println(value2);// 输出：0// 用于将指定键和值合并到 Map 中。如果指定的键不存在或其对应的值为 null，则直接将指定的键值对存储在 Map 中；如果指定的键存在且其对应的值不为 null，则使用指定的合并函数合并新值和旧值，并将合并结果存储在 Map 中。Map<String, Integer> map6 = new HashMap<>();map6.put("key1", 1);// 合并一个新值map6.merge("key1", 2, (oldValue, newValue) -> oldValue + newValue);System.out.println(map6);// 输出：{key1=3}// 再次合并相同的键和新值map6.merge("key1", 4, (oldValue, newValue) -> oldValue * newValue);System.out.println(map6);// 输出：{key1=12}// 将指定的键值对存储在 Map 中，但仅在该键不存在时才执行存储操作。如果指定的键已经存在于 Map 中，则该方法不会进行任何操作。Map<String, Integer> map7 = new HashMap<>();map7.put("key1", 1);// 尝试插入一个新的键值对map7.putIfAbsent("key2", 2);System.out.println(map7); // 输出：{key1=1, key2=2}// 再次尝试插入相同的键和新的值map7.putIfAbsent("key1", 3);System.out.println(map7); // 输出：{key1=1, key2=2}// 清空 HashMap 中的所有键值对：hashMap.clear();// hashMap = {}}
}

TreeMap:

实现了 SortedMap 接口，并基于红黑树实现。它允许存储键值对，并且可以按照键的自然顺序或指定的比较器顺序进行排序。

常见的操作:

创建 TreeMap 对象：

TreeMap<KeyType, ValueType> treeMap = new TreeMap<>();

添加键值对到 TreeMap：
```
treeMap.put(key, value);
```
获取指定键对应的值：
```
ValueType value = treeMap.get(key);
```

检查是否包含指定的键：

boolean containsKey = treeMap.containsKey(key);

检查是否包含指定的值：

boolean containsValue = treeMap.containsValue(value);

删除指定键对应的键值对：
```
treeMap.remove(key);
```
获取 TreeMap 的大小（键值对的个数）：
```
int size = treeMap.size();
```
清空 TreeMap 中的所有键值对：
```
treeMap.clear();
```

迭代遍历 TreeMap 的键或值：

// 遍历键 
for (KeyType key : treeMap.keySet()) { 
System.out.println(key); 
} 
// 遍历值 
for (ValueType value : treeMap.values()) { 
System.out.println(value); 
}

由于 TreeMap 基于红黑树实现，因此可以保证元素的有序性。但是，相对于 HashMap，TreeMap 的插入、删除和查找操作的时间复杂度更高，为 O(log n)。

LinkedHashMap:

它是 HashMap 的一个子类，同时也实现了 Map 接口。与 HashMap 不同的是，LinkedHashMap 保留了元素的插入顺序，即可以按照元素插入的顺序进行迭代

基本操作：

创建 LinkedHashMap 对象：

LinkedHashMap<KeyType, ValueType> linkedHashMap = new LinkedHashMap<>();

添加键值对到 LinkedHashMap：
```
linkedHashMap.put(key, value);
```

获取指定键对应的值：

ValueType value = linkedHashMap.get(key);

检查是否包含指定的键：

boolean containsKey = linkedHashMap.containsKey(key);

检查是否包含指定的值：

boolean containsValue = linkedHashMap.containsValue(value);

删除指定键对应的键值对：
```
linkedHashMap.remove(key);
```
获取 LinkedHashMap 的大小（键值对的个数）：
```
int size = linkedHashMap.size();
```
清空 LinkedHashMap 中的所有键值对：

   linkedHashMap.clear();

迭代遍历 LinkedHashMap 的键、值或键值对：

// 遍历键
for (KeyType key : linkedHashMap.keySet()) {System.out.println(key);
}// 遍历值
for (ValueType value : linkedHashMap.values()) {System.out.println(value);
}// 遍历键值对
for (Map.Entry<KeyType, ValueType> entry : linkedHashMap.entrySet()) {KeyType key = entry.getKey();ValueType value = entry.getValue();System.out.println(key + ": " + value);
}

LinkedHashMap 的性能相对于 HashMap 稍差，因为它需要维护一个双向链表来记录元素的插入顺序。因此，在不需要保持元素插入顺序的情况下，可以优先选择使用 HashMap。

练习：

list

//1.定义一个方法listTest(ArrayList<String> al, String s),要求使用contains()方法判断al集合里面是否包含s

package come.list01;
//1.定义一个方法listTest(ArrayList<String> al, String s),要求使用contains()方法判断al集合里面是否包含s
import java.util.ArrayList;public class d1 {public static void main(String[] args) {ArrayList<String> Al= new ArrayList<>();Al.add("s");Al.add(0,"b");Al.add(2,"c");System.out.println("Al = " + Al);boolean pd1 = listTest(Al,"s");if(pd1) {System.out.println("存在s ");}else {System.out.println("不存在s");}}public static boolean listTest(ArrayList<String> al, String s){boolean pd = al.contains("s");return pd;}//Al = [b, s, c]//存在s }

//2.定义一个方法listTest(ArrayList<String> al), 要求使用isEmpty()判断al里面是否有元素。

package come.list01;
//2.定义一个方法listTest(ArrayList<String> al), 要求使用isEmpty()判断al里面是否有元素。
import java.util.ArrayList;public class d2 {public static void main(String[] args) {ArrayList<String> Al= new ArrayList<>();Al.add("s");Al.add("d");System.out.println("Al = " + Al);boolean b = listTest(Al);if (b) {System.out.println("AL集合为空");}else{System.out.println("AL集合不为空");}}public static boolean listTest(ArrayList<String> al){boolean pd = al.isEmpty();return pd;}//Al = [s, d]//AL集合不为空}

//3.定义一个方法listTest(ArrayList<String> al, String s)，要求返回s在al里面第一次出现的索引，如果s没出现过返回-1

package come.list01;import java.lang.reflect.Array;
import java.util.ArrayList;//3.定义一个方法listTest(ArrayList<String> al, String s)，要求返回s在al里面第一次出现的索引，如果s没出现过返回-1
public class d3 {public static void main(String[] args) {ArrayList<String> al = new ArrayList<>();al.add("b");al.add("s");al.add("c");al.add("d");System.out.println("al = " + al);int i = listTest(al, "s");System.out.println("s的索引： = " + i);}public static int listTest(ArrayList<String> al, String S) {int size = al.size();for (int i = 0; i < size; i++) {String A = al.get(i);if (A.equals(S)) {// System.out.println(i);return i;}}return -1;}//al = [b, s, c, d]//s的索引： = 1
}

//4.定义一个学生类Student，包含三个属性姓名、年龄、性别，创建三个学生对象存入ArrayList集合中。
// A：遍历集合遍历输出。
// B：求出年龄最大的学生，然后将该对象的姓名变为：小猪佩奇。

package come.list01;import java.util.ArrayList;//4.定义一个学生类Student，包含三个属性姓名、年龄、性别，创建三个学生对象存入ArrayList集合中。
//	A：遍历集合遍历输出。
//	B：求出年龄最大的学生，然后将该对象的姓名变为：小猪佩奇。
public class d4 {public static void main(String[] args) {ArrayList<Student> students = new ArrayList<>();Student student1 = new Student("小明",15,"男");Student student2 = new Student("小红",16,"女");Student student3 = new Student("小强",17,"男");students.add(student1);students.add(student2);students.add(student3);System.out.println("修改前");for (Student student : students) {System.out.println("student = " + student);}int max=students.get(0).getAge();Student sut=null;for (Student student : students) {int age=student.getAge();if(max<age){max=age;sut=student;}}System.out.println("修改后");sut.setName("小猪佩奇");for (Student student : students) {System.out.println("student = " + student);}}//修改前//student = Student{name='小明', age='15', sex='男'}//student = Student{name='小红', age='16', sex='女'}//student = Student{name='小强', age='17', sex='男'}//修改后//student = Student{name='小明', age='15', sex='男'}//student = Student{name='小红', age='16', sex='女'}//student = Student{name='小猪佩奇', age='17', sex='男'}
}

student

package come.list01;import java.util.Objects;public class Student {String name;int age;String sex;public Student() {}public Student(String name, int age, String sex) {this.name = name;this.age = age;this.sex = sex;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age='" + age + '\'' +", sex='" + sex + '\'' +'}';}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return Objects.equals(name, student.name) &&Objects.equals(age, student.age) &&Objects.equals(sex, student.sex);}@Overridepublic int hashCode() {return Objects.hash(name, age, sex);}
}

//2.在测试类中，利用满参构造创建4个对象，将对象存入集合中。

package come.d1;//2.在测试类中，利用满参构造创建4个对象，将对象存入集合中。import come.d1.TPhone;import java.util.ArrayList;public class text01 {public static void main(String[] args) {ArrayList<TPhone> tP = new ArrayList<>();TPhone tPhone1 = new TPhone("华为",1200,4);TPhone tPhone2 = new TPhone("苹果",9000,1);//       华为-1200-4  苹果-9000-1  锤子-3000-3  小米-1800-2TPhone tPhone3 = new TPhone("锤子",3000,3);TPhone tPhone4 = new TPhone("小米",1800,2);tP.add(tPhone1);tP.add(tPhone2);tP.add(tPhone3);tP.add(tPhone4);System.out.println("原集合为：\n"+tP);ArrayList<TPhone> tP1 = new ArrayList<>();//    3.遍历集合，将使用年限小于2或价格低于2000的手机筛选出来。for (TPhone tPhone : tP) {if(tPhone.getPrice()<2000||tPhone.getUsefulLife()<2){tP1.add(tPhone);}}System.out.println("年限小于2或价格低于2000的手机有：");for (TPhone phone : tP1) {System.out.println(phone.getBrand()+"-"+phone.getPrice()+"-"+phone.getUsefulLife());//    4.在控制台上打印所有筛选出来的对象（格式：华为-1200-4）}}// 原集合为：//[TPhone{brand='华为', price=1200.0, UsefulLife=4}, TPhone{brand='苹果', price=9000.0, UsefulLife=1}, TPhone{brand='锤子', price=3000.0, UsefulLife=3}, TPhone{brand='小米', price=1800.0, UsefulLife=2}]//年限小于2或价格低于2000的手机有：//华为-1200.0-4//苹果-9000.0-1//小米-1800.0-2}

//①定义public static ArrayList<Phone> filter(ArrayList<Phone> list,double price) {...}方法:
//       要求：遍历list集合，将list中价格大于参数price的元素存入到另一个ArrayList<Phone> 中并返回
//    ②在main方法内完成以下要求:
//       a.根据以下内容创建并初始化3个Phone对象
//          {"小米MIX2",2999,"新机皇"}
//          {"Iphone8", 5888,"火爆新机"}
//          {"VIVO X9s",1998,"火爆新机"}
//       b.创建一个ArrayList<Phone> list_phone，将上面的3个Phone对象添加到list_phone中，
//          调用filter方法传入list_phone和2000，根据返回的list集合输出元素信息
//    示例如下：
//       小米MIX2-2999-新机皇
//       Iphone8-5888-火爆新机
//

package come.d2;import java.util.ArrayList;
import java.util.List;//①定义public static ArrayList<Phone> filter(ArrayList<Phone> list,double price) {...}方法:
//			要求：遍历list集合，将list中价格大于参数price的元素存入到另一个ArrayList<Phone> 中并返回
//		②在main方法内完成以下要求:
//			a.根据以下内容创建并初始化3个Phone对象
//				{"小米MIX2",2999,"新机皇"}
//				{"Iphone8", 5888,"火爆新机"}
//				{"VIVO X9s",1998,"火爆新机"}
//			b.创建一个ArrayList<Phone> list_phone，将上面的3个Phone对象添加到list_phone中，
//				调用filter方法传入list_phone和2000，根据返回的list集合输出元素信息
//		示例如下：
//			小米MIX2-2999-新机皇
//			Iphone8-5888-火爆新机
//
public class PhoneTest {public static void main(String[] args) {Phone phone1 = new Phone("小米MIX2",2999,"新机皇");Phone phone2 = new Phone("Iphone8", 5888,"火爆新机");Phone phone3 = new Phone("VIVO X9s",1998,"火爆新机");ArrayList<Phone> list_phone = new ArrayList<>();list_phone.add(phone1);list_phone.add(phone2);list_phone.add(phone3);ArrayList<Phone> filter = filter(list_phone, 2000);for (Phone phone : filter) {System.out.println(phone.getName()+"-"+phone.getPrice()+"-"+phone.getType());}}public static ArrayList<Phone> filter(ArrayList<Phone> list, double price) {ArrayList<Phone> phones = new ArrayList<>();for (Phone phone : list) {if(phone.getPrice()>price){phones.add(phone);}}return phones;}// 小米MIX2-2999.0-新机皇//Iphone8-5888.0-火爆新机
}

//分析以下需求，并用代码实现
//    1.创建一个储存整数的集合,键盘录入5个数据存入集合
//    2.遍历集合,将集合中大于10的元素打印到控制台上,并求和.

package come.d3;import java.util.ArrayList;
import java.util.Scanner;//分析以下需求，并用代码实现
//		1.创建一个储存整数的集合,键盘录入5个数据存入集合
//		2.遍历集合,将集合中大于10的元素打印到控制台上,并求和.
public class d3 {public static void main(String[] args) {ArrayList<Integer> i = new ArrayList<>();Scanner sc = new Scanner(System.in);System.out.println("请输入五个数：");int i1 = sc.nextInt();int i2 = sc.nextInt();int i3= sc.nextInt();int i4 = sc.nextInt();int i5 = sc.nextInt();i.add(i1);i.add(i2);i.add(i3);i.add(i4);i.add(i5);int sum=0;for (Integer integer : i) {if(integer>10){System.out.print(integer+"\t");sum=sum+integer;}}System.out.println("集合中大于10的元的和为："+sum);}
}

//根据要求完成以下功能：
//    a.定义ArrayList集合，存入如下整数：
//       11，22， 55，66， 77 , 88
//    b.遍历集合,删除大于60的元素,在控制台打印输出删除后的集合中所有元素

package come.d4;import java.util.ArrayList;//根据要求完成以下功能：
//		a.定义ArrayList集合，存入如下整数：
//			11，22， 55，66， 77 , 88
//		b.遍历集合,删除大于60的元素,在控制台打印输出删除后的集合中所有元素
public class d4 {public static void main(String[] args) {ArrayList<Integer> integers = new ArrayList<>();integers.add(11);integers.add(22);integers.add(55);integers.add(77);integers.add(88);System.out.println("原集合为："+integers);for (int i = 0; i < integers.size(); i++) {if(integers.get(i)>60){integers.remove(i);i--;}}System.out.println("删除大于60的元素后的集合为："+integers);}
}

set

//1.自定义人类，包含姓名和年龄属性。创建4个人存储到HashSet中，姓名和年龄相同的人看做同一人不存储

package com.hashset;import java.util.Objects;public class Man {private String name;private  int age;public Man() {}public Man(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "man{" +"姓名：'" + name + '\'' +", 年龄：'" + age + '\'' +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Man man = (Man) o;return Objects.equals(name, man.name) &&Objects.equals(age, man.age);}@Overridepublic int hashCode() {return Objects.hash(name, age);}
}

package com.hashset;import java.util.HashSet;//1.自定义人类，包含姓名和年龄属性。创建4个人存储到HashSet中，姓名和年龄相同的人看做同一人不存储
public class textName {public static void main(String[] args) {HashSet<Man> man = new HashSet<>();Man man1 = new Man("小明",14);Man man2 = new Man("小红",12);Man man3 = new Man("小明",14);Man man4 = new Man("小红",12);man.add(man1);man.add(man2);man.add(man3);man.add(man4);System.out.println("man = "+man );}// man = [man{姓名：'小红', 年龄：'12'}, man{姓名：'小明', 年龄：'14'}]
}

//2,键盘录入一个字符串,去掉字符串中的重复字符

package com.hashSet_2;
//2,键盘录入一个字符串,去掉字符串中的重复字符
import java.util.HashSet;
import java.util.Scanner;public class d2 {public static void main(String[] args) {HashSet<String> str = new HashSet<>();Scanner sc = new Scanner(System.in);System.out.println("输入字符串：");String s = sc.nextLine();char[] chars = s.toCharArray();for (int i = 0; i < chars.length; i++) {String a=String.valueOf(chars[i]);str.add(a);}System.out.println("输出：");System.out.println("str = " + str);}
}

//3,两个集合{"a","b","c","d","e"},{"d","e","f","g","h"}合并成一个集合,并且去掉重复的

package com.d2;
//3,两个集合{"a","b","c","d","e"},{"d","e","f","g","h"}合并成一个集合,并且去掉重复的
import java.util.HashSet;public class hashSet_3 {public static void main(String[] args) {HashSet<String> st1= new HashSet<>();HashSet<String> st2= new HashSet<>();st1.add("a");st1.add("b");st1.add("c");st1.add("d");st1.add("e");st2.add("d");st2.add("e");st2.add("f");st2.add("g");st2.add("h");System.out.println("st1 = " + st1);System.out.println("st2 = " + st2);st1.addAll(st2);System.out.println("合并后： " + st1);}//st1 = [a, b, c, d, e]//st2 = [d, e, f, g, h]//合并后： [a, b, c, d, e, f, g, h]
}

//4,有5个学生对象,如下{"lucy", 28, 98},{"lily", 23, 97},{"robt", 25, 100},{"wily", 15, 100},{"klin", 29, 93},
//分别表示的是学生的姓名,年龄和分数.现要按学生成绩进行降序,如果成绩相同那么就按年龄进行升序
// 输出格式如下:wily-15-100 robt-25-100 lucy-28-98 lily-23-97 klin-29-93

package com.treeSet;import java.util.Comparator;
import java.util.Objects;public class Student {private String name;private int age;private int score;public Student() {}public Student(String name, int age, int score) {this.name = name;this.age = age;this.score = score;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public int getScore() {return score;}public void setScore(int score) {this.score = score;}@Overridepublic String toString() {return "{"  + name +"-" + age +"-" + score +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return age == student.age &&score == student.score &&Objects.equals(name, student.name);}@Overridepublic int hashCode() {return Objects.hash(name, age, score);}}

package com.treeSet;import java.util.Comparator;
import java.util.TreeSet;//4,有5个学生对象,如下{"lucy", 28, 98},{"lily", 23, 97},{"robt", 25, 100},{"wily", 15, 100},{"klin", 29, 93},
//分别表示的是学生的姓名,年龄和分数.现要按学生成绩进行降序,如果成绩相同那么就按年龄进行升序
//	输出格式如下:wily-15-100 robt-25-100 lucy-28-98 lily-23-97 klin-29-93
public class Text {public static void main(String[] args) {Student student1 = new Student("lucy", 28, 98);Student student2= new Student("lily", 23, 97);Student student3 = new Student("robt", 25, 100);Student student4 = new Student("wily", 15, 100);Student student5 = new Student("klin", 29, 93);TreeSet<Student> stu = new TreeSet<>(new Comparator<Student>() {@Overridepublic int compare(Student o1, Student o2) {int result=o2.getScore()-o1.getScore();if(result==0){result=o1.getAge()-o2.getAge();}return result;}});stu.add(student1);stu.add(student2);stu.add(student3);stu.add(student4);stu.add(student5);System.out.println("排序后:");System.out.println(stu);}}

map

//1.往一个Map集合中添加若干元素。获取Map中的所有value.

package come.D1;import java.util.HashMap;//1.往一个Map集合中添加若干元素。获取Map中的所有value.
public class Text01 {public static void main(String[] args) {HashMap<String, Integer> map = new HashMap<>();map.put("小明",13);map.put("小王",12);map.put("小李",14);map.put("小张",16);map.put("小陈",15);Integer s = map.get("小明");System.out.println(map);System.out.println(s);System.out.println(map.get("小王"));System.out.println(map.get("小李"));System.out.println(map.get("小张"));System.out.println(map.get("小陈"));}
}

汽车练习

package come.D2;import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class Test {public static void main(String[] args) {Car car1 = new Car("小米","青色");Car car2 = new Car("华为","蓝色");Car car3 = new Car("vivo","红色");Car car4 = new Car("苹果","白色");HashMap<Car, Integer> map= new HashMap<>();map.put(car1, 1999);map.put(car2, 3999);map.put(car3, 2999);map.put(car4, 4999);Set<Car> cars = map.keySet();for (Car car : cars) {Integer in= map.get(car);System.out.println(car+"价格："+in);}
//map.entrySet.varSet<Map.Entry<Car, Integer>> entries = map.entrySet();//entries.for.varfor (Map.Entry<Car, Integer> entry : entries) {Car key = entry.getKey();Integer value = entry.getValue();System.out.println(key+"value = " + value);}}
}

//.现在有一个map集合如下：
//Map<Integer,String> map =?new?HashMap<Integer, String>();
// map.put(1,"张三丰");
// map.put(2,"周芷若");
// map.put(3,"汪峰");
// map.put(4,"灭绝师太");
//
//要求：
// 1.遍历集合，并将序号与对应人名打印。
// 2.向该map集合中插入一个编码为5姓名为李晓红的信息
// 3.移除该map中的编号为1的信息
// 4.将map集合中编号为2的姓名信息修改为"周林"

package come.D3;import java.util.HashMap;
import java.util.Set;//.现在有一个map集合如下：
//Map<Integer,String> map =?new?HashMap<Integer, String>();
//	map.put(1,"张三丰");
//	map.put(2,"周芷若");
//	map.put(3,"汪峰");
//	map.put(4,"灭绝师太");
//
//要求：
//	1.遍历集合，并将序号与对应人名打印。
//	2.向该map集合中插入一个编码为5姓名为李晓红的信息
//	3.移除该map中的编号为1的信息
//	4.将map集合中编号为2的姓名信息修改为"周林"
public class Text {public static void main(String[] args) {HashMap<Integer, String> map = new HashMap<>();map.put(1,"张三丰");map.put(2,"周芷若");map.put(3,"汪峰");map.put(4,"灭绝师太");System.out.println("改前：");System.out.println(map);Set<Integer> in = map.keySet();System.out.println("遍历打印：");for (Integer integer : in) {String s = map.get(integer);if(integer==1){}System.out.println(integer+""+s);}map.remove(1);map.put(5,"李红");map.put(2,"周林");System.out.println("更改后：");System.out.println(map);}
}

//4.定义一个泛型为String类型的List集合，统计该集合中每个字符出现的次数。

package come.D4;import java.util.ArrayList;import java.util.Collections;
import java.util.HashMap;//4.定义一个泛型为String类型的List集合，统计该集合中每个字符出现的次数。
//
//例如：集合中有”abcbcd”两个元素，程序最终输出格式为：“a = 1,b = 2,c = 2,d = 1”
public class Text {public static void main(String[] args) {ArrayList<String> list= new ArrayList<>();
Collections.addAll(list,"a","b","c","b","c","d");//Object[] ob = list.toArray();System.out.println("list集合：");System.out.println(list);HashMap<String, Integer> map = new HashMap<>();for (String s : list) {if(map.containsKey(s)){Integer in = map.get(s);in++;map.put(s,in);}else{map.put(s,1);}}System.out.println("元素个数：");System.out.println(map);}
}

洗牌

package fapai;import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Set;
public class FaPai {//洗牌和发牌的功能public static void main(String[] args) {//1.生成牌String[] color ={"♥","♠","♣","♦"};String[] number = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};//创建一个HashMap来存牌 key-编号(1-54)  value-牌面HashMap<Integer, String> map = new HashMap<>();//定义变量,记录牌的编号int count = 1;//双重for循环生成牌面for (String c : color) {for (String n : number) {//将编号和牌面存入map集合map.put(count,c+n);count++;}}//将大小王装入map.put(count,"大王");count++;map.put(count,"小王");//2.洗牌//获得所有牌的编号Set<Integer> set = map.keySet();//将set变为listArrayList<Integer> list = new ArrayList<>();list.addAll(set); //将set集合的值复制一份到list集合中//洗牌Collections.shuffle(list);//3.发牌//创建三个集合代表玩家ArrayList<Integer> list1 = new ArrayList<>();ArrayList<Integer> list2 = new ArrayList<>();ArrayList<Integer> list3 = new ArrayList<>();ArrayList<Integer> dipai = new ArrayList<>();//发牌//list集合中存储的是所有牌的编号,乱序的for (int i = 0; i < list.size(); i++) {//根据索引获取list中存储的编号Integer index = list.get(i);//根据索引分配if(i <= 2){dipai.add(index);}else if(i%3==0){list1.add(index);}else if(i%3==1){list2.add(index);}else{list3.add(index);}}//展示for (Integer integer : list1) {String s = map.get(integer);System.out.print(s+" ");}System.out.println();for (Integer integer : list2) {String s = map.get(integer);System.out.print(s+" ");}System.out.println();for (Integer integer : list3) {String s = map.get(integer);System.out.print(s+" ");}System.out.println();for (Integer integer : dipai) {String s = map.get(integer);System.out.print(s+" ");}}}