• java list set map日子记录

    List集合

    概念

    是一个容器,作用为存放多个数据,通常用来替代数组

    特点

    1. 只能存放引用类型

    2. 所有集合都来自于java.util包

    List , Set , Map都是接口

    List的存储特点

    有序,有下标,元素可以重复

    List的常用实现类

    1. ArrayList (常用)

      • JDK1.2 底层数组实现 查询快,增删慢 线程不安全,效率高

    2. LinkedList

      • JDK1.2 底层链表实现 查询慢,增删快 线程不安全,效率高

    3. Vector

      • JDK1.0 底层数组实现 都慢 线程安全,效率低

    创建

    • 建议使用多态

    List 集合名=new 实现类();

    常用方法

    • 集合名.方法名(实参列表)

    1. boolean add(元素): 往集合末尾添加一个元素

    2. void add(下标, 元素): 将元素添加至指定下标位置

    3. boolean addAll(集合名)：将指定集合元素添加至当前集合末尾

    4. boolean addAll(下标，集合名)：将指定集合元素添加至当前集合指定下标位置

    5. int size()：获取集合长度

    6. 元素 get(下标)：获取指定下标位置的元素

      • 下标不可超出使用范围，否则报出下标越界异常

    7. boolean contains(元素)：判断是否包含指定元素

    8. boolean containsAll(集合名)：判断当前集合中是否包含指定集合的所有元素

    9. 下标 indexOf(元素)：获取指定元素第一次出现的下标

    10. 下标 lastIndexOf(元素)：获取指定元素最后一次出现的下标

    11. boolean isEmpty()：判断集合元素是否为空，不可判比null值

    12. 被删除的元素 remove(下标):删除指定下标位置的元素

    13. boolean remove(元素)：删除指定元素

      • 如果集合元素为整数值，则会优先认定值为下标。所以删除整数值元素时只能通过下标删除

    14. 旧元素 set(下标，新元素)：将指定下标位置的值替换为新元素值

    15. Object[] toArray()：将集合转换为数组

    遍历

    1. 下标遍历

    1. for(int i=0;i<集合名.size();i++){
    2.     //通过集合名.get(i)的方式获取当前元素
    3. }
    4.  
    5. List list = new ArrayList();
    6.         list.add(10);
    7.         list.add(20);
    8.         list.add(30);
    9.         list.add(40);
    10.         list.add(50);
    11.  
    12.         //下标遍历
    13.         for (int i = 0; i < list.size(); i++) {
    14.             System.out.print(list.get(i)+" ");
    15.         }
    16.         System.out.println();

    迭代器遍历

    1. 获取集合的迭代器：集合名.iterator()

    2. 操作迭代器：

      • boolean hasNext()：判断是否存在下一元素

      • 元素 next()：使指针后移一位，获取下一元素

    3. 使用：

      • 迭代过程中不可增删元素

      • 一次迭代只能调用一次next方法，否则迭代与操作元素数量不一致

    1. //获取迭代器
    2.         Iterator it = list.iterator();
    3.         //利用循环操作迭代器
    4.         while(it.hasNext()){
    5.             Object o = it.next();
    6.             if (o != null) {
    7.                 System.out.print(o+"  ");
    8.             }
    9.         }
    10.         System.out.println();
    11.  
    12. 外遍历forEach
    13. for(数据类型 元素名:集合名){
    14.     //元素名就代表正在被遍历的元素
    15. }
    16.  
    17. for (Object o : list) {
    18.             System.out.print(o+"  ");
    19.         }
    20.         System.out.println();
    21.  
    22. 1. - 遍历过程中无法增删元素
    23.    - JDK5.0
    24.  
    25. 2. 自遍历forEach
    26.  
    27.    - JDK8.0
    28.    - 集合名.forEach(Consumer接口实现类对象)
    29.  
    30.  
    31. list.forEach(new Consumer() {
    32.             @Override
    33.             public void accept(Object o) {
    34.                 //参数o就表示当前元素
    35.                 System.out.print(o+"  ");
    36.             }
    37.         });
    38.         System.out.println();
    39.         //自遍历forEach-lambda
    40.         list.forEach(o -> System.out.print(o + "  "));
    41.  
    42.  
    43.  
    44.  
    1. ## 泛型
    2.  
    3. - 用于集合： 约束集合可存放的数据类型
    4.  
    5. ## 泛型
    6.  
    7. - 用于集合： 约束集合可存放的数据类型
    8.  
    9. ~~~java
    10. List<泛型类型> 集合名=new 实现类名<泛型类型>();
    11. ~~~
    12.  
    13. ### 使用
    14.  
    15. 1. 存放类型为基本类型时，需要将泛型类型声明为对应包装类型
    16.  
    17. 2. 前后泛型声明必须一致
    18.  
    19. 3. 前边泛型不可省略
    20.  
    21. 4. 后边泛型<>内容可省
    22.  
    23.    ~~~java
    24.    List<泛型类型> 集合名=new 实现类名<>();
    25.    ~~~
    26.  
    27. ~~~java
    28. package com.by.test;
    29.  
    30. import java.util.ArrayList;
    31. import java.util.Iterator;
    32. import java.util.List;
    33. import java.util.function.Consumer;
    34.  
    35. public class Test4 {
    36.     public static void main(String[] args) {
    37.         List list = new ArrayList<>();
    38.         list.add(10);
    39.         list.add(20);
    40.         list.add(30);
    41.         list.add(40);
    42.         list.add(50);
    43.        /* list.add(5.5);
    44.         list.add("abc");*/
    45.         //四种遍历方式
    46.         //下标遍历
    47.         for (int i = 0; i < list.size(); i++) {
    48.             //接收当前元素
    49.             Integer n = list.get(i);
    50.             System.out.print(n+"  ");
    51.         }
    52.         System.out.println();
    53.         //迭代器遍历
    54.         Iterator it = list.iterator();
    55.         while (it.hasNext()) {
    56.             Integer n = it.next();
    57.             System.out.print(n+"  ");
    58.         }
    59.         System.out.println();
    60.         //外遍历
    61.         for (Integer i : list) {
    62.             System.out.print(i+"  ");
    63.         }
    64.         System.out.println();
    65.         //自遍历
    66.         list.forEach(new Consumer() {
    67.             @Override
    68.             public void accept(Integer i) {
    69.                 System.out.print(i+"  ");
    70.             }
    71.         });
    72.         System.out.println();
    73.         //lambda
    74.         list.forEach(i-> System.out.print(i+"  "));
    75.         
    76.     }
    77. }
    78. ~~~

    Set集合

    Collection

    • 是List和Set的父接口

    • 所有集合都是由Collection或者Map派生

    特点

    1. 内部存放List和Set的共性方法

    2. 没有直接实现类

    Set的存储特点

    无序,无下标,元素不可重复

    Set的常用实现类

    1. HashSet

      • JDK1.2 底层哈希表(数组+链表)实现 线程不安全,效率高

    2. LinkedHashSet

      • JDK1.2 使HashSet的子类,底层哈希表实现 线程不安全,效率高

    3. TreeSet

      • JDK1.2 底层红黑树实现,是SortedSet的实现类 线程不安全,效率高

      红黑树:树状结构存放数据,使用的是二分查找法,特点为查询效率快

    创建

    • 建议使用多态

    Set<泛型> 集合名=new 实现类名<>();

    常用方法

    • 所有方法都继承自Collection,无独有方法

    遍历

    1. 迭代器遍历

    2. 外遍历forEach

    3. 自遍历forEach

    哈希表的去重原理

    1. 先调用元素的hashCode方法获取哈希码值

    2. 通过哈希码值%数组长度(16)得到存放下标

    3. 如果下标位置未存有元素,则直接存放

    4. 如果下标位置存有元素, 则调用当前元素的equals方法与下标位置元素进行值的比较

    5. 都不相同, 在下标位置上继续链表存放

    6. 有相同,则舍弃添加当前元素

    使用

    1. HashSet和LinkedHashSet如果存放的是自定义类型，则必须重写hashCode和equals方法才能实现去重

    2. LinkedHashSet可以保证元素存入与取出的顺序一致

    3. TreeSet可以实现对元素进行默认的升序排序

      • 如果TreeSet中存放的是自定义类型，则必须自定义排序规则

      • 排序方式:

        1. 实现Comparable接口，重写CompareTo方法

          • 思路：让当前对象this和参数对象o进行比较

          • 实现：对谁排序，就让谁实现

          • 规则：

            • 从小到大：

              this的值>o的值，返回正数

              this的值

            • 从大到小：

              this的值>o的值，返回负数

              this的值

              相等返回0

    1. package com.by.entity;
    2.  
    3. public class Student implements Comparable{
    4.     private String name;
    5.     private int age;
    6.     private double score;
    7.  
    8.     //省略getter、setter、构造
    9.  
    10.     @Override
    11.     public int compareTo(Student o) {
    12.         //根据学生成绩从高到底排序
    13.         if (this.score > o.score) {
    14.             return -1;
    15.         } else if (this.score < o.score) {
    16.             return 1;
    17.         }
    18.         return 0;
    19.     }
    20. }
    21.  
    22.  
    23. 实现Comparator接口，重写compare方法
    24.  
    25. - 思路: 让参数o1和o2进行比较
    26. - 实现:在集合创建处的小括号内传入实现类对象
    27.  
    28. Set set = new TreeSet<>((o1,o2)->{
    29.             //根据学生成绩从低到高
    30.             if (o1.getScore() > o2.getScore()) {
    31.                 return 1;
    32.             } else if (o1.getScore() < o2.getScore()) {
    33.                 return -1;
    34.             }
    35.             return 0;
    36.         });
    37.  
    38.  
    39. 1. - > 1. 默认识别Comparable,但是Comparator优先级更高
    40.      > 2. Comparator更能保护类的单一职责,有利于后期代码的维护, 集合排序扩展性更高,更推荐该方式
    41.  
    42. 2. TreeSet去重规则:当compareTo或compare方 法返回值为0时去重

    Map集合

    存储特点

    • 以键值对的形式存储数据

    • 键(key): 无序,无下标,元素不可重复

    • 值(value): 无序,无下标,元素可以重复

    常用实现类

    1. HashMap

      • JDK1.2 底层哈希表实现 线程不安全,效率高

    2. LinkedHashMap

      • JDK1.2 是HashMap的子类,底层哈希表实现 线程不安全,效率高

    3. TreeMap

      • JDK1.2 是SortedMap的实现类,底层红黑树实现 线程不安全,效率高

    4. Hashtable

      • JDK1.0 底层哈希表实现 线程安全,效率低

    5. Properties

      • JDK1.0 是Hashtable的子类,底层哈希表实现 线程安全,效率低

    创建

    • 建议使用多态

    Map<键的泛型,值的泛型> 集合名=new 实现类名<>();

    常用方法

    K: 键

    V: 值

    1. V put(K,V):向集合中添加一个键值对

      • 如果键已经存在,则进行值的覆盖

    2. int size(): 获取集合长度

    3. boolean containsKey(K): 判断集合是否包含指定键

    4. boolean containsValue(V): 判断集合是否包含指定值

    5. V get(K): 根据键获取值

    1. ## 遍历
    2.  
    3. 1. 键遍历
    4.    - Set keySet(): 获取集合所有的键放入Set集合返回
    5.  
    6. ~~~java
    7. //先获取所有的键
    8.         Set set1 = map.keySet();
    9.         //遍历键
    10.         set1.forEach(k -> System.out.println(k + "  " + map.get(k)));
    11. ~~~
    12.  
    13. 2. 值遍历
    14.    - Collection values(): 获取集合所有的值放入Collection集合返回
    15.  
    16. ~~~java
    17. //获取所有的值
    18.         Collection coll = map.values();
    19.         //遍历值
    20.         for (String s : coll) {
    21.             System.out.println(s);
    22.         }
    23. ~~~
    24.  
    25. 3. 键值对遍历
    26.    - Set<  Map.Entry >  entrySet(): 将所有的键值对对象放入Set集合返回
    27.    - entry对象.getKey(): 获取entry对象中的键
    28.    - entry对象.getValue():获取entry对象中的值
    29.  
    30. ~~~java
    31. //获取到所有的entry对象
    32.         Set> set2 = map.entrySet();
    33.         //遍历entry对象
    34.         set2.forEach(entry-> System.out.println(entry.getKey()+","+entry.getValue()));
    35. ~~~
    36.  
    37. 4. 自遍历forEach
    38.    - 集合名.forEach(BiConsumer接口实现类对象)
    39.  
    40. ~~~java
    41. System.out.println("自遍历-->匿名内部类:");
    42. 		map.forEach(new BiConsumer() {
    43.             @Override
    44.             public void accept(String k, String v) {
    45.                 System.out.println(k+"  ,  "+v);
    46.             }
    47.         });
    48.         System.out.println("自遍历-->lambda:");
    49.         map.forEach((k,v)->System.out.println(k+"  ,  "+v));
    50. ~~~
    51.

    使用

    1. 除去TreeMap之外, 如果键为自定义类型,则必须重写hashCode和equals方法才能实现去重

    2. HashMap可以存放null值,键只能有一个null,值可以存在多个null

    3. LinkedHashMap在HashMap的基础上可以保证元素存入和取出的顺序一致

    4. TreeMap可以根据键进行默认的升序排序

      • 如果键为自定义类型,则需要自定义排序规则,方式与TreeSet一致

      • 键不可为null,否则排序会导致空指针

      • 仍然在compareTo或者compare方法返回值为0时去重

    5. Hashtable无法存放null值

    6. Properties只能存放String类型的数据

      • 不推荐使用多态

      • 无法使用泛型

      • setProperty(String,String): 向集合中添加一个键值对

      • String getProperty(String): 根据键获取值

      • load(输入流): 通过输入流将配置文件的内容读取到集合中

  • 相关阅读:
    http&https内容与比较
    机器学习实战（4）——训练模型
    百家饭OpenAPI平台秋季更新-向全能OpenAPI编辑器挺进
    python获取安卓Hierarchy并解析
    77. 组合
    什么是Redis？
    leetCode 213. 打家劫舍 II 动态规划 房间连成环怎么偷呢？
    Linux5.x启动过程分析
    5.RabbitMQ高级特性
    计算机毕业设计ssm点餐系统平台l4fk2系统+程序+源码+lw+远程部署
  • 原文地址：https://blog.csdn.net/webxscan/article/details/134291576