Java集合接口的使用（笔记）

已于 2022-05-19 22:05:56 修改
阅读量445 收藏 4
点赞数 1
分类专栏： javaSE 文章标签： java javase
于 2021-01-23 17:27:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45626589/article/details/113053069
版权

文章目录

集合

概述：用来存储引用类型，集合的长度可变
面试题：集合与数组的区别？

  1. 长度区别：数组一旦创建，长度不可变；集合可支持容度的改变
  2. 类型区别：集合只能存储引用类型（其他类型自动装箱），数组既可以存储引用类型，又可以存储基本类型
  3. 元素区别：数组只能存储一种类型元素，即元素的类型唯一性，集合可以存储多种类型的元素，可以用泛型约束

一、collection接口

1. collection接口为集合类的父接口，单列集合，提供许多功能，其长度可变，可以存储多种类型元素。子接口：List,Set
2.集合框架
在这里插入图片描述
3. collection接口常用方法

package cn.tedu.day13;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

/**
 * 方法摘要
 *  boolean add(E e)
 *           确保此 collection 包含指定的元素（可选操作）。
 *  boolean addAll(Collection<? extends E> c)
 *           将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
 *  void clear()
 *           移除此 collection 中的所有元素（可选操作）。
 *  boolean contains(Object o)
 *           如果此 collection 包含指定的元素，则返回 true。
 *  boolean containsAll(Collection<?> c)
 *           如果此 collection 包含指定 collection 中的所有元素，则返回 true。
 *  boolean equals(Object o)
 *           比较此 collection 与指定对象是否相等。
 *  int hashCode()
 *           返回此 collection 的哈希码值。
 *  boolean isEmpty()
 *           如果此 collection 不包含元素，则返回 true。
 *  Iterator<E> iterator()
 *           返回在此 collection 的元素上进行迭代的迭代器。
 *  boolean remove(Object o)
 *           从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
 *  boolean removeAll(Collection<?> c)
 *           移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
 *  boolean retainAll(Collection<?> c)
 *           仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
 *  int size()
 *           返回此 collection 中的元素数。
 *  Object[] toArray()
 *           返回包含此 collection 中所有元素的数组。
 */
public class MyCollection {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<String>();
        list.add("傻逼");
        list.add("憨逼");
        list.add("二逼");

        Collection c = new ArrayList();
        c.add("古力娜扎");
        c.add("迪丽热巴");
        c.add("马儿扎哈");

        //list.clear();清空集合
        list.add("赵丽颖");
        System.out.println(list);//打印集合
        System.out.println(list.isEmpty());//是否为空
        System.out.println(list.remove("赵丽颖"));//移除元素
        System.out.println(list.contains("二逼"));//是否包含元素
        System.out.println(list.hashCode());//获取哈希值
        Object[] obj = c.toArray();//将集合变成数组
        System.out.println(Arrays.toString(obj));
        System.out.println("__________________");
        System.out.println(c);
        System.out.println(list);
        System.out.println(c.addAll(list));//添加参数集合中所以元素
        System.out.println(c.containsAll(list));//是否包含参数集合中的所有元素
        System.out.println(c.retainAll(list));//保留交集元素
        System.out.println(c.removeAll(list));//删除参数集合中的所有元素
        System.out.println(c.size());//元素个数
        System.out.println(c);

        list.add("古力娜扎");
        list.add("迪丽热巴");
        list.add("马儿扎哈");
        System.out.println(list);
    }
}

运行结果
在这里插入图片描述

二、List接口

特点：

  1. 可以存储相同的元素，有序的集合
  2. 元素有序，可以根据索引访问元素
  3. 可以存储null值
  4. 常用方法测试
