stream of java_java8新特性之强大的Stream API

Stream API

Stream是Java8中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找、过滤和映射数据等操作。

使用Stream API 对集合数据进行操作,就类似于使用 SQL 执行的数 据库查询。

也可以使用Stream API来并行执行操作。

简而言之,Stream API 提供了一种高效且易于使用的处理数据的方式。

流(Stream) 到底是什么呢?

Stream流是数据渠道,用于操作数据源(集合、数组等)所生成的元素序列,以下三点注意。

Stream 自己不会存储元素。

Stream 不会改变源对象。相反,他们会返回一个持有结果的新Stream。

Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream流操作的三大步

创建Stream流 //一个数据源 集合/数组/Stream静态方法 获取一个Stream流

中间操作 //对数据源的数据进行处理,过滤,筛选等等

终止操作 //执行中间操作链,产生结果

创建Stream流

1.集合创建Stream流

/****

* java8中的Collection接口方法

* stream() 顺序流

* parallelStream() 并行流(后面再说这个)

*/

@Test

public void test01() {

//声明一个list

List list = new ArrayList();

// default Stream stream() 顺序流

// default Stream parallelStream() 并行流

// 创建一个顺序流

Stream stream1 = list.stream();

// 创建一个并行流

Stream stream2 = list.parallelStream();

}

2.数组创建Stream流

/****

* 数组创建Stream流

* Java8 中的 Arrays 的静态方法 stream() 可以获取数组流

*/

@Test

public void test02() {

// Java8 中的 Arrays 的静态方法 stream() 可以获取数组流

// public static Stream stream(T[] array)

String[] arr = new String[10];

Stream stream = Arrays.stream(arr);

}

3.由值创建Stream流 Stream.of()

/****

* 由值创建Stream流

* Stream.of()

*/

@Test

public void test03() {

// 可以使用静态方法 Stream.of(), 通过显式值创建一个流。它可以接收任意数量的参数。

Stream stream = Stream.of("1", "2", "3", "4");

}

4.由函数创建Stream无限流 iterate.generate() Stream.generate()

/****

* 由函数创建Stream无限流

*

* seed种子 f 一元运算接口

* Stream.iterate(T seed,UnaryOperator f)

*

* supplier 供给型型接口

* Stream.generate(Supplier supplier)

*/

@Test

public void test04() {

// 可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。

// args1 seed 开始种子, args2 一元函数式接口

//迭代 public static Stream iterate(final T seed, final UnaryOperator f)

Stream stream1 = Stream.iterate(0, (x) -> x + 1);

//args 一个供给型接口

// 生成 public static Stream generate(Supplier s) :

Stream stream2 = Stream.generate(() -> new Random().nextInt(100));

}

Stream流中间操作

多个中间操作可以连接起来形成一个流水线,除非流水线上触发终止操作,否则中间操作不会执行任何的处理,而在终止操作时一次性全部处理,称为“惰性求值”。看一下一些常用的api:

1.流中排除不符合条件的元素:filter

/****

* filter(Predicate p)

* 接收一个断言式接口,从流中排除不符合条件的元素

*/

@Test

