关于集合，案例说明（相关其他知识在其他作品里）

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量130 收藏
点赞数 1
分类专栏： javaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52627845/article/details/110672148
版权

集合

1. 集合类的体系结构
集合
Collection 单列
List 可重复
ArrayList
LinkedList
Set 不可重复
HashSet
TreeSet
Map 双列
HashMap
ConcurrentMap
TreeMap
ConcurrentHashMap
Properties

2. Collection集合

2.1 数组与集合的区别

  • 相同点
    • 都是容器，可以存储多个数据
  • 不同点
    • 数组的长度是不可变的，集合的长度是可变的
    • 数组可以存储基本数据类型和引用数据类型，集合只能存储引用数据类型
      • 如果要用集合存储基本数据类型，需要对应的包装类

2.2 Collection集合概述与使用

  • 概述
    • 是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
    • JDK不提供此接口的任何直接实现，它提供更具体地子接口实现（如Set和List）
  • 创建Collection集合的对象
    • 多态的方式
    • 具体的实现类ArrayList
  • Collection集合的常用方法
方法名说明
boolean add(E e)添加元素
boolean remove(Object o)从集合中移除指定的元素
boolean removeIf(Object o)根据条件进行移除
void clear()清空集合中的元素
boolean contains(Object o)判断集合中是否存在指定的元素
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中元素的个数

2.3 Collection集合的遍历

2.3.1 迭代器
  • 迭代器介绍
    • 迭代器
      • 集合的专用遍历方式
    • Iterator iterator()
      • 返回此集合中元素的迭代器，通过集合对象的iterator()方法得到
  • Iterator中的常用方法
方法使用
boolean hasNext()判断当前位置是否有元素可以取出
E next()获取当前位置的元素，将迭代器对象移向下一个索引位置
void remove()删除迭代器对象当前指向的元素
2.3.2 Collection集合的遍历
  • 代码实现
public class IteratorDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<>();

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        c.add("javaee");

        //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();

        //用while循环改进元素的判断和获取
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }
}
2.3.3 迭代器中删除方法
  • void remove()
    • 删除迭代器对象当前指向的元素
  • 代码实现
public class IteratorDemo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");

        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            if("b".equals(s)){
                //指向谁,那么此时就删除谁.
                it.remove();
            }
        }
        System.out.println(list);
    }
}
2.3.4 增强for循环
  • 介绍
    • 它是JDK5之后出现的，其内部原理是一个Iterator迭代器
    • 实现Iterable接口的类才可以使用迭代器和增强for
    • 简化数组和Collection集合的遍历
  • 格式
    • for（元素的数据类型 变量名 : 集合/数组名）{
      已经将当前遍历到的元素封装到变量中了，直接使用变量即可
      }
  • 代码实现
public class MyCollectonDemo1 {
    public static void main(String[] args) {
        ArrayList<String> list =  new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        //1,数据类型一定是集合或者数组中元素的类型
        //2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
        //3,list就是要遍历的集合或者数组
        for(String str : list){
            System.out.println(str);
        }
    }
}

3. List集合

3.1 List集合的概述及特点

  • 概述
    • 有序集合，这里的有序指的是存取的顺序
    • 用户可以精确控制列表中每个元素的插入位置，可通过整数索引访问元素
    • 与Set集合不同，列表通常允许重复的元素
  • 特点
    • 存取有序
    • 可重复
    • 有索引

3.2 特有方法

  • 方法介绍
方法名描述
void add(int index,E element)在此集合中的指定位置插入指定的元素
E remove(int index)删除指定索引处的元素，返回被删除的元素
E set(int index,E element)修改指定索引处的元素，返回被修改的元素
E get(int index)返回指定索引处的元素
  • 示例代码
