集合简介与使用

已于 2023-07-01 00:24:28 修改
阅读量45 收藏
点赞数
分类专栏： 笔记周志 文章标签： java c# 开发语言
于 2023-05-14 10:53:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74163755/article/details/130666417
版权

文章目录

集合框架体系

  1. 集合主要分为单列集合和双列集合

  2. Collection接口主要有两个重要的子接口 List和Set，他们的实现子类都是单列集合

  3. Map接口的实现子类是双列集合 k-v

在这里插入图片描述

Collection接口和常用方法

  1. collection实现子类可以存放多个元素，每个元素可以是Object

  2. 有些Collection的实现类，可以存放重复的元素，有些不可以

  3. 有些Collection的实现类，有些是有序的（List),有些不是有序（Set)

  4. Collection接口没有直接的实现子类，是通过它的子接口Set 和 List 来实现的

    /**
*Collection接口常用方法
*/
public class CollectionMethod {
	@SuppressWarnings({"all"})
	public static void main(String[] args) {
        List list = new ArrayList();

        list.add("jack");
        list.add(10);
        list.add(true);
        System.out.println("list=" + list);
        list.remove(0);
        list.remove(true);
        System.out.println("list=" + list);
        System.out.println(list.contains("jack"));
        System.out.println(list.size());
        list.clear();
        System.out.println("list=" + list);
        ArrayList list2 = new ArrayList();
        list2.add("红楼梦");
        list2.add("三国演义");
        list.addAll(list2);
        System.out.println("list=" + list);
        System.out.println(list.containsAll(list2));//T
        list.add("聊斋");
        list.removeAll(list2);
        System.out.println("list=" + list);
        }
}

    • Collection接口遍历元素方式1-使用Iterator（迭代器）

      1. Iterator对象称为迭代器，主要用于遍历 Collection 集合中的元素。

      2. 所有实现了Collection接口的集合类都有一个iterator()方法，用以返回
        一个实现了Iterator接口的对象，即可以返回一个迭代器。

      3. Iterator 的结构．

      4. Iterator仅用于遍历集合，Iterator 本身并不存放对象。

        • hasNext()
        • next() //在调用next()之前要调用iterator.hasnext()进行检测，否则抛出异常
        • remove()
        /**
*迭代器演示
*/
public class CollectionIterator {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(new Book("三国演义", "罗贯中", 10.1));
        col.add(new Book("小李飞刀", "古龙", 5.1));
        col.add(new Book("红楼梦", "曹雪芹", 34.6));

        Iterator iterator = col.iterator();
        while (iterator.hasNext()) {
        	Object obj = iterator.next();
        	System.out.println("obj=" + obj);
        }

        iterator = col.iterator();
        System.out.println("===第二次遍历===");
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
    }
}

    • Collection接口遍历对象方式2-for循环增强

      1. 增强for就是简化版的iterator，本质一样，只能用于遍历集合或或数组
      2. 基本语法for(元素类型 元素名：集合名或数组名){

      ​ 访问元素

      }

    /**
*for循环增强

* 创建 3 个 Dog {name, age} 对象，放入到 ArrayList 中，赋给 List 引用
* 用迭代器和增强 for 循环两种方式来遍历
 */
public class CollectionExercise {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Dog("小黑", 3));
        list.add(new Dog("大黄", 100));
        list.add(new Dog("大壮", 8));
        //先使用 for 增强
        for (Object dog : list) {
        	System.out.println("dog=" + dog);
        }
        //使用迭代器
        System.out.println("===使用迭代器来遍历===");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
        	Object dog = iterator.next();
        	System.out.println("dog=" + dog);
        }
    }
}

List接口和常用方法

  • List 接口是 Collection 接口的子接口

    • List集合类中元素有序（即添加顺序和取出顺序一致）、且可重复
    • List集合中的每个元素都有其对应的顺序索引，即支持索引。
    • List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
    /**
*List接口应用
*/
public class List_ {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        list.add("tom");
        System.out.println("list=" + list);

        System.out.println(list.get(3));
}

  • List接口常用方法

    /**
*List接口常用方法
*/
public class ListMethod {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("张三丰");
        list.add("贾宝玉");

        list.add(1, "派大星");
        System.out.println("list=" + list);

        List list2 = new ArrayList();
        list2.add("jack");
        list2.add("tom");
        list.addAll(1, list2);
        System.out.println("list=" + list);

