Java集合

最新推荐文章于 2024-07-13 22:56:10 发布
最新推荐文章于 2024-07-13 22:56:10 发布
阅读量54 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56348008/article/details/119700254
版权

集合接口框架

//集合框架
     |----Collection接口：单列集合，用来存储一个一个的对象
          |----List接口：存储'有序'的、'可重复的数据'。  -->“动态”数组,替换原有的数组
               |----ArrayList：作为'List接口的主要实现类'；线程不安全的，效率高；底层使用Object[] elementData数组存储
    //ArrayList和Vector使用数组存储，LinkedList使用链表存储
               |----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
               |----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储数组
    
          |--Set接口：'存储无序的、不可重复的数据'   -->高中讲的“集合”
               |--HashSet：作为'Set接口主要实现类'；线程不安全；可以存                储null值
               		|--LinkedHashSet：作为HashSet的子类；遍历其内部					   数据时，可以按照添加的顺序遍历,对于频繁的遍历操作，                     LinkedHashSet效率高于HashSet.
               |----TreeSet：可以按照添加对象的指定属性，进行排序。

     |----Map:双列数据，存储key-value对的数据   ---类似于高中的函数：y = f(x)
          |----HashMap:作为'Map的主要实现类'；线程不安全的，效率高；存储null的key和value
               |----LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。原因：在原有的HashMap底层结构基础上，添加了'一对指针'，'指向前一个和后一个元素'。对于频繁的遍历操作，此类执行效率高于HashMap。
          |----TreeMap:保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的'自然排序或定制排序; 底层使用红黑树
          |----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value
               |----Properties:常用来处理配置文件。key和value都是String类型
                 
HashMap的底层：数组+链表  （jdk7及之前）
             数组+链表+红黑树 （jdk 8）

Collection 接口方法

要求：向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()

Iterator迭代器接口

集合元素的遍历操作，使用迭代器Iterator接口
1.内部的方法：hasNext() 和 next() //next():①指针下移 ②将下移以后集合位置上的元素返回
2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，
默认游标都在集合的第一个元素之前。
3.内部定义了remove(), 可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()

Iterator迭代器方法

Interator对象相当于指针，指向集合中的指定位置元素。Interator对象调用方法时，操作的是Interator对象所指对应位置上的集合元素。

hasNext()方法

hasNext():判断是否还有下一个元素
    Iterator iterator = coll.iterator();
    while(iterator.hasNext()){
       //next():①指针下移 ②将下移以后集合位置上的元素返回
       System.out.println(iterator.next()); }

迭代器执行原理在这里插入图片描述

remove()方法

//删除集合中"Tom"
//如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，再调用remove都会报IllegalStateException。
        Iterator iterator = coll.iterator();
        while (iterator.hasNext()){
//            iterator.remove();
            Object obj = iterator.next();
            if("Tom".equals(obj)){
                iterator.remove();
//        iterator.remove(); 调用next()之后调用两次remove方法
            } }
  //遍历集合 :此时iterator已经指向集合最底部，所以应该得到新迭代器对象
        iterator = coll.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next()); }

foreach循环

//内部仍然调用了迭代器。iterator指针、hasNext()、next()

//for(集合中元素的类型 局部变量 ：集合对象)        
        for (Object obj : coll){
            System.out.println(obj); }

//coll对象会取集合内部中的元素，先取第一个元素，赋给Object类型的变量obj，以此类推....取到最后一个位置。

Collection子接口一：List

ArrayList

//数组需要初始化长度，List动态"数组"，扩容帮我们做好了
1. ArrayList的源码分析：
   	 1.1 jdk 7情况下
       ArrayList list = new ArrayList();
       //底层创建了长度是10的 Object[]数组elementData
       list.add(123);//elementData[0] = new Integer(123);
       ...
       list.add(11);//如果此次的添加导致底层elementData数组容量不够，        则扩容。
      //默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复       制到新的数组中。
      // 结论：建议开发中使用带参的构造器：ArrayList list = new        	    ArrayList(int capacity),确定底层创建数组的长度
	1.2 jdk 8中ArrayList的变化：
      ArrayList list = new ArrayList();//底层Object[]    			  elementData初始化为{}.并没有创建长度为10的数组
      list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并  		 将数据123添加到elementData[0]
      ...
      后续的添加和扩容操作与jdk 7 无异。
    1.3 小结：jdk7中的ArrayList的对象的创建类似于'单例的饿汉式'，而jdk8中的ArrayList的对象的创建类似于'单例的懒汉式'，延迟数组的创建，节省内存。

LinkedList

 2. LinkedList的源码分析：
      LinkedList list = new LinkedList(); //内部声明了Node类型的      	 first和last属性，默认值为null
      list.add(123);//将123封装到Node中，创建了Node对象。
      //其中，Node定义为：体现了LinkedList的双向链表的说法
      private static class Node<E>
            E item;
            Node<E> next;
            Node<E> prev;

            Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev; } }
3. Vector的源码分析：jdk7和jdk8中通过Vector()构造器创建对象时，底层       都创建了长度为10的数组。在扩容方面，默认扩容为原来的数组长度的2倍。

List接口中的常用方法

增：add(Object obj)
删：remove(int index) / remove(Object obj) //重载
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：① Iterator迭代器方式  //hasNext和next
     ② 增强for循环  //foreach
     ③ 普通的循环
//add和addAll区别：add把右边当成一个整体j，addAll把右边集合每个元素当成一个加入数组
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 lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素，并返回此元素
Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从fromIndex到		toIndex位置的子集合 //包括fromIndex，不包括toIndex

面试题

面试题：ArrayList、LinkedList、Vector三者的异同？
同：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
不同：见《 集合接口框架 》

Collection子接口二：Set

1. Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。
    
2. 要求：向Set(主要指：HashSet、LinkedHashSet)中添加的数据，其所在的类'一定要重写hashCode()和equals()
    要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码

HashSet

一、Set：存储无序的、不可重复的数据
1.无序性：不等于随机性
有序性：是指'存储数据在存储空间上相邻，一个接一个排列 
'视觉上的“有序性' ：LinkedHashSet按照 添加数据的顺序索引遍历
'存储方式是无序': LinkedHashSet和其他Set接口下的实现类 :按照hash值存储
2.不可重复性：保证添加的元素按照equals()判断时，不能返回true.即：相同元素只能添加一个
二、'添加元素的过程'：以HashSet为例：
    我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，
    //哈希值不同，两数相异；哈希值相同且equals()返回true，两数相同
    //哈希值不同，但根据哈希值计算地址的算法任可能得出相同地址
    //set：数组和链表都是其储存方式
    
    此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断数组此位置上是否已经有元素：
  ①如果此位置上没有其他元素，则元素a添加成功。 --->情况1
  ②如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
            如果hash值不相同，则元素a添加成功。--->情况2
            如果hash值相同，进而需要调用元素a所在类的equals()方法：
                   equals()返回true,元素a添加失败
                   equals()返回false,则元素a添加成功。--->情况3
    对于添加成功情况2、3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。
    jdk 7 :元素a放到数组中，指向原来的元素。
    jdk 8 :原来的元素在数组中，指向元素a
    总结：七上八下

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

指定索引位置上数据以链表的方式存储 图

在这里插入图片描述

LinkedHashSet

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

TreeSet

1.向TreeSet中添加的数据，要求是相同类的对象。
2.两种排序方式：自然排序（实现Comparable接口）和定制排序（Comparator）
3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals().
4.定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals().

@Test //自然排序
public void test1(){
    TreeSet set = new TreeSet();
//安照所比较类的compareTo()方法，来排序
    set.add(new User("Tom",12));
    set.add(new User("Jerry",32));
    set.add(new User("Jim",2));
    set.add(new User("Mike",65));
    set.add(new User("Jack",33));
    set.add(new User("Jack",56));
    
    Iterator iterator = set.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next()); } }

@Test //定制排序 方式一:如下；方式二:在自建类重写compareTo，然后调用
public void test2(){
    Comparator com = new Comparator() {
        //按照年龄从小到大排列
        @Override
        public int compare(Object o1, Object o2) {
            if(o1 instanceof User && o2 instanceof User){
                User u1 = (User)o1;
                User u2 = (User)o2;
                return Integer.compare(u1.getAge(),u2.getAge());
            }else{
   throw new RuntimeException("输入的数据类型不匹配"); } } };
    
    TreeSet set = new TreeSet(com);
    set.add(new User("Tom",12));
    set.add(new User("Jerry",32));
    set.add(new User("Jim",2));
    set.add(new User("Mike",65));
    set.add(new User("Mary",33));
    set.add(new User("Jack",33));
    set.add(new User("Jack",56));

    Iterator iterator = set.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next()); } }

面试题

其中Person类中重写了hashCode()和equal()方法

HashSet set = new HashSet();
Person p1 = new Person(1001,"AA");
Person p2 = new Person(1002,"BB");
set.add(p1);//按照1001、AA的哈希值计算的地址存储 p1
set.add(p2);
p1.name = "CC";//AA --> CC
set.remove(p1);//根据1001、CC的哈希值计算地址，没有查找到元素
System.out.println(set);//remove没有删掉p1，剩两个元素
set.add(new Person(1001,"CC"));//根据1001、CC哈希值计算地址，找到没有元素存储在这里 添加成功！
System.out.println(set);//添加了一个元素，剩三个元素
set.add(new Person(1001,"AA"));//根据1001、AA哈希值去找地址，发现已经有元素，然后判断两元素哈希值，1001、AA和1001、CC的哈希值不同，故以链表的形式添加成功
System.out.println(set);//添加了一个元素，剩四个元素

在List内去除重复数字值

public static List duplicateList(List list) {
    HashSet set = new HashSet();
    //HashSet作用：给Li
    set.addAll(list);
    return new ArrayList(set); }
public static void main(String[] args) {
    List list = new ArrayList();
    list.add(new Integer(1));
    list.add(new Integer(2));
    list.add(new Integer(2));
    list.add(new Integer(4));
    list.add(new Integer(4));
    List list2 = duplicateList(list);
    for (Object integer : list2) {
        System.out.println(integer); } }

Map接口

'面试题：

  1. HashMap的底层实现原理？
  2. HashMap 和 Hashtable的异同？
  3. CurrentHashMap 与 Hashtable的异同？（暂时不讲）
  一、Map结构的理解：
    Map中的key:'无序的、不可重复的'，使用Set存储所有的key  ---> key所在的类要重写equals()和hashCode() （以HashMap为例）
    Map中的value:'无序的、可重复的'，使用Collection存储所有的value --->value所在的类要重写equals()
    一个键值对：key-value构成了一个Entry对象。
    Map中的entry:无序的、不可重复的，使用Set存储所有的entry

HashMap

 二、HashMap的底层实现原理？以'jdk7'为例说明：
      HashMap map = new HashMap():
      在实例化以后，底层创建了长度是16的一维数组Entry[] table。
      ...可能已经执行过多次put...
      map.put(key1,value1):
      首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。
      如果此位置上的数据为空，此时的key1-value1添加成功。 ----情况1
      如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值：
      		如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。----情况2
            如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，比较：
                如果equals()返回false:此时key1-value1添加成功。----情况3
     /*修改功能*/如果equals()返回true:使用value1替换value2。

   补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。
         
在不断的添加过程中，会涉及到扩容问题，当超出临界值1(且要存放的位置非空)时，扩容。默认的扩容方式：扩容为原来容量的2倍，并'将原有的数据复制过来。
          
      'jdk8' 相较于jdk7在底层实现方面的不同：
      1. new HashMap():底层没有创建一个长度为16的数组
      2. jdk 8底层的数组是：Node[],而非Entry[]
      3. 首次调用put()方法时，底层创建长度为16的数组
      4. jdk7底层结构只有：数组+链表。jdk8中底层结构：数组+链表+红黑树。
         4.1 形成链表时，七上八下（jdk7:新的元素指向旧的元素。jdk8：旧的元素指向新的元素）
         4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。

      DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
      DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
      threshold：扩容的临界值，=容量*填充因子：16 * 0.75 => 12
      TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8
      MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64

LinkedHashMap

 三、LinkedHashMap的底层实现原理（了解）
      源码中：
      static class Entry<K,V> extends HashMap.Node<K,V> {
            Entry<K,V> before, after;//能够记录添加的元素的先后顺序
            Entry(int hash, K key, V value, Node<K,V> next) {
               super(hash, key, value, next); } }

TreeMap

//向TreeMap中添加数据key-value，key必须是有同一个类创建的对象，
//因为要按照key进行排序：自然排序、定制排序

Properties

  1. 新建一个 *.properties 文件，里面存放key-value值

    name=Tom
password=abc123

  2. Properties处理属性文件

    //Properties：常用来处理配置文件。key和value都是String类型
public static void main(String[] args) throws IOException {
    Properties pros = new Properties();
    FileInputStream fis = new FileInputStream ("jdbc.properties")
    pros.load(fis);//加载流对应的文件
    String name = pros.getProperty("name");
    String password = pros.getProperty("password");
    System.out.println("name ="+name+";password ="+password);

Map常用方法

Map中定义的方法：
添加、删除、修改操作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据 ；'map.size()不会空指针异常
元素查询的操作：
Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等
元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合

总结：常用方法：
 添加：put(Object key,Object value)
 删除：remove(Object key)
 修改：put(Object key,Object value)
 查询：get(Object key)
 长度：size()
 遍历：keySet() / values() / entrySet()

public void test5(){
    Map map = new HashMap();
    map.put("AA",123);
    map.put(45,1234);
    map.put("BB",56);

    //遍历所有的key集：keySet()
    Set set = map.keySet();
    Iterator iterator = set.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }
    System.out.println();
    //遍历所有的value集：values()
    Collection values = map.values();
    for(Object obj : values){
        System.out.println(obj);
    }
    System.out.println();
    //遍历所有的key-value
    Set set = map.entrySet();
    Iterator iterator = set.iterator();
    while (iterator.hasNext()){
       System.out.println(iterator.next());
   } } }

Collections工具类

Collections 是一个操作Collection(Set、List)、和Map等集合的工具类

Collections常用方法

reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
    'List dest = Arrays.asList(new Object[list.size()]);
        'Collections.copy(dest,list);
        'System.out.println(dest);
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

同步控制

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

//返回的list1即为线程安全的List
List list1 = Collections.synchronizedList(list);
m0_56348008
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 集合
04-07
本文将深入探讨Java集合框架的基础知识，包括接口、类、以及它们在实际开发中的应用。 首先，Java集合框架由一系列接口和实现这些接口的类组成。主要的接口有`List`、`Set`和`Queue`，它们各自代表了不同特性的数据...
Java集合概述与实例分析
10-26
Java集合框架是Java编程语言中的一个核心特性，它提供了一种高效、灵活的方式来存储和操作对象数组。在Java中，集合被分为两个主要接口：Collection和Map。本篇将深入探讨Collection接口及其子接口，包括List和Set，...
实验05 Java集合.doc
06-27
Java集合框架是Java编程语言中一个非常重要的组成部分，它提供了一组高级的数据结构，使得开发者能够更方便地管理和操作对象。在本次实验中，我们主要关注了三个主要的集合接口：Set、List和Map，以及它们的一些常见...
Elsaticsearch java基本操作
qq_62383709的博客
07-13 336
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 377
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 437
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2381
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1436
在 Java 中，可以通过多种方法将一个Object转换为Integer。
elk部署springboot
Chihirozy的博客
07-11 274
elk部署springboot。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 3327
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
Java 线程池详解
最新发布
qq_41591215的博客
07-13 633
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
牛马程序员的博客
07-10 761
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
uboot的功能
weixin_43732386的博客
07-13 16
uboot=裸机程序，uboot的核心功能是启动内核。
秋招Java后端开发冲刺——MyBatisPlus总结
qq_50604294的博客
07-13 345
本文对MyBatisPlus进行了介绍，并对其特点、基本使用和扩展功能进行了总结概括。
项目实战--XML文档解析工具
qq_40623672的博客
07-11 883
XML (eXtensible Markup Language)指可扩展标记语言，标准通用标记语言的子集，可以标记数据、定义数据类型，可以允许自定义标记语言进行数据承载，通常被用来传输和存储数据，定义也简单，遵循核心DTD（文档类型定义）语法约束。> < site > < name > CSDN博客网站 </ name > < url > https://blog.csdn.net/ </ url > < desc > 技术学习网站 </ desc > </ site >
android gradle开发基础
点灯师的博客
07-10 1006
Gradle是一个开源的构建自动化系统，专注于灵活性和性能。它支持多种编程语言和平台，包括Android开发。Gradle使用Groovy或Kotlin DSL（领域特定语言）来描述构建逻辑，但底层实现是用Java编写的，确保了系统的稳定性和高效性。Gradle结合了Ant的灵活性和Maven的约定优于配置的理念，为开发者提供了更强大的构建能力。Android Gradle开发基础涵盖了Gradle的基本概念、环境配置、构建脚本的编写、任务与插件的使用等多个方面。
基于JAVA+SpringBoot+Vue+Echarts的充电数据大屏可视化分析
azhou的代码园
07-12 540
随着电动汽车的普及，城市中充电设施的需求日益增长。为了提高充电设施的管理效率和用户体验，本文提出了一个停车场充电桩数据可视化平台的设计与实现。该平台旨在集成、处理并展示来自多个充电桩的实时数据，帮助管理者进行有效监控和决策支持，同时为车主提供便捷、直观的充电信息查询服务。首先，本研究分析了现代停车场充电桩管理的业务需求，确定了平台的主要功能模块，包括管理员登录，数据源excel导入、数据清洗、大屏数据展示、以及不同维度数据分析图表展示等。
（补充）：java各种进制、原码、反码、补码和文本、图像、音频在计算机中的存储方式
smalltorch的博客
07-09 1130
java中的各种进制的转换关系计算机中文本、图片、音频三种数据类似是怎么存在计算机中的普及图像、和音频的一些常识知识计算机数据分为三种： 文本（Text）数据：数字，字母，特殊符号等等、（Image）图片数据、（Sound）声音数据。有且仅有这三种，其中视频是图片和音频数据的组合。【注】：无论是文本、图片、还是音频计算机都是以二进制存储，即用一堆0,1数字来表示。这是怎么做到的，下面我们简单了解一下，其实这块属于计算机组成原理的知识。先来了解一下进制吧。信号与系统数字信号处理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值