什么是集合_代码007

本文介绍: 在数学中，集合是由一些确定的对象组成的整体。这些对象称为集合的元素，在Java中，集合（Collection）是一种用来存储和操作一组对象的容器。Java提供了多个集合类和接口，位于java.util包中，用于处理不同类型的集合需求。Java中的集合主要分为两大类：Collection和Map。Collection：是存储一组对象的集合接口，它的子接口包括List、Set和Queue。

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

在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 = 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); }

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 = 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]
        
    }
}

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 = 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 = {}

    }
}

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;
    }

    @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);
    }
}

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;
    }

    @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);

    }


}

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.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+" ");
            }

        }
    }

原文地址:https://blog.csdn.net/qq_67832732/article/details/135425748

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。

如若转载，请注明出处：http://www.7code.cn/show_54418.html

如若内容造成侵权/违法违规/事实不符，请联系代码007邮箱：suwngjj01@126.com进行投诉反馈，一经查实，立即删除！

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。