Java 集合、泛型（二）

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量174 收藏
点赞数 1
分类专栏： Java 文章标签： java 集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chinus_yan/article/details/121187885
版权

接上篇

1、Set接口

 Set接口:也称Set集合,但凡是实现了Set接口的类都叫做Set集合
	特点: 元素无索引,元素不可重复(唯一) （以下三种集合必须满足）
    HashSet集合: 实现类--元素存取无序
    LinkedHashSet集合:实现类--元素存取有序
    TreeSet集合:实现类--> 对元素进行排序
 注意:
	1.Set集合没有特殊的方法,都是使用Collection接口的方法
    2.Set集合没有索引,所以遍历元素的方式就只有: 增强for循环,或者迭代器

1.1 HashSet集合

java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不能保证不一致)。

public class Test {
    public static void main(String[] args) {
        /*
            HashSet集合: 元素存取无序,元素不可重复,元素无索引
         */
        // 创建HashSet集合对象,限制集合元素的类型为String
        HashSet<String> set = new HashSet<>();

        // 往集合中添加元素
        set.add("nba");
        set.add("cba");
        set.add("bac");
        set.add("abc");
        set.add("nba");

        System.out.println(set);// [cba, abc, bac, nba]
    }
}

HashSet集合存储数据的结构（哈希表）

哈希表底层结构

在JDK1.8之前，哈希表底层采用数组+链表实现，即使用数组处理冲突，同一hash值的链表都存储在一个数组索引里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下图所示。
在这里插入图片描述

HashSet保证元素唯一原理

-HashSet集合存储数据的结构---哈希表结构
    哈希表结构:
          jdk8以前: 数组+链表
          jdk8以后: 数组+链表+红黑树
                链表元素个数没有超过8: 数组+链表
                链表元素个数超过8: 数组+链表+红黑树

-HashSet集合保证元素唯一的原理--依赖hashCode()和equals()方法
    1.当存储元素的时候,就会调用该元素的hashCode()方法计算该元素的哈希值
    2.判断该哈希值对应的位置上,是否有元素:
    3.如果该哈希值对应的位置上,没有元素,就直接存储
    4.如果该哈希值对应的位置上,有元素,说明产生了哈希冲突
    5.产生了哈希冲突,就得调用该元素的equals方法,与该位置上的所有元素进行一一比较:
       如果比较的时候,有任意一个元素与该元素相同,那么就不存储
       如果比较完了,没有一个元素与该元素相同,那么就直接存储

补充:
     Object类: hashCode()和equals()方法;
              hashCode():Object类中的hashCode()方法主要是根据地址值计算哈希值
              equals方法():Object类中的equals()方法是比较地址值

在这里插入图片描述

HashSet存储自定义类型元素

给HashSet中存放自定义类型元素时，**需要重写对象中的hashCode和equals方法，**建立自己的比较方式，才能保证HashSet集合中的对象唯一.

public class Person{
    /**
     * 姓名
     */
    public String name;
    /**
     * 年龄
     */
    public int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

测试类：

public class Demo {
    public static void main(String[] args) {
        // 创建多个Person对象
        Person p1 = new Person("张三", 18);
        Person p2 = new Person("李四", 38);
        Person p3 = new Person("王五", 28);
        Person p4 = new Person("张三", 18);

        // 创建HashSet集合对象,限制集合中元素的类型为Person
        HashSet<Person> set = new HashSet<>();

        // 往集合中添加Person对象
        set.add(p1);
        set.add(p2);
        set.add(p3);
        set.add(p4);

        // 遍历打印集合中的元素
        for (Person p : set) {
            System.out.println(p);
        }

        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());
        System.out.println(p3.hashCode());
        System.out.println(p4.hashCode());
    }
}

1.1.1 Hashtable

Java集合篇：Hashtable原理详解（JDK1.8）

Hashtable概述

java.util.Hashtable<k,v>
Hashtable底层是一个哈希表，它是一个线程安全的集合，单线程集合，速度慢，Hashtable集合不能存储null值，null键。

HashMap集合底层是一个哈希表，是线程不安全集合，是一个多线程集合，不过它的速度很快，可以存储null值，null键。

不过Hashtable集合逐渐被HashMap集合取代，但是Hashtable的子类Properties依然沿用，Properties集合也是唯一一个和IO流相结合的集合。

