十二、集合（2）

本章概要

  • 添加元素组
  • 集合的打印
  • 列表 List

添加元素组

在 java.util 包中的 Arrays 和 Collections 类中都有很多实用的方法，可以在一个 Collection 中添加一组元素。

Arrays.asList() 方法接受一个数组或是逗号分隔的元素列表（使用可变参数），并将其转换为 List 对象。 Collections.addAll() 方法接受一个 Collection 对象，以及一个数组或是一个逗号分隔的列表，将其中元素添加到 Collection 中。下边的示例展示了这两个方法，以及更通用的 、所有 Collection 类型都包含的addAll() 方法：

// collections/AddingGroups.java
// Adding groups of elements to Collection objects
import java.util.*;public class AddingGroups {public static void main(String[] args) {Collection<Integer> collection = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));Integer[] moreInts = {6, 7, 8, 9, 10};collection.addAll(Arrays.asList(moreInts));// Runs significantly faster, but you can't// construct a Collection this way:Collections.addAll(collection, 11, 12, 13, 14, 15);Collections.addAll(collection, moreInts);// Produces a list "backed by" an array:List<Integer> list = Arrays.asList(16, 17, 18, 19, 20);list.set(1, 99); // OK -- modify an element// list.add(21); // Runtime error; the underlying// array cannot be resized.}
}

Collection 的构造器可以接受另一个 Collection，用它来将自身初始化。因此，可以使用 Arrays.asList() 来为这个构造器产生输入。但是， Collections.addAll() 运行得更快，而且很容易构建一个不包含元素的 Collection ，然后调用 Collections.addAll() ，因此这是首选方式。

Collection.addAll() 方法只能接受另一个 Collection 作为参数，因此它没有 Arrays.asList() 或 Collections.addAll() 灵活。这两个方法都使用可变参数列表。

也可以直接使用 Arrays.asList() 的输出作为一个 List ，但是这里的底层实现是数组，没法调整大小。如果尝试在这个 List 上调用 add() 或 remove()，由于这两个方法会尝试修改数组大小，所以会在运行时得到“Unsupported Operation（不支持的操作）”错误：

