Java 集合、迭代器

news2024/11/25 7:00:41

Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，除了集合，该框架也定义了几个 Map 接口和类。Map 里存储的是键/值对。尽管 Map 不是集合，但是它们完全整合在集合中。

序号接口描述
1Collection 

Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。

Collection 接口存储一组不唯一，无序的对象。

2List 

List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。

List 接口存储一组不唯一，有序（插入顺序）的对象。

3Set

Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。

Set 接口存储一组唯一，无序的对象。

4SortedSet
继承于Set保存有序的集合。
5Map

Map 接口存储一组键值对象，提供key（键）到value（值）的映射。

6Map.Entry
描述在一个Map中的一个元素（键/值对）。是一个 Map 的内部接口。
7SortedMap
继承于 Map，使 Key 保持在升序排列。
8Enumeration
这是一个传统的接口和定义的方法，通过它可以枚举（一次获得一个）对象集合中的元素。这个传统接口已被迭代器取代。

常用集合：

Collection ：
-List 接口：元素按进入先后有序保存，可重复，插入删除会引起其他元素位置改变
-----LinkedList 底层数据结构是链表，查询慢，增删快，线程不安全，效率高，可以存储重复元素
-----ArrayList 底层数据结构是数组，查询快，增删慢，线程不安全，效率高，可以存储重复元素
-----Vector 底层数据结构是数组，查询快，增删慢，线程安全，效率低，可以存储重复元素
------------Stack 是Vector类的实现类
-Set 接口： 仅接收一次，无序不可重复，并做内部排序，插入和删除不会引起元素位置改变 
-----HashSet 使用hash表（数组）存储元素
------------LinkedHashSet 链表维护元素的插入次序
-----TreeSet 底层实现为二叉树，元素排好序

Map ：
-----Hashtable 接口实现类， 同步， 线程安全
-----HashMap 接口实现类 ，无同步， 线程不安全
------------LinkedHashMap 双向链表和哈希表实现
------------WeakHashMap
-----TreeMap 红黑树对所有的key进行排序
-----IdentifyHashMap

一、Collection 

1.1 Java List

以下情况使用 ArrayList :

  • 频繁访问列表中的某一个元素。
  • 只需要在列表末尾进行添加和删除元素操作。

以下情况使用 LinkedList :

  • 你需要通过循环迭代来访问列表中的某些元素。
  • 需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

1.1.1 ArrayList

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。

import java.util.*;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob"); //1、添加：元素到sites对象中
        sites.set(0,"Yahu"); //2、第一个参数为索引位置，第二个为要修改的值、
        sites.remove(1);     //3、删除第2个元素
        System.out.println(sites.size());         //4、输出对象长度
        for (int i = 0; i < sites.size(); i++) {  //5、for循环迭代输出
            System.out.println(sites.get(i));
        }
        for (String i : sites) {    //6、for-each循环迭代输出
            System.out.println(i);
        }
        ArrayList<Integer> li=new ArrayList<>();  //7、存放整数元素
        Collections.sort(sites);  //8、Collections类中sort() 方法可以对字符或数字列表进行排序排序
        System.out.println(sites);
    }
}

常规方法：

方法描述 （arraylist对象：arr）
add()将元素插入到指定位置的 arraylist 中 
addAll()添加集合中的所有元素到 arraylist 中 
clear() 删除 arraylist 中的所有元素 
clone()

复制一份 arraylist 

ArrayList<String> arrs = (ArrayList<String>)arr.clone();

contains()判断元素是否在 arraylist 
get()通过索引值获取 arraylist 中的元素 
indexOf()返回 arraylist 中元素的索引值 
removeAll()删除存在于指定集合中的 arraylist里的所有元素 
remove()删除 arraylist 里的单个元素 
size()返回 arraylist 里元素数量 
isEmpty() 判断 arraylist 是否为空 
subList()

截取部分 arraylist 的元素 

sites.subList(1, 3);//截取第一个和第二个元素