1.2 LinkedHashSet

我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？

在HashSet下面有一个子类java.util.LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。

public class Test {
    public static void main(String[] args) {
        /*
            LinkedHashSet集合: 元素存取有序,元素无索引,元素不可重复(唯一)
                采用哈希表+链表结构，由哈希表保证元素唯一，由链表保证元素存取有序
         */
        // 创建LinkedHashSet集合,限制集合中元素的类型为Integer类型
        LinkedHashSet<Integer> set = new LinkedHashSet<>();// 存取有序
        //HashSet<Integer> set = new HashSet<>();// 存取无序

        // 往集合中存储数据
        set.add(300);
        set.add(100);
        set.add(200);
        set.add(500);
        set.add(400);
        set.add(400);

        System.out.println(set);// [300, 100, 200, 500, 400] 
        //打印集合变量时，依次调用元素的toString方法
    }
}

1.3 TreeSet集合

TreeSet集合是Set接口的一个实现类,底层依赖于TreeMap,是一种基于红黑树的实现,其特点为：

  1. 元素唯一
  2. 元素没有索引
  3. 使用元素的自然顺序对元素进行排序，或者根据创建 TreeSet 时提供的 Comparator 比较器
    进行排序，具体取决于使用的构造方法：
public TreeSet()：								根据其元素的自然排序进行排序(升序)
public TreeSet(Comparator<E> comparator):    根据指定的比较器进行排序

public class Test {
    public static void main(String[] args) {
        /*
            TreeSet集合: 元素无索引,元素唯一,对元素进行排序
                通过构造方法实现排序:
                    public TreeSet()：						     根据其元素的自然排序进行排序
                            默认规则排序:集合元素所属的类需要实现Comparable接口,重写compareTo方法,在compareTo方法中指定默认排序规则

                    public TreeSet(Comparator<E> comparator):    根据指定的比较器进行排序
                            指定规则排序: 通过传入Comparator接口的实现类对象,在实现类对象中重写compare方法,在compare方法中指定排序规则
         */
        // 按照默认规则排序---->默认升序
        // 创建TreeSet集合,限制集合中元素的类型为Integer类型
        TreeSet<Integer> set = new TreeSet<>();

        // 往集合中存储数据
        set.add(300);
        set.add(100);
        set.add(200);
        set.add(500);
        set.add(400);
        set.add(400);
        System.out.println(set);// [100, 200, 300, 400, 500]

        System.out.println("===========================================");
        // 按照指定规则排序---->降序
        // 创建TreeSet集合,限制集合中元素的类型为Integer类型
        TreeSet<Integer> set1 = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                /*
                    指定排序规则:
                    前减后  升序
                    后减前  降序
                    前:第一个参数  后:第二个参数
                 */
                return o2 - o1;
            }
        });

        // 往集合中存储数据
        set1.add(300);
        set1.add(100);
        set1.add(200);
        set1.add(500);
        set1.add(400);
        set1.add(400);
        System.out.println(set1);// [500, 400, 300, 200, 100]

        System.out.println("===========================================");
        // 按照指定规则排序---->升序
        // 创建TreeSet集合,限制集合中元素的类型为Integer类型
        TreeSet<Integer> set2 = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                /*
                    指定排序规则:
                    前减后  升序
                    后减前  降序
                    前:第一个参数  后:第二个参数
                 */
                return o1 - o2;
            }
        });

        // 往集合中存储数据
        set2.add(300);
        set2.add(100);
        set2.add(200);
        set2.add(500);
        set2.add(400);
        set2.add(400);
        System.out.println(set2);// [100, 200, 300, 400, 500]
    }
}

2、Map集合

Map<K,V>集合的特点: K用来限制键的类型,V用来限制值的类型
         1.Map集合存储元素是以键值对的形式存储,每一个键值对都有键和值
         2.Map集合的键是唯一,值可以重复,如果键重复了,那么值就会被覆盖
         3.根据键取值

Map集合子类:
    - HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。
                    由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

    - LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。
               通过链表结构可以保证键值对的存取顺序一致；
               通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

    - TreeMap<K,V>：TreeMap集合和Map相比没有特有的功能，底层的数据结构是红黑树；
                可以对元素的键进行排序，排序方式有两种:自然排序和比较器排序