        System.out.println(list.indexOf("tom"));//2
        list.add("派大星");
        System.out.println("list=" + list);
        System.out.println(list.lastIndexOf("派大星"));
        list.remove(0);
        System.out.println("list=" + list);
        list.set(1, "小美");
        System.out.println("list=" + list);
        List returnlist = list.subList(0, 2);
        System.out.println("returnlist=" + returnlist);
    }
}

  • List的三种遍历方式[ArrayList,LinkedList,Vector]

    1. 使用iterator
    2. 使用增强for
    3. 使用普通for
    /**
*三种遍历方式
*/
public class ListFor {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        List list = new LinkedList();
        list.add("jack");
        list.add("tom");
        list.add("严浩翔");
        list.add("宋亚轩");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        }
        System.out.println("=====增强 for=====");
        for (Object o : list) {
        	System.out.println("o=" + o);
        }
        System.out.println("=====普通 for====");
        for (int i = 0; i < list.size(); i++) {
        	System.out.println("对象=" + list.get(i));
        }
    }
}

ArrayList底层结构

ArrayList的注意事项

  1. 允许加入所有元素，包括null；ArrayList 可以加入null,并且多个
  2. ArrayList是由数组来实现数据存储的
  3. ArrayList 基本等同于Vector,除了 ArrayList是线程不安全（执行效率高） 看源码．在多线程情况下，不建议使用ArrayList

ArrayList的底层操作机制源码分析

  1. ArrayList中维护了一个Object类型的数组elementData. [debug 看源码］
    transient Object[] elementData;//transient 表示瞬间，短暂的，表示该属性不会被序
    列号
  1. 当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0,第1
    次添加，则扩容elementData为10,如需要再次扩容，则扩容elementData为1.5倍。
  1. 如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，
    则直接扩容elementData为1.5倍。

Vector底层结构

  1. Vector类的定义说明

    public class Vector< E >

    extends AbstractList< E >

    inplements List< E >,RandonAccess,Cloneable,Serializable

  2. Vector底层也是一个对象数组，protected Object[] elementData;

  3. Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized

    public synchronized E get(int index){

    ​ if (index>= elementCount)

    ​ throw new ArraylndexOutOfBoundsException(index):

    ​ return elementData(index);

  4. 在开发中，需要线程同步安全时，考虑使用Vector

LinkedList底层结构

LinkedList的全面说明

  1. LinkedList底层实现了双向链表和双端队列特点
  1. 可以添加任意元素（元素可以重复），包括null
  2. 线程不安全，没有实现同步

LinkedList的底层操作机制

  1. LinkdList底层维护了一个双向链表．
  2. LinkedList中维护了两个属性first和last分别指向 首节点和尾节点
  3. 每个节点（Node对象），里面又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个节点。最终实现双向链表。
  4. 所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高。

Set接口和常用方法

基本介绍

  1. 无序（添加和取出的顺序不一致），没有索引
  2. 不允许重复元素，所以最多包含一个null

Set接口的常用方法

  • 和List接口一样，Set接口也是Collection的子接口，因此，常用方法和Collection接口一样。

Set接口的遍历方式

​ 同Collection的遍历方式一样，因为Set接口也是Collection接口的子接口。

  1. 可以使用迭代器

  2. 增强for

  3. 不能使用索引的方式来获取．

    /**
*Set接口常用方法
*/
public class SetMethod {
    public static void main(String[] args) {
        Set set = new HashSet();
        set.add("john");
        set.add("lucy");
        set.add("john");
        set.add("jack");
        set.add("mary");
        set.add(null);//
        set.add(null);//再次添加 null
        for(int i = 0; i <10;i ++) {
        	System.out.println("set=" + set);
        }
        //遍历
        //方式 1： 使用迭代器
        System.out.println("=====使用迭代器====");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
        set.remove(null);
        //方式 2: 增强 for
        System.out.println("=====增强 for====");
        for (Object o : set) {
        	System.out.println("o=" + o);
        }
    }
}

Set接口实现类-HashSet

  1. HashSet实现了Set接口

  2. HashSet实际上是HashMap

    public HashSet(){

    ​ map=new HashMap<>();

    }

  3. 可以存放null值，但是只能有一个null

  4. HashSet不保证元素是有序的，取决于hash后，再确定索引的结果．（即，不保证存放元素的顺序和取出顺序一致）

  5. 不能有重复元素／对象．

    /**
*HashSet
*/
public class HashSet_ {
    public static void main(String[] args) {
        Set hashSet = new HashSet();
        hashSet.add(null);
        hashSet.add(null);
        System.out.println("hashSet=" + hashSet);
    }
}

HashSet底层机制

  1. HashSet底层是HashMap，HashMap底层是 ：数组+链表+红黑树
  2. HashSet的添加元素底层是如何实现的
    1. HashSet 底层是 HashMap
    2. 添加一个元素时，先得到hash值。转成－＞索引值
    3. 找到存储数据表table,看这个素引位置是否已经存放的有元素
    4. 如果没有，直接加入
    5. 如果有，调用 equals 比较，如果相同，就放弃添加，如果不相同，则添加到最后
    6. 在JavaB中，如果一条链表的元素个数到达 TREEIFY THRESHOLD(默认是8),并且table的大小＞＝MIN_TREEIFY_CAPACITY(默认64),就会进行树化（红黑树）
  3. HashSet的扩容和转成红黑树机制
    1. HashSet底层是HashMap, 第一次添加table 数组扩容到16,临界值（threshold)是 16* 加载因子（loadFactor)0.75=12
    2. 如果table 数组使用到了临界值12,就会扩容到16*2=32,新的临界值就是32 *0.75=24,依次类推
  4. 在Java8中，如果一条链表的元素个数到达 TREEIFY THRESHOLD(默认是8),并且table的大小＞＝
    MIN TREEIFY CAPACITY(默认64),就会进行树化（红黑树），否则仍然采用数组扩容机制