set()替换 arraylist 中指定索引的元素 
sort()对 arraylist 元素进行排序 
toArray()将 arraylist 转换为数组 
toString() 将 arraylist 转换为字符串 
lastIndexOf()

返回指定元素在 arraylist 中最后一次出现的位置 

int position = arr.lastIndexOf("YL");

ensureCapacity() 设置指定容量大小的 arraylist 
lastIndexOf() 返回指定元素在 arraylist 中最后一次出现的位置 
retainAll() 

保留 arraylist 中在指定集合中也存在的那些元素 

arr.retainAll(arr2);

containsAll()

查看 arraylist 是否包含指定集合中的所有元素 

boolean result = arr.containsAll(arr2);

trimToSize()

将 arraylist 中的容量调整为数组中的元素个数 

arr.trimToSize();

removeRange()

删除 arraylist 中指定索引之间存在的元素 

arr.removeRange(1, 3);

replaceAll()

将给定的操作内容替换掉数组中每一个元素 

arr.replaceAll(e -> e.toUpperCase());

removeIf() 

删除所有满足特定条件的 arraylist 元素  

arr.removeIf(e -> e.contains("Tao"))；

forEach()

遍历 arraylist 中每一个元素并执行特定操作 ：将ArrayList对象的表达式作为 forEach() 方法的参数传入，lambda 表达式将动态数组中的每个元素乘以 10，然后输出结果

arr.forEach((e) -> {
    e = e * 10;
    System.out.print(e + " ");  
}); 

实例：

import java.util.*;
//遍历ArrayList
public class Test{
 public static void main(String[] args) {
     List<String> list=new ArrayList<String>();
     list.add("Hello");
     list.add("World");
     list.add("HA");

     //第一种遍历：使用 For-Each 遍历 List
     for (String str : list) {    //也可以改写for(int i=0;i<list.size();i++) 这种形式
        System.out.println(str);
     }
 
     //第二种遍历：把链表变为数组相关的内容进行遍历
     String[] strArray=new String[list.size()];
     list.toArray(strArray);
     for(int i=0;i<strArray.length;i++) //这里也可以改写为  for(String str:strArray) 这种形式
     {
        System.out.println(strArray[i]);
     }
     
    //第三种遍历：使用迭代器进行相关遍历
     Iterator<String> ite=list.iterator();
     while(ite.hasNext())//判断下一个元素之后有值
     {
         System.out.println(ite.next());
     }
 }
}
//[Hello,World,HA]

1.1.2 LinkedList

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。

// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");//1、添加元素
        sites.add("Runoob");
        //2、使用 addFirst() 在头部添加元素
        sites.addFirst("BaiDu");
        //3、尾部添加
        sites.addLast("Wiki");
        //4、使用 removeFirst() 移除头部元素
        sites.removeFirst();
        //5、使用 removeLast() 移除尾部元素
        sites.removeLast();
        //6、使用 getFirst() 获取头部元素
        System.out.println(sites.getFirst());
        //7、使用 getLast() 获取尾部元素
        System.out.println(sites.getLast());
        //9、迭代获取元素
        for (int size = sites.size(), i = 0; i < size; i++) {
            System.out.println(sites.get(i));
        }
        //10、for-each 迭代
        for (String i : sites) {
            System.out.println(i);
        }
        //11、foreach遍历方式 
        sites.forEach(ites->{
        System.out.println(ites);
    });
        System.out.println(sites);
    }
}
方法描述
public boolean add(E e)链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public void add(int index, E element)向指定位置插入元素。
public boolean addAll(Collection c)将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。
public boolean addAll(int index, Collection c)将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。
public void addFirst(E e)元素添加到头部。
public void addLast(E e)元素添加到尾部。
public boolean offer(E e)向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public boolean offerFirst(E e)头部插入元素，返回是否成功，成功为 true，失败为 false。
public boolean offerLast(E e)尾部插入元素，返回是否成功，成功为 true，失败为 false。
public void clear()清空链表。
public E removeFirst()删除并返回第一个元素。
public E removeLast()删除并返回最后一个元素。
public boolean remove(Object o)删除某一元素，返回是否成功，成功为 true，失败为 false。
public E remove(int index)删除指定位置的元素。
public E poll()删除并返回第一个元素。
public E remove()删除并返回第一个元素。
public boolean contains(Object o)判断是否含有某一元素。
public E get(int index)返回指定位置的元素。
public E getFirst()返回第一个元素。
public E getLast()返回最后一个元素。
public int indexOf(Object o)查找指定元素从前往后第一次出现的索引。
public int lastIndexOf(Object o)查找指定元素最后一次出现的索引。
public E peek()返回第一个元素。
public E element()返回第一个元素。
public E peekFirst()返回头部元素。
public E peekLast()返回尾部元素。
public E set(int index, E element)设置指定位置的元素。
public Object clone()克隆该列表。
public Iterator descendingIterator()返回倒序迭代器。
public int size()返回链表元素个数。
public ListIterator listIterator(int index)返回从指定位置开始到末尾的迭代器。
public Object[] toArray()返回一个由链表元素组成的数组。
public T[] toArray(T[] a)返回一个由链表元素转换类型而成的数组。