package cn.tedu.day13;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * list集合
 * 特点：
 *  1.有序，可以重复元素的集合
 *  2.可以存储null值
 *  3.可以根据索引获取元素
 *  4.list接口也有迭代器
 *  5.List接口提供了两种搜索指定对象的方法
 *
 * 常用方法
 * boolean add(E e)
 *           向列表的尾部添加指定的元素（可选操作）。
 *  void add(int index, E element)
 *           在列表的指定位置插入指定元素（可选操作）。
 *  boolean addAll(Collection<? extends E> c)
 *           添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。
 *  boolean addAll(int index, Collection<? extends E> c)
 *           将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
 *  void clear()
 *           从列表中移除所有元素（可选操作）。
 *  boolean contains(Object o)
 *           如果列表包含指定的元素，则返回 true。
 *  boolean containsAll(Collection<?> c)
 *           如果列表包含指定 collection 的所有元素，则返回 true。
 *  boolean equals(Object o)
 *           比较指定的对象与列表是否相等。
 *  E get(int index)
 *           返回列表中指定位置的元素。
 *  int hashCode()
 *           返回列表的哈希码值。
 *  int indexOf(Object o)
 *           返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
 *  boolean isEmpty()
 *           如果列表不包含元素，则返回 true。
 *  Iterator<E> iterator()
 *           返回按适当顺序在列表的元素上进行迭代的迭代器。
 *  int lastIndexOf(Object o)
 *           返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
 *  ListIterator<E> listIterator()
 *           返回此列表元素的列表迭代器（按适当顺序）。
 *  ListIterator<E> listIterator(int index)
 *           返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
 *  E remove(int index)
 *           移除列表中指定位置的元素（可选操作）。
 *  boolean remove(Object o)
 *           从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
 *  boolean removeAll(Collection<?> c)
 *           从列表中移除指定 collection 中包含的其所有元素（可选操作）。
 *  boolean retainAll(Collection<?> c)
 *           仅在列表中保留指定 collection 中所包含的元素（可选操作）。
 *  E set(int index, E element)
 *           用指定元素替换列表中指定位置的元素（可选操作）。
 *  int size()
 *           返回列表中的元素数。
 *  List<E> subList(int fromIndex, int toIndex)
 *           返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
 *  Object[] toArray()
 *           返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
 *
 *  面试题：iterdtor()与listIterator()的区别？
 *         1.iterator()来自父接口collection，ListIterator()来自List接口
 *         2.iterator()返回父接口，ListIterator()返回子接口
 *         3.listIterator()既有父接口的功能，又有自己扩展功能，如逆向遍历
 */
public class Mylist {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("迪丽热巴");
        list.add("古力娜扎");
        list.add("马儿扎哈");
        list.add("迪丽热巴");
        list.add(null);
        System.out.println(list);
        list.add(1,"韩梅梅");//在索引处添加元素，后面元素往后移
        System.out.println(list);
        System.out.println(list.get(2));//获取索引处元素
        System.out.println(list.indexOf("迪丽热巴"));//获取元素第一次出现的下标
        System.out.println(list.lastIndexOf("迪丽热巴"));//获取元素最后一次出现的下标
        list.remove(4);//删除索引处的元素
        list.set(3,"angelababa");//替换索引处的元素
        System.out.println(list);
        List<String> list2 = list.subList(2,4);//集合的截取，包含左不包含右
        System.out.println(list2);
        
		//List的元素遍历
        System.out.println("1.迭代器iterator()遍历");
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String data = it.next();
            System.out.print(data+" ");
        }
        System.out.println();
        System.out.println("2.下标遍历");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");

        }
        System.out.println();
        System.out.println("3.foreach遍历");
        for (String data : list){
            System.out.print(data+" ");
        }

        System.out.println();
        System.out.println("4.ListIterator()遍历");
        ListIterator<String> it2 = list.listIterator();
        while (it2.hasNext()){
            String str = it2.next();
            System.out.print(str+" ");
        }

        System.out.println();
        System.out.println("5.ListIterator()逆向遍历");
        while (it2.hasPrevious()) {
            String data = it2.previous();
            System.out.print(data+" ");
        }

    }
}

运行结果
在这里插入图片描述
子类ArrayList和LinkedList，Vector

  1. Arraylist:底层存储的数据结构为数组，每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。

  2. LinkedList:List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。

  3. Vector：Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。

测试-LinkedList

package cn.tedu.day14;

import java.util.LinkedList;

public class MyLinkedList {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.addFirst(0);
        list.addLast(5);
        System.out.println(list);
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
        System.out.println(list.removeFirst());
        System.out.println(list.removeLast());
        System.out.println(list);
        list.set(1,9);
        System.out.println(list.get(1));
    }
}

运行结果
在这里插入图片描述

三、set接口

1. 特点：不能存储相同的元素，元素无序，底层存储的数据结构为哈希表（数组+链表）
2. set接口不能存储相同元素的原理：重写hashCode()和equals()方法

  • boolean add(E e) 如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。更确切地讲，如果此 set 没有包含满足 (enull ? e2null : e.equals(e2)) 的元素 e2，则向该 set 中添加指定的元素 e。如果此 set 已经包含该元素，则该调用不改变此 set 并返回 false。结合构造方法上的限制，这就可以确保 set 永远不包含重复的元素。
  • HashSet底层存储原理为哈希表，创建HashSet对象时其实是在创建HashMap对象，添加元素时本质上在调用HashMap的put方法，添加的元素存储在映射里的key,map集合里的key不唯一，于是set就不包含相同的元素
    在这里插入图片描述