Set接口实现类-LinkedHashSet

  1. LinkedHashSet 是 HashSet的子类

  1. LinkedHashSet 底层是一个 LinkedHashMap,底层维护了一个数组＋双向链表

  2. LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的。

  1. LinkedHashSet 不允许添重复元素
/**
*LinkedHashSet
*/
public class LinkedHashSetExercise {
    public static void main(String[] args) {
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add(new Car("奥拓", 1000));
        linkedHashSet.add(new Car("奥迪", 300000));
        linkedHashSet.add(new Car("法拉利", 10000000));
        linkedHashSet.add(new Car("保时捷", 70000000));
        System.out.println("linkedHashSet=" + linkedHashSet);
        }
}
   @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Car car = (Car) o;
        return Double.compare(car.price, price) == 0 &&
            Objects.equals(name, car.name);
    }
    @Override
    public int hashCode() {
    	return Objects.hash(name, price);
    }
}

LinkedHashSet底层机制

  1. 在LinkedHastSet 中维护了一个hash表和双向链表
    （LinkedHashSet 有 head 和 tail)
  2. 每一个节点有 before 和 after 属性，这样可以形成双向链表
  3. 在添加一个元素时，先求hash值，在求索引，确定该元素在table的位置，然后将添加的元素加入到双向链表（如果已经
    存在，不添加［原则和hashset一样］）
    tail.next=newElement //示意代码
    newElement.pre = tail
    tail =newEelment;
  4. 这样的话，我们遍历LinkedHashSet 也能确保插入顺序和遍历顺序一致

Map接口和常用方法

  1. Map与Collection并列存在。用于保存具有映射关系的数据：KelValue
  1. Map 中的 key和 value 可以是任何引用类型的数据，会封装到HashMap$Node对象中

  1. Map 中的key 不允许重复，原因和HashSet一样

  2. Map 中的 value 可以重复

  1. Map的key 可以为 null,value 也可以为null,注意 key为null,只能有一个，value 为null ,可以多个。

  1. 常用String类作为Map的 key

  2. key和value 之间存在单向一对一关系，即通过指定的 key 总能找到对应的 value

/**
*Map
*/
public class Map_ {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("no1", "派大星");
        map.put("no2", "章鱼哥");
        map.put("no1", "痞老板");
        map.put(null, null); 
        map.put(null, "abc"); 
        map.put("no3", null); 
        map.put("no4", null); 
        map.put(1, "海绵宝宝");
        map.put(new Object(), "金毛狮王");

        System.out.println(map.get("no2"));
        System.out.println("map=" + map);
    }
}

Map接口常用方法

/**
*Map常用方法
*/
public class MapMethod {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("刘耀文", new Book("", 100));
        map.put("刘耀文", "宋亚轩");
        map.put("严浩翔", "滕丽蓉");
        map.put("朴灿烈", "滕丽蓉");
        map.put("王鹤棣", null);
        map.put(null, "赵丽颖");
        map.put("鹿晗", "关晓彤");