使用较少，类比ArrayList，不举例。

1.1.3 Vector

Vector是一种老的动态数组，是线程同步的，效率很低，一般不使用。

1.2 Java Set

1.2.1 HashSet

HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。HashSet 允许有 null 值，是无序的，即不会记录插入的顺序。HashSet 非线程安全， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的，在多线程访问时必须显式同步对 HashSet 的并发访问。

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");  //1、重复的元素不会被添加
        System.out.println(sites.contains("Taobao"));//2、判断元素是否存在于集合当中
        sites.remove("Taobao"); //3、删除元素，删除成功返回 true，否则为 false
        sites.clear();//4、清除全部               
        for (String i : sites) { //5、for-each 迭代
            System.out.println(i);
        }
       /*6、注意：Set无序，无法使用元素下标输出元素遍历集合
       for (int size = sites.size(), i = 0; i < size; i++)*/
       //7、foreach遍历方式 
       sites.forEach(ites->{
         System.out.println(ites);
    });
        System.out.println(sites);
    }
}

1.2.2 LinkedHashSet 

底层数据结构采用链表和哈希表共同实现，链表保证了元素的顺序与存储顺序一致，哈希表保证了元素的唯一性。线程不安全，效率高。

1.2.3 TreeSet 

底层数据结构采用二叉树来实现，元素唯一且已经排好序。

二、Map

2.1 Java Map

2.1.1 HashMap

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

HashMap 是无序的，即不会记录插入的顺序。HashMap 的 key 与 value 类型可以相同也可以不同，可以是字符串（String）类型的 key 和 value，也可以是整型（Integer）的 key 和字符串（String）类型的 value。HashMap 中的元素是对象，一些常见的基本类型可以使用它的包装类。

// 引入 HashMap 类      
import java.util.HashMap;

public class RunoobTest {
    public static void main(String[] args) {
        //1、创建 HashMap 对象 Sites
        HashMap<Integer, String> Sites = new HashMap<Integer, String>();
        Sites.put(1, "Google");
        Sites.put(2, "Runoob");
        Sites.put(3, "Taobao");
        Sites.put(4, "Zhihu");
        System.out.println(Sites);
        //2、输出元素{1=Google, 2=Runoob, 3=Taobao, 4=Zhihu}
        System.out.println(Sites.get(3));//输出Taobao
        for (Integer i : Sites.keySet()) {
            System.out.println("key: " + i + " value: " + Sites.get(i));
        }
          //3、返回所有 value 值
        for(String value: Sites.values()) {
          //4、输出每一个value
          System.out.print(value + ", ");
          //5、使用Entry对象遍历
      Map<String, Integer> map = new HashMap<>();
        map. put("yly", 177);
        map. put("yrc" ,176);
        map. put("zcz" ,175);
        Set<Map.Entry<String, Integer>> set = map.entrySet();
        //for迭代遍历
        for (Map.Entry<String, Integer> entry : set) {
            System.out.println(entry.getKey()+entry.getValue());
        }
    }
        }
    }
}
方法