// collections/AsListInference.java
import java.util.*;class Snow {
}class Powder extends Snow {
}class Light extends Powder {
}class Heavy extends Powder {
}class Crusty extends Snow {
}class Slush extends Snow {
}public class AsListInference {public static void main(String[] args) {List<Snow> snow1 = Arrays.asList(new Crusty(), new Slush(), new Powder());//- snow1.add(new Heavy()); // ExceptionList<Snow> snow2 = Arrays.asList(new Light(), new Heavy());//- snow2.add(new Slush()); // ExceptionList<Snow> snow3 = new ArrayList<>();Collections.addAll(snow3,new Light(), new Heavy(), new Powder());snow3.add(new Crusty());// Hint with explicit type argument specification:List<Snow> snow4 = Arrays.<Snow>asList(new Light(), new Heavy(), new Slush());//- snow4.add(new Powder()); // Exception}
}

在 snow4 中，注意 Arrays.asList() 中间的“暗示”（即 <Snow> ），告诉编译器 Arrays.asList() 生成的结果 List 类型的实际目标类型是什么。这称为_显式类型参数说明_（explicit type argument specification）。

集合的打印

必须使用 Arrays.toString() 来生成数组的可打印形式。但是打印集合无需任何帮助。下面是一个例子，这个例子中也介绍了基本的Java集合：

// collections/PrintingCollections.java
// Collections print themselves automatically
import java.util.*;public class PrintingCollections {static Collection fill(Collection<String> collection) {collection.add("rat");collection.add("cat");collection.add("dog");collection.add("dog");return collection;}static Map fill(Map<String, String> map) {map.put("rat", "Fuzzy");map.put("cat", "Rags");map.put("dog", "Bosco");map.put("dog", "Spot");return map;}public static void main(String[] args) {System.out.println(fill(new ArrayList<>()));System.out.println(fill(new LinkedList<>()));System.out.println(fill(new HashSet<>()));System.out.println(fill(new TreeSet<>()));System.out.println(fill(new LinkedHashSet<>()));System.out.println(fill(new HashMap<>()));System.out.println(fill(new TreeMap<>()));System.out.println(fill(new LinkedHashMap<>()));}
}

在这里插入图片描述

这显示了Java集合库中的两个主要类型。它们的区别在于集合中的每个“槽”（slot）保存的元素个数。 Collection 类型在每个槽中只能保存一个元素。此类集合包括： List ，它以特定的顺序保存一组元素； Set ，其中元素不允许重复； Queue ，只能在集合一端插入对象，并从另一端移除对象（就本例而言，这只是查看序列的另一种方式，因此并没有显示它）。 Map 在每个槽中存放了两个元素，即_键_ (key)和与之关联的_值_ (value)。

默认的打印行为，使用集合提供的 toString() 方法即可生成可读性很好的结果。 Collection 打印出的内容用方括号括住，每个元素由逗号分隔。 Map 则由大括号括住，每个键和值用等号连接（键在左侧，值在右侧）。

第一个 fill() 方法适用于所有类型的 Collection ，这些类型都实现了 add() 方法以添加新元素。

ArrayList 和 LinkedList 都是 List 的类型，从输出中可以看出，它们都按插入顺序保存元素。两者之间的区别不仅在于执行某些类型的操作时的性能，而且 LinkedList 包含的操作多于 ArrayList 。本章后面将对这些内容进行更全面的探讨。

HashSet ， TreeSet 和 LinkedHashSet 是 Set 的类型。从输出中可以看到， Set 仅保存每个相同项中的一个，并且不同的 Set 实现存储元素的方式也不同。 HashSet 使用相当复杂的方法存储元素，现在只需要知道，这种技术是检索元素的最快方法，因此，存储顺序看上去没有什么意义（通常只关心某事物是否是 Set 的成员，而存储顺序并不重要）。如果存储顺序很重要，则可以使用 TreeSet ，它把对象按照比较规则来排序；还有 LinkedHashSet ，它把对象按照被添加的先后顺序来排序。

Map （也称为_关联数组_）使用_键_来查找对象，就像一个简单的数据库。所关联的对象称为_值_。 假设有一个 Map 将美国州名与它们的首府联系在一起，如果想要俄亥俄州（Ohio）的首府，可以用“Ohio”作为键来查找，几乎就像使用数组下标一样。正是由于这种行为，对于每个键， Map 只存储一次。

Map.put(key, value) 添加一个所想要添加的值并将它与一个键（用来查找值）相关联。 Map.get(key) 生成与该键相关联的值。上面的示例仅添加键值对，并没有执行查找。这将在稍后展示。

请注意，这里没有指定（或考虑） Map 的大小，因为它会自动调整大小。 此外， Map 还知道如何打印自己，它会显示相关联的键和值。

本例使用了 Map 的三种基本风格： HashMap ， TreeMap 和 LinkedHashMap 。

键和值保存在 HashMap 中的顺序不是插入顺序，因为 HashMap 实现使用了非常快速的算法来控制顺序。 TreeMap 把所有的键按照比较规则来排序， LinkedHashMap 在保持 HashMap 查找速度的同时按照键的插入顺序来排序。

列表List

List承诺将元素保存在特定的序列中。 List 接口在 Collection 的基础上添加了许多方法，允许在 List 的中间插入和删除元素。

有两种类型的 List ：

  • 基本的 ArrayList ，擅长随机访问元素，但在 List 中间插入和删除元素时速度较慢。
  • LinkedList ，它通过代价较低的在 List 中间进行的插入和删除操作，提供了优化的顺序访问。 LinkedList 对于随机访问来说相对较慢，但它具有比 ArrayList 更大的特征集。

下面的示例导入 typeinfo.pets ，超前使用了类型信息一章中的类库。这个类库包含了 Pet 类层次结构，以及用于随机生成 Pet 对象的一些工具类。此时不需要了解完整的详细信息，只需要知道两点：

  1. 有一个 Pet 类，以及 Pet 的各种子类型。
  2. 静态的 new PetCreator().list() 方法返回一个填充了随机选取的 Pet 对象的 ArrayList：

ListFeatures.java

import java.util.*;public class ListFeatures {public static void main(String[] args) {Random rand = new Random(47);List<Pet> pets = new PetCreator().list(7);System.out.println("1: " + pets);Hamster h = new Hamster();pets.add(h); // Automatically resizesSystem.out.println("2: " + pets);System.out.println("3: " + pets.contains(h));pets.remove(h); // Remove by objectPet p = pets.get(2);System.out.println("4: " + p + " " + pets.indexOf(p));Pet cymric = new Cymric();System.out.println("5: " + pets.indexOf(cymric));System.out.println("6: " + pets.remove(cymric));// Must be the exact object:System.out.println("7: " + pets.remove(p));System.out.println("8: " + pets);pets.add(3, new Mouse()); // Insert at an indexSystem.out.println("9: " + pets);List<Pet> sub = pets.subList(1, 4);System.out.println("subList: " + sub);System.out.println("10: " + pets.containsAll(sub));Collections.sort(sub); // In-place sortSystem.out.println("sorted subList: " + sub);// Order is not important in containsAll():System.out.println("11: " + pets.containsAll(sub));Collections.shuffle(sub, rand); // Mix it upSystem.out.println("shuffled subList: " + sub);System.out.println("12: " + pets.containsAll(sub));List<Pet> copy = new ArrayList<>(pets);sub = Arrays.asList(pets.get(1), pets.get(4));System.out.println("sub: " + sub);copy.retainAll(sub);System.out.println("13: " + copy);copy = new ArrayList<>(pets); // Get a fresh copycopy.remove(2); // Remove by indexSystem.out.println("14: " + copy);copy.removeAll(sub); // Only removes exact objectsSystem.out.println("15: " + copy);copy.set(1, new Mouse()); // Replace an elementSystem.out.println("16: " + copy);copy.addAll(2, sub); // Insert a list in the middleSystem.out.println("17: " + copy);System.out.println("18: " + pets.isEmpty());pets.clear(); // Remove all elementsSystem.out.println("19: " + pets);System.out.println("20: " + pets.isEmpty());pets.addAll(new PetCreator().list(4));System.out.println("21: " + pets);Object[] o = pets.toArray();System.out.println("22: " + o[3]);Pet[] pa = pets.toArray(new Pet[0]);System.out.println("23: " + pa[3].id());}
}

其它相关类：

Cat.java

public class Cat extends Pet {public Cat(String name) { super(name); }public Cat() { super(); }
}

Creator.java

import java.lang.reflect.InvocationTargetException;
import java.util.*;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;public abstract class Creator implements Supplier<Pet> {private Random rand = new Random(47);// The different types of Pet to create:public abstract List<Class<? extends Pet>> types();@Overridepublic Pet get() { // Create one random Petint n = rand.nextInt(types().size());try {return types().get(n).getConstructor().newInstance();} catch (InstantiationException |NoSuchMethodException |InvocationTargetException |IllegalAccessException e) {throw new RuntimeException(e);}}public Stream<Pet> stream() {return Stream.generate(this);}public Pet[] array(int size) {return stream().limit(size).toArray(Pet[]::new);}public List<Pet> list(int size) {return stream().limit(size).collect(Collectors.toCollection(ArrayList::new));}
}

Cymric.java

public class Cymric extends Manx {public Cymric(String name) { super(name); }public Cymric() { super(); }
}

Dog.java

public class Dog extends Pet {public Dog(String name) { super(name); }public Dog() { super(); }
}

EgyptianMau.java

public class EgyptianMau extends Cat {public EgyptianMau(String name) { super(name); }public EgyptianMau() { super(); }
}

Hamster.java

public class Hamster extends Rodent {public Hamster(String name) { super(name); }public Hamster() { super(); }
}

Individual.java

import java.util.Objects;public class Individual implements Comparable<Individual> {private static long counter = 0;private final long id = counter++;private String name;public Individual(String name) {this.name = name;}// 'name' is optional:public Individual() {}@Overridepublic String toString() {return getClass().getSimpleName() +(name == null ? "" : " " + name);}public long id() {return id;}@Overridepublic boolean equals(Object o) {return o instanceof Individual &&Objects.equals(id, ((Individual) o).id);}@Overridepublic int hashCode() {return Objects.hash(name, id);}@Overridepublic int compareTo(Individual arg) {// Compare by class name first:String first = getClass().getSimpleName();String argFirst = arg.getClass().getSimpleName();int firstCompare = first.compareTo(argFirst);if (firstCompare != 0) {return firstCompare;}if (name != null && arg.name != null) {int secondCompare = name.compareTo(arg.name);if (secondCompare != 0) {return secondCompare;}}return (arg.id < id ? -1 : (arg.id == id ? 0 : 1));}
}

Manx.java

public class Manx extends Cat {public Manx(String name) { super(name); }public Manx() { super(); }
}

Mouse.java

public class Mouse extends Rodent {public Mouse(String name) { super(name); }public Mouse() { super(); }
}

Mutt.java

public class Mutt extends Dog {public Mutt(String name) { super(name); }public Mutt() { super(); }
}

Pet.java

public class Pet extends Individual {public Pet(String name) {super(name);}public Pet() {super();}
}

PetCreator.java

import java.util.*;public class PetCreator extends Creator {// No try block needed.public static finalList<Class<? extends Pet>> ALL_TYPES = Collections.unmodifiableList(Arrays.asList(Pet.class, Dog.class, Cat.class, Rodent.class,Mutt.class, Pug.class, EgyptianMau.class,Manx.class, Cymric.class, Rat.class,Mouse.class, Hamster.class));// Types for random creation:private static finalList<Class<? extends Pet>> TYPES =ALL_TYPES.subList(ALL_TYPES.indexOf(Mutt.class),ALL_TYPES.size());@Overridepublic List<Class<? extends Pet>> types() {return TYPES;}public static void main(String[] args) {System.out.println(TYPES);List<Pet> pets = new PetCreator().list(7);System.out.println(pets);}
}
/* Output:
[class reflection.pets.Mutt, class reflection.pets.Pug,
class reflection.pets.EgyptianMau, class
reflection.pets.Manx, class reflection.pets.Cymric, class
reflection.pets.Rat, class reflection.pets.Mouse, class
reflection.pets.Hamster]
[Rat, Manx, Cymric, Mutt, Pug, Cymric, Pug]
*/

Pug.java

public class Pug extends Dog {public Pug(String name) { super(name); }public Pug() { super(); }
}

Rat.java

public class Rat extends Rodent {public Rat(String name) { super(name); }public Rat() { super(); }
}

Rodent.java

public class Rodent extends Pet {public Rodent(String name) { super(name); }public Rodent() { super(); }
}

打印内容如下：

在这里插入图片描述

打印行都编了号，因此可从输出追溯到源代码。 第 1 行输出展示了原始的由 Pet 组成的 List 。 与数组不同， List 可以在创建后添加或删除元素，并自行调整大小。这正是它的重要价值：一种可修改的序列。在第 2 行输出中可以看到添加一个 Hamster 的结果，该对象将被追加到列表的末尾。

可以使用 contains() 方法确定对象是否在列表中。如果要删除一个对象，可以将该对象的引用传递给 remove() 方法。同样，如果有一个对象的引用，可以使用 indexOf() 在 List 中找到该对象所在位置的下标号，如第 4 行输出所示中所示。

当确定元素是否是属于某个 List ，寻找某个元素的索引，以及通过引用从 List 中删除元素时，都会用到 equals() 方法（根类 Object 的一个方法）。每个 Pet 被定义为一个唯一的对象，所以即使列表中已经有两个 Cymrics ，如果再创建一个新的 Cymric 对象并将其传递给 indexOf() 方法，结果仍为 -1 （表示未找到），并且尝试调用 remove() 方法来删除这个对象将返回 false 。对于其他类， equals() 的定义可能有所不同。例如，如果两个 String 的内容相同，则这两个 String 相等。因此，为了防止出现意外，请务必注意 List 行为会根据 equals() 行为而发生变化。

第 7、8 行输出展示了删除与 List 中的对象完全匹配的对象是成功的。

可以在 List 的中间插入一个元素，就像在第 9 行输出和它之前的代码那样。但这会带来一个问题：对于 LinkedList ，在列表中间插入和删除都是廉价操作（在本例中，除了对列表中间进行的真正的随机访问），但对于 ArrayList ，这可是代价高昂的操作。这是否意味着永远不应该在 ArrayList 的中间插入元素，并最好是转换为 LinkedList ？不，它只是意味着你应该意识到这个问题，如果你开始在某个 ArrayList 中间执行很多插入操作，并且程序开始变慢，那么你应该看看你的 List 实现有可能就是罪魁祸首（发现此类瓶颈的最佳方式是使用分析器 profiler）。优化是一个很棘手的问题，最好的策略就是置之不顾，直到发现必须要去担心它了（尽管去理解这些问题总是一个很好的主意）。

subList() 方法可以轻松地从更大的列表中创建切片，当将切片结果传递给原来这个较大的列表的 containsAll() 方法时，很自然地会得到 true。请注意，顺序并不重要，在第 11、12 行输出中可以看到，在 sub 上调用直观命名的 Collections.sort() 和 Collections.shuffle() 方法，不会影响 containsAll() 的结果。 subList() 所产生的列表的幕后支持就是原始列表。因此，对所返回列表的更改都将会反映在原始列表中，反之亦然。

retainAll() 方法实际上是一个“集合交集”操作，在本例中，它保留了同时在 copy 和 sub 中的所有元素。请再次注意，所产生的结果行为依赖于 equals() 方法。

第 14 行输出展示了使用索引号来删除元素的结果，与通过对象引用来删除元素相比，它显得更加直观，因为在使用索引时，不必担心 equals() 的行为。

removeAll() 方法也是基于 equals() 方法运行的。 顾名思义，它会从 List 中删除在参数 List 中的所有元素。

set() 方法的命名显得很不合时宜，因为它与 Set 类存在潜在的冲突。在这里使用“replace”可能更适合，因为它的功能是用第二个参数替换索引处的元素（第一个参数）。

第 17 行输出表明，对于 List ，有一个重载的 addAll() 方法可以将新列表插入到原始列表的中间位置，而不是仅能用 Collection 的 addAll() 方法将其追加到列表的末尾。

第 18 - 20 行输出展示了 isEmpty() 和 clear() 方法的效果。

第 22、23 行输出展示了如何使用 toArray() 方法将任意的 Collection 转换为数组。这是一个重载方法，其无参版本返回一个 Object 数组，但是如果将目标类型的数组传递给这个重载版本，那么它会生成一个指定类型的数组（假设它通过了类型检查）。如果参数数组太小而无法容纳 List 中的所有元素（就像本例一样），则 toArray() 会创建一个具有合适尺寸的新数组。 Pet 对象有一个 id() 方法，可以在所产生的数组中的对象上调用这个方法。

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

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

相关文章

VMware标准虚拟交换机和分布式交换机

VMware标准虚拟交换机和分布式交换机

一、虚拟交换机 初期的网络虚拟化&#xff0c;是非常狭义的概念&#xff0c;主要指的是因为计算资源虚拟化&#xff0c;每台物理宿主机上安装了虚拟化软件&#xff0c;同时会部署了虚拟交换机&#xff0c;负责物理机上面承载的VM&#xff08;虚拟机&#xff09;之间与对外的通…
阅读更多...
C++ Day7

C++ Day7

一、auto关键字 1.1 概念 C11中引出了变量的类型自动推导&#xff0c;它和Python 不一样&#xff0c;C需要用auto关键字来引导 1.2 作用 auto修饰变量&#xff0c;可以自动推导出变量的数据类型 1.3注意 1> 使用auto修饰变量时&#xff0c;必须初始化 2> auto的右值…
阅读更多...
便携式明渠流量计工作原理

便携式明渠流量计工作原理

便携式明渠流量计工作原理是什么&#xff1f; 简单来说便携式明渠流量计是一种用于测量明渠水流量的仪器。它的工作原理基于流速-水位关系&#xff0c;通过测量水流速度和水位差来计算明渠的流量。 具体原理如下&#xff1a; 1.测量水流速度&#xff1a;通常使用悬挂在水中的水…
阅读更多...
SAP_ABAP_接口技术_PI实践总结

SAP_ABAP_接口技术_PI实践总结

SAP ABAP顾问能力模型梳理_企业数字化建设者的博客-CSDN博客SAP Abap顾问能力模型https://blog.csdn.net/java_zhong1990/article/details/132469977一、背景说明 1.1 案例介绍 1.1.1 实现OA系统 --> PI系统 --> SAP系统的过程 二、实现步骤 1.2 PI中间件的实现过程 …
阅读更多...
钉钉小程序引用阿里巴巴图标

钉钉小程序引用阿里巴巴图标

2.打开的界面如图&#xff0c;先建一个iconfont.acss文件&#xff0c;全选浏览器打开的样式代码&#xff0c;复制粘贴进新建的iconfont.acss文件中 3.使用
阅读更多...
openCV实战-系列教程4：图像梯度计算（Sobel算子/开运算/梯度计算方法/scharr算子/lapkacian算子）、源码解读

openCV实战-系列教程4：图像梯度计算（Sobel算子/开运算/梯度计算方法/scharr算子/lapkacian算子）、源码解读

&#x1f9e1;&#x1f49b;&#x1f49a;&#x1f499;&#x1f49c;OpenCV实战系列总目录 打印一个图片单独做出一个函数&#xff1a; def cv_show(img,name):cv2.imshow(name,img)cv2.waitKey()cv2.destroyAllWindows() 1、sobel算子 先读进来一个原型白色图 img cv2.…
阅读更多...
java自动登录 selenium 自动登录并获取cookie

java自动登录 selenium 自动登录并获取cookie

选择操作网页 我用的edge&#xff0c;谷歌我的版本太高没有对应的驱动… 下载Edge的驱动程序&#xff0c;直接解压就好里面只有一个.exe文件 https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/ 复制即用&#xff0c;看注释 import com.alibaba.fastjs…
阅读更多...
python的观察者模式案例

python的观察者模式案例

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言二、具体代码写在结尾 前言 最近写安卓的代码比较多&#xff0c;了解了java代码的注册回调机制&#xff0c;也就是观察者模式&#xff0c;搜索了一下python也有…
阅读更多...
RabbitMQ---work消息模型

RabbitMQ---work消息模型

1、work消息模型 工作队列或者竞争消费者模式 在第一篇教程中&#xff0c;我们编写了一个程序&#xff0c;从一个命名队列中发送并接受消息。在这里&#xff0c;我们将创建一个工作队列&#xff0c;在多个工作者之间分配耗时任务。 工作队列&#xff0c;又称任务队列。主要思…
阅读更多...
SystemVerilog interface详细介绍

SystemVerilog interface详细介绍

1. Interface概念 System Verilog中引入了接口定义&#xff0c;接口与module 等价的定义&#xff0c;是要在其他的接口、module中直接定义&#xff0c;不能写在块语句中&#xff0c;跟class是不同的。接口是将一组线捆绑起来&#xff0c;可以将接口传递给module。 2. 接口的优…
阅读更多...
Maven入门教程(一)：安装Maven环境

Maven入门教程(一)：安装Maven环境

视频教程&#xff1a;Maven保姆级教程 Maven入门教程(一)&#xff1a;安装Maven环境 Maven入门教程(二)&#xff1a;idea/Eclipse使用Maven Maven入门教程(三)&#xff1a;Maven语法 Maven入门教程(四)&#xff1a;Nexus私服 Maven入门教程(五)&#xff1a;自定义脚手架 Maven项…
阅读更多...
Vscode画流程图

Vscode画流程图

1.下载插件 Draw.id Integration 2.桌面新建文件&#xff0c;后缀名改为XXX.drawio 在vscode打开此文件 &#xff0c;就可以进行绘制流程图啦
阅读更多...
6.Redis-hash

6.Redis-hash

hash 哈希类型中的映射关系通常称为field-value&#xff0c;⽤于区分 Redis 整体的键值对&#xff08;key-value&#xff09;&#xff0c;注意这⾥的value是指field对应的值&#xff0c;不是键&#xff08;key&#xff09;对应的值&#xff0c;请注意 value 在不同上下⽂的作⽤…
阅读更多...
R语言和Python用泊松过程扩展：霍克斯过程Hawkes Processes分析比特币交易数据订单到达自激过程时间序列...

R语言和Python用泊松过程扩展：霍克斯过程Hawkes Processes分析比特币交易数据订单到达自激过程时间序列...

全文下载链接&#xff1a;http://tecdat.cn/?p25880 本文描述了一个模型&#xff0c;该模型解释了交易的聚集到达&#xff0c;并展示了如何将其应用于比特币交易数据。这是很有趣的&#xff0c;原因很多。例如&#xff0c;对于交易来说&#xff0c;能够预测在短期内是否有更多…
阅读更多...
EVO大赛是什么

EVO大赛是什么

价格是你所付出的东西&#xff0c;而价值是你得到的东西 EVO大赛是什么&#xff1f; “EVO”大赛全称“Evolution Championship Series”&#xff0c;是北美最高规格格斗游戏比赛&#xff0c;大赛正式更名后已经连续举办12年&#xff0c;是全世界最大规模的格斗游戏赛事。常见…
阅读更多...
angular抛出 ExpressionChangedAfterItHasBeenCheckedError错误分析

angular抛出 ExpressionChangedAfterItHasBeenCheckedError错误分析

当变更检测完成后又更改了表达式值时&#xff0c;Angular 就会抛出 ExpressionChangedAfterItHasBeenCheckedError 错误。Angular 只会在开发模式下抛出此错误。 在开发模式下&#xff0c;Angular 在每次变更检测运行后都会执行一次附加检查&#xff0c;以确保绑定没有更改。这…
阅读更多...
Java 8 新特性——Lambda 表达式（2）

Java 8 新特性——Lambda 表达式（2）

一、Java Stream API Java Stream函数式编程接口最初在Java 8中引入&#xff0c;并且与 lambda 一起成为Java开发里程碑式的功能特性&#xff0c;它极大的方便了开放人员处理集合类数据的效率。 Java Stream就是一个数据流经的管道&#xff0c;并且在管道中对数据进行操作&…
阅读更多...
springBoot打印精美logo

springBoot打印精美logo

文章目录 &#x1f412;个人主页&#x1f3c5;JavaEE系列专栏&#x1f4d6;前言&#xff1a;&#x1f380;文本logo &#x1f412;个人主页 &#x1f3c5;JavaEE系列专栏 &#x1f4d6;前言&#xff1a; 本篇博客主要以提供springBoot打印精美logo &#x1f380;文本logo ??…
阅读更多...
博流RISC-V芯片BL616开发环境搭建

博流RISC-V芯片BL616开发环境搭建

文章目录 1、工具安装2、代码下载3、环境变量配置4、下载交叉编译器5、编译与下载运行6、使用ninja编译 本文分别介绍博流RISC-V芯片 BL616 在 Windows和Linux 下开发环境搭建&#xff0c;本文同时适用BL618&#xff0c;BL602&#xff0c;BL702&#xff0c;BL808系列芯片。 1、…
阅读更多...
电商数据接口API：品牌价格监控与数据分析的重要工具

电商数据接口API：品牌价格监控与数据分析的重要工具

一、引言 随着电子商务的快速发展&#xff0c;传统品牌企业越来越重视在线销售市场。为了在竞争激烈的市场环境中取得成功&#xff0c;企业需要实时掌握市场动态&#xff0c;了解自身产品的销售情况、价格趋势以及竞品信息。为了实现这一目标&#xff0c;各大电商平台&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023