        System.out.println("map=" + map);
        map.remove(null);
        Object val = map.get("鹿晗");
        System.out.println("k-v=" + map.size());
        System.out.println(map.isEmpty());
        System.out.println("结果=" + map.containsKey("hsp"));
        }
}
class Book {
    private String name;
    private int num;
    public Book(String name, int num) {
        this.name = name;
        this.num = num;
    }
}

Map接口遍历方法

  1. containKey:查找键是否存在

  2. keySet：获取所有的键

  3. entrySet：获取所有关系k-v

  4. values：获取所有的值

    /**
*Map遍历方式
*/
public class MapFor {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("刘耀文", "宋亚轩");
        map.put("严浩翔", "滕丽蓉");
        map.put("朴灿烈", "滕丽蓉");
        map.put("王鹤棣", null);
        map.put(null, "赵丽颖");
        map.put("鹿晗", "关晓彤");

        Set keyset = map.keySet();
            //(1) 增强 for
        System.out.println("-----第一种方式-------");
        for (Object key : keyset) {
        	System.out.println(key + "-" + map.get(key));
        }
        //(2) 迭代器
        System.out.println("----第二种方式--------");
        Iterator iterator = keyset.iterator();
        while (iterator.hasNext()) {
        	Object key = iterator.next();
        	System.out.println(key + "-" + map.get(key));
        }

        Collection values = map.values();
        //(1) 增强 for
        System.out.println("---取出所有的 value 增强 for----");
        for (Object value : values) {
        	System.out.println(value);
        }
        //(2) 迭代器
        System.out.println("---取出所有的 value 迭代器----");
        Iterator iterator2 = values.iterator();
        while (iterator2.hasNext()) {
        	Object value = iterator2.next();
            System.out.println(value);
        }
        Set entrySet = map.entrySet();// EntrySet<Map.Entry<K,V>>
        //(1) 增强 for
        System.out.println("----使用 EntrySet 的 for 增强(第 3 种)----");
        for (Object entry : entrySet) {

        	Map.Entry m = (Map.Entry) entry;
        	System.out.println(m.getKey() + "-" + m.getValue());
        }
        //(2) 迭代器
        System.out.println("----使用 EntrySet 的 迭代器(第 4 种)----");
        Iterator iterator3 = entrySet.iterator();
        while (iterator3.hasNext()) {
        	Object entry = iterator3.next();
        } 
        Map.Entry m = (Map.Entry) entry;
        System.out.println(m.getKey() + "-" + m.getValue());
     }
}

Map接口实现类-HashMap

  1. Map接口的常用实现类：HashMap、Hashtable和Properties.

  2. HashMap是 Map 接口使用频率最高的实现类。

  3. HashMap 是以 key-val 对的方式来存储数据（HashMap$Node类型）［案例 Entry]

  4. key不能重复，但是值可以重复，允许使用null键和null值。

  5. 如果添加相同的key,则会覆盖原来的key-val,等同于修改．（key不会替换，val会替换）

  6. 与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的．（jdk8的

    hashMap 底层数组＋链表＋红黑树）

  7. HashMap没有实现同步，因此是线程不安全的，方法没有做同步互斥的操作，没有synchronized

HashMap底层机制

扩容机制［和HashSet相同］

  1. HashMap底层维护了Node类型的数组table,默认为null
  2. 当创建对象时，将加载因子（loadfactor)初始化为0.75.
  3. 当添加key-val时，通过key的哈希值得到在table的索引。然后判断该素引处是否有元素，如果没有元素直接添加。如果该索引处有元素，继续判断该元素的key和准备加入的key是否相等，如果相等，则直接替换val;如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容。
  4. 第1次添加，则需要扩容table容量为16,临界值（threshold)为12 (16*0.75)
  5. 以后再扩容，则需要扩容table容量为原来的2倍（32),临界值为原来的2倍，即24,依次类推
  6. 在Java8中，如果一条链表的元素个数超过TREEIFY_THRESHOLD(默认是8),并且table的大小＞＝MIN_TREEIFY_CAPACITY(默认64),就会进行树化（红黑树）

Map接口实现类-Hashtable

  1. 存放的元素是键值对：即 K-V
  2. hashtable的键和值都不能为null,否则会抛出NullPointerException
  3. hashTable 使用方法基本上和HashMap一样
  4. hashTable 是线程安全的（synchronized),hashMap 是线程不安全的
  5. 简单看下底层结构
    HashTable的应用案例
    ／／下面的代码是否正确，如果错误，为什么？
    Hashtable table = new Hashtable()😕/ok
    table.put(“john”,100);//ok
    table.put(null, 100);//异常
    table.put(“john”,null);//异常
    table.put(“lucy”,100);//ok
    table.put(“lic”, 100);//ok
    table.put(“lic”,88);//替换