public class MyListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        
        //method1(list);
        //method2(list);
        //method3(list);
        //method4(list);
    }

    private static void method4(List<String> list) {
        String s = list.get(0);
        System.out.println(s);
    }

    private static void method3(List<String> list) {
        //        E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
        //被替换的那个元素,在集合中就不存在了.
        String result = list.set(0, "qqq");
        System.out.println(result);
        System.out.println(list);
    }

    private static void method2(List<String> list) {
        //        E remove(int index)		删除指定索引处的元素，返回被删除的元素
        //在List集合中有两个删除的方法
        //第一个 删除指定的元素,返回值表示当前元素是否删除成功
        //第二个 删除指定索引的元素,返回值表示实际删除的元素
        String s = list.remove(0);
        System.out.println(s);
        System.out.println(list);
    }

    private static void method1(List<String> list) {
        //        void add(int index,E element)	在此集合中的指定位置插入指定的元素
        //原来位置上的元素往后挪一个索引.
        list.add(0,"qqq");
        System.out.println(list);
    }
}

4. List集合的实现类

4.1 List集合子类的特点

  • ArrayList集合
    • 底层是数组结构实现，查询快、增删慢
  • LinkedList集合
    • 底层是链表结构实现，查询慢、增删快

4.2 ArrayList集合

  • ArrayList集合的底层数据结构是数组
  • 该集合常用方法即为List集合的方法

4.3 LinkedList集合

  • 该集合的底层数据结构为链表

  • 特有方法

    方法名说明
    public void addFirst(E e)在该列表开头插入指定的元素
    public void addLast(E e)将指定的元素追加到此列表的末尾
    public E getFirst()返回此列表中的第一个元素
    public E getLast()返回此列表中的最后一个元素
    public E removeFirst()从此列表中删除并返回第一个元素
    public E removeLast()从此列表中删除并返回最后一个元素

  • 示例代码

public class MyLinkedListDemo4 {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
//        public void addFirst(E e)	在该列表开头插入指定的元素
        //method1(list);

//        public void addLast(E e)	将指定的元素追加到此列表的末尾
        //method2(list);

//        public E getFirst()		返回此列表中的第一个元素
//        public E getLast()		返回此列表中的最后一个元素
        //method3(list);

//        public E removeFirst()		从此列表中删除并返回第一个元素
//        public E removeLast()		从此列表中删除并返回最后一个元素
        //method4(list);
      
    }

    private static void method4(LinkedList<String> list) {
        String first = list.removeFirst();
        System.out.println(first);

        String last = list.removeLast();
        System.out.println(last);

        System.out.println(list);
    }

    private static void method3(LinkedList<String> list) {
        String first = list.getFirst();
        String last = list.getLast();
        System.out.println(first);
        System.out.println(last);
    }

    private static void method2(LinkedList<String> list) {
        list.addLast("www");
        System.out.println(list);
    }

    private static void method1(LinkedList<String> list) {
        list.addFirst("qqq");
        System.out.println(list);
    }
}

5. Set集合

5.1 概述和特点

  • 不可以存储重复元素
  • 没有索引，不能使用普通for循环遍历

5.2 Set集合的使用

  • 存储字符串并遍历代码实现
public class MySet1 {
    public static void main(String[] args) {
      	//创建集合对象
        Set<String> set = new TreeSet<>();
      	//添加元素
        set.add("ccc");
        set.add("aaa");
        set.add("aaa");
        set.add("bbb");

//        for (int i = 0; i < set.size(); i++) {
//            //Set集合是没有索引的，所以不能使用通过索引获取元素的方法
//        }
      
      	//遍历集合
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-----------------------------------");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

6. TreeSet集合

6.1 概述和特点

  • 该集合的底层数据结构为树结构
  • 不可以存储重复元素
  • 没有索引
  • 可以将元素按照规则进行排序
    • TreeSet()
      • 根据其元素的自然排序进行排序
    • TreeSet(Comparator comparator)
      • 根据指定的比较器进行排序

6.2 基本使用案例

  • 存储Integer类型的整数并遍历
public class TreeSetDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> ts = new TreeSet<Integer>();

        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);

        ts.add(30);

        //遍历集合
        for(Integer i : ts) {
            System.out.println(i);
        }
    }
}

6.3 自然排序Comparable使用案例

  • 案例需求
    • 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
    • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
  • 代码实现
    • 创建学生类