在这里插入图片描述
3. 测试set接口常用方法

注：set接口没有什么扩展的方法，全部是继承自collection父类接口的方法，set接口的主要作用是去重元素

package cn.tedu.day14;
/**
 * set集合：无可重复，无序，底层是哈希表/散列表（map）
 */

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Text_Set {
    public static void main(String[] args) {
        //本质上创建hashset，实际上创建hashmap
        Set<Object> set = new HashSet<>();
        //本质上，是将数据存入map里，即set.put(e,new Object),v是常量
        set.add("来了老弟");
        set.add("qew");
        set.add(6.6);
        set.add(null);
        set.add(null);
        System.out.println(set.isEmpty());
        System.out.println(set.size());

        //1.继承自collection接口的iterator（）
        Iterator it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println(set.contains(6.6));

        //2.for each
        for (Object obj : set){
            System.out.print(obj+" ");
        }

    }
}

在这里插入图片描述

4.子类HashSet，TreeSet,LinkedHashSet

  1. HashSet:此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。 此类为基本操作提供了稳定性能，这些基本操作包括 add、remove、contains 和 size，假定哈希函数将这些元素正确地分布在桶中。对此 set 进行迭代所需的时间与 HashSet 实例的大小（元素的数量）和底层 HashMap 实例（桶的数量）的“容量”的和成比例。因此，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。
  2. TreeSet:基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。 此实现为基本操作（add、remove 和 contains）提供受保证的 log(n) 时间开销。
  3. LinkedHashSet;具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。注意，插入顺序不 受在 set 中重新插入的 元素的影响。（如果在 s.contains(e) 返回 true 后立即调用 s.add(e)，则元素 e 会被重新插入到 set s 中。）

四、Map接口

接口 Map<K,V>
类型参数：
K - 此映射所维护的键的类型
V - 映射值的类型

  1. 特点：不允许重复的key,value值可以重复，若添加已有的key值，会覆盖原先的key-value映射
    key,value一 一对应，可以根据键提取对应的值
    存放的都是无序数据
    初始容量是16，默认的加载因子是0.75

测试–map接口

package cn.tedu.day14;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * 方法摘要
 *  void clear()
 *           从此映射中移除所有映射关系（可选操作）。
 *  boolean containsKey(Object key)
 *           如果此映射包含指定键的映射关系，则返回 true。
 *  boolean containsValue(Object value)
 *           如果此映射将一个或多个键映射到指定值，则返回 true。
 *  Set<Map.Entry<K,V>> entrySet()
 *           返回此映射中包含的映射关系的 Set 视图。
 *  boolean equals(Object o)
 *           比较指定的对象与此映射是否相等。
 *  V get(Object key)
 *           返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
 *  int hashCode()
 *           返回此映射的哈希码值。
 *  boolean isEmpty()
 *           如果此映射未包含键-值映射关系，则返回 true。
 *  Set<K> keySet()
 *           返回此映射中包含的键的 Set 视图。
 *  V put(K key, V value)
 *           将指定的值与此映射中的指定键关联（可选操作）。
 *  void putAll(Map<? extends K,? extends V> m)
 *           从指定映射中将所有映射关系复制到此映射中（可选操作）。
 *  V remove(Object key)
 *           如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
 *  int size()
 *           返回此映射中的键-值映射关系数。
 *  Collection<V> values()
 *           返回此映射中包含的值的 Collection 视图。
 */
public class Text_HashMap {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        System.out.println();
        map.put(1,"娜娜莉");
        map.put(2,"尤菲");
        map.put(3,"夏利");
        map.put(4,"卡莲");
        map.put(5,"科内利亚");
        map.put(null,null);//允许存入空值
        map.put(5,"朱雀");//key唯一，如果存入相同的key，则会覆盖之前的value

        System.out.println(map.containsKey(1));
        System.out.println(map.containsValue("娜娜莉"));
        System.out.println(map.get(1));
        System.out.println(map.isEmpty());
        System.out.println(map.remove(5));//删除key,返回value
        System.out.println(map.size());

        //返回key的set键集合
        System.out.println("返回key的set键集合");
        Set<Integer> set = map.keySet();
        for (Integer key : set){
            System.out.println(key);
        }