描述

/*HashMap<String, Integer> prices = new HashMap<>();
        prices.put("Shoes", 200);
        prices.put("Bag", 300);
        prices.put("Pant", 150);
        System.out.println("HashMap: " + prices);*/

clear()删除 hashMap 中的所有键/值对
clone()复制一份 hashMap
isEmpty()判断 hashMap 是否为空
size()计算 hashMap 中键/值对的数量
put()将键/值对添加到 hashMap 中
putAll()将所有键/值对添加到 hashMap 中，已存在的将会被替换
putIfAbsent()如果 hashMap 中不存在指定的key键，则将指定的键/值对插入到 hashMap 中
remove()删除 hashMap 中指定键 key 的映射关系
containsKey()检查 hashMap 中是否存在指定的 key 对应的映射关系
containsValue()检查 hashMap 中是否存在指定的 value 对应的映射关系
replace()

替换 hashMap 中指定的 key 对应的 value

        // 替换key为2的映射
        String value = sites.replace(2, "Wiki");

replaceAll()将 hashMap 中的所有映射关系替换成给定的函数所执行的结果
get()获取指定 key 对应的 value
getOrDefault()

获取指定 key 对应的 value，如果找不到 key ，则返回设置的默认值

 // Not Found - 如果 HashMap 中没有该 key，则返回默认值
        String value = sites.getOrDefault(1, "Not Found");
        System.out.println("Value for key 1:  " + value);

forEach()

对 hashMap 中的每个映射执行指定的操作

 prices.forEach((key, value) -> {
            // 所有value 价格减少百分之 10
            value = value - value * 10/100;
            System.out.print(key + "=" + value + " ");
        });

entrySet()

返回 hashMap 中所有映射项的集合集合视图

System.out.println("sites HashMap: " + sites);
// 返回映射关系中 set view
System.out.println("Set View: " + sites.entrySet());

/*sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
Set View: [1=Google, 2=Runoob, 3=Taobao]*/

keySet()返回 hashMap 中所有 key 组成的集合视图
values()返回 hashMap 中存在的所有 value 值
merge()

添加键值对到 hashMap 中，如果原来有那就是更新键值对

    int returnedValue = prices.merge("Shirt", 100, (oldValue, newValue) -> oldValue + newValue);
    System.out.println("Price of Shirt: " + returnedValue);

compute()

对 hashMap 中指定 key 的值进行重新计算

int newPrice = prices.compute("Shoes", (key, value) -> value - value * 10/100);
        System.out.println("Discounted Price of Shoes: " + newPrice);

/*HashMap: {Pant=150, Bag=300, Shoes=200}
Discounted Price of Shoes: 180
Updated HashMap: {Pant=150, Bag=300, Shoes=180}*/

computeIfAbsent()

对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasMap 中

  int shoesPrice = prices.computeIfPresent("Shoes", (key, value) -> value + value * 10/100);
        System.out.println("Price of Shoes after VAT: " + shoesPrice);

/*HashMap: {Pant=150, Bag=300, Shoes=200}
Price of Shoes after VAT: 220
Updated HashMap: {Pant=150, Bag=300, Shoes=220}*/

computeIfPresent()

对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中
        System.out.println("HashMap: " + prices);
        // 重新计算鞋加上10%的增值税后的价值
        int shoesPrice = prices.computeIfPresent("Shoes", (key, value) -> value + value * 10/100);
        System.out.println("Price of Shoes after VAT: " + shoesPrice);

/*HashMap: {Pant=150, Bag=300, Shoes=200}
Price of Shirt: 280
Updated HashMap: {Pant=150, Shirt=280, Bag=300, Shoes=200}*/

2.1.2 HashTable（略）

2.1.1 TreeMap（略）

三、迭代器 （Iterator）