public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        //按照对象的年龄进行排序
        //主要判断条件: 按照年龄从小到大排序
        int result = this.age - o.age;
        //次要判断条件: 年龄相同时，按照姓名的字母顺序排序
        result = result == 0 ? this.name.compareTo(o.getName()) : result;
        return result;
    }
}
  • 测试类
public class MyTreeSet2 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<>();
	    //创建学生对象
        Student s1 = new Student("zhangsan",28);
        Student s2 = new Student("lisi",27);
        Student s3 = new Student("wangwu",29);
        Student s4 = new Student("zhaoliu",28);
        Student s5 = new Student("qianqi",30);
		//把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
		//遍历集合
        for (Student student : ts) {
            System.out.println(student);
        }
    }
}

6.4 比较器排序Comparator的使用案例

  • 案例需求
    • 存储老师对象并遍历，创建TreeSet集合使用带参构造方法
    • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
  • 代码实现
    • 创建老师类
public class Teacher {
    private String name;
    private int age;

    public Teacher() {
    }

    public Teacher(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 "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
  • 测试类
public class MyTreeSet4 {
    public static void main(String[] args) {
      	//创建集合对象
        TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                //o1表示现在要存入的那个元素
                //o2表示已经存入到集合中的元素
              
                //主要条件
                int result = o1.getAge() - o2.getAge();
                //次要条件
                result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
                return result;
            }
        });
		//创建老师对象
        Teacher t1 = new Teacher("zhangsan",23);
        Teacher t2 = new Teacher("lisi",22);
        Teacher t3 = new Teacher("wangwu",24);
        Teacher t4 = new Teacher("zhaoliu",24);
		//把老师添加到集合
        ts.add(t1);
        ts.add(t2);
        ts.add(t3);
        ts.add(t4);
		//遍历集合
        for (Teacher teacher : ts) {
            System.out.println(teacher);
        }
    }
}

6.5 两种比较方式总结

  • 两种比较方式对比
    • 自然排序: 自定义类实现Comparable接口,重写compareTo方法,根据返回值进行排序
    • 比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象,重写compare方法,根据返回值进行排序
    • 在使用的时候,默认使用自然排序,当自然排序不满足现在的需求时,必须使用比较器排序
  • 两种方式中关于返回值的规则
    • 如果返回值为负数，表示当前存入的元素是较小值，存左边
    • 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
    • 如果返回值为正数，表示当前存入的元素是较大值，存右边

7. HashSet集合

7.1 概述和特点

  • 底层数据结构是哈希表
  • 存取无序
  • 不可以存储重复元素
  • 没有索引，不能使用普通的for循环遍历

7.2 基本应用

  • 存储字符串并遍历
  • 代码实现
public class HashSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> set = new HashSet<String>();

        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        //不包含重复元素的集合
        set.add("world");

        //遍历
        for(String s : set) {
            System.out.println(s);
        }
    }
}
  • 总结
    • HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法
    • 只有当hashCode方法返回的值是相同的，并且equals方法返回的是true，那么此时才认为这个元素在集合中已经存在了

8. Map集合

8.1 概述和特点

  • 概述
    • interface Map<K,V> K：键的类型；V：值的类型
  • 特点
    • 双列集合，一个键对应一个值
    • 键是唯一的，不可以重复，值可以重复
    • Map是双列集合的顶层接口，不能直接创建对象

8.2 常用方法

方法名说明
V put(K key,V value)添加元素
V remove(Object key)根据键删除键值对元素
void clear()移除所有的键值对元素
boolean containsKey(Object key)判断集合是否包含指定的键
boolean containsValue(Object value)判断集合是否包含指定的值
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中键值对的个数

8.3 获取功能

方法名说明
V get(Object key)根据键获取值
Set keySet()获取所有键的集合
Collection values()获取所有值的集合
Set<Map.Entry<K,V>> entrySet()获取所有键值对对象的集合
  • 示例代码
public class MapDemo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