        //返回value值的collection集合
        System.out.println("返回value值的collection集合");
        Collection<String> value = map.values();
        for (String values : value) {
            System.out.println(values);
        }

        //返回key-value的set试图
        System.out.println("返回key-value");
        Set<Map.Entry<Integer,String>> out = map.entrySet();
        for (Map.Entry<Integer,String> x : out) {
            Integer key = x.getKey();
            String values = x.getValue();
            System.out.println(key+"="+values);
        }

    }
}

运行结果
在这里插入图片描述

五、集合总结

  1. List接口
    • ArrayList：底层存储数据结构为数组，查询快，增删慢，线程不安全，不同步，效率高，可以存储重复元素，元素有索引，默认容量10
    • LinkedList ：底层存储数据结构为链表（双向链表），查询慢，增删快，线程不安全，不同步，可以存储重复元素，元素有索引，支持随机位置增删，但是在定位时需要线性扫描，效率低
    • Vector：底层存储数据结构为数组，查询快，增删慢，线程安全，同步，效率低，可以存储重复元素，默认容量10
  2. Set接口
    • HashSet：底层存储数据结构为哈希表（HashMap），元素无序且唯一，线程不安全，不同步，效率高，可以存储null元素，元素的唯一性是靠所存储元素类型是否重写hashCode()和equals()方法来保证的
    • LinkedHashSet ：底层数据结构采用链表和哈希表共同实现，链表维护元素的插入次序，哈希表保证了元素的唯一性，线程不安全，效率高。
    • TreeSet ：底层实现为红黑树，元素唯一并且排好序，不允许重复元素，线程不安全，不同步
  3. Map接口
    • HashMap ：底层数据结构为哈希表（数组+链表结构），具有映射关系的集合，Map里保存着两组数据：key和value，没有同步， 线程不安全，运行存储null值，但是不能存储重复元素，会覆盖掉value值，性能好
    • Hashtable ：接口实现类， 线程同步，安全，性能差
    • TreeMap ：红黑树对所有的key进行排序 ，有自然排序和定制排序
      集合的使用分析
      HashMap和HashTable:HashMap去掉了HashTable的contains方法，但是加上了containsValue()和containsKey()方法。HashTable同步的，而HashMap是非同步的，效率上比HashTable要高。HashMap允许空键值，而HashTable不允许。

HashMap：适用于Map中插入、删除和定位元素。
Treemap：适用于按自然顺序或自定义顺序遍历键(key)。

线程安全集合类与非线程安全集合类
LinkedList、ArrayList、HashSet是非线程安全的，Vector是线程安全的;
HashMap是非线程安全的，HashTable是线程安全的;
StringBuilder是非线程安全的，StringBuffer是线程安全的。

数据结构
ArrayXxx:底层数据结构是数组，查询快，增删慢
LinkedXxx:底层数据结构是链表，查询慢，增删快
HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序

