JDK8新特性(一)集合之 Stream 流式操作

1.Stream流由来

       首先我们应该知道:Stream流的出现,主要是用在集合的操作上。在我们日常的工作中,经常需要对集合中的元素进行相关操作。诸如:增加、删除、获取元素、遍历。

        最典型的就是集合遍历了。接下来我们先举个例子来看看 JDK8 Stream流式操作出现之前,我们对集合操作的过程,从中来了解一下 JDK8 之前集合操作数据的弊端。

     Demo:现在有一个List集合,集合中有如下数据:"张无忌"、"周芷若"、"杨逍"、"张强"、"张三丰"、"赵敏"

    public static void main(String[] args) {List<String> list = new ArrayList<>();Collections.addAll(list,"张无忌","周芷若","杨逍","张强","张三丰","赵敏");/*** 需求:*   1.拿到所有姓"张"的名字*   2.拿到长度为3个字的名字*   3.将最终结果进行打印*///JDK8 以前遍历操作集合for (String name : list) {if(name.startsWith("张") && name.length() == 3){System.out.println(name);}}//JDK8 以后使用Stream()流遍历操作集合/**************3.使用 Stream流来操作******************/list.stream().filter(name.startsWith("张") && name->name.length()==3).forEach(name-> System.out.println("111------"+name));}

       使用stream流式操作,直接阅读代码的字面意思即可完美展示无关逻辑方式的语义:①获取流  ② 过滤姓张  ③过滤长度为3  ④遍历打印。我们真正要做的事情内容便能够被更好的体现在代码中。

2.Stream流式思想

  注意:Stream流 和 IO 流(InputStream/OutputStream)没有任何关系,请暂时忘记对传统IO流的固有印象。

       Stream流式思想类似于工厂车间的"生产流水线",Stream流不是一种数据结构,不会保存数据,而是对数据进行加工处理。Stream 可以看做是流水线上的一个工序。在流水线上,通过多个工序让一个原材料加工成一个商品。

3.获取Stream流的两种方式 

java.util.stream.Stream<T> 是 JDK8 新加入的流接口。获取一个流非常简单,有以下两种常用的方式:

1.所有的 Collection 集合都可以通过 .stream() 方法来获取流;
2.使用 Stream 接口的 .of() 静态方法,可以获取流。
    public static void main(String[] args) {//方式1:根据Collection获取流//Collection接口中有一个默认的方法:default Stream<E> stream()//1.List获取流List<String> list = new ArrayList<>();Stream<String> stream01 = list.stream();//2.Set获取流Set<String> set = new HashSet<>();Stream<String> stream02 = set.stream();//3.Map获取流//Map 并没有继承自 Collection 接口,所有无法通过该 map.stream()获取流。但是可用通过如下三种方式获取:Map<String,String> map = new HashMap<>();Stream<String> stream03 = map.keySet().stream();Stream<String> stream04 = map.values().stream();List<Map.Entry<String, String>> collect = map.entrySet().stream().collect(Collectors.toList());Stream<Map.Entry<String, String>> stream = map.entrySet().stream();//方式2:Stream中的静态方法of获取流// static<T> Stream<T> of(T... values)// T... values:可变参数,实际原理就是可变数组(传递String数组进去)//1.字符串获取流Stream<String> stream06 = Stream.of("aa", "bb", "cc");//2.数组类型(基本类型除外)String[] strs = {"aa","bb","cc"};Stream<String> stream07 = Stream.of(strs);//3.基本数据类型的数组int[] arr = {1,2,3,4};//看着没报错,但是看到返回值是 int[],这是 Stream流把整个数组看做一个元素来操作,而不是操作数组中的int元素(这样子是不行的!!!)Stream<int[]> stream08 = Stream.of(arr);}

4.Stream流常用方法

      Stream流模型的操作很丰富,这里介绍一些常用的API。这些方法可以被分成两种类型:

  •  终结方法:返回值类型不再是 Stream 类型的方法,不再支持链式调用。本小节中,终结方法包括 count() forEach() 方法;
  • 非终结方法:又叫函数拼接方法。值返回值类型仍然是 Stream 类型的方法,支持链式调用(除了终结方法外,其与方法均为非终结方法)

5.Stream流使用注意事项

Stream流只能操作一次;
Stream方法返回的是新的流;
Stream不调用终止方法,中间的操作不会执行。

6.Stream流常用方法 

   提醒以下所有代码部分,能简化部分尽量简化,均使用最简格式!!! 

 1.forEach 

void forEach(Consumer<? super T> action);

        forEach() 方法用来遍历流中的数据,是一个终结方法。该方法接收一个 Consumer 接口函数,会将每一个流元素交给该函数进行处理。示例如下:

public class StreamDemo{public static void main(String[] args){List<String> list = new ArrayList<>();Collections.addAll(list,"Mary","Lucy","James","Johson","Steve");//forEach()遍历//未简写//list.forEach((String str)->{//    System.out.println(str);//});//简写1//list.forEach(str-> System.out.println(str));//最终简写list.forEach(System.out::println);}
}

测试结果: 

2.count 

 long count();

 count() 方法,用来统计集合中的元素个数,是一个终结方法。该方法返回一个 long 值代表元素个数,示例如下:

    public static void main(String[] args) {List<String> list = new ArrayList<>();Collections.addAll(list, "Mary", "Lucy", "James", "Johson", "Steve");//count()计算集合中元素个数long count = list.stream().count();System.out.println("元素个数为:" + count);}

 

3.filter 

Stream<T> filter(Predicate<? super T> predicate);

filter() 方法,用于过滤数据,返回符合过滤条件的数据,是一个非终结方法。我们可以通过 filter() 方法将一个流转换成另一个子集流。该接口接收一个 Predicate 函数式接口参数(可以是一个 Lambda 或 方法引用) 作为筛选条件。

    public static void main(String[] args) {List<String> list = new ArrayList<>();Collections.addAll(list,"Mary","Lucy","James","Johson","Steve");//filter()过滤,返回以"J"开头的名字list.stream().filter(str->str.startsWith("J")).forEach(System.out::println);//写法二list.stream().filter(str->{if (str.startsWith("J")){return true;}return false;}).forEach(System.out::println);}

  测试结果:

4.limit

Stream<T> limit(long maxSize);

       limit() 方法,用来对 Stream 流中的数据进行截取,只取用前 n 个,是一个非终结方法。参数是一个 long 型,如果集合当前长度大于参数则进行截取,否则不进行操作。因为 limit() 是一个非终结方法,所以必须调用终止方法。示例如下:

    public static void main(String[] args) {List<String> list = new ArrayList<>();Collections.addAll(list, "Mary", "Lucy", "James", "Johson", "Steve");//limit()截取,截取list集合前三个元素list.stream().limit(3).forEach(System.out::println);}

 5.skip

      如果希望跳过前几个元素,去取后面的元素,则可以使用 skip()方法,获取一个截取之后的新流,它是一个非终结方法。参数是一个 long 型,如果 Stream 流的当前长度大于 n,则跳过前 n 个,否则将会得到一个长度为 0 的空流。因为 limit() 是一个非终结方法,所以必须调用终止方法。示例如下:

Stream<T> skip(long n);
    public static void main(String[] args) {List<String> list = new ArrayList<>();Collections.addAll(list,"Mary","Lucy","James","Johson","Steve");//skip()跳过list集合前2个元素,获取剩下的元素list.stream().skip(2).forEach(System.out::println);}

 备注:使用 skip() 和 limit() 方法,即可实现类似分页的操作了。示例如下:

    //一页10条 分页操作//第一页skip(0).limit(10)//第二页skip(10).limit(10)//第三页skip(20).limit(10)...

6.map

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

      map() 方法,可以将流中的元素映射到另一个流中。即:可以将一种类型的流转换为另一种类型的流(区别:map返回的是指定类型(比如int),而flatMap返回的还是一个Stream流),map() 方法是一个非终结方法。该接口需要一个 Function 函数式接口参数,可以将当前流中的T类型数据转换为另一种R类型的流。

       这个方法有三个对于原始类型的变种方法,分别是:mapToInt,mapToLong 和 mapToDouble。这三个方法也比较好理解,比如 mapToInt 就是把原始 Stream 转换成一个新的 Stream,这个新生成的 Stream 中的元素都是 int 类型。之所以会有这样三个变种方法,可以免除自动装箱/拆箱的额外消耗。(参考:本文 15 mapToInt/mapToLong/mapToDouble)

       因为 map() 方法是一个非终结方法,所以必须调用终止方法。通过如下示例,使用 map() 方法,通过方法引用,便将字符串类型转换成了 Integer 类型。示例如下:

    public static void main(String[] args) {List<String> list = new ArrayList<>();Collections.addAll(list, "11", "22", "33", "44", "55");//通过map()方法,可以将String类型的流转换为int类型的流/*list.stream().map((String str)->{return Integer.parseInt(str);}).forEach((Integer num) -> {System.out.println(num);});*///简化://list.stream().map(str->Integer.parseInt(str)).forEach(str->System.out.println(str));//简化后:list.stream().map(Integer::parseInt).forEach(System.out::println);}

 7.flatMap

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

flatMap 的使用,同 map 类似。map只是一维 1对1 的映射,返回的是指定的类型;

      而flatMap返回的则还是一个Stream流,可以对其进行进一步操作。(区别:map返回的是指定类型(比如int),而flatMap返回的还是一个Stream流)

      我的理解为:假如你的集合流中包含子集合(或者需要更深进一步操作),那么使用 flatMap 可以返回该子集合的集合流。示例代码如下所示:

public class Province {private String name;private List<String> city;//get/set 方法
}public class flatMapDemo{public static void main(String[] args) {List<Province> provinceList = new ArrayList<>();List<String> bjCityList = new ArrayList<>();bjCityList.add("海淀");bjCityList.add("朝阳");List<String> shCityList = new ArrayList<>();shCityList.add("黄埔");shCityList.add("闵行");Province bjProvince = new Province();bjProvince.setName("北京");bjProvince.setCity(bjCityList);provinceList.add(bjProvince);Province shProvince = new Province();shProvince.setName("上海");shProvince.setCity(shCityList);provinceList.add(shProvince);//使用map,需要多次forEachprovinceList.stream().map(str->str.getCity()).forEach(cityList -> cityList.forEach(System.out::println));System.out.println("----------");//使用 flatMapprovinceList.stream().flatMap(str->str.getCity().stream()).forEach(System.out::println);}
}

 测试结果:

8.sorted 

sorted() 方法,可以用来对 Stream 流中的数据进行排序。sorted()方法共有以上两种情况:

    //根据元素的自然规律排序Stream<T> sorted();//根据比较器指定的规则排序Stream<T> sorted(Comparator<? super T> comparator);

       因为 sorted() 方法是一个非终结方法,所以必须调用终止方法。

       场景:①sorted() 方法:按照自然规律,默认为升序排序。

                  ②sorted(Comparator comparator)  方法,按照指定的比较器规则排序(以降序为例)。 示例如下:

    public static void main(String[] args){//sorted():根据元素的自然规律排序Stream<Integer> stream01 = Stream.of(66,33,11,55);stream01 .sorted().forEach(System.out::println);System.out.println("   -----  ");//sorted(Comparator<? super T> comparator):根据比较器规则降序排序Stream<Integer> stream02 = Stream.of(66,33,11,55);stream02 .sorted((i1,i2)-> i2-i1).forEach(System.out::println);}

9.distinct 

distinct() 方法,可以用来去除重复数据。因为 distinct() 方法是一个非终结方法,所以必须调用终止方法。

       去除重复数据,此处有几种情况:①基本类型去重   ②String类型去重    ③引用类型去重(对象去重)

       ①②使用 distinct() 方法可以直接去重  ③对象类型需要重写 equals() 和 hasCode() 方法,使用 distinct() 方法才能去重成功。示例如下:

public static void main(String[] args){//基本类型去重Stream<Integer> stream01 = Stream.of(66,33,11,55,33,22,55,66);stream01 .distinct().forEach(System.out::println);//字符串去重Stream<String> stream02 = Stream.of("AA","BB","AA");stream02.distinct().forEach(System.out::println);//自定义对象去重//(Person对象类,有String name,Integer age 两个属性,两参数构造器,get/set()方法,重写了equals(),hashCode(),toString()方法。此处就不附Person实体类了)BiFunction<String,Integer,Person> fn1 = Person::new;Stream<Person> stream14 = Stream.of(fn1.apply("西施", 18), fn1.apply("貂蝉", 20), fn1.apply("王昭君", 22), fn1.apply("杨玉环", 23), fn1.apply("杨玉环", 23));stream14.distinct().forEach(System.out::println);}

 测试结果:

    6633115522----AABB----Person{name='西施', age=18}Person{name='貂蝉', age=20}Person{name='王昭君', age=22}Person{name='杨玉环', age=23}

10.match

//allMatch 全匹配(匹配所有,所有元素都需要满足条件-->返回true)
boolean allMatch(Predicate<? super T> predicate);
//anyMatch 匹配某个元素(只要有一个元素满足条件即可-->返回true)
boolean anyMatch(Predicate<? super T> predicate);
//noneMatch 匹配所有元素(所有元素都不满足指定条件-->返回true)
boolean noneMatch(Predicate<? super T> predicate);

       match() 方法,可以用来判断 Stream 流中的数据是否匹配指定的条件。allMatch()、anyMatch()、noneMatch() 方法都是终结方法,返回值为 bollean。示例如下:

    public static void main(String[] args){Stream<Integer> stream01 = Stream.of(5, 3, 6, 1);boolean allMatch = stream01.allMatch(i -> i > 0);System.out.println("allMatch匹配:"+allMatch);Stream<Integer> stream02 = Stream.of(5, 3, 6, 1);boolean anyMatch = stream02 .anyMatch(i -> i > 5);System.out.println("anyMatch匹配:"+anyMatch);Stream<Integer> stream03 = Stream.of(5, 3, 6, 1);boolean noneMatch = stream03 .noneMatch(i -> i < 3);System.out.println("noneMatch匹配:"+noneMatch);}

11.max / min 

    Optional<T> max(Comparator<? super T> comparator);Optional<T> min(Comparator<? super T> comparator);

       max() 和 min() 方法,用来获取 Stream 流中的最大值和最小值。该接口需要一个 Comparator 函数式接口参数,根据指定排序规则来获取最大值,最小值。

       为了保证数据的准确性,此处排序规则需要是升序排序。因为:max() 方法获取的是排序后的最后一个值,min() 方法获取的是排序后的第一个值。如果使用降序排序后,那么 max() 和 min() 方法就相反了,就有异常了。示例如下:

    public static void main(String[] args){//max()Stream<Integer> stream01 = Stream.of(33, 11, 22, 5);Optional<Integer> max = stream01.max((i1, i2) -> i1 - i2);System.out.println("最大值:"+max.get());//min()Stream<Integer> stream02 = Stream.of(33, 11, 22, 5);Optional<Integer> min = stream02.min((i1, i2) -> i1 - i2);System.out.println("最小值:"+min.get());}

测试结果:

12.reduce 

//1.
Optional<T> reduce(BinaryOperator<T> accumulator);
//2.
T reduce(T identity, BinaryOperator<T> accumulator);
//3.
<U> U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<U> combiner);

     如果需要将 Sream 流中的所有数据,归纳得到一个数据的情况,可以使用 reduce() 方法。如果需要对 Stream 流中的数据进行求和操作、求最大/最小值等(都是归纳为一个数据的情况),此处就可以用到 reduce() 方法。示例如下

    public static void main(String[] args){//reduce():求和操作Stream<Integer> stream01 = Stream.of(4,3,5,6);Integer sum = stream01.reduce(0,(x,y)-> x + y);System.out.println("求和:"+sum);//reduce():求最大值操作Stream<Integer> stream03 = Stream.of(4,3,5,6);Integer max= stream03.reduce(0,(x,y)-> x > y ? x : y);System.out.println("最大值为:"+max);//reduce():求最小值操作Stream<Integer> stream02 = Stream.of(4,3,5,6);Optional<Integer> max1= stream02.reduce((x, y)-> x < y ? x : y);System.out.println("最小值为:"+max1.get());}

 测试结果: 

 结果分析:(求和分析) 

  1. 求和流程:

  2. 第一次:将默认值赋值给x,取出集合第一个元素赋值给y

  3. 第二步:将上一次返回的结果赋值给x,取出集合第二个元素赋值给y

  4. 第三步:继续执行第二步(如下图所示)

13.map 和 reduce 方法组合使用 

    map() 和 reduce() 方法组合使用,可以解决很多日常工作中遇到的问题。我们就从如下场景了解:

       场景一:现在有一个 Person 类,有两个属性:name 和 age,新建四个 Person类,然后完成如下操作:① 求出所有年龄的总和   ②求出 Person 类中的最大年龄

    public static void main(String[] args){BiFunction<String,Integer,Person> fn2 = Person::new;//1.求出所有年龄的总和(年龄为int值,默认为0,此处可以使用待默认值的reduce()方法)Stream<Person> stream01 = Stream.of(fn2.apply("刘德华", 58), fn2.apply("张学友", 56), fn2.apply("郭富城", 54), fn2.apply("黎明", 52));//基本写法://Integer total = stream01.map(p -> p.getAge()).reduce(0,(x, y) -> x + y);//(方法引用)简化后:Integer total = stream01.map(p -> p.getAge()).reduce(0,Integer::sum);System.out.println("年龄总和为:"+total);//2.找出最大年龄Stream<Person> stream02 = Stream.of(fn2.apply("刘德华", 58), fn2.apply("张学友", 56), fn2.apply("郭富城", 54), fn2.apply("黎明", 52));//基本写法:        //Integer maxAge = stream02.map(p -> p.getAge()).reduce(0, (x, y) -> x > y ? x : y);//(方法引用)简化后:Integer maxAge = stream02.map(p -> p.getAge()).reduce(0, Integer::max);System.out.println("最大年龄为:"+maxAge);}

 测试结果 

    年龄总和为:220最大年龄为:58

 场景二:统计字符串 "a" 出现的次数

    public static void main(String[] args){Stream<String> stream03 = Stream.of("a", "b", "c", "d", "a", "c", "b", "a");//map() 和 reduce() 方法组合使用Integer aTotal = stream03.map(str -> {if (str == "a") {return 1;} else {return 0;}}).reduce(0, Integer::sum);System.out.println("a次数:"+aTotal);}

 14.mapToInt / mapToDouble / mapToLong

//mapToInt()
IntStream mapToInt(ToIntFunction<? super T> mapper);
//mapToLong()
LongStream mapToLong(ToLongFunction<? super T> mapper);
//mapToDouble()
DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);

  我们通过 Stream<Integer>  stream = Stream.of(1,2,3,4,5); 这种方式,返回值为 Stream<Integer> 这种包装类的泛型,这种方式虽然用起来没有问题,但是它在效率上还是存在着一定的问题。

       当我们将一对数字转成 Stream 流时,因为泛型的原因,只能使用 Integer 包装类。会先把这些数字包装成 Integer 类

//1.Integer是一个类,占用的内存肯定比 int 大
//2.Stream流在操作时,会存在自动装箱和拆箱操作
Stream<Integer> stream = Stream.of(2,3,5,6,7);//把大于3的打印出来(num在Stream流中是Integer类型,在与3比较时,显然会存在自动拆装箱问题),效率会有影响
stream.filter(num -> num > 3).forEach(System.out::println);

       所以在 JDK8 中,对 Stream 流还新增了一个 mapToInt()方法。该方法可以将流中操作的 Integer 包装类,在 Stream 流中转换成直接来操作 int 类型,效率明显会高一点。

示例如下:

    public static void main(String[] args){//使用 mapToInt()方法IntStream intStream = Stream.of(1, 2, 3, 4, 5, 6).mapToInt((Integer num) -> {return num.intValue();});//(使用方法引用)简化后IntStream intStream1 = Stream.of(1, 2, 3, 4, 5, 6).mapToInt(Integer::intValue);intStream1.filter(n->n>3).forEach(System.out::println);/*** 使用mapToInt(),返回值是一个IntStream类型.我们看一下它们的继承结构图(如下所示):* IntStream 和 Stream<Integer> 类型进行比较。发现他们都继承自 BaseStream。所以它们区别不大* 只不过 IntStream 内部操作的是 int 基本类型的数据,省去自动拆装箱过程。从而可以节省内存开销*/}

 继承结构图:

提示:

        mapToDouble() / mapToLong() 的使用,与 mapToInt()一致,此处不再介绍。

15.concat 

public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {Objects.requireNonNull(a);Objects.requireNonNull(b);@SuppressWarnings("unchecked")Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>((Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());return stream.onClose(Streams.composedClose(a, b));
}

 concat() 方法,可以将两个Stream流合并成一个流进行返回。如果是三个流,则需要两两合并,不能一次性合并三个流。concat() 方法是 Stream 接口的静态方法,我们可以直接使用类名.方法名】调用。

注意:concat() 方法此处接收的是 Stream 类型,不能接收 IntStream 等类型。concat() 是一个静态方法,与 java.lang.String 中的 concat() 方法是不同的。

    public static void main(String[] args){//concat()方法Stream<Integer> aStream = Stream.of(1, 2, 3);Stream<Integer> bStream = Stream.of(4, 5, 6);Stream<Integer> concatStream = Stream.concat(aStream, bStream);concatStream.forEach(System.out::println);}

 测试结果:

16.peek 

介绍:该方法会生成一个包含原 Stream 的所有元素的新 Stream,同时会提供一个消费函数(Consumer实例),新Stream每个元素被消费的时候都会执行给定的消费函数 

存在此方法的目的,主要是为了在您需要的地方支持调试,查看元素流过管道中特定点的情况

主要用于开发过程中调试使用!!!

    public static void main(String[] args){List<String> list = Stream.of("one", "two", "three", "four").filter(e -> e.length() > 3).peek(e -> System.out.println("大于三---" + e)).map(String::toUpperCase).peek(e -> System.out.println("转大写---" + e)).collect(Collectors.toList());}

 17.allMatch / anyMatch / noneMatch 匹配相关

这三个方法,均返回 boolean 类型 

allMatch:是不是Stream中的所有元素都满足给定的匹配条件
anyMatch:Stream中是否存在任何一个元素满足匹配条件
noneMatch:是不是Stream中的所有元素都不满足给定的匹配条件
    public static void main(String[] args) {
// Stream中元素,所有元素长度都>2boolean flag = Stream.of("one", "two", "three", "four").allMatch(str -> str.length() > 2);System.out.println(flag);     // 返回值:true// Stream中元素,是不是存在任何一个元素长度>4boolean flag1 = Stream.of("one", "two", "three", "four").anyMatch(str -> str.length() > 4);System.out.println(flag1);     // 返回值:true// Stream中元素,所有元素长度没有一个元素<1boolean flag2 = Stream.of("one", "two", "three", "four").noneMatch(str -> str.length() < 1);System.out.println(flag2);     // 返回值:true}

 

18.findFirst / findAny 

findFirst:返回Stream中的第一个元素,如果Stream为空,返回空Optional
findAny:返回的元素是不确定的,对于同一个列表多次调用findAny()有可能会返回不同的值。使用findAny()是为了更高效的性能。如果是数据较少,串行地情况下,一般会返回第一个结果,如果是并行的情况,那就不能确保是第一个
    public static void main(String[] args) {Optional<String> first = Stream.of("one", "two", "three", "four").findFirst();System.out.println(first.get());Optional<String> any = Stream.of("one", "two", "three", "four").findAny();System.out.println(any.get());Optional<String> any1 = Stream.of("one", "two", "three", "four").parallel().findAny();System.out.println(any1.get());}

 

 19.collect

collect() 方法的使用,也有很多内容学习,此处内容过多,不做一一列举。

       如需了解 Stream 流 collect() 方法的使用介绍,你可以看博主下一文章学习了解。请点击如下链接跳转:JDK8新特性(二):Stream流 collect() 方法的详细使用介绍

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

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

相关文章

《WebKit 技术内幕》学习之九(2): JavaScript引擎

2 V8引擎 2.1 基础 V8是一个开源项目&#xff0c;也是一个JavaScript引擎的实现。它最开始是由一些语言方面的专家设计出来的&#xff0c;后被Google收购&#xff0c;成为了JavaScript引擎和众多相关技术的引领者。其目的很简单&#xff0c;就是为了提高性能。因为在当时之前…

【学习】focal loss 损失函数

focal loss用于解决正负样本的不均衡情况 通常我们需要预测的正样本要少于负样本&#xff0c;正负样本分布不均衡会带来什么影响&#xff1f;主要是两个方面。 样本不均衡的话&#xff0c;训练是低效不充分的。因为困难的正样本数量较少&#xff0c;大部分时间都在学习没有用…

216. 组合总和 III - 力扣(LeetCode)

题目描述 找出所有相加之和为 n 的 k 个数的组合&#xff0c;且满足下列条件&#xff1a; 只使用数字1到9每个数字 最多使用一次 返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次&#xff0c;组合可以以任何顺序返回。 输入示例 k 3, n 7输出示例 [[1,2,…

深入理解Kubernetes探针和.NET服务健康检查机制

前言 随着越来越多的软件采用云原生和微服务架构&#xff0c;我们面临着更多的技术挑战&#xff0c;比如&#xff1a; Kubernetes如何在容器服务异常终止、死锁等情况下&#xff0c;发现并自动重启服务&#xff1b;当服务依赖的关键服务&#xff08;例如数据库&#xff0c;Red…

Dockerfile-xxxx

1、Dockerfile-server FROM openjdk:8-jdk-alpine WORKDIR /app COPY . . CMD java -Xms1536M -Xmx1536M -XX:UseG1GC -jar -Dlog4j2.formatMsgNoLookupstrue -Dloader.pathresources,lib -Duser.timezoneGMT-05 /app/server-main-1.0.0.jar 2、Dockerfile-bgd #FROM openjdk…

8. UE5 RPG创建UI(上)

UI是显示角色的一部分属性玩家可以直接查看的界面&#xff0c;通过直观的形式在屏幕上显示角色的各种信息。如何使用一种可扩展&#xff0c;可维护的形式来制作&#xff0c;这不得不说到耳熟能详的MVC架构。 MVC&#xff08;Model-View-Controller&#xff09;是一种常见的软件…

如何在Linux上部署Nexus私服

如何在Linux上部署Nexus私服 Nexus 是一个强大的仓库管理解决方案&#xff0c;由Sonatype公司开发。它主要用于软件开发中各种依赖包和构件的存储、管理和分发。 1、为什么要部署nexus&#xff1f; 统一管理依赖&#xff1a;在软件开发过程中&#xff0c;项目通常会依赖大量的…

[Linux 杂货铺] —— 权限(文件权限和目录配置)

目录 &#x1f308;前言 &#x1f4c1; 文件的属性 &#x1f4c1; 权限的概念 &#x1f4c2;拥有者和所属组&#xff08;角色&#xff09;&#xff1a; &#x1f4c2;用户&#xff08;具体的人&#xff09;&#xff1a; &#x1f4c1; 权限的管理 &#x1f4c2;1. chmod…

如何让亚马逊,速卖通,美客多店铺排名和流量稳定爬升

一、关键词优化 关键词是亚马逊店铺排名的关键。通过合理的关键词优化&#xff0c;可以提高店铺的曝光率。卖家需要研究消费者的搜索习惯和行为&#xff0c;了解他们使用哪些关键词进行搜索&#xff0c;然后将这些关键词用于商品描述、标题和元数据中。此外&#xff0c;还可以…

Linux - 安装字体库解决乱码问题

文章目录 问题描述步骤资源 问题描述 该安装方法&#xff0c;不区分中文和英文字体 Java在linux上转word文档为pdf&#xff0c; linux的字体缺失&#xff0c;导致了转出的pdf为乱码。 ● Linux将word转为pdf后出现乱码&#xff1f; ● 在linux上将word转为pdf 是乱码 ● 在lin…

第一篇【传奇开心果短博文系列】Python的库OpenCV技术点案例示例:cv2常用功能和方法

传奇开心果短博文系列 短博文系列目录Python的库OpenCV技术点案例示例系列 短博文目录一、前言二、常用功能和方法示例三、归纳总结 短博文系列目录 Python的库OpenCV技术点案例示例系列 短博文目录 一、前言 cv2是Python中常用的第三方库&#xff0c;也称为OpenCV库&#…

在全志H616核桃派上实现USB摄像头的OpenCV颜色检测

在给核桃派开发板用OpenCV读取图像并显示到pyqt5的窗口上并加入颜色检测功能&#xff0c;尝试将图像中所有蓝色的东西都用一个框标记出来。 颜色检测核心api 按照惯例&#xff0c;先要介绍一下opencv中常用的hsv像素格式。颜色还是那个颜色&#xff0c;只是描述颜色用的参数变…

【C语言编程之旅 7】刷题篇-函数

第1题 解析 A&#xff1a;错误&#xff0c;一个函数只能返回一个结果 B&#xff1a;正确&#xff0c;将形参存在数组中&#xff0c;修改数组中内容&#xff0c;可以通过数组将修改结果带出去 C&#xff1a;正确&#xff0c;形参如果用指针&#xff0c;最终指向的是外部的实参…

SpringBoot3.1.7集成Kafka和Kafka安装

一、背景 我们在很多系统开发都需要用到消息中间件&#xff0c;目前来说Kafka凭借其优秀的性能&#xff0c;使得它的使用率已经是名列前茅了&#xff0c;所以今天我们将它应用到我们的系统 二、版本选择 在使用一个中间件一定要考虑版本的兼容性&#xff0c;否则后面会遇到很…

[足式机器人]Part2 Dr. CAN学习笔记- 最优控制Optimal Control Ch07-3 线性二次型调节器(LQR)

本文仅供学习使用 本文参考&#xff1a; B站&#xff1a;DR_CAN Dr. CAN学习笔记 - 最优控制Optimal Control Ch07-3 线性二次型调节器&#xff08;LQR&#xff09; 1. 数学推导2. 案例反洗与代码详解 1. 数学推导 2. 案例反洗与代码详解

Go 的 Http 请求系统指南

文章目录 快速体验请求方法URL参数响应信息BodyStatusCodeHeaderEncoding 图片下载定制请求头复杂的POST请求表单提交提交文件 CookieClient 上设置 Cookie请求上设置 Cookie 重定向和请求历史超时设置总超时连接超时读取超时 请求代理错误处理总结 前几天在 “知乎想法” 谈到…

【力扣】记录一下竞赛分上 Knight

记录一下力扣上 Knight 力扣的题还是相对来说比较简单的&#xff0c;前两个月写的题多一点&#xff0c;后面几乎都是只做了每日一题&#xff0c;感觉正常来说刷个两三个月的题水平就差不多够了&#xff0c;甚至在我才刷半个月的时候就可以做三题了&#xff0c;排名和现在差不多…

自然语言处理的崛起:从初步分析到深度理解

自然语言处理&#xff08;NLP&#xff09;是计算机科学、人工智能和语言学的交叉领域&#xff0c;旨在让计算机能够理解和生成人类语言。随着时间的推移&#xff0c;NLP 经历了一系列革命性的变化&#xff0c;从简单的规则和模式匹配到如今的深度学习模型&#xff0c;它们使计算…

宝塔面板SRS音视频TRC服务器启动失败

首先&#xff0c;查找原因 1.先看srs服务在哪 find / -type f -name srs 2>/dev/null运行结果&#xff1a; /var/lib/docker/overlay2/5347867cc0ffed43f1ae24eba609637bfa3cc7cf5f8c660976d2286fa6a88d2b/diff/usr/local/srs/objs/srs /var/lib/docker/overlay2/5347867…

STL——vector模拟实现

在学习过程种 &#xff0c;学习看源码是很有必要的&#xff0c;它可以让你更清楚的知道一些代码的细节&#xff0c;你也会发现源码将效率利用到了极致&#xff0c;不得不佩服写出源码的人。 下面我将配合源码来实现一个简单的vector&#xff0c;下面请看源码 看源码我们首先要…