//        V get(Object key):根据键获取值
//        System.out.println(map.get("张无忌"));
//        System.out.println(map.get("张三丰"));

//        Set<K> keySet():获取所有键的集合
//        Set<String> keySet = map.keySet();
//        for(String key : keySet) {
//            System.out.println(key);
//        }

//        Collection<V> values():获取所有值的集合
        Collection<String> values = map.values();
        for(String value : values) {
            System.out.println(value);
        }
    }
}

8.4 遍历（根据键找值）

  • 遍历思路
    • 由于存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
      • 把所有的丈夫都集中起来
      • 遍历丈夫的集合，获取到每一个丈夫
      • 根据丈夫去找对应的妻子
  • 步骤分析
    • 获取所有键的集合，用keySet（）方法实现
    • 遍历键的集合，获取到每一个键，用增强for实现
    • 根据键去找值，用get（Object key）方法实现
  • 代码实现
public class MapDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //获取所有键的集合。用keySet()方法实现
        Set<String> keySet = map.keySet();
        //遍历键的集合，获取到每一个键。用增强for实现
        for (String key : keySet) {
            //根据键去找值。用get(Object key)方法实现
            String value = map.get(key);
            System.out.println(key + "," + value);
        }
    }
}

8.5 遍历（根据键值对对象找键和值）

  • 遍历思路
    • 由于存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
      • 获取所有结婚证的集合
      • 遍历结婚证的集合，得到每一个结婚证
      • 根据结婚证获取丈夫和妻子
  • 步骤分析
    • 获取所有键值对对象的集合
      • Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
    • 遍历键值对对象的集合，得到每一个键值对对象
      • 用增强for实现，得到每一个Map.Entry
    • 根据键值对对象获取键和值
      • 用getKey()得到键
      • 用getValue()得到值
  • 代码实现
public class MapDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //遍历键值对对象的集合，得到每一个键值对对象
        for (Map.Entry<String, String> me : entrySet) {
            //根据键值对对象获取键和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "," + value);
        }
    }
}

8.6 遍历（使用forEach方法）

  • 使用forEach方法进行遍历
public class Demo4 {
    public static void main(String[] args) {
        HashMap<Student,String> hm = new HashMap<>();
        Student s1 = new Student("张三",23);
        Student s2 = new Student("李四",24);
        Student s3 = new Student("王五",25);

        hm.put(s1,"上海");
        hm.put(s2,"北京");
        hm.put(s3,"郑州");

        hm.forEach((student,s) -> System.out.println(student.getName() + "---" + student.getAge() + "---" + s));
    }
}

9. Map集合子类

9.1 HashMap集合

  • 概述和特点
    • HashMap底层是哈希表结构的
    • 依赖hashCode方法和equals方法保证键的唯一
    • 如果键要存储的是自定义对象，需要重写hashCode和equals方法
  • 使用
    • 继承了Map集合的方法

9.2 TreeMap集合

  • 概述和特点
    • TreeMap底层是红黑树结构
    • 依赖自然排序或者比较器排序,对键进行排序
    • 如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则
  • 使用
    • 继承了Map集合的方法