Java搬码工
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java集合（完整笔记）
05-14
作者在学习过程中自己整理的Java集合笔记，包括开发中常见的单列集合（Collection）和双列集合（Map）以及开发中集合常用的接口，类，以及方法等，适合零基础小白，笔记详细，希望和大家一起学习的道路上我们可以...
JAVA集合（二）List接口详解
超级程序诞生的博客
10-01 2864
添加10个以上的元素（比如String "hello"),在2号位插入一个元素”快船总冠军“，获得第五个元素，删除第六个元素，修改第七个元素，在使用迭代器遍历集合，要求：使用List的实现类ArrayList完成。我们先进行new一个类：ArrayList，然后新建一个Book类,然后进行创建它的构造方法，设置它的getter和setter,同时设置它的toString方法。（3）List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。我们看看其他类怎么样。
【Java基础】前端传一个数组或者集合后台怎么接受（案例详解）
热门推荐
Java后端技术栈
07-20 2万+
解答前端除了传一个集合外，还要传一个字符串或者数字等属性，我们创建一个VO对象来接受即可解决如上的问题。前后端传参，最重要的还是统一好对应的参数属性名称，传参方式等，提前确认好，开发效率会大幅提高。业务场景传入的集合代表要操作的数据，传入的字符串，字符串/数字不同走不同的业务逻辑等。你是否遇到过这样的问题，就是前端除了传一个集合外，还要传一个字符串或者数字等属性？我们可以debug查看一下入参，很清晰的可以看到前端传入的参数。业务场景一前端传对象的集合后端就用对应的list接受即可。...
java中集合类接口
最新发布
qq_27390023的博客
05-16 419
【代码】java中集合类接口。
Java使用get请求接收List集合数据(json)并导出报表
weixin_43656426的博客
01-07 8585
Java使用get请求接收list集合(json) 导出报表
java后端同时接受对象和集合以及多个对象和集合的传参
程序员小明1024
07-30 1771
【代码】java后端同时接受对象和集合以及多个对象和集合的传参。
Java 中的集合接口详解
swadian2008的博客
08-17 779
理解Java Collection接口，可以更好地使用和管理集合对象，并了解集合框架的常用操作和特性。此外，Java提供了许多实现Collection接口的类，包括ArrayList、LinkedList、HashSet、TreeSet等，它们提供了不同的数据结构和特性，可以根据实际需求选择合适的实现类来操作和管理集合。
java超强笔记
12-03
随着对基础知识的掌握，笔记会进一步带你探索Java集合框架，包括数组列表、链表、队列、栈、映射等数据结构，以及它们在实际问题中的应用。此外，多线程编程也是Java的一大亮点，笔记会介绍线程的创建与同步机制，如...
Java基础 学习笔记 Markdownr版
06-27
2. 集合：在13集合.md中，详细讲解了Java集合框架，包括ArrayList、LinkedList、HashSet、HashMap等基本集合类的使用，以及List、Set、Map接口的特性。此外，还可能涉及泛型的概念，泛型（14泛型.md）提高了代码的...
集合框架学习笔记
04-02
这篇学习笔记将深入探讨Java集合框架的基础概念、主要类库以及常见应用场景。 首先，Java集合框架分为两种基本类型：List（列表）和Set（集）。List接口代表有序的集合，允许重复元素，如ArrayList和LinkedList；而...
java 集合部分笔记
05-19
java 集合部分笔记 1 集合的概述 2 Collection接口和Iterator接口（迭代器） 3 List接口 4 Set接口 5 Map接口
java后台实现用list接收重复的对象属性
06-11
java实现后台用list接收前台重复的name属性的值 接收重复属性 后台数组接收前台重复的name
Java 集合类 接口
qq_51308613的博客
04-30 1797
List、Set、Map、Arrays Collection接口、 Iterator（迭代器）接口 List接口 ArrayList的随机访问性能好，LinkedList动态插入、删除元素所用时间少 ArrayList（顺序列表） List<类型> listname =newArrayList<类型>(); LinkedList（链式列表） List<类型> listname =newLinkedList<类型>(); ...
【Java基础22】集合的各个接口实现
天赋决定上限，努力决定下限！
03-18 310
集合的各个接口实现
SSM框架-接口入参参数如何接收List集合？
知易行难
07-30 1万+
前端参数构建 后台接口参数接收
Java学习集合之List接口
Java学习博客
08-03 583
Java集合之List接口和两个实现类
java中关于接口多个实现如何进行注入总结
royal1235的博客
11-14 1371
注意：点睛之笔就是每个实现类里面都返回了对应的枚举值，这样就可以直接在controller里面注入List，利用枚举值来判断，将不同的开卡类型的请求分别转发到不同的实现类里面。需求：需求就是我一个系统既可以开通工商银行虚拟卡，也可以开通建设银行的虚拟卡，开通之后将开卡数据存储到数据库。step5：定义controller，调用接口来完成不同的开卡请求，打到不同银行开卡实现类里面。step3：定义工商银行开卡实现类。step4：定义建设银行开卡实现类。step5：定义开卡银行枚举类。
Java 并发异步编程，原来十个接口的活现在只需要一个接口就搞定!
Java 架构师之路
12-31 600
作者：锦成同学来源：http://39sd.cn/A514E引言先来看一些APP的获取数据,诸如此类,一个页面获取N多个,多达10个左右的一个用户行为数据,比如:点赞数,发布文章数,点...
统一管理java线性处理多个不同业务
mineskey的博客
05-26 253
1、注册统一接口类组件（ApplicationContextAware） @Component public class CalcServiceLocator implements ApplicationContextAware { /** * 用于保存接口实现类名及对应的类 */ private List<ACalcBase> calcImpl; /** * 获取应用上下文并获取相应的接口实现类 * * @param
java笔记整理(超详细) java笔记整理(超详细)
07-14
Java笔记整理（超详细）涵盖了Java编程语言的基础知识和高级概念，主要关注于Java的特性、面向对象编程和集合框架。以下是详细内容： 1. **Java语言特点**： - Java是一种简单易学的语言，它的设计原则强调了清晰...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值