Map 综述（二）：彻头彻尾理解 LinkedHashMap

本质上，HashMap和双向链表合二为一即是LinkedHashMap。所谓LinkedHashMap，其落脚点在HashMap，因此更准确地说，它是一个将所有Entry节点链入一个双向链表的HashMap。在LinkedHashMapMap中，所有put进来的Entry都保存在一个的哈希表中，但由于它又额外定义了一个以head为头结点的双向链表，因此对于每次put进来Entry，除了将其保存到哈希表中对应的位置上之外，还会将其插入到双向链表的尾部。
在这里插入图片描述更直观地，下图很好地还原了LinkedHashMap的原貌：HashMap和双向链表的密切配合和分工合作造就了LinkedHashMap。特别需要注意的是，next用于维护HashMap各个桶中的Entry链，before、after用于维护LinkedHashMap的双向链表，虽然它们的作用对象都是Entry，但是各自分离，是两码事儿。

Map的常用方法

Map接口中定义了很多方法，常用的如下：

  • public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。

  • public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。

  • public V get(Object key) 根据指定的键，在Map集合中获取对应的值。

  • boolean containsKey(Object key):判断该集合中是否有此键

  • boolean containsValue(Object value):如果该Map集合将一个或多个键映射到指定的值，则返回 true

  • public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。

  • public Collection<V> values(): 获取Map集合中所有的值，存储到Collection集合中。

  • public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
    Map.Entry<K,V>:表示键值对对象—把键值对包装成一个对象,该对象的类型就是Entry类型

tips:

使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；

若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

Map的遍历

方式1:键找值方式

通过元素中的键，获取键所对应的值

分析步骤：

  1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:keyset()
  2. 遍历键的Set集合，得到每一个键。
  3. 根据键，获取键所对应的值。方法提示:get(K key)

方式2:键值对方式

Entry<K,V>接口:简称Entry项,表示键值对对象,用来封装Map集合中的键值对
Entry<K,V>接口:是Map接口中的内部接口,在外部使用的时候是这样表示: Map.Entry<K,V>

Map集合中提供了一个方法来获取所有键值对对象:
            public Set<Map.Entry<K,V>> entrySet()

根据键值对对对象获取键和值:
            - public K getKey()：获取Entry对象中的键。
            - public V getValue()：获取Entry对象中的值。

Map遍历方式二:根据键值对对象的方式
            1.获取集合中所有键值对对象，以Set集合形式返回。  Set<Map.Entry<K,V>> entrySet()
            2.遍历所有键值对对象的集合，得到每一个键值对(Entry)对象。
            3.在循环中,可以使用键值对对对象获取键和值   getKey()和getValue()

HashMap存储自定义类型

  • 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法。
  • 如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。

LinkedHashMap介绍

HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？
使用LinkedHashMap

  • 通过链表结构可以保证元素的存取顺序一致；
  • 通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

TreeMap介绍

TreeMap集合和Map相比没有特有的功能，底层的数据结构是红黑树；可以对元素的**键进行排序，排序方式有两种:自然排序和比较器排序；到时使用的是哪种排序，取决于我们在创建对象的时候所使用的构造方法；

构造方法

public TreeMap()									使用自然排序
public TreeMap(Comparator<? super K> comparator) 	   通过比较器指定规则排序

public class Test {
    public static void main(String[] args) {
        /*
            TreeMap集合: 键唯一,值可以重复,如果键重复了,值就覆盖,可以根据键对键值对进行排序
                public TreeMap()									根据键按照默认规则进行排序
                public TreeMap(Comparator<? super K> comparator) 	通过比较器指定规则排序
         */
        // 按照键的默认规则排序: ---->升序
        // 创建TreeMap集合,限制键的类型为Integer,值的类型为String
        TreeMap<Integer, String> map = new TreeMap<>();

        // 往map集合中添加键值对
        map.put(300, "深圳");
        map.put(100, "北京");
        map.put(200, "广州");
        map.put(500, "上海");
        map.put(400, "武汉");
        map.put(400, "深圳");
        System.out.println(map);

        System.out.println("+=================================");

        // 按照指定规则排序: ---->降序
        // 创建TreeMap集合,限制键的类型为Integer,值的类型为String
        TreeMap<Integer, String> map1 = new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                /*
                    前减后: 升序
                    后减前: 降序
                    前:第一个参数  后:第二个参数
                 */
                return o2 - o1;
            }
        });

        // 往map集合中添加键值对
        map1.put(300, "深圳");
        map1.put(100, "北京");
        map1.put(200, "广州");
        map1.put(500, "上海");
        map1.put(400, "武汉");
        map1.put(400, "深圳");
        System.out.println(map1);
    }
}

