当前位置： 首页 > news >正文

常见的集合

news 2025/6/28 7:19:33

1、Collection

  1. 单列集合的根接口

  2. 遍历方法

    Collection<String> c = new ArrayList<>();
c.add("赵敏");
c.add("小昭");
c.add("素素");
c.add("灭绝");
System.out.println(c); //[赵敏, 小昭, 素素, 灭绝]//1、迭代器遍历
Iterator<String> it = c.iterator();
while(it.hasNext()){String e = it.next();System.out.println(s);
}//2.使用增强for遍历集合
for(String s: c){System.out.println(s); 
}//3、forEac遍历
c.forEach(new Consumer<String>{@Overridepublic void accept(String s){System.out.println(s);}
});//也可以使用lambda表达式对匿名内部类进行简化
c.forEach(s->System.out.println(s)); //[赵敏, 小昭, 素素, 灭绝]

  3. 常用方法

    Collection<String> c = new ArrayList<>();
//1.public boolean add(E e): 添加元素到集合
c.add("java1");
c.add("java1");
c.add("java2");
c.add("java2");
c.add("java3");
System.out.println(c); //打印: [java1, java1, java2, java2, java3]//2.public int size(): 获取集合的大小
System.out.println(c.size()); //5//3.public boolean contains(Object obj): 判断集合中是否包含某个元素
System.out.println(c.contains("java1")); //true
System.out.println(c.contains("Java1")); //false//4.pubilc boolean remove(E e): 删除某个元素，如果有多个重复元素只能删除第一个
System.out.println(c.remove("java1")); //true
System.out.println(c); //打印: [java1,java2, java2, java3]//5.public void clear(): 清空集合的元素
c.clear(); 
System.out.println(c); //打印：[]//6.public boolean isEmpty(): 判断集合是否为空 是空返回true 反之返回false
System.out.println(c.isEmpty()); //true//7.public Object[] toArray(): 把集合转换为数组
Object[] array = c.toArray();
System.out.println(Arrays.toString(array)); //[java1,java2, java2, java3]//8.如果想把集合转换为指定类型的数组，可以使用下面的代码
String[] array1 = c.toArray(new String[c.size()]);
System.out.println(Arrays.toString(array1)); //[java1,java2, java2, java3]//9.还可以把一个集合中的元素，添加到另一个集合中
Collection<String> c1 = new ArrayList<>();
c1.add("java1");
c1.add("java2");
Collection<String> c2 = new ArrayList<>();
c2.add("java3");
c2.add("java4");
c1.addAll(c2); //把c2集合中的全部元素，添加到c1集合中去
System.out.println(c1); //[java1, java2, java3, java4]
1、List系列集合（有序、有下标，元素可以重复）
1、ArrayList
  1. 查询快、增删慢
  2. 实现原理：数组
  3. 底层原理：
    • 利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组
    • 添加第一个元素时，底层会创建一个新的长度为10的数组
    • 存满时，会扩容1.5倍
    • 如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度已实际为准
    • 在这里插入图片描述
2、LinkedList

  1. 查询慢，增删快

  2. 实现原理：双链表

  3. 源码查看在这里插入图片描述

  4. 应用场景

    //1.创建一个队列：先进先出、后进后出
LinkedList<String> queue = new LinkedList<>();
//入对列
queue.addLast("第1号人");
queue.addLast("第2号人");
queue.addLast("第3号人");
queue.addLast("第4号人");
System.out.println(queue);//出队列
System.out.println(queue.removeFirst());	//第4号人
System.out.println(queue.removeFirst());	//第3号人
System.out.println(queue.removeFirst());	//第2号人
System.out.println(queue.removeFirst());	//第1号人
3、ArrayList与LinkedList的增删效率对比注意事项
		//ArrayList与LinkedList的增删快慢，主要针对于从中间索引插入，例如：ArrayList<String> arrayList = new ArrayList<>();LinkedList<String> linkedList = new LinkedList<>();System.out.println("--------------------------arrayList-------------------------------------");Date date = new Date();System.out.println("date = " + date);//10:26:43arrayList.add("xxxXXXxxx");arrayList.add("xxxXXXxxx");arrayList.add("xxxXXXxxx");for (int i = 0; i < 300000; i++) {//使用这个方法，会出现ArrayList比LinkedList效率更高的情况//arrayList.add("xxxXXXxxx");arrayList.add(2,"xxxXXXxxx");}Date date2 = new Date();System.out.println("date2 = " + date2);//10:26:47System.out.println("-----------------------------linkedList----------------------------------");Date date3 = new Date();System.out.println("date3 = " + date3);//10:26:47linkedList.add("xxxXXXxxx");linkedList.add("xxxXXXxxx");linkedList.add("xxxXXXxxx");for (int i = 0; i < 300000; i++) {//使用这个方法，会出现ArrayList比LinkedList效率更高的情况//linkedList.add("xxxXXXxxx");linkedList.add(2,"xxxXXXxxx");}Date date4 = new Date();System.out.println("date4 = " + date4);//10:26:47
2、Set系列集合（无序、无下标，元素不能重复）
1、HashSet
  1. 无序、无索引、不重复
  2. 去重对象：需重写equals与hashCode方法
  3. 实现原理：哈希表：数组+链表+红黑树
  4. 底层原理
    1. 创建一个默认长度16的数组，默认加载因子为0.75
    2. 使用元素的哈希值对数组的长度求余，计算出应存入的位置
    3. 判断当前位置是否为null，如果是null直接存入
    4. 如果不为空，表示有元素，调用hashCode与equals方法比较，相等，则不存；不相等，则存入数组
2、LinkedHashSet

  1. 有序、无索引、不重复

  2. 存入对象时，需指定排序方式

  3. 实现原理：哈希表：数组+链表+红黑树

    //方法1：第一步：先让Student类，实现Comparable接口
//注意：Student类的对象是作为TreeSet集合的元素的
public class Student implements Comparable<Student>{private String name;private int age;private double height;//无参数构造方法public Student(){}//全参数构造方法public Student(String name, int age, double height){this.name=name;this.age=age;this.height=height;}//...get、set、toString()方法自己补上..//第二步：重写compareTo方法//按照年龄进行比较，只需要在方法中让this.age和o.age相减就可以。/*原理：在往TreeSet集合中添加元素时，add方法底层会调用compareTo方法，根据该方法的结果是正数、负数、还是零，决定元素放在后面、前面还是不存。*/@Overridepublic int compareTo(Student o) {//this：表示将要添加进去的Student对象//o: 表示集合中已有的Student对象return this.age-o.age;}
}

    //方法2：创建TreeSet集合时，传递比较器对象排序
/*
原理：当调用add方法时，底层会先用比较器，根据Comparator的compare方是正数、负数、还是零，决定谁在后，谁在前，谁不存。
*/
//下面代码中是按照学生的年龄升序排序
Set<Student> students = new TreeSet<>(new Comparator<Student>{@Overridepublic int compare(Student o1, Student o2){//需求：按照学生的身高排序return Double.compare(o1,o2); }
});//创建4个Student对象
Student s1 = new Student("至尊宝",20, 169.6);
Student s2 = new Student("紫霞",23, 169.8);
Student s3 = new Student("蜘蛛精",23, 169.6);
Student s4 = new Student("牛魔王",48, 169.6);//添加Studnet对象到集合
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
System.out.println(students);
3、TreeSet

  1. 可排序(升序)、无索引、不重复

  2. 存入对象时，需指定排序方式

    1. 自定义的类实现Comparable接口
    2. 调用TreeSet集合有参数构造器，可以设置Comparator对象

  3. 实现原理：红黑树

    //排序方式2
Comparator<Computer> computerComparator = new Comparator<Computer>(){@Overridepublic int compare(Computer o1, Computer o2) {//o2.getPrice()-o1.getPrice()降序//o1.getPrice()-o2.getPrice()升序return o2.getPrice()-o1.getPrice();}};Computer computer1 = new Computer("DELL", 5000, "红色");Computer computer2 =new Computer("HUAWEI",8000,"黑色");Computer computer3 =new Computer("LANXIAN",4000,"红色");Computer computer4 =new Computer("LANXIAN",2000,"黑色");Computer computer5 =new Computer("LANXIAN",1000,"黄色");TreeSet<Computer> computers = new TreeSet<>(computerComparator);computers.add(computer1);computers.add(computer2);computers.add(computer3);computers.add(computer4);computers.add(computer5);Iterator<Computer> iterator = computers.iterator();while (iterator.hasNext()){Computer next = iterator.next();System.out.println(next.toString());}

2、Map

  1. key=value的形式存在

  2. 遍历方法

    // 准备一个Map集合。Map<String, Double> map = new HashMap<>();map.put("蜘蛛精", 162.5);map.put("蜘蛛精", 169.8);map.put("紫霞", 165.8);map.put("至尊宝", 169.5);map.put("牛魔王", 183.6);System.out.println(map);// 1、获取Map集合的全部键Set<String> keys = map.keySet();for (String key : keys) {// 根据键获取对应的值double value = map.get(key);System.out.println(key + "=====>" + value);}// 2、调用Map集合提供entrySet方法，把Map集合转换成键值对类型的Set集合Set<Map.Entry<String, Double>> entries = map.entrySet();for (Map.Entry<String, Double> entry : entries) {String key = entry.getKey();double value = entry.getValue();System.out.println(key + "---->" + value);}//3、遍历map集合，传递匿名内部类map.forEach(new BiConsumer<String, Double>() {@Overridepublic void accept(String k, Double v) {System.out.println(k + "---->" + v);}});//遍历map集合，传递Lambda表达式map.forEach(( k,  v) -> {System.out.println(k + "---->" + v);});}
}
1、HashMap

  1. 它的键是无序、不重复，没有索引

  2. 底层查看在这里插入图片描述

  3. 往Map集合中存储自定义对象作为键，为了保证键的唯一性，我们应该重写hashCode方法和equals方法

    //比如有如下案例：往HashMap集合中存储Student对象作为键，学生的家庭住址当做值。要求，当学生对象的姓名和年龄相同时就认为键重复。public class Student implements Comparable<Student> {private String name;private int age;private double height;// this  o@Overridepublic int compareTo(Student o) {return this.age - o.age; // 年龄升序排序}@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 && Double.compare(student.height, height) == 0 && Objects.equals(name, student.name);}@Overridepublic int hashCode() {return Objects.hash(name, age, height);}public Student() {}public Student(String name, int age, double height) {this.name = name;this.age = age;this.height = height;}//...get,set方法自己补全....@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", height=" + height +'}';}
}
2、LinkedHashMap
  1. 它的键有序的、不重复、无索引。
3、TreeMap

  1. 默认按照键的升序排列，键不重复，无索引

  2. 存入对象时，需指定排序方式

    //方法1
//第一步：先让Student类，实现Comparable接口
public class Student implements Comparable<Student>{private String name;private int age;private double height;//无参数构造方法public Student(){}//全参数构造方法public Student(String name, int age, double height){this.name=name;this.age=age;this.height=height;}//...get、set、toString()方法自己补上..//按照年龄进行比较，只需要在方法中让this.age和o.age相减就可以。/*原理：在往TreeSet集合中添加元素时，add方法底层会调用compareTo方法，根据该方法的结果是正数、负数、还是零，决定元素放在后面、前面还是不存。*/@Overridepublic int compareTo(Student o) {//this：表示将要添加进去的Student对象//o: 表示集合中已有的Student对象return this.age-o.age;}
}

    /**方法2* 目标：掌握TreeMap集合的使用。*/
public class Test3TreeMap {public static void main(String[] args) {Map<Student, String> map = new TreeMap<>(new Comparator<Student>() {@Overridepublic int compare(Student o1, Student o2) {return Double.compare(o1.getHeight(), o2.getHeight());}});
//        Map<Student, String> map = new TreeMap<>(( o1,  o2) ->   Double.compare(o2.getHeight(), o1.getHeight()));map.put(new Student("蜘蛛精", 25, 168.5), "盘丝洞");map.put(new Student("蜘蛛精", 25, 168.5), "水帘洞");map.put(new Student("至尊宝", 23, 163.5), "水帘洞");map.put(new Student("牛魔王", 28, 183.5), "牛头山");System.out.println(map);}
}

3、卡牌案例

  1. 新建Card卡牌类

    package com.wh.cards;
//implements Comparable<Card>,重写compareTo方法，实现Card集合按Card.size大小排序
public class Card implements Comparable<Card>{private String number;private String color;private int size;public Card(String number, String color, int size) {this.number = number;this.color = color;this.size = size;}public String getNumber() {return number;}public void setNumber(String number) {this.number = number;}public String getColor() {return color;}public void setColor(String color) {this.color = color;}public int getSize() {return size;}public void setSize(int size) {this.size = size;}@Overridepublic String toString() {return "Card{" +"number='" + number + '\'' +", color='" + color + '\'' +", size=" + size +'}';}@Overridepublic int compareTo(Card o) {//return this.size-o.size升序//return o.size-this.size降序return this.size-o.size;}
}

  2. 新建Room房间类

    package com.wh.cards;import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;public class Room {List list= new ArrayList<Card>();public Room() {//构造函数，先把54张牌搞出来int size=0;String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};// b、花色：个数确定了，类型确定。String[] colors = {"♠", "♥", "♣", "♦"};for (int i = 0; i < numbers.length; i++) {for (int j = 0; j < colors.length; j++) {list.add(new Card(numbers[i],colors[j],size));}size++;}Card c1 = new Card("",  "🃏" , ++size);Card c2 = new Card("", "👲" , ++size);list.add(c1);list.add(c2);/*System.out.println("list.size()="+list.size());for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i).toString());}*/}public void start(){ArrayList xiaoLi= new ArrayList<Card>();ArrayList xiaoJiang= new ArrayList<Card>();ArrayList xiaoPeng= new ArrayList<Card>();// 打乱ArrayList的顺序Collections.shuffle(list);for (int i = 0; i < list.size()-3; i++) {if(i%3==1){xiaoLi.add(list.get(i));}else if(i%3==2){xiaoJiang.add(list.get(i));}else if(i%3==0){xiaoPeng.add(list.get(i));}}//底牌打印System.out.println(list.get(list.size()-3).toString());System.out.println(list.get(list.size()-2).toString());System.out.println(list.get(list.size()-3).toString());//底牌添加xiaoLi.add(list.get(list.size()-3));xiaoLi.add(list.get(list.size()-2));xiaoLi.add(list.get(list.size()-1));//手牌排序Collections.sort(xiaoLi);Collections.sort(xiaoJiang);Collections.sort(xiaoPeng);System.out.println("xiaoLi的牌，xiaoLi.size()="+xiaoLi.size());for (int i = 0; i < xiaoLi.size(); i++) {System.out.println(xiaoLi.get(i).toString());}System.out.println("*****************************");System.out.println();System.out.println("xiaoJiang的牌，xiaoJiang.size()="+xiaoJiang.size());for (int i = 0; i < xiaoJiang.size(); i++) {System.out.println(xiaoJiang.get(i).toString());}System.out.println("*****************************");System.out.println();System.out.println("xiaoPeng的牌，xiaoPeng.size()="+xiaoPeng.size());for (int i = 0; i < xiaoPeng.size(); i++) {System.out.println(xiaoPeng.get(i).toString());}System.out.println("*****************************");}
}

  3. 新建测试类

    package com.wh.cards;
public class test {public static void main(String[] args) {Room room=new Room();room.start();}
}

  4. 另一种实现方式

    public class Demo {public static void main(String[] args) {//准备牌ArrayList<String> number = new ArrayList<>();ArrayList<String> color = new ArrayList<>();Map<Integer, String> poker = new HashMap<>();Collections.addAll(number, "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2");Collections.addAll(color, "♠", "♥", "♣", "♦");int i=0;for (String s1 : number) {for (String s2 : color) {i++;poker.put(i,s1+s2);}}poker.put(53, "👲");poker.put(54, "🃏");System.out.println("poker = " + poker);//打乱牌ArrayList<Integer> key_list = new ArrayList<>(poker.keySet());Collections.shuffle(key_list);System.out.println("key_list = " + key_list);//发牌HashMap<Integer, String> User_map1 = new HashMap<>();HashMap<Integer, String> User_map2 = new HashMap<>();HashMap<Integer, String> User_map3 = new HashMap<>();HashMap<Integer, String> floor_map4 = new HashMap<>();for (int j = 0; j < key_list.size(); j++) {if(j>=key_list.size()-3){floor_map4.put(key_list.get(j), poker.get(key_list.get(j)));}else if(j%3==0){User_map1.put(key_list.get(j), poker.get(key_list.get(j)));}else if(j%3==1){User_map2.put(key_list.get(j), poker.get(key_list.get(j)));}else if(j%3==2){User_map3.put(key_list.get(j), poker.get(key_list.get(j)));}}User_map1.putAll(floor_map4);//看牌getLookPoker(User_map1);getLookPoker(User_map2);getLookPoker(User_map3);getLookPoker(floor_map4);}private static void getLookPoker(HashMap<Integer, String> map) {map.forEach((k,v)-> System.out.print(v+"\t"));System.out.println();}
}
http://www.lryc.cn/news/433148.html

相关文章：

  • Swift知识点---RxSwift学习
  • 驾驭不断发展的人工智能世界
  • 冒泡排序——基于Java的实现
  • Mendix 创客访谈录｜Mendix赋能汽车零部件行业：重塑架构，加速实践与数字化转型
  • 船舶机械设备5G智能工厂物联数字孪生平台，推进制造业数字化转型
  • 什么是jsonp请求
  • 【C++】STL容器详解【上】
  • 助贷行业的三大严峻挑战：贷款中介公司转型债务重组业务
  • 力扣第42题 接雨水
  • 轻松录制每一刻：探索2024年免费高清录屏应用
  • 【小沐学OpenGL】Ubuntu环境下glfw的安装和使用
  • [数据集][目标检测]汽油检泄漏检测数据集VOC+YOLO格式237张2类别
  • 图文解析保姆级教程：Postman专业接口测试工具的安装和基本使用
  • jenkins配置流水线
  • SQL 编程基础
  • sql 中名字 不可以 包含 mysql中 具有 特定意义 的单词
  • 分布式部署①
  • 开源可视化大屏superset Docker环境部署
  • tomato靶场通关攻略
  • 【Spring Boot 3】【Web】处理跨域资源共享 CORS
  • HUAWEI华为MateBook B5-420 i5 集显(KLCZ-WXX9,KLCZ-WDH9)原装出厂Windows10系统文件下载
  • 算法练习题10：leetcode76最小覆盖子串-滑动窗口
  • Svn常用操作技巧详细说明
  • 六、MySQL高级—架构介绍（1）
  • TensorRT-For-YOLO-Series项目：实现yolov10模型的python-tensorrt推理（对比int8与fp16推理差异）
  • 码上君量化互助社群介绍
  • Qt使用小技巧之按钮动态变化
  • MySQL——事务与存储过程（三）存储过程的使用（1）调用存储过程
  • 基于VUE2-dataV和echarts实现的可视化大屏，百分比适配PC端
  • FastAPI模块化：为复杂应用程序提供清晰的结构