在数学中，集合是由一些确定的对象组成的整体。这些对象称为集合的元素，
在Java中，集合（Collection）是一种用来存储和操作一组对象的容器。Java提供了多个集合类和接口，位于java.util包中，用于处理不同类型的集合需求。
Java中的集合主要分为两大类：Collection和Map。
Collection：是存储一组对象的集合接口，它的子接口包括List、Set和Queue。
Map：是一种键值对（Key-Value）映射的数据结构，它的实现类有HashMap、TreeMap、LinkedHashMap等。
这些集合类提供了丰富的方法，用于添加、删除、查询、遍历等操作。通过使用集合，可以方便地管理和操作一组对象，并提供了更高效的数据存取方式。
动态数组?? 它实现了 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 = false
boolean 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
// 可以方便地对列表进行遍历、修改和定位操作。
// 获取列表 Spliterator
Spliterator<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); }双向链表数据结构 它实现了 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 = true
linkedList.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]
}
}
它实现了 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 = []
}
}
它实现了 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 = []
}
}
队列 遵循先进先出（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
}
}
实现了 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 = true
System.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);
// 输出：1
int 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 = {}
}
}
实现了 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)。
它是 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。?
//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;
}
@Override
public 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;
}
@Override
public 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);
}
@Override
public 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-2
TPhone 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);
}
}
//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;
}
@Override
public String toString() {
return "man{" +
"姓名：'" + name + '\'' +
", 年龄：'" + age + '\'' +
'}';
}
@Override
public 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);
}
@Override
public 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;
}
@Override
public String toString() {
return "{" + name +
"-" + age +
"-" + score +
'}';
}
@Override
public 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);
}
@Override
public 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>() {
@Override
public 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);
}
}
//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.var
Set<Map.Entry<Car, Integer>> entries = map.entrySet();
//entries.for.var
for (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变为list
ArrayList<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+" ");
}
}
}