3、集合的嵌套

总述：任何集合内部都可以存储其它任何集合

List嵌套List

public class Test1 {
    public static void main(String[] args) {
        /*
            集合的嵌套:
                - List嵌套List
                - List嵌套Map
                - Map嵌套Map
            结论:任何集合内部都可以存储其它任何集合
         */
        //  List嵌套List
        // 创建一个List集合,限制元素类型为String
        List<String> list1 = new ArrayList<>();

        // 往集合中添加元素
        list1.add("AAA");
        list1.add("BBB");
        list1.add("CCC");

        // 创建一个List集合,限制元素类型为String
        List<String> list2 = new ArrayList<>();

        // 往集合中添加元素
        list2.add("DDD");
        list2.add("EEE");
        list2.add("FFF");

        // 创建一个List集合,限制元素类型为List集合 (List集合中的元素是List集合)
        List<List<String>> list = new ArrayList<>();
        list.add(list1);
        list.add(list2);

        // 遍历
        for (List<String> e : list) {
            for (String name : e) {
                System.out.println(name);
            }
            System.out.println("=============");
        }

        System.out.println(list);
    }
}

List嵌套Map

public class Test2 {
    public static void main(String[] args) {
        /*
            List嵌套Map:

         */
        // 创建Map集合对象
        Map<String,String> map1 = new HashMap<>();
        map1.put("it001","AAA");
        map1.put("it002","BBB");

        // 创建Map集合对象
        Map<String,String> map2 = new HashMap<>();
        map2.put("h001","CCC");
        map2.put("h002","DDD");

        // 创建List集合,用来存储以上2个map集合
        List<Map<String,String>> list = new ArrayList<>();
        list.add(map1);
        list.add(map2);

        System.out.println(list.size()); // 2

        for (Map<String, String> map : list) {
            // 遍历获取出来的map集合对象
            Set<String> keys = map.keySet();// 获取map集合所有的键
            // 根据键找值
            for (String key : keys) {
                System.out.println(key + ","+ map.get(key));
            }
        }

    }
}

Map嵌套Map