辰伏
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
集合————示例详解
zjh2436114981的博客
08-20 851
java集合示例部分详细解
集合的例题
bjdxxf的博客
07-02 1582
例题1：自定义MyList类，实现存取元素的功能。 定义add方法，可以保存元素，添加MyList尾部。 定义remove方法，可以获取到最后添加的元素，并从MyList中移除该元素。 定义show方法，可以展示MyList中的元素。 例题2.随机验证码。 随机生成十组六位字符组成的验证码。 验证码由大小写字母、数字字符组成。 例题3.集合工具类。 定义findIndex方法，在某...
集合相关
zhijingege的博客
12-09 171
集合笔记集合架构Collection（接口）：API:遍历方式：Set（接口）：HashSet：HashSet研究的两个问题：LinkedHashSet：TreeSet：TreeSet的排序：List（接口）：ArrayList：遍历方式LinkedList：遍历方式：同ArrayList（略）LinkedList和ArrayList的区别Vector：（淘汰）遍历方式：同ArrayList（略）...
言简意赅，盘点知识图谱在各领域的应用
一个写湿的程序猿
05-06 8857
言简意赅，盘点知识图谱在各领域的应用01 语义匹配02 搜索推荐03 问答对话04 推理决策05 区块链协作 什么是知识图谱？通俗易懂 01 语义匹配 语义匹配是搜索推荐、智能问答和辅助决策的基础。在没有知识图谱以前，文本匹配主要依靠字面匹配为主，通过数据库搜索来获取匹配结果。但这种做法存在两个问题，一方面是文本输入本身的局限性造成检索遗漏；另一方面，检索结果的评价缺少可解释性，排序受到质疑，因此往往无法搜到想要的结果。 知识图谱的出现有效解决了上述两个问题，一方面通过关键词扩展获得更多输入效果，另一方面通
java案例作品
08-29
本作品集包含了两个Java编程案例，旨在展示Java在实际问题解决中的应用和能力。以下是这两个案例可能涉及的关键知识点： 1. **面向对象编程**：Java的基础是面向对象编程（OOP），它将现实世界的问题映射为类和对象...
Authorware软件制作的互动作品集合
06-25
《Authorware软件制作的互动作品集合》是一份以日本知名动漫角色犬夜叉为主题的学习资料，旨在通过Authorware这一强大的多媒体创作工具，帮助用户了解和掌握互动作品的制作技巧。Authorware是美国Macromedia公司（后...
（优化版）大鱼吃小鱼，初学作品-少儿编程scratch项目源代码文件案例素材.zip
11-06
- **游戏案例**：表示这是一个通过游戏形式来教授编程知识的例子，使学习过程更具趣味性和互动性。 - **少儿趣味编程**：强调了以娱乐和创新的方式引导孩子们接触和学习编程，提高他们的逻辑思维和问题解决能力。 - ...
简洁清爽科技产品响应式手机客户端手机appapp互联网展示案例作品设计个人主页设计案例企业bootstrap.rar
09-12
下面我们将深入探讨相关知识点： 1. **响应式设计**：响应式设计是一种网页设计方法，它允许网页根据访问设备的不同（如手机、平板电脑或桌面电脑）自动调整布局、内容和功能。在这个模板中，通过CSS3媒体查询和...
50款原生js案例（绝美整合）
10-26
这个“50款原生js案例（绝美整合）”集合了作者半年的辛勤整理，包含了各种JavaScript插件和效果，旨在帮助开发者们提升技能，找到灵感。下面我们将深入探讨这些标签所代表的知识点，并对每个部分进行详细的阐述。 ...
spring事务详细讲解-深入浅出
小电玩
09-08 470
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1454
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 523
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 539
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
自定义Stater
m0_63624484的博客
09-07 718
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
基于SpringBoot的旅游管理系统
heye0910032的博客
09-08 408
随着科技的发展，旅游管理系统的信息化成为提升旅游服务效率的关键。本系统采用JSP技术和SpringBoot框架，结合MySQL数据库，旨在实现一个功能全面、操作简便、安全可靠的旅游管理平台。系统通过需求分析、系统设计、功能实现和测试，确保了良好的用户体验和数据处理能力，为旅游业务的现代化管理提供了强有力的技术支持。本研究成功开发了一个基于SpringBoot的旅游管理系统，该系统通过集成多种旅游管理功能，显著提高了旅游服务的效率和质量。系统的用户友好界面和强大的后端功能，使得管理员和用户都能从中受益。
MyBatis面试
Tony_yitao的博客
09-09 673
MyBatis面试
Linux服务器Java启动脚本
Jack魏
09-08 551
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 324
步骤很详细，直接上教程……
Java泛型与集合详解：设计与应用
此外，还会介绍如何利用泛型优化代码，提高代码的类型安全性，以及如何避免潜在的空指针异常和其他类型相关的运行时错误。 《Java泛型和集合》不仅适合初学者系统学习这两个概念，也适合有一定经验的Java开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值