Java迭代器是 Java 集合框架中的一种机制，是一种用于遍历集合（如列表、集合和映射等）的接口。它提供了一种统一的方式来访问集合中的元素，而不需要了解底层集合的具体实现细节。迭代器不是一个集合，它是一种用于访问集合的方法。以下图示主要方法。

//主要是作为循环和遍历
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<Integer> sites = new ArrayList<Integer>();
        sites.add("1");
        sites.add("2");
        sites.add("3");
        sites.add("4");
        // 获取迭代器
        Iterator<Integer> it = sites.iterator();
        // 输出集合中的第一个元素
        System.out.println(it.next());//1
        // 输出集合中的所有元素
        while(it.hasNext()) {
            System.out.print(it.next());
            }//1 2 3 4 
        for(Integer i:sites){
            System.out.print(i+" ");
            }//1 2 3 4
        while(it.hasNext()) {
            Integer i = it.next();
            if(i < 10) {  
                it.remove();  //删除小于 10 的元素
            }
            System.out.println(sites);//[]
        }
/*注意：Java 迭代器是一种单向遍历机制，即只能从前往后遍历集合中的元素，不能往回遍历。同时，在使用迭代器遍历集合时，不能直接修改集合中的元素，而是需要使用迭代器的 remove() 方法来删除当前元素*/
}
import java.util.ArrayList;
import java.util.Iterator;
 
public class Person(String name) {
    private String name;

    public void setName(String name){
    this.name = name;}
    
    public String getName(){
    return name;}
}
public class test {
    public static void main(String[] args) {
        ArrayList<Person> array = new ArrayList<Person>();
 
        Person p1 = new Person("Y");
        Person p2 = new Person("L");
        Person p3 = new Person("Y");
        Person p4 = new Person("G");
 
        array.add(p1);
        array.add(p2);
        array.add(p3);
        array.add(p4);
 
        Iterator<Person> iterator = array.iterator();
 
        for (Person pp : array){
            System.out.print(pp.getName());//Y L Y G 
        }
        
        array.forEach(obj -> System.out.print(obj.getName()));//Y L Y G 
 
        for(Person p : array){
            p.setName("B");
        }
 
        while(iterator.hasNext()){
            System.out.print(iterator.next().getName()); //B B B B
        }
 
    }
}

 参考资料：菜鸟教程 - 学的不仅是技术，更是梦想！

参考文献1：详解java集合，Collection，list，set，map汇总 - 知乎 (zhihu.com)

参考文献2：java集合超详解_java集合使用-CSDN博客

参考文献4：Java迭代器(iterator详解以及和for循环的区别)_java里迭代器能在for循环中使用么-CSDN博客

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1444757.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【EAI 015】CLIPort: What and Where Pathways for Robotic Manipulation

【EAI 015】CLIPort: What and Where Pathways for Robotic Manipulation

论文标题&#xff1a;CLIPort: What and Where Pathways for Robotic Manipulation 论文作者&#xff1a;Mohit Shridhar1, Lucas Manuelli, Dieter Fox1 作者单位&#xff1a;University of Washington, NVIDIA 论文原文&#xff1a;https://arxiv.org/abs/2109.12098 论文出处…
阅读更多...
sheng的学习笔记-docker部署springboot

sheng的学习笔记-docker部署springboot

部署文章目录&#xff1a;目录 docker部署&#xff0c;原理&#xff0c;命令&#xff0c;可以参考&#xff1a;docker原理图&#xff0c;部署&#xff0c;命令 目录 将springboot部署到docker中 遇到过的问题&#xff1a; pom配置 操作步骤 生成jar 构建镜像 查看镜像d…
阅读更多...
C语言之预处理详解

C语言之预处理详解

目录 1. 预定义符号2. #define定义常量3. #define定义宏练习 4. 带有副作用的宏参数5. 宏替换的规则6. 宏函数的对比宏和函数的一个对比 7. #和###运算符##运算符 8. 命名约定9. #undef10. 命令行定义11. 条件编译常见的条件编译 12. 头文件的包含头文件的包含方式库文件包含嵌…
阅读更多...
移动端web开发布局