public class Test3 {
    public static void main(String[] args) {
        /*
            Map嵌套Map:

         */
        // 创建Map集合对象
        Map<String,String> map1 = new HashMap<>();
        map1.put("it001","AAA");
        map1.put("it002","BBB");

        // 创建Map集合对象
        Map<String,String> map2 = new HashMap<>();
        map2.put("h001","CCC");
        map2.put("h002","DDD");

        // 创建Map集合,把以上2个Map集合作为值存储到这个map集合中
        Map<String, Map<String, String>> map = new HashMap<>();

        map.put("001",map1);
        map.put("002",map2);

        System.out.println(map.size());// 2

        // 获取map集合中的所有键
        Set<String> keys = map.keySet();
        // 遍历所有的键
        for (String key : keys) {
            // 根据键找值
            Map<String, String> value = map.get(key);
            // 遍历value这个Map集合
            Set<String> keySet = value.keySet();
            for (String k : keySet) {
                String v = value.get(k);
                System.out.println(k+","+v);
            }
        }
    }
}
chinusyan
关注
专栏目录
java获得集合的泛型类型_Java集合之泛型类和泛型接口
weixin_32512261的博客
02-28 857
1. 为什么要有泛型1.1 不使用泛型的问题当不使用泛型时，集合中是可以存放任意类型对象的，只要把对象存储集合后，那么他们都会被提升为Object类型。当我们在取出每一个对象，并且进行相应的操作，需要进行类型转换。观察下面代码：public static void main(String[] args) {Collection coll = new ArrayList();coll.add("ab...
java 集合泛型+数据结构
08-07
java 集合泛型+数据结构
Java集合-泛型
Philanderers的博客
12-25 1244
1、Array(数组）、ArrayList和LinkedList的区别 Array(数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。Array获取数据的时间复杂度是O(1),但是要删除数据却是开销很大，因为这需要重排数组中的所有数据,(因为删除数据以后, 需要把后面所有的数据前移)。缺点:数组初始化必须指定初始化的长度, 否则报错。 例如: int[] a = new int[4];//推荐使用int[] 这种方式初始化 ​ int
Java集合学习：泛型
qq_59212867的博客
06-15 637
Java泛型
Java 中的泛型（两万字超全详解）
热门推荐
林二月的博客
08-02 7万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
Java集合泛型之泛型方法
sun10367的博客
07-19 366
目录定义格式：泛型方法使用非静态泛型方法静态泛型方法泛型可变个数形参 为了让方法可以操作不同类型的数据，而且类型不确定，可以将泛型定义在方法上。 定义格式： 权限修饰符 <类型形参> 返回值类型 方法名(参数){...} 只有在修饰符和返回值类型之间用 <类型形参> 声明的方法才是泛型方法，使用泛型类或泛型接口的泛型的方法不一定是泛型方法。 在方法返回值类型前面声明的类型形参，只能在当前方法中使用，用于表示形参的类型、返回值类型或方法局部变量的类型，与泛型方法所属的类或接口无关，与
java集合 — — 泛型
mocoll的博客
08-28 1008
三、泛型 3.1、泛型概述 在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。 提示:泛型是数据类型的一部分,我们将类名与泛型合并一起看做数据类型。 3.2、泛型的定义和使用 我们在集合中会大呈使用到泛型,这里来完整地学习泛型知识。 泛型,用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。 3.2.1、定义和使用含有泛型的类 定义格式：
Java集合--泛型集合
likehack的博客
09-07 832
泛型集合的使用
Java攻略集合之泛型
qq_57767445的博客
11-08 601
比较器排序：创建TreeSet对象的时候传递Comparator的实现类对象，重写compare方法，根据返回值进行排序。没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取，删除Set集合里的元素。>：表示元素类型未知的ArrayList，它的元素可以匹配任何的类型。此处T可以随便写为任意标识，常见的如T，E，K，V等形式的参数常用于表示泛型。在使用的时候，默认使用自然排序，当自然排序不满足现在的需求时，使用比较器排序。2、如果返回值为0，表示当前存入的元素跟集合中元素重复类，不存。
java集合之泛型
Walker_sis的博客
03-08 3684
泛型概述 java泛型是JDK1.5中引入的一个新特性，本质是参数化类型，把类型作为参数传递。 常见的形式由泛型类，泛型方法，泛型接口 语法：<T…>T称为类型占位符，表示一种引用类型。 好处： 提高代码的重用性 防止类型转换异常，提高代码的安全性。 3)规范类型 泛型的分类 泛型类 package genericedemo; /** * 定义的泛型类 */ public class GenericeClass<E,T> { //属性 private E
Java基础程序——集合和泛型
weixin_45890771的博客
04-14 902
目录 一、集合(Collection) 1.1、概述 1.2、集合继承关系图 1.3、集合的方法 二、迭代器 2.1、迭代器概述 2.1、迭代器的实现原理 2.3、集合迭代中的转型 三、增强for循环 3.1、增强for循环遍历数组 3.2、增强for循环遍历集合 四、泛型 4.1、泛型的定义和使用 4.2、擦拭法 4.3、泛型类 4.4、泛型方法 4.5、泛型的接口 4.6、泛型的好处 4.7、泛型的通配符 4.8、泛型的定 一、集合(Collectio...
Java集合、泛型和枚举
06-14
Java集合框架是Java编程语言中不可或缺的一部分，它提供了...总的来说，Java集合、泛型和枚举是构建复杂数据结构和实现业务逻辑的关键工具。熟练掌握这些概念和它们的使用方法，将极大地提升Java编程的效率和代码质量。
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 892
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 289
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 491
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1001
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 634
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
java 集合 泛型
07-27
Java集合框架是一组用于存储和操作数据的类和...Java集合框架中的许多类都支持泛型，例如ArrayList、LinkedList、HashSet等。通过使用泛型，我们可以更好地利用Java集合框架提供的功能，并提高代码的可读性和可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值