public void test01() {

Integer[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

//使用Stream流的静态方法 of创建一个Stream流

Stream stream = Stream.of(nums);

//过滤操作 接收一个断言式接口 排除不符合条件的元素 输出结果

stream.filter((x) -> x > 5).forEach(System.out::println);

}

2.流中去除重复元素:distinct

/***

* distinct()

* 筛选,通过流所生成元素的 hashCode() 和 equals() 去除重复元素

*/

@Test

public void test02() {

Integer[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1};

//使用Stream流的静态方法 of创建一个Stream流

Stream stream = Stream.of(nums);

//去除重复的元素

stream.distinct().forEach(System.out::println);

}

3.截取流获取前n个元素:limit

/***

* limit(long maxSize)

* 接收一个long型数值流中的元素个数不操过maxSize个,

*/

@Test

public void test03() {

//使用Stream流的静态方法 generate创建一个Stream无限流

Stream stream = Stream.generate(() -> new Random().nextInt(100));

//截断流获取前n个元素 最大n个

stream.limit(10).forEach(System.out::println);

}

4.跳过流前n个元素:skip

/***

* skip(long n)

* 接收一个long型数值 跳过流前n个元素获取后面的元素和 limit(n)相反

*/

@Test

public void test04() {

Integer[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1};

//使用Stream流的静态方法 generate创建一个Stream无限流

Stream stream = Arrays.stream(nums);

stream.skip(3).forEach(System.out::println);

}

5.映射流中的每一个元素:map

/****

* map(Function f)

* 接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素。

*/

@Test

public void test05() {

Integer[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

//使用Stream流的静态方法 generate创建一个Stream无限流

Stream stream = Arrays.stream(nums);

// 将每个元素*2

stream.map(x -> x * 2).forEach(System.out::println);

}

6.将流中元素映射成一个新的Double型元素:mapToDouble

/****

* mapToDouble(ToDoubleFunction f)

* 接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的Double型元素。

* 注意原数组要可以转换成Double型

*/

@Test

public void test06() {

Integer[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

//使用Stream流的静态方法 generate创建一个Stream无限流

Stream stream = Arrays.stream(nums);

// 将每个元素 变成double

stream.mapToDouble(x -> x * 2).forEach(System.out::println);

}

7.将流中元素映射成一个新的Long型元素:mapToDouble

/****

* mapToLong(ToDoubleFunction f)

* 接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的Long型元素。

* 注意原数组要可以转换成Long型

*/

@Test

public void test07() {

Integer[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

//使用Stream流的静态方法 generate创建一个Stream无限流

Stream stream = Arrays.stream(nums);

// 将每个元素 变成double

stream.mapToDouble(x -> x * 2).forEach(System.out::println);

}

8.将流中的每个值都换成另一个流,然后把所有流连接成一个流:flatMap

/****

* flatMap(ToDoubleFunction f)

* 接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流

*/

@Test

public void test08() {

String[] strings = {"hello lambda", "hello", "lambda"};

// Stream的静态方法 of获取流

Stream testStream = Stream.of(strings);

// 流中的元素换成另一个流 分割处理 然后去重 打印

testStream.flatMap(str -> Arrays.stream(str.split(" "))).distinct().forEach(System.out::println);

}

9.产生一个新流,其中按自然顺序排序:sorted

/**

* sorted()

* 产生一个新流,其中按自然顺序排序

*/

@Test

public void test09() {

Integer[] nums = {1, 4, 2, 6, 3, 0, 9, 8, 7, 5};

Arrays.stream(nums).sorted().forEach(System.out::println);

}

10.产生一个新流,其中按比较器顺序排序:sorted

/**

* sorted(Comparator comparator)

* 产生一个新流,其中按比较器顺序排序

*/

@Test

public void test10() {

Integer[] nums = {-1, 4, -2, 6, -3, 0, 9, -8, 7, -5};

//例如 按照绝对值排序

Arrays.stream(nums).sorted(Comparator.comparing(x -> Math.abs(x))).forEach(System.out::println);

}

Stream流的终止操作

终端操作会从流的流水线生成结果。 其结果可以是任何不是流的值,例如:List、Integer、boolean

1.判断流中的元素是否全部满足某一个条件:allMatch

/****

* allMatch(Predicate predicate)

* 接收一个断言式接口 全匹配 返回boolean

*/

@Test

public void test01() {

Integer[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

//使用Stream流的静态方法 of创建一个Stream流

Stream stream = Stream.of(nums);

// 匹配数组元素是否全部大于等于0

System.out.println(stream.allMatch((x) -> x >= 0));

}

2.判断流中的元素至少满足某一个条件:anyMatch

/****

* anyMatch(Predicate predicate)

* 接收一个断言式接口 至少匹配一个 返回boolean

*/

@Test

public void test02() {

Integer[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

//使用Stream流的静态方法 of创建一个Stream流

Stream stream = Stream.of(nums);

// 匹配数组元素是否有大于10的元素

System.out.println(stream.anyMatch((x) -> x > 10));

}

3.判断流中的元素都不满足某一个条件:noneMatch

/****

* noneMatch(Predicate predicate)

* 接收一个断言式接口 是否没有匹配的元素 返回boolean

*/

@Test

public void test03() {

Integer[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

//使用Stream流的静态方法 of创建一个Stream流

Stream stream = Stream.of(nums);

// 匹配数组元素是否没有大于10的元素

System.out.println(stream.noneMatch((x) -> x > 10));

}

4.返回流元素中的第一个元素:findFirst

/****

* findFirst()

* 返回Optional

*/

@Test

public void test04() {

Integer[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1};

//使用数组Arrays创建流

Stream stream = Arrays.stream(nums);

//返回流元素中的第一个元素

Optional optional = stream.findFirst();

System.out.println(optional.get());

}

5.返回流元素中的任意一个元素:findAny

/****

* findAny()

* 返回Optional

*/

@Test

public void test05() {

Integer[] nums = {2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1};

//使用数组Arrays创建流

Stream stream = Arrays.stream(nums);

//返回流元素中的任意元素

Optional optional = stream.findAny();

System.out.println(optional.get());

}

6.返回流元素总数:count

/****

* count()

* 返回流元素总数 Long型

*/

@Test

public void test06() {

Integer[] nums = {2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1};

//使用数组Arrays创建流

Stream stream = Arrays.stream(nums);

Long aLong = stream.count();

System.out.println(aLong);

}

7.返回流元素中的最大元素:max

/****

* max(Comparator comparator)

* 返回流元素最大值

* 接收一个比较器

*/

@Test

public void test07() {

Integer[] nums = {2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1};

//使用数组Arrays创建流

Stream stream = Arrays.stream(nums);

//返回流元素中的最大元素

Optional optional = stream.max(Integer::compare);

System.out.println(optional.get());

}

8.返回流元素中的最小元素:min

/****

* max(Comparator comparator)

* 返回流元素最小值

* 接收一个比较器

*/

@Test

public void test08() {

Integer[] nums = {2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1};

//使用数组Arrays创建流

Stream stream = Arrays.stream(nums);

//返回流元素中的最小元素

Optional optional = stream.min(Integer::compare);

System.out.println(optional.get());

}

9.内部迭代:forEach

/****

* forEach(Consumer consumer)

* 接收一个消费性接口

* 内部迭代(使用 Collection 接口需要用户去做迭代,称为外部迭代。

* 相反,Stream API 使用内部 迭代——它帮你把迭代做了)

*/

@Test

public void test09() {

Integer[] nums = {2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1};

Arrays.stream(nums).forEach(System.out::println);

}

10.将流中元素反复结合起来,得到一个值:reduce

/***

* reduce(BinaryOperator accumulator)

* 可以将流中元素反复结合起来,得到一个值。返回Optional

* 接收一个二元运算接口

*/

@Test

public void test10() {

Integer[] nums = {2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1};

// 依次累加

Object object = Arrays.stream(nums).reduce((x, y) -> x + y).get();

System.out.println(object);

}

11.将流中元素反复结合起来(有一个起始值),得到一个值:reduce

/***

* reduce(T iden, BinaryOperator accumulator)

* 接收一个二元运算接口

* 可以将流中元素反复结合起来,得到一个值。返回 T

*/

@Test

public void test11() {

Integer[] nums = {2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1};

// iden 作为一个值先加入运算然后 依次累加

Object object = Arrays.stream(nums).reduce(10, (x, y) -> x * y);

System.out.println(object);

}

12.将流转换为List:stream.collect(Collectors.toList())

/***

* collect(Collector collector)

* 将流转换为其他形式。

* 接收一个 Collector接口的实现,用于给Stream中元素做汇总的方法

* Collectors 实用类提供了很多静态方法,可以方便地创建常见收集器实例

* Collectors.toList()

* // 将数组变成了 list

*/

@Test

public void test12() {

Integer[] nums = {2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1};

Stream stream = Arrays.stream(nums);

List list = stream.collect(Collectors.toList());

// 将数组变成了 list

System.out.println(list.size());

}

13.将流转换为Set:stream.collect(Collectors.toSet())

/***

* Collectors.toSet()

* 将数组变成了 set

*/

@Test

public void test13() {

Integer[] nums = {2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1};

Stream stream = Arrays.stream(nums);

Set set = stream.collect(Collectors.toSet());

// 将数组变成了 set

System.out.println(set.size());

}

14.将流转换为Collection:stream.collect(Collectors.toSet())

/***

* Collectors.toCollection(ArrayList::new)

* Collectors.toCollection(HashSet::new)

* 将数组变成了 Collection

*/

@Test

public void test14() {

Integer[] nums = {2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1};

Stream stream = Arrays.stream(nums);

Collection collection = stream.collect(Collectors.toCollection(HashSet::new));

// 将数组变成了 collection

System.out.println(collection.size());

}

15.计算流中元素的个数:stream.collect(Collectors.counting())

/***

* Collectors.counting()

* 计算流中元素的个数

*/

@Test

public void test15() {

Integer[] nums = {2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1};

Stream stream = Arrays.stream(nums);

Long integer = stream.collect(Collectors.counting());

System.out.println(integer);

}

16.计算流中元素的对象的某一个属性平均值:stream.collect(Collectors.summingDouble())

/***

* Collectors.summingDouble(ToDoubleFunction mapper)

* 计算流中元素的对象的某一个属性平均值

* 接收一个 计算int、long、 double、值的函数 接口

*/

@Test

public void test16() {

List employees = new ArrayList<>(3);

Employee employe1 = new Employee(1, "A1", 5000);

Employee employe2 = new Employee(1, "A2", 8000);

Employee employe3 = new Employee(1, "A3", 10000);

employees.add(employe1);

employees.add(employe2);

employees.add(employe3);

Stream stream = employees.stream();

Double sumSalary = stream.collect(Collectors.summingDouble(Employee::getSalary));

System.out.println(sumSalary);

}

17.计算流中元素的对象的某一个属性平均值:stream.collect(Collectors.averagingDouble())

/***

* Collectors.averagingDouble(ToDoubleFunction mapper)

* 计算流中元素的对象的某一个属性平均值

* 接收一个 计算int、long、 double、值的函数 接口

*/

@Test

public void test17() {

List employees = new ArrayList<>(3);

Employee employe1 = new Employee(1, "A1", 5000);

Employee employe2 = new Employee(1, "A2", 8000);

Employee employe3 = new Employee(1, "A3", 10000);

employees.add(employe1);

employees.add(employe2);

employees.add(employe3);

Stream stream = employees.stream();

Double avgSalary = stream.collect(Collectors.averagingDouble(Employee::getSalary));

System.out.println(avgSalary);

}

18.连接流中元素的对象的某一个属性字符串:stream.collect(Collectors.joining())

/***

* Collectors.joining()

* 连接流中元素的对象的某一个属性字符串

*/

@Test

public void test18() {

List employees = new ArrayList<>(3);

Employee employe1 = new Employee(1, "A1", 5000);

Employee employe2 = new Employee(1, "A2", 8000);

Employee employe3 = new Employee(1, "A3", 10000);

employees.add(employe1);

employees.add(employe2);

employees.add(employe3);

Stream stream = employees.stream();

String names = stream.map((x) -> x.getName() + "-").collect(Collectors.joining());

System.out.println(names);

}

19.收集器中最小值:stream.collect(Collectors.minBy())

/***

* Collectors.maxBy(Comparator comparator)

* 根据比较器选择最小值

* 接收一个比较器

*/

@Test

public void test19() {

Integer[] nums = {1, 2, 3, 4, 5, 7, 8, 9, 3, 4, 56};

Stream stream = Arrays.stream(nums);

Optional optional = stream.collect(Collectors.minBy(Integer::compareTo));

System.out.println(optional.get());

}

20.收集器中某一属性之和:stream.collect(Collectors.reducing())

/***

* Collectors.reducing(U identity,Function super T, ? extends U> mapper,BinaryOperator op)

* 从一个作为累加器的初始值开始,利用BinaryOperator与流中元素逐个结合,从而归约成单个值

* 接收二元计算接口

*/

@Test

public void test20() {

List employees = new ArrayList<>(3);

Employee employe1 = new Employee(1, "A1", 5000);

Employee employe2 = new Employee(1, "A2", 8000);

Employee employe3 = new Employee(1, "A3", 10000);

employees.add(employe1);

employees.add(employe2);

employees.add(employe3);

Stream stream = employees.stream();

// identity : 0d 类型和后面的元素类型 保持一致

Double aDouble = stream.collect(Collectors.reducing(0d, Employee::getSalary, Double::sum));

System.out.println(aDouble);

}

21.收集器转换为另一类型然后处理:stream.collect(Collectors.collectingAndThen())

/***

* Collectors.collectingAndThen(Collector downstream,Function finisher)

* 转换函数返回的类型

* 包裹另一个收集器,对其结果转换函数

*/

@Test

public void test21() {

List employees = new ArrayList<>(3);

Employee employe1 = new Employee(1, "A1", 5000);

Employee employe2 = new Employee(1, "A2", 8000);

Employee employe3 = new Employee(1, "A3", 10000);

employees.add(employe1);

employees.add(employe2);

employees.add(employe3);

Stream stream = employees.stream();

// 转换函数返回的类型 返回set

// 包裹另一个收集器,对其结果 set 进行处理 判断时候为空

Boolean bool = stream.collect(Collectors.collectingAndThen(Collectors.toSet(), Set::isEmpty));

System.out.println(bool);

}

22.收集器按照某一属性分组:stream.collect(Collectors.groupingBy())

/***

* 根据某属性值对流分组,属 性为K,结果为V

* Collectors.groupingBy(Function super T, ? extends K> classifier)

* 传入一个 代表流元素的属性

* 返回 以属性为key value为 list的map

*/

@Test

public void test22() {

List employees = new ArrayList<>(3);

Employee employe1 = new Employee(1, "A1", 5000);

Employee employe2 = new Employee(1, "A2", 8000);

Employee employe3 = new Employee(1, "A3", 10000);

employees.add(employe1);

employees.add(employe2);

employees.add(employe3);

Stream stream = employees.stream();

Map map = stream.collect(Collectors.groupingBy(Employee::getName));

Set set=map.entrySet();

for (Object str:set) {

System.out.println(str);

System.out.println(map.get(str));

}

}

23.收集器按照某一属性(boolean类型)分组:stream.collect(Collectors.partitioningBy())

/***

* 根据true或false进行分区

* Collectors.groupingBy(Function super T, ? extends K> classifier)

* 传入一个 代表流元素的属性

* 返回 以属性(flase/true)为key value为 list的map

*/

@Test

public void test23() {

List employees = new ArrayList<>(3);

Employee employe1 = new Employee(1, "A1", 5000,false);

Employee employe2 = new Employee(1, "A2", 8000,true);

Employee employe3 = new Employee(1, "A3", 10000,false);

employees.add(employe1);

employees.add(employe2);

employees.add(employe3);

Stream stream = employees.stream();

Map map = stream.collect(Collectors.partitioningBy(Employee::getFlag));

Set set=map.entrySet();

for (Object str:set) {

System.out.println(str);

System.out.println(map.get(str));

}

}

辅助类Employee

/**

* @author black猫

* @date 2019-11-25

* 员工类

*/

public class Employee {

private int id;

private String name;

private double salary;

private boolean flag;

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public double getSalary() {

return salary;

}

public void setSalary(double salary) {

this.salary = salary;

}

public boolean getFlag() {

return flag;

}

public void setFlag(boolean flag) {

this.flag = flag;

}

public Employee(int id, String name, double salary){

this.id=id;

this.name=name;

this.salary=salary;

}

public Employee(int id, String name, double salary,boolean flag){

this.id=id;

this.name=name;

this.salary=salary;

this.flag=flag;

}

@Override

public String toString() {

return "Employee{" +

"id=" + id +

", name='" + name + '\'' +

", salary=" + salary +

", flag=" + flag +

'}';

}

}

我的小结

Stream是java8提供的java.util.stream.*包下的强大Api,结合lambda表达式,可以快速、高效、便捷的对集合数据进行处理, 熟练掌握之后,就像写sql一样操作集合数据,功能强大,代码不再那么臃肿、冗余。爽!!!

文章首发于黑猫のBlog欢迎来留言啊!!!

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

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

相关文章

【学习笔记】数据链路层——随机访问介质访问控制(ALOHA、CSMA、CSMA/CD、CSMA/CA),截断二进制指数规避算法

文章目录小前言一. ALOHA协议纯ALOHA协议时隙ALOHA协议ALOHA对比CSMA协议定义与分类① 1-坚持CSMA② 非坚持CSMA③ p-坚持CSMA总结CSMA/CD协议传播时延对载波监听的影响确定重传时机&#xff1a;截断二进制指数规避算法最小帧长问题CSMA/CA协议工作原理CSMA/CD 与 CSMA/CA的对比…

pca算法介绍及java实现_PCA算法原理及实现

众所周知&#xff0c;PCA(principal component analysis)是一种数据降维的方式&#xff0c;能够有效的将高维数据转换为低维数据&#xff0c;进而降低模型训练所需要的计算资源。以上是比较官方的说法&#xff0c;下面是人话(正常人讲的话)版。pca就是一种能够有效压缩数据的方…

【学习笔记】数据链路层——轮询访问介质控制(轮询协议、令牌传递协议)

文章目录一. 轮询访问介质控制二. 轮询协议三. 令牌传递协议结束语PPT截自王道考研B站教程 一. 轮询访问介质控制 结合了前面的信道划分访问控制、随机访问MAC协议的优点&#xff1a; 既要不产生冲突&#xff0c;又要发送时占全部带宽。 二. 轮询协议 轮询开销&#xff1a;…

java boolean 多线程_JAVA多线程两个实用的辅助类(CountDownLatch和AtomicBoolean)

AtomicBoolean它允许一个线程等待一个线程完成任务&#xff0c;然后运行:A boolean value that may be updated atomically. See the java.util.concurrent.atomic package specification for description of the properties of atomic variables. An AtomicBoolean is used in…

【学习笔记】局域网基本概念和体系结构,以太网、无线局域网与PPP协议、HDLC协议

文章目录一. 局域网&#xff1a;特点与要素① 拓扑结构② 传输介质③ 介质访问控制方法④ 局域网的分类⑤ IEEE 802标准⑥ MAC子层和LLC子层二. 以太网① 概述② 提供无连接、不可靠的服务③ 传输介质与拓扑结构的发展④ 10BAST-T以太网⑤ 适配器与MAC地址⑥ 以太网MAC帧⑦ 高速…

java truevfs_Java-Apache Commons VFS:使用FTP

我正在尝试通过FTP使用Apache Commons VFS.在我的FTP上,具有文件和文件夹的下一个结构&#xff1a;//test/test/in/test/in/file1.txt/test/in/file2.txt我需要连接并从/ test / in文件夹中读取所有文件(它一直在变化).码&#xff1a;FileSystemManager fsManager null;FileSy…

【学习笔记】数据链路层——链路层设备:物理层拓展以太网、链路层拓展以太网与冲突域和广播域

文章目录一. 冲突域与广播域① 定义与对比图② 例子二. 物理层扩展以太网三. 链路层扩展以太网① 网桥定义透明网桥源路由网桥② 以太网交换机PPT截自B站王道考研教程 本文内容导图 一. 冲突域与广播域 可以先只是简单看看定义&#xff0c;然后看完二、三后再回来看对比图和…

java jui 正则表达式_常规正则表达式练习

PS&#xff1a;join()数组转串&#xff0c;split()串转数组1、test()&#xff1a;在字符串查找符合正则的内容&#xff0c;如果查找到返回true&#xff0c;反之返回false用法&#xff1a;正则.test(字符串)2、search()&#xff1a;在字符串搜索符合正则的内容&#xff0c;找到就…

【学习笔记】网络层——概述、数据交换方式:电路交换、报文交换与分组交换(数据报与虚电路)

文章目录一. 概述二. 数据交换方式① 电路交换② 报文交换③ 分组交换④ 分组交换 && 报文交换举例对比⑤ 三种数据交换方式比较总结三. 分组交换的两种方式① 定义传输单元名词辨析② 数据报③ 虚电路④ 数据报与虚电路的对比ppt截自王道考研B站教程 太不容易了&#…

java代码中 作用_Java利用开发中代码生成工具的作用

Java利用开发中代码生成工具的作用2010-6-5文字大小:大中小近来&#xff0c;随着各种代码生成工具的不断涌现(如SpringSource的Spring Roo、Skyway Builder Community Edition 6.3及Blu Age的M2Spring等)&#xff0c;人们又将留心力转移到了这些代码生成工具在企业级Java使用开…

【学习记录】网络层——IP数据报(格式与分片)

文章目录一. IP数据报格式二. IP数据报分片① 为什么要分片?② 标识、标志与片偏移③ 例题单位为nB小结PPT截自王道考研教程 tips&#xff1a;b是位&#xff0c;B是字节。 一. IP数据报格式 在本章节中&#xff0c;暂时不区分IP数据报与分组。 生存时间(Time To Live)&#xf…

java计算器 运算符优先级_跪求大神帮忙,怎样在java 计算器中实现,四则运算优先级;...

该楼层疑似违规已被系统折叠 隐藏此楼查看此楼代码如下&#xff0c;跪求大神补充import java.awt.*;import java.awt.event.*;import java.awt.image.BufferedImage;import java.io.File;import java.io.IOException;import javax.imageio.ImageIO;import javax.swing.JFrame;i…

自动驾驶学习笔记(二十二)——自动泊车算法

#Apollo开发者# 学习课程的传送门如下&#xff0c;当您也准备学习自动驾驶时&#xff0c;可以和我一同前往&#xff1a; 《自动驾驶新人之旅》免费课程—> 传送门 《Apollo开放平台9.0专项技术公开课》免费报名—>传送门 文章目录 前言 感知算法 定位算法 规划算法…

java中保留小数位_Java中保留两位小数的方法

Java中保留4位小数的方法&#xff1a;import java.math.BigDecimal;import java.text.DecimalFormat;import java.text.NumberFormat;public class format {double f 111231.5585;public void m1() {BigDecimal bg new BigDecimal(f);double f1 bg.setScale(2, BigDecimal.R…

【学习笔记】 IPv4地址、NAT与子网掩码、子网划分

文章目录一. IP地址① 在例子中理解③ IP地址的分类④ 特殊IP地址⑤ 私有IP地址⑥ 各类IP的对比二. NAT三. 子网划分与子网掩码① 子网划分② 子网掩码例题1例题2③ 使用子网时路由的转发PPT截自王道考研教程 一. IP地址 可以理解成上网设备的身份证号唯一点分十进制&#xff…

java对象底层原存储结构图解_图解图库JanusGraph系列-一文知晓“图数据“底层存储结构...

大家好&#xff0c;我是洋仔&#xff0c;JanusGraph图解系列文章&#xff0c;实时更新~图数据库文章总目录&#xff1a;转载文章请保留以下声明&#xff1a;一&#xff1a;存储模式留言或私信我&#xff0c;邀请你加入“图数据库交流”微信群&#xff01;1、图内容本文以下所有…

【学习笔记】网络层——无分类编址CIDR、ARP协议、DHCP协议和ICMP协议

文章目录一. CIDR① 定义② 构成超网③ 最长前缀匹配二. ARP协议① 定义② 例题三. DHCP协议① 主机如何获取IP②DHCP协议四. ICMP协议① ICMP差错报告报文类型&#xff08;5种&#xff09;数据字段不发送的情况② ICMP询问报告报文类型应用一. CIDR ① 定义 在点分十进制后加…

jdbc连接mysql的配置文件_如何实现jdbc连接数据库并通过配置文件调用数据的方法(代码)...

本篇文章给大家带来的内容是关于如何实现jdbc连接数据库并通过配置文件调用数据的方法(代码) &#xff0c;有一定的参考价值&#xff0c;有需要的朋友可以参考一下&#xff0c;希望对你有所帮助。Dbutil类package com.db;import java.io.IOException;import java.io.InputStrea…

【学习笔记】网络层——IPv6:地址表示、IPv4的对比、IPv4过渡到IPv6、基本地址类型等

文章目录一.1) 为什么要有IPv62&#xff09;数据报格式3&#xff09;IPv4和IPv6的区别4&#xff09;IPv6地址表示形式5&#xff09;IPv6基本地址类型6&#xff09;IPv4到IPv6的过渡方法一. 1) 为什么要有IPv6 CIDR、NAT只是缓解IPv4空间殆尽&#xff0c;治标不治本。 而IPv6可…

java使用枚举做审核_JAVA—枚举

前言&#xff1a;枚举是一种规范它规范了参数的形式&#xff0c;这样就可以不用考虑类型的不匹配并且显式的替代了int型参数可能带来的模糊概念 枚举像一个类&#xff0c;又像一个数组。Enum作为Sun全新引进的一个关键字&#xff0c;看起来很象是特殊的class, 它也可以有自己的…