Map接口实现类-Properties

1.Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形
式来保存数据。
2.他的使用特点和Hashtable类似
3.Properties 还可以用于从xxx.properties 文件中，加载数据到Properties类对象，
并进行读取和修改
4.说明： xxx.properties 文件通常作为配置文件（后续还会遇到.xml.和yaml的配置文件）

/**
*Properties基本使用
*/
public class Properties_ {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.put("john", 100);
        properties.put("lucy", 100);
        properties.put("lic", 100);
        properties.put("lic", 88);换
        System.out.println("properties=" + properties);

        System.out.println(properties.get("lic"));//88
        properties.remove("lic");

        properties.put("john", "约翰");
        System.out.println("properties=" + properties);
    }
}

开发中如何选择集合实现类

在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择，分析如下：
1.先判断存储的类型（一组对象[单列]或一组键值对[双列]）

  1. 一组对象［单列］：Collection接口
    允许重复：List
    增删多：LinkedList[底层维护了一个双向链表］
    改查多：ArrayList[底层维护 Object类型的可变数组］
    不允许重复：Set
    无序：HashSet[底层是HashMap,维护了一个哈希表 即（数组＋链表＋红黑树）］
    排序：TreeSet
    插入和取出顺序一致：LinkedHashSet,维护数组＋双向链表
  2. 一组健值对［双列］：Map
    键无序：HashMap[底层是：哈希表 jdk7:数组＋链表，jdk8:数组＋链表＋红黑树］
    键排序：TreeMap
    键插入和取出顺序一致：LinkedHashMap
    读取文件 Properties

Collections工具类

Collections 工具类介绍

  1. Collections是一个操作 Set、List 和 Map 等集合的工具类
  2. Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作

排序操作：(均为static方法)

  1. reverse(List):反转 List 中元素的顺序

  2. shuffle(List):对 List 集合元素进行随机排序

  3. sort(List):根据元素的自然顺序对指定 List集合元素按升序排序

  1. sort(List,Comparator):根据指定的Comparator产生的顺序对 List集合元素进行排序
  1. swap(List,int, int):将指定 list 集合中的i 处元素和 j 处元素进行交换
/**
*Collections排序方法
*/
public class Collections_ {
    public static void main(String[] args) {

        List list = new ArrayList();
        list.add("tom");
        list.add("smith");
        list.add("king");
        list.add("milan");
        list.add("tom");
        Collections.reverse(list);
        System.out.println("list=" + list);
         for (int i = 0; i < 5; i++) {
         	Collections.shuffle(list);
        	System.out.println("list=" + list);
         }
        Collections.sort(list);
        System.out.println("自然排序后");
        System.out.println("list=" + list);

        Collections.sort(list, new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {

        }
        });
        System.out.println("字符串长度大小排序=" + list);

        Collections.swap(list, 0, 1);
        System.out.println("交换后的情况");
        System.out.println("list=" + list);

        System.out.println("自然顺序最大元素=" + Collections.max(list));

        Object maxObject = Collections.max(list, new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
        	return ((String)o1).length() - ((String)o2).length();
        }
        });
        System.out.println("长度最大的元素=" + maxObject);
  
        System.out.println("tom 出现的次数=" + Collections.frequency(list, "tom"));

        ArrayList dest = new ArrayList();

        for(int i = 0; i < list.size(); i++) {
        	dest.add("");
        }
        Collections.copy(dest, list);
        System.out.println("dest=" + dest);
 
        Collections.replaceAll(list, "tom", "汤姆");
        System.out.println("list 替换后=" + list);
    }
}

查找，替换

  1. Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素
  2. Object max(Collection,Comparator):根据 Comparator 指定的顺序，返回给定集合中的最大元素
  3. Object min(Collection)
  4. Object min(Collection,Comparator)
  5. int frequency(Collection,Object):返回指定集合中指定元素的出现次数
  6. void copy(List dest,List src):将src中的内容复制到dest中
  7. boolean replaceAll(List list,Object oldVal, Object newVal):使用新值替换 List 对象的所有旧值
Rillia
关注
专栏目录
集合框架·List集合简介
weixin_54877075的博客
05-16 1995
相信大家初学Java时对集合的概念也有一定的了解，那么java里面的集合又是什么呢？ 一、集合是什么？ 它和数组不同，数组既可以存储基本数据类型，也可以存储引用数据类型。而集合只能存储引用数据类型，比如你存入一个int型数据18放入集合中，其实它是自动转换成Integer类后存入的，Java中每一种基本数据类型都有对应的引用类型，如果存储基本数据类型，会被自动装箱。 它就像一个容器，专门用来存储java对象（实际上是对象名，即指向地址的指针），这些对象可以是任意数据类型，并且长度可变。其中，这些集..
集合详解
weixin_46056866的博客
02-14 524
集合 集合类的特点：提供一种存储空间可变的的存储模型。 集合只能存储引用类型的数据。 集合： Collection(单列)和Map（双列） ​ Collection(单列)： List(可重复) Set(不可重复) Map（双列）：HashMap TreeMap 等（实现类） List(可重复)：ArrayList LinkList （实现类） Set(不可重复)：HashSet LinkedHashSet TreeSet（实现类） (上下是继承关系，父类有的方法，子类都有，还有
Scala中集合的使用
qq_57691507的博客
04-13 1734
Scala中集合的使用
【Redis】Set集合类型基本使用
兮动人
01-18 1144
文章目录1. 简介2. 常用命令3. set数据结构 1. 简介 set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。 Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表，所以添加，删除，查找的复杂度都是O(1)。 一个算法，随着数据的增加，执行时间的长短，如果
集合
qq_36914723的博客
03-07 288
集合的特点： 集合中只能存储对象，比如集合中存入int型数据，它会自动转化为Integer类后存入； 集合里放的是多个对象的引用，对象本身还是放在堆内存中； 集合可以存放不同类型，不限数量的数据类型。 List（列表；实现了Iterable接口，有序，可以包含重复元素） ArrayList和LinkedList区别:1.ArrayList是基于动态数组的数据结构，LinkedList基于循...
Java集合与数组区别简介及相互转换实例
08-28
Java集合与数组区别简介及相互转换实例 Java集合（Collection）和数组（Array）是Java语言中两种常用的数据存储结构，它们之间存在着一定的区别和联系。本文将主要介绍Java集合与数组的区别简介及相互转换实例，...
java 集合简介
08-09
首先，让我们讨论使用Java集合框架的优势。集合框架允许动态扩展容量，这意味着在运行时可以根据需要自动增加数组大小，避免了预先设定固定大小数组的限制。此外，集合框架提供了丰富的功能，如迭代、排序、搜索、...
lingo集合使用
04-07
#### 一、Lingo简介与集合功能概述 Lingo是一款用于构建和求解线性、非线性以及整数优化问题的专业软件。它提供了直观的语法结构来定义数学模型，使得用户能够快速地将实际问题转化为计算机可处理的形式。在Lingo中...
Java使用Iterator迭代器遍历集合数据的方法小结
08-25
Java使用Iterator迭代器遍历集合数据的方法小结 Java语言中，使用Iterator迭代器遍历集合数据是一种常见的操作。本文主要介绍了Java使用Iterator迭代器遍历集合数据的方法，并结合实例形式分析了Java迭代器进行集合...
Java-网络
最新发布
2301_81543552的博客
09-14 452
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
上传文件到钉盘流程详解
jspyth的博客
09-14 486
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 600
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 804
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
C#基础（11）函数重载
a6s686的博客
09-12 819
我们通过这些例子的学习，想毕你一定已经掌握了函数重载的相关内容，我相信你只要稍加练习，便能达到很熟练的程度。不过不管知识点难或者简单，还是那句话，学习路上，戒骄戒躁，脚踏实地。请期待我的下一篇博客！
Spring AMQP给消息添加头信息
yong472727322的博客
09-10 281
【代码】Spring AMQP给消息添加头信息。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 846
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
Spring-di基本使用
2301_76862031的博客
09-09 1412
spirngDi环境搭建，使用流程，set注入，构造注入，对象注入，外部引入注入，内部创建注入，外部引入级联赋值注入，list集合注入，map集合注入，util注入
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 290
spirng security中的几大组件的差异和执行顺序
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1049
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
模糊集合与模糊控制理论简介
模糊控制是基于模糊逻辑的控制方法，它允许使用自然语言或模糊规则来描述复杂的控制策略。在实际应用中，比如控制一个设备的温度，除了设定精确的温度值，还可以设置像“适度”或“较热”这样的模糊条件。模糊控制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值