java集合（笔记）

最新推荐文章于 2024-06-12 11:59:04 发布
最新推荐文章于 2024-06-12 11:59:04 发布
阅读量229 收藏
点赞数 2
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65201998/article/details/124535627
版权

文章目录

十一.java集合

（1）集合概述

一.集合框架的概述

1.集合、数组都是对多个数据进行存储操作的结构，简称java容器

说明:此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储(.txt,.jpg,.avi,数据库中)

2.1数组在存储多个数据方面的特点:

一旦初始化以后，其长度确定了
数组一旦定义好以后，其数组元素的类型已经确定。我们只能操作指定类型的参数了。比如String[] arr;

2.2数组在存储多个数据方面的缺点:

一旦初始化以后，其长度不可被修改
数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，数组不可满足。

（2）集合框架

Collection接口：单列集合，用来存储一个一个的对象

​ 三个子接口：

list接口：存储有序的、可重复的数据 —> 动态数组
ArrayList,LinkedList,Vector

set接口：存储无序的、不可重复的数据 —> 相当于高中讲的集合
HashSet,LinkedHashSet,TreeSet

Map接口：双列集合，用来存储一对(key–value)一对的数据 —>高中函数y=f(x)
HashMap,LinkedHashMap,TreeMap,Hashtable,Properties

（3）Collection方法

image-20220429151002490 image-20220429151032598 
/**
 *  Collection接口中的方法的使用
 *  像Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()
 *
 * @author: ccw
 * @date: 2022/4/29 13:11
 */

public class CollectionTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();

        //add(object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);//自动装箱
        coll.add(new Date());

        //size():获取添加的元素的个数
        System.out.println(coll.size());

        //addAll():将coll1集合中的元素添加到当前集合中
        Collection coll1=new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);
        System.out.println(coll1.size());

        //isEmpty:判断当前集合是否为空
        System.out.println(coll.isEmpty());
    }

    @Test
        public void test2(){
        Collection coll2=new ArrayList();
        coll2.add(123);
        coll2.add(456);
        coll2.add(new String("Tom"));
        coll2.add(false);
        coll2.add(new Person("Jerry",20));

        //contains(Object obj):判断当前集合中是否包含obj
        //我们在判断时会调用obj对象所在类的equals()。

        boolean contains = coll2.contains(123);
        System.out.println(contains);
        System.out.println(coll2.contains(new String("Tom")));//true(重写了equals方法，比较的是实体内容)
        System.out.println(coll2.contains(new Person("Jerry",20)));//false(未重写equals方法)

        //containsAll(collection coll1)判断形参coll1中所有元素是否都存在于当前集合中
        Collection  coll3 =  Arrays.asList(123,456);
        System.out.println(coll2.containsAll(coll3));

    }
    @Test
    public void test3(){
        Collection coll=new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("Jerry",20));

        //remove(Object obj):从当前集合中移除obj元素
        coll.remove(123);
        System.out.println(coll);
        coll.remove(new Person("Jerry",20));
        System.out.println(coll);


        //removeAll(Collection coll1):从当前集合中移除coll1中所有的元素,并返回当前集合(差集)
        Collection coll1=Arrays.asList(false,new String("Tom"));
        coll.removeAll(coll1);
        System.out.println(coll);
    }
@Test
    public void test4() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("Jerry", 20));

        //retainAll(Collection coll1):获取当前集合和roll1集合的交集，并返回给当前集合（交集）
//        Collection coll1=Arrays.asList(123,456,789);
//        coll.retainAll(coll1);
//        System.out.println(coll);

        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add(456);
        coll1.add(new String("Tom"));
        coll1.add(false);
        coll1.add(new Person("Jerry", 20));

        //equals(Object obj)：要想返回true，需要当前集合和形参的元素都相同
        System.out.println(coll.equals(coll1));
    }
    @Test
    public void test5() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("Jerry", 20));

        //hashCode():返回当前对象的哈希值
        System.out.println(coll.hashCode());

        //集合--->数组：toArray()
        Object[] arr = coll.toArray();
        for(int i = 0;i < arr.length;i++){
            System.out.println(arr[i]);
        }

        //数组--->集合
        List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
        System.out.println(list);

        //注意点:
        List arr1 = Arrays.asList(new int[]{123,456});//识别为一个元素
        System.out.println(arr1);//[[I@5b80350b]

        List arr2 = Arrays.asList(new Integer[]{123,456});
        System.out.println(arr2);//[123, 456]

    
        
    }
}

（4）迭代器Iterator接口

1.hasNext（）和next（）方法

/**
 * 集合元素的遍历操作，使用迭代器Iterator接口
 * iterator():返回Iterator接口的实例，用于遍历集合元素。放在IteratorTest.java中测试
 * 
 *
 *
 * @author: ccw
 * @date: 2022/4/30 14:41
 */
public class IteratorTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("Jerry", 20));

        Iterator iterator = coll.iterator();
        //方式一：
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        //报异常：NoSuchElementException
//        System.out.println(iterator.next());
        //方式二：不推荐
        for(int i = 0;i < coll.size();i++){
            System.out.println(iterator.next());
        }

        //方式三：推荐
        while(iterator.hasNext()){//判断coll中是否还有元素
            System.out.println(iterator.next());//next()进行下移
        }

    }
}

2.remove（）方法

此方法可以在遍历的时候，删除集合中的元素

注意点：如果还未调用next()或在上一次调用next方法之后已经调用了remove 方法，再调用remove都会报IllegalStateException。

 public void test2() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("Jerry", 20));



        Iterator iterator = coll.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            if("Tom".equals(obj)){
                //删除集合中的"Tom"
                iterator.remove();
            }
        }

        
            //需要新建Iterator对象重新从头开始遍历
             iterator = coll.iterator();
            while(iterator.hasNext()){
                System.out.println(iterator.next());
            }
    }
}

3.foreach（增强for循环）

/**
 * JDk5.0 新增了foreach循环，用来遍历集合、数组
 *
 * 
 * @author: ccw
 * @date: 2022/4/30 15:45
 */
public class ForTest {
    @Test
    public void test1(){
    Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("Jerry", 20));

        //for(集合元素的类型  局部变量 : 集合对象)
        //内部仍然使用了迭代器
        for(Object obj:coll){
            System.out.println(obj);
        }
    }
}

（5）List接口

List：存储有序的、可重复的数据 —> 动态数组

三个实现类：ArrayList,LinkedList,Vector

ArrayList,LinkedList,Vector三者异同：

同：

三个类都实现了List接口。数据存储的特点：存储的是有序的，可重复的数据

不同：

ArrayList:作为List的主要实现类，线程不安全，效率高；底层使用Object[ ] elementData存储

LinkedList：对于频繁的插入删除操作，使用此类效率比ArrayList高；底层使用双向链表存储

Vector：作为List的古老实现类；线程安全，效率低；底层使用Object[ ] elementData存储

（6）List接口中的常用方法

  • void add(int index, object ele):在index位置插入ele元素

  • boolean addAll(int index,collection eles):从index位置开始将eles中的所有元素添加进来

  • Object get(int index):获取指定index位置的元素

  • int indexOf(object obj):返回obj在集合中首次出现的位置

  • int lastIndex0f(object obj):返回obj在当前集合中末次出现的位置

  • Object remove(int index):移除指定index位置的元素，并返回此元素

  • Object set(int index，object ele):设置指定index位置的元素为ele

  • list sublist(int fromIndex,int toIndex):返回从fromIndex到toIndex位置的子集合

    public class ListTest {
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);

//        void add(int index, object ele):在index位置插入ele元素
        list.add(0,"BB");
        System.out.println(list);

//        boolean addAll(int index,collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(7, 8, 9);
        list.addAll(list1);
        System.out.println(list);

//        Object get(int index):获取指定index位置的元素
        System.out.println(list.get(0));

//        int indexOf(object obj):返回obj在集合中首次出现的位置
        System.out.println(list.indexOf("AA"));
        System.out.println(list.indexOf("aa"));//如果找不到，返回-1

//        int lastIndex0f(object obj):返回obj在当前集合中末次出现的位置（与上同理）

//        Object remove(int index):移除指定index位置的元素，并返回此元素
        System.out.println(list.remove(1));

//        Object set(int index，object ele):设置指定index位置的元素为ele
        list.set(1,"654");
        System.out.println(list);

//        list sublist(int fromIndex,int toIndex):返回从fromIndex到toIndex位置的子集合(左闭右开)
        List subList = list.subList(3, 8);//创建一个来接收子类
        System.out.println(subList);
        //超出集合角标范围会报IndexOutOfBoundsException
//        List subList = list.subList(3, 9);

    }
}

（7）Set接口

Set：存储无序的、不可重复的数据 —> 相当于高中讲的集合

Set接口中没有声明额外定义的新方法，使用的都是Collection中声明过的方法

​ 三个实现类：HashSet,LinkedHashSet,TreeSet

HashSet：作为Set接口主要实现类；线程不安全；可以存储null值

LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历

TreeSet：可以按照添加对象的指定属性，进行排序

一：存储无序的、不可重复的数据说明，以HashSet为例：

1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序进行添加，而是根据数据的哈希值决定的。

2.不可重复性：保证添加的元素按照equals()判断时，不能返回true。即相同的元素只能添加一个。

二：添加元素的过程。以HashSet为例：

我们向HashSet添加元素a，首先调用元素a的HashCode（）方法计算出元素的哈希值，然后此哈希值通过某种算法计算出在HashSet底层数组的存放位置（索引位置），判断此数组上是否有元素。

如果此位置没有元素，则元素a直接添加成功此位置；

如果此位置有其他元素b（或以链表形式存在的多个元素），则比较元素a与元素b的哈希值。
如果哈希值不想同，则元素a添加成功。
如果哈希值相同，则需要调用元素a的equals（）方法比较。如果返回true，则元素添加失败，如果返回false， 则元素a添加成功

对于添加成功的数据a，与已经存在于索引位置上的元素以链表的方式存储

JDK7:元素a放入数组，指向原来的元素

JDK8:原来的元素在数组中，指向元素a

总结：七上八下

HashSet底层：数组+链表的结构

LinkedHashSet：

作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。
优点：对于频繁的遍历操作，效率比HashSet效率高

TreeSet：可以按照添加对象的指定属性，进行排序

1.向TreeSet添加的数据，要求是相同类的对象

2.两种排序方式：自然排序和定制排序
自然排序中，比较两个对象是否相同的标准为：compareTo（）返回0，不再是equals（）。
定制排序中，比较两个对象是否相同的标准为：compare（）返回0，不再是equals（）。

（8）hashCode() 的重写

image-20220501183859492

（9）Map接口

Map接口：双列集合，用来存储一对(key–value)一对的数据 —>高中函数y=f(x)
实现类：

​ HashMap：作为Map的主要实现类，线程不安全，效率高；存储null的key和value
​ LinkedHashMap：HashMap子类
​ 保证在遍历Map元素时，可以按照指定的顺序实现遍历。
​ 原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素
​ 对于频繁的遍历操作，LinkedHashMap比HashMap效率高

​ TreeMap：保证可以按照添加的key–value对进行排序，实现排序遍历；考虑key的自然排序或定制排序
​ 底层使用红黑树

​ Hashtable：作为古老实现类，线程安全，效率低；不能存储null的key和value
​ Properties：Hashtable子类，常用来处理配置文件。key和value都是String类型

（10）key-value结构特点

Map中的key:无序的、不可重复的，使用Set存储所有的key–>key所在的类要重写equals（）和hashCode（）方法
（以HashMap为例）
Map 中的value:无序的、可重复的，使用Collection存储所有的–>value所在的类要重写equals（）
一个键值对: key-value构成了一个Entry对象。
Map中的entry:无序的、不可重复的，使用Set存储所有的entry

（11）Map常用方法：

添加、删除、修改操作:

  1. object put(Object key,Object value):将指定key-vaLue添加到(或修改)当前map对象中

  2. void putAll(Map m):将m中的所有key-value对存放到当前map中

  3. object remove(Object key):移除指定key的key-value对，并返回value

  4. void clear():清空当前map中的所有数据

    元素查询的操作:

  5. object get(Object key):获取指定key对应的value

  6. boolean containsKey (Object key):是否包含指定的key

  7. boolean containsValue(Object value):是否包含指定的value

  8. int size():返回map 中key-value对的个数

  9. boolean isEmpty():判断当前map是否为空

  10. boolean equals(Object obj):判断当前map和参数对象obj是否相等

    元视图操作的方法:

  11. set keySet():返回所有key构成的Set集合

  12. Collection values():返回所有value构成的Collection集合

  13. set entrySet():返回所有kev-value对构成的Set集合

public class MapTest {
    @Test
    public void test1(){
        Map map = new HashMap();
        //添加
        map.put("AA",65);
        map.put(45,22);
        map.put("BB",66);
        //修改
        map.put("AA",88);

//        void putAll(Map m):将m中的所有key-value对存放到当前map中
        Map map1 = new HashMap();
        map1.put("CC",67);
        map1.put("DD",68);
        map.putAll(map1);
        System.out.println(map);

//        object remove(Object key):移除指定key的key-value对，并返回value
        map.remove("DD");
        System.out.println(map);

//        void clear():清空当前map中的所有数据
        map.clear();
        System.out.println(map);
    }

    @Test
    public void test2(){
        Map map = new HashMap();
        map.put("AA",65);
        map.put(45,22);
        map.put("BB",66);
        map.put("AA",88);

//        object get(Object key):获取指定key对应的value
        System.out.println(map.get("AA"));//88

//        boolean containsKey (Object key):是否包含指定的key
        System.out.println(map.containsKey(45));//true

//        boolean containsValue(Object value):是否包含指定的value
        System.out.println(map.containsValue("66"));//false

//        int size():返回map 中key-value对的个数(重写的相当于已经覆盖，不算)
        System.out.println(map.size());//3

//        boolean isEmpty():判断当前map是否为空
        System.out.println(map.isEmpty());//false

//        boolean equals(Object obj):判断当前map和参数对象obj是否相等
        Map map1 = new HashMap();
        map1.put(45,22);
        map1.put("BB",66);
        map1.put("AA",88);
        System.out.println(map.equals(map1));//true

    }
//元视图操作的方法(遍历):
    @Test
    public void test3(){
        Map map = new HashMap();
        map.put(45,22);
        map.put("BB",66);
        map.put("AA",88);

//      set keySet():返回所有key构成的Set集合
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

//      Collection values():返回所有value构成的Collection集合
        Collection values = map.values();
        Iterator iterator1 = values.iterator();
        while(iterator1.hasNext()){
            System.out.println(iterator1.next());
        }

//      set entrySet():返回所有kev-value对构成的Set集合
        Set entrySet = map.entrySet();
        Iterator iterator2 = entrySet.iterator();
        while(iterator2.hasNext()){
            System.out.println(iterator2.next());

    }
    }
    
}

（12）Collections工具类

Collections是一个操作Set，List和Map等集合的工具类

​ 排序操作:(均为static方法)

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

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

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

  4. sort(List，Comparator):根据指定的 Comparator产生的顺序对 List集合元素进行排序

  5. swap(List，int,int):将指定list集合中的i处元素和j处元素进行交换

    查找、替换

  6. Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素

  7. Object max(Collection，Comparator):根据Comparator指定的顺序，返回给定集合中的最大元素

  8. Object min(Collection)

  9. Object min(Collection，Comparator)

  10. int frequency(Collection，Object):返回指定集合中指定元素的出现次数

  11. void copy(List dest,List src):将src中的内容复制到dest中

  12. boolean replaceAll(List list，Object oldVal，Object newVal):使用新值替换List对象的所有旧值

public class CollectionsTest {
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(11);
        list.add(55);
        list.add(33);
        list.add(77);

//        reverse(List):反转List中元素的顺序
        Collections.reverse(list);//list本身被修改
        System.out.println(list);

//        shuffle(List):对 List集合元素进行随机排序
        Collections.shuffle(list);
        System.out.println(list);

//        sort(List):根据元素的自然顺序对指定List集合元素按升序排序（自然排序）
//        sort(List，Comparator):根据指定的 Comparator产生的顺序对 List集合元素进行排序（定制排序）
        Collections.sort(list);//list必须是同类型的数据，否则报ClassCastException
        System.out.println(list);

//        void copy(List dest,List src):将src中的内容复制到dest中
//        错误：
//        ArrayList dest = new ArrayList();
//        Collections.copy(dest,list);//报IndexOutOfBoundsException
//        正确：
        List dest = Arrays.asList(new Object[list.size()]);
        Collections.copy(dest,list);
        System.out.println(dest);
    }

}

（13）synchronized()方法

collections类中提供了多个synchronizedXxx()方法， 该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题

0.0~0.0
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java：浮点数比较
qq_46119575的博客
03-14 1534
Java浮点数的比较是开发中经常遇到的问题，但是很容易出错。本文主要介绍了浮点数比较的正确方法和常见的注意事项。本文主要介绍了Java浮点数比较存在误差的原因，介绍了浮点数比较的正确方法。易错点在于：（1）BigDemical构造数字时，一定要传入字符串而不是数字（2）0.0和-0.0问题希望对大家有用！
Java double数据类型中的0.0和-0.0问题
热门推荐
ouy5933的专栏
05-18 1万+
在写LeetCode的时候，一个题目需要计算两两点之间的斜率，使用double类型数据保存的时候，已经有预感到了精度的问题了，自己认为理论上在一次计算中，对于同一个double值如0.5，在同一个计算机类数据表示形式是一样的，可以忽略不计，但是实际中遇见的是double数据类型0.0和-0.0的比较问题。System.out.println(0.0 == -0.0); System.out.prin
java的-0和0_Java中的0.0和-0.0(IEEE 754)
weixin_42396760的博客
02-16 1934
Java完全兼容IEEE 754吧？但我对java如何决定浮点加法和减法的符号感到困惑.这是我的测试结果：double a = -1.5;double b = 0.0;double c = -0.0;System.out.println(b * a); //-0.0System.out.println(c * a); //0.0System.out.println(b + b); //0.0...
Java double/float数据类型中的0.0和-0.0问题
小白
07-05 1万+
double或float数据类型0.0和-0.0的比较问题。
JAVA学习笔记0.0
libra0的博客
06-28 356
加入了一个新公司，最近需要学习写Java。因为很赶，只好半懂不懂就上了。 在刷教程的时候有以下试验代码： public class decoratorExam { public interface AbstractPerson { //具有展示的功能 void show(); } public class Me implements ...
java 集合笔记
weixin_47625806的博客
03-21 168
个人java 集合笔记
Java集合笔记
IAMLSL的博客
01-31 414
11-1 Java集合框架概述 一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。 数组在内存存储方面的特点： 数组初始化以后，长度就确定了。 数组声明的类型，就决定了进行元素初始化时的类型 数组在存储数据方面的弊端： 1)数组初始化以后，长度就不可变了，不便于扩展 2)数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不
Java学习笔记——集合
D77的博客
08-01 625
Java 集合框架主要包括两种类型的容器： 集合（Collection）—— 存储一个元素集合； 图（Map）—— 存储键/值对映射；
Java集合（完整笔记）
05-14
作者在学习过程中自己整理的Java集合笔记，包括开发中常见的单列集合（Collection）和双列集合（Map）以及开发中集合常用的接口，类，以及方法等，适合零基础小白，笔记详细，希望和大家一起学习的道路上我们可以...
Java集合学习笔记.pdf
11-28
Java集合学习笔记.pdf
java 集合部分笔记
05-19
java 集合部分笔记 1 集合的概述 2 Collection接口和Iterator接口（迭代器） 3 List接口 4 Set接口 5 Map接口
java集合框架笔记
03-18
List set ArraryList Map java集合框架笔记 基于Array的List，其实就是封装了Array所不具备的一些功能方便我们使用
java笔记集合
01-14
这里面包含很多以前学习java做的笔记，从java基础到框架，框架整合 ，jdbc，数据库连接，Servlet，jsp等之类的，非常适合初学者下载，学习java当中可以走少很多弯路。
简单的项目部署脚本（转载）
u010230019的博客
06-09 625
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1298
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 432
修改菜品——后端Java
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 423
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
【Java02】Java中数组的定义与初始化
饮冰室
06-10 526
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 284
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
java基础笔记md
最新发布
06-15
Java基础知识笔记通常会涵盖以下几个核心主题： 1. Java概述：包括Java的历史、平台无关性、JVM（Java Virtual Machine）的作用和Java的核心API（如java.lang包）。 2. 数据类型和变量：基本数据类型（如int, ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值