• 集合总结（Java）

     Collection

    常用方法
    1. package com.test01;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Collection;
    5. /*
    6.             添加元素---boolean add(E e);
    7.             移除元素---boolean remove(Object c);
    8.             判断元素是否存在---boolean contains(Object c);
    9.  */
    10. public class S {
    11.     public static void main(String[] args) {
    12. //        创建Collectiom的对象
    13.         Collection s = new ArrayList<>();
    14.  
    15. //        添加元素---boolean add(E e);
    16.         s.add("Hello");
    17.         s.add("world");
    18.  
    19. //        重写toString()方法
    20.         System.out.println(s);
    21.  
    22. //        移除元素---boolean remove(Object c);
    23.         s.remove("Hello");
    24.         System.out.println(s);
    25.  
    26. //      判断元素是否存在---boolean contains(Object c);
    27.         System.out.println(s.contains("world"));
    28.  
    29. //        判断集合是否为空 boolean isEmpty();
    30.         System.out.println(s.isEmpty());
    31.  
    32. //        返回长度---int size();
    33.         System.out.println(s.size());
    34.  
    35. //        清空元素---void claer();
    36.         s.clear();
    37.     }
    38. }
    遍历方法
    1. package com.test01;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Collection;
    5. import java.util.Iterator;
    6.  
    7. public class S {
    8.     public static void main(String[] args) {
    9. //        创建Collection的对象
    10.         Collection s = new ArrayList<>();
    11.  
    12.         s.add("1");
    13.         s.add("2");
    14.         s.add("3");
    15. //        返回集合中元素的迭代器，通过集合中iterator()方法得到
    16.         Iterator it = s.iterator();
    17.  
    18. //        通用遍历方法
    19. //        boolean hasNext()----如果集合中有更多的元素，则返回true
    20. //        E next()----返回迭代器中的下一个元素
    21.         while(it.hasNext()){
    22.             String a = it.next();
    23.             System.out.println(a);
    24.         }
    25.     }
    26. }

    List

    常用方法

    遍历与Collection类似//可能会出现并发修改异常

    多了一种遍历方法

    快捷键为list.fori，回车

    1. package com.test01;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Collection;
    5. import java.util.Iterator;
    6. import java.util.List;
    7.  
    8. public class S {
    9.     public static void main(String[] args) {
    10.         List list = new ArrayList<>();
    11.         list.add("1");
    12.         list.add("2");
    13.         list.add("3");
    14.  
    15. //        void add(int idnex,E c)----在指定索引添加元素
    16.         list.add(1,"100");
    17.  
    18. //        也是重写了toString()方法
    19.         System.out.println(list);
    20.  
    21. //        E remove(int x)-----删除指定元素，并返回此元素
    22.         System.out.println(list.remove(1));
    23.         System.out.println(list);
    24.  
    25. //        E set(int x,E a)----修改指定元素，并返回此元素
    26.         System.out.println(list.set(1,"200"));
    27.         System.out.println(list);
    28.  
    29. //        E get(int x)----得到指定元素
    30.         System.out.println(list.get(2));
    31.         for (int i = 0; i < list.size(); i++) {
    32.             System.out.println(list.get(i));
    33.         }
    34.     }
    35. }
    ListIterato:列表迭代器
    1. package com.test01;
    2.  
    3. import java.util.*;
    4.  
    5. public class S {
    6.     public static void main(String[] args) {
    7.         List list = new ArrayList<>();
    8.         list.add("1");
    9.         list.add("2");
    10.         list.add("3");
    11.         ListIterator it = list.listIterator();
    12.  
    13. //        //正向,不常用
    14. //        while(it.hasNext()){
    15. //            System.out.println(it.next());
    16. //        }
    17. //        System.out.println("----------");
    18. //
    19. //        //反向，不常用
    20. //        while(it.hasPrevious()){
    21. //            System.out.println(it.previous());
    22. //        }
    23. //
    24. //        System.out.println("--------");
    25.         //add()方法，重点掌握
    26.         while(it.hasNext()){
    27.             String s = it.next();
    28.             if(s.equals("2")){
    29.                 it.add("10");
    30.             }
    31.  
    32.         }
    33.         System.out.println(list);
    34.     }
    35. }
    增强for
    1. public class S {
    2.     public static void main(String[] args) {
    3.         List list = new ArrayList<>();
    4.         list.add("1");
    5.         list.add("2");
    6.         list.add("4");
    7.         for(String i : list){
    8.             System.out.println(i);
    9.         }
    10.     }
    11. }
    ArrayList----底层是数组
    LinkedList
    LinkedList---底层是链表
    1. public class dome {
    2.     public static void main(String[] args) {
    3.         LinkedList linkedList = new LinkedList<>();
    4.  
    5.         //boolean addFirst(E e)在头加入元素,removeFirst()同理，getFirst()
    6.         linkedList.addFirst("1");
    7.         //在尾加入元素，removeLast()同理,getLast()
    8.         linkedList.addLast("3");
    9.  
    10.         for(String it : linkedList){
    11.             System.out.println(it);
    12.         }
    13.         
    14.     }
    15. }

    HashSet

    需要重写hascode()

    底层是哈希表

    3种遍历不能用普通循环

    不保证存储和输出顺序一致

    LinkedKist
    1. /*
    2.             存储和输出顺序一致
    3.             保证唯一性
    4.  */
    5. public class S {
    6.     public static void main(String[] args) {
    7.         LinkedHashSet linkedHashSet = new LinkedHashSet<>();
    8.         linkedHashSet.add("1");
    9.         linkedHashSet.add("2");
    10.         linkedHashSet.add("3");
    11.         linkedHashSet.add("3");
    12.         for(String it : linkedHashSet){
    13.             System.out.println(it);
    14.         }
    15.     }
    16. }
    TreeSet
    1. /*
    2.             元素有序，这里的有序是按照一定的规则进行排序，取决于构造方法，默认根据自然元素进行排序
    3.             不能用普通for
    4.             元素具有唯一性
    5.  */
    6. public class S {
    7.     public static void main(String[] args) {
    8.         TreeSet integers = new TreeSet<>();
    9.         integers.add(1);
    10.         integers.add(2);
    11.         integers.add(2);
    12.         integers.add(4);
    13.         for(Integer it : integers){
    14.             System.out.println(it);
    15.         }
    16.     }
    17. }
     比较器Comparable的使用
    1. public class Student implements Comparable{
    2.     private String name;
    3.     private int age;
    4.     public Student(){
    5.  
    6.     }
    7.     public Student(String name,int age){
    8.         this.name=name;
    9.         this.age=age;
    10.     }
    11.     public void show(){
    12.         System.out.println(name+age+"岁");
    13.     }
    14.  
    15.     public String getName() {
    16.         return name;
    17.     }
    18.  
    19.     public void setName(String name) {
    20.         this.name = name;
    21.     }
    22.  
    23.     public int getAge() {
    24.         return age;
    25.     }
    26.  
    27.     public void setAge(int age) {
    28.         this.age = age;
    29.     }
    30.  
    31.     @Override
    32.     public int compareTo(Student o) {
    33. //        return 0;不加入
    34. //        return 1;加入
    35. //        return -1;加前面
    36.         int num = this.age-o.age;
    37.         int num1 = num==0?this.name.compareTo(o.name):num;
    38.         return num1;
    39.     }
    40. }
    1. public class dome {
    2.     public static void main(String[] args) {
    3.         TreeSet treeSet = new TreeSet<>();
    4. /*    //可以用这个代替
    5.         TreeSet treeSet = new TreeSet<>(new Comparator() {
    6.             @Override
    7.             public int compare(Student o1, Student o2) {
    8.                 int num = o1.getAge()-o2.getAge();
    9.                 int num1 = num==0?o1.getName().compareTo(o2.getName()):num;
    10.                 return num1;
    11.             }
    12.         });
    13. */
    14.         Student s1 = new Student("lihua",10);
    15.         Student s2 = new Student("yaoming",30);
    16.         Student s3 = new Student("hh",20);
    17.         Student s4 = new Student("hh",20);
    18.         treeSet.add(s1);
    19.         treeSet.add(s2);
    20.         treeSet.add(s3);
    21.         treeSet.add(s4);
    22.         for(Student it : treeSet){
    23.             System.out.println(it.getName()+","+it.getAge());
    24.         }
    25.     }
    26. }

    Map

    Map基本知识
    1. public class dome {
    2.     public static void main(String[] args) {
    3.         //创建对象
    4.         Map map = new HashMap<>();
    5.         //添加功能
    6.         map.put("1","wa");//添加元素
    7.         map.put("2","rrrr");
    8.         map.put("3","weewee");
    9.         map.put("2","qqqq");//注意
    10.  
    11.         //获取功能
    12.         System.out.println(map.get("1"));//获取值
    13.         Set set = map.keySet();//获取所有键
    14.         Collection collection = map.values();//获取所有值
    15.  
    16.         System.out.println(map);
    17.  
    18.         //基本方法
    19.         System.out.println("-------");
    20.         System.out.println(map.remove("2"));//返回值,删除
    21.         System.out.println(map.remove("6"));//返回为空
    22.         System.out.println(map);
    23.         System.out.println("-------------");
    24.  
    25.         System.out.println(map.containsKey("3"));//是否包含此key
    26.         System.out.println(map.containsValue("wa"));//是否包含vaul
    27.  
    28.         System.out.println(map.isEmpty());//判断是否为空
    29.  
    30.         System.out.println(map.size());//返回长度
    31.         map.clear();//清空map
    32.  
    33.     }
    34. }
    Map的遍历

    1.

    1. public class dome {
    2.     public static void main(String[] args) {
    3.         Map map = new HashMap<>();
    4.         map.put("1","a");
    5.         map.put("2","b");
    6.         map.put("3","c");
    7.  
    8.         Set set = map.keySet();
    9.  
    10.         for(String it : set){
    11.             System.out.println(it+","+map.get(it));
    12.         }
    13.     }
    14. }

    2.

    1. Set> entries = map.entrySet();
    2.         for(Map.Entry ma : entries){
    3.             System.out.println(ma.getKey()+","+ma.getValue().getName()+","+ma.getValue().getAge());
    4.         }
     ArrayList嵌套HashMap
    1. public class dome {
    2.     public static void main(String[] args) {
    3.         ArrayList> arrayList = new ArrayList<>();
    4.         HashMap map1 = new HashMap<>();
    5.         HashMap map2 = new HashMap<>();
    6.         map1.put("1","2");
    7.         map1.put("2","3");
    8.         map2.put("a","b");
    9.         map2.put("b","c");
    10.         arrayList.add(map1);
    11.         arrayList.add(map2);
    12.         for(HashMap it : arrayList){
    13.             Set set = it.keySet();
    14.             for(String me : set){
    15.                 System.out.println(me+","+it.get(me));
    16.             }
    17.         }
    18.     }
    19. }
    HashMap嵌套ArrayList
    1. public class dome {
    2.     public static void main(String[] args) {
    3.         HashMap> map = new HashMap<>();
    4.         ArrayList arrayList1 = new ArrayList();
    5.         arrayList1.add("张三");
    6.         arrayList1.add("李四");
    7.         map.put("编号：1",arrayList1);
    8.         ArrayList arrayList2 = new ArrayList<>();
    9.         arrayList2.add("王五");
    10.         arrayList2.add("赵六");
    11.         map.put("编号：2",arrayList2);
    12.         Set>> entries = map.entrySet();
    13.         for(Map.Entry> me : entries){
    14.             System.out.println(me.getKey());
    15.             ArrayList ss = me.getValue();
    16.             for(String it : ss){
    17.                 System.out.println(it);
    18.             }
    19.         }
    20.     }
    21. }
    TreeMap

    是TreeSet与HashMap结合

    Collections

    基本方法
    1. public class dome {
    2.     public static void main(String[] args) {
    3.         List list = new ArrayList<>();
    4.         list.add(12);
    5.         list.add(34);
    6.         list.add(23);
    7.         list.add(78);
    8.  
    9.         //排序
    10.         Collections.sort(list);
    11.         System.out.println(list);
    12.  
    13.         //反转
    14.         Collections.reverse(list);
    15.         System.out.println(list);
    16.  
    17.         //随机排序
    18.         Collections.shuffle(list);
    19.         System.out.println(list);
    20.     }
    21. }
     Collections排序
    1. public class dome {
    2.     public static void main(String[] args) {
    3.         ArrayList arrayList = new ArrayList<>();
    4.         Student s1  = new Student("zhangsan",12);
    5.         Student s2 = new Student("lisi",12);
    6.         Student s3 = new Student("lihua",234);
    7.         arrayList.add(s1);
    8.         arrayList.add(s2);
    9.         arrayList.add(s3);
    10.         Collections.sort(arrayList, new Comparator() {//也可用Student重写方法
    11.             @Override
    12.             public int compare(Student o1, Student o2) {
    13.                 int num = o1.getAge()-o2.getAge();
    14.                 int num1 = num==0?o1.getName().compareTo(o2.getName()):num;
    15.                 return num1;
    16.             }
    17.         });
    18.         for(Student it : arrayList){
    19.             System.out.println(it.getName()+","+it.getAge());
    20.         }
    21.     }
    22. }

  • 相关阅读:
    Dubbo的使用
    nlp之文本转向量
    Redis的缓存雪崩、缓存穿透、缓存击穿
    MySQL数据库管理基本操作（一）
    场景应用：利用Redis实现分布式Session
    ARM指令集--数据处理指令
    销售外勤自动生成日报：每天节省 20 分钟，每年节省 121小时，把更多精力放在客户开发和跟进上
    题解：ABC319C - False Hope
    C语言中各种运算符用法
    汽车网络安全--安全芯片应用场景解析
  • 原文地址：https://blog.csdn.net/weixin_74139128/article/details/134039765