移动端web开发布局

目录 flex布局&#xff1a; flex布局父项常见属性&#xff1a; flex布局子项常见属性&#xff1a; REM适配布局&#xff1a; 响应式布局&#xff1a; flex布局&#xff1a; 需要先给父类盒子设置display&#xff1a;flex flex是flexiblebox的缩写&#xff0c;意为"弹…
阅读更多...
【DC渗透系列】DC-4靶场

【DC渗透系列】DC-4靶场

主机发现 arp-scan -l┌──(root㉿kali)-[~] └─# arp-scan -l Interface: eth0, type: EN10MB, MAC: 00:0c:29:6b:ed:27, IPv4: 192.168.100.251 Starting arp-scan 1.10.0 with 256 hosts (https://github.com/royhills/arp-scan) 192.168.100.1 00:50:56:c0:00:08 …
阅读更多...
【人工智能教育】“奇幻森林里的决战：小明‘剑’指期末，勇闯试卷迷宫

【人工智能教育】“奇幻森林里的决战：小明‘剑’指期末，勇闯试卷迷宫

在智慧校园的奇幻乐园中&#xff0c;教育的故事不再局限于传统的粉笔与黑板&#xff0c;而是跃然于光影之间&#xff0c;流淌于数据之海。小明和他的同学们正是这个新世界的探险者&#xff0c;他们手握名为“智能辅导助手”的魔法棒&#xff0c;勇闯知识的迷宫。每当他们在力学…
阅读更多...
sheng的学习笔记-网络爬虫scrapy框架

sheng的学习笔记-网络爬虫scrapy框架

基础知识&#xff1a; scrapy介绍 何为框架&#xff0c;就相当于一个封装了很多功能的结构体&#xff0c;它帮我们把主要的结构给搭建好了&#xff0c;我们只需往骨架里添加内容就行。scrapy框架是一个为了爬取网站数据&#xff0c;提取数据的框架&#xff0c;我们熟知爬虫总…
阅读更多...
腾讯云4核8G服务器多少钱一年？

腾讯云4核8G服务器多少钱一年？

腾讯云4核8G服务器S5和轻量应用服务器优惠价格表&#xff0c;轻量应用服务器和CVM云服务器均有活动&#xff0c;云服务器CVM标准型S5实例4核8G配置价格15个月1437.3元&#xff0c;5年6490.44元&#xff0c;标准型SA2服务器1444.8元一年&#xff0c;轻量应用服务器4核8G12M带宽一…
阅读更多...
JavaScript 遍历文档生成目录结构

JavaScript 遍历文档生成目录结构

JavaScript 遍历文档生成目录结构 要遍历 HTML 文档并生成目录结构&#xff0c;你可以使用 JavaScript 来进行 DOM 操作和遍历。以下是一个简单的示例代码&#xff0c;演示了如何遍历文档中的标题元素&#xff08;例如 <h1>、<h2>、<h3> 等&#xff09;&…
阅读更多...
c++求三个数中最大数

c++求三个数中最大数

#include<iostream> using namespace std; int main() { int a,b,c; cout<<"请输入三个数字"<<endl;//end后面为小写的L cin>>a>>b>>c; if(a>b&&a>c) cout<<"最大数为a:"<<a<<e…
阅读更多...
vulnhub--＞hacksudo-Thor靶机详细思路

vulnhub--＞hacksudo-Thor靶机详细思路

目录 1. IP探测2.端口服务扫描3.网站漏洞扫描4.目录扫描5.信息分析6.破壳漏洞(Shellshock)nmap---漏洞检测CVE-2014-6271 7.nc反弹8.提权9.service提权 1. IP探测 ┌──(root㉿kali)-[~] └─# arp-scan -l Interface: eth0, type: EN10MB, MAC: 00:0c:29:10:3c:9b, IPv4: 19…
阅读更多...
Day39- 动态规划part07

Day39- 动态规划part07

一、爬楼梯 题目一&#xff1a;57. 爬楼梯 57. 爬楼梯&#xff08;第八期模拟笔试&#xff09; 题目描述 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬至多m (1 < m < n)个台阶。你有多少种不同的方法可以爬到楼顶呢&#xff1f; 注意&#xff1a;…
阅读更多...
python接口自动化---接口测试报告模板（详解）

python接口自动化---接口测试报告模板（详解）

简介 接口测试报告是软件测试过程中非常重要的一部分&#xff0c;通过接口测试报告我们可以了解系统在接口层面上的稳定性和可靠性。下面是一个简单的接口测试报告模板&#xff1a; 测试概述 在这个部分中&#xff0c;您需要简要阐述接口测试的目的和范围。测试环境 在这个部…
阅读更多...
第80讲订单管理功能实现

第80讲订单管理功能实现

后端 <?xml version"1.0" encoding"UTF-8" ?> <!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace"com.java1234.mapper.OrderM…
阅读更多...
opencv mat用法赋值克隆的操作和一些基本属性

opencv mat用法赋值克隆的操作和一些基本属性

//Mat基本结构 (头部 数据部分) //赋值的话 就是修改了指针位置 但还是指向了原来数据 并没创建数据 本质上并没有变 //只有克隆或者拷贝时 它才会真正复制一份数据 //代码实现 //创建方法 - 克隆 //Mat m1 src.clone(); //复制 //Mat m2; //src.copyTo(m2); //赋值法 …
阅读更多...
007集——数据存储的端序(大端序和小端序转换代码)——VB/VBA

007集——数据存储的端序(大端序和小端序转换代码)——VB/VBA

VB/VBA存储的端序 1、要想制造高性能的VB/VBA代码&#xff0c;离了指针是很难办到的。 2、因为VB/VBA里&#xff0c;用Long来表示指针&#xff0c;而32位(包括64位兼容的)计算机里4字节整数的处理&#xff0c;是最快的方式&#xff01; 3、要想用指针来处理数据&#xff0c;…
阅读更多...
刘知远LLM——神经网络基础

刘知远LLM——神经网络基础

文章目录 神经网络基础基本构成如何训练&#xff1f; Word2Vec例子负采样&#xff1a; 循环神经网络 RNN门控计算单元 GRU长短时记忆网络 LSTM遗忘门输入门输出门双向RNN卷积神经网络 CNNpytorch实战 神经网络基础 基本构成 全称&#xff1a;人工神经网络。启发于生物神经细胞…
阅读更多...
LeetCode 0094.二叉树的中序遍历：递归/迭代(栈模拟递归)

LeetCode 0094.二叉树的中序遍历：递归/迭代(栈模拟递归)

【LetMeFly】94.二叉树的中序遍历&#xff1a;递归/迭代(栈模拟递归) 力扣题目链接&#xff1a;https://leetcode.cn/problems/binary-tree-inorder-traversal/ 给定一个二叉树的根节点 root &#xff0c;返回 它的 中序 遍历 。 示例 1&#xff1a; 输入&#xff1a;root […
阅读更多...
第三百一十六回

第三百一十六回

[tod] 我们在上一章回中介绍了"如何在输入框中处理光标"相关的内容&#xff0c;本章回中将介绍如何添加输入框默认值.闲话休提&#xff0c;让我们一起Talk Flutter吧。 1. 概念介绍 在项目中经常使用输入框获取用户输入的内容&#xff0c;有时候在输入框中反复输入相…
阅读更多...
Modern C++ 内存篇2 - 关于relocation的思考

Modern C++ 内存篇2 - 关于relocation的思考

在上一节《Modern C 内存篇1 - std::allocator VS pmr-CSDN博客》我们详细讨论了关于如何判断用不用memmove优化的代码&#xff0c;结论可以总结为&#xff1a; 只有_Tp是trivial 且 用std::allocator 才会调用memmove。 所有case如下表格所示&#xff1a; No_Tpallocator typ…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023