JDK8 Stream测试

如何创建一个流Stream，三种方法：测试

1、通过 java.util.Collection.stream()

2、通过数组来创建流

3、静态方法：使用Stream的静态方法：of()、iterate()、generate()

public class StreamJ {public static void main(String[] args){
//        getOfStream();getDusk();}public void anyMatch(){List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");boolean b = strings.stream().anyMatch(s -> s == "abc");System.out.println(b);}//创建一个空流public static void getDusk(){Stream<String> ao=Stream.empty();//创建无限流，通过limit提取指定大小//随机产生20个数字，是生成一个随机的int值,该值介于[0,n)的区间,也就是0到n之间的随机int值,包含0而不包含nStream.generate(()->"number"+new Random().nextInt()).limit(20).forEach(System.out::println);//创建20个StudentStream.generate(()->new Student("name",10)).limit(20).forEach(System.out::println);}//通过 java.util.Collection.stream() 方法用集合创建流public static void getStream(){List<String> sl= Arrays.asList("a","b","c","d");//创建一个顺序流Stream<String> sortD=sl.stream();//创建一个并行流Stream<String> parallelStream=sl.parallelStream();}//通过数组来创建流public static void getArrayStream(){int[] arr={1,2,3,4,5};IntStream inStream= Arrays.stream(arr);}//使用Stream的静态方法：of()、iterate()、generate()public static void getOfStream(){Stream<Integer> instream=Stream.of(1,2,3,4,5);//指定一个常量seed，生成从seed到常量f的流(1,2,3,4,5)Stream<Integer> insreamt=Stream.iterate(0,(a)->a+1).limit(6);insreamt.forEach(System.out::println);//一下俩种写法输出是一样的UnaryOperator.identity()是Java8的一元运算符，输入是什么，输出就是什么Stream.iterate(0,x->x).limit(10).forEach(System.out::println);Stream.iterate(0, UnaryOperator.identity()).limit(10).forEach(System.out::println);//下面是对循环的写法Stream.iterate(0,(a)->a+1).limit(6).forEach(a->{System.out.print(a +"\n");});Stream<Double> dStream=Stream.generate(Math::random).limit(5);dStream.forEach(System.out::println);//以上代码等同于DoubleStream intStream = DoubleStream.generate(()-> { return (int)(Math.random()); });intStream.limit(5).forEach(System.out::println);}static class Student{private String name;private int age;public Student(String name, int age) {this.name = name;this.age = age;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}}
}

以下几点需要注意：

lambda表达式的一种简写，这种简写的学名叫eta-conversion或者叫η-conversion把 x -> System.out.println(x) 简化为 System.out::println 的过程称之为 eta-conversion把 System.out::println 简化为 x -> System.out.println(x) 的过程称之为 eta-expansion范式:
类名::方法名
方法调用
person -> person.getAge();
可以替换成
Person::getAgex -> System.out.println(x)
可以替换成
System.out::println
out是一个PrintStream类的对象，println是该类的方法，依据x的类型来重载方法创建对象
() -> new ArrayList<>();
可以替换为
ArrayList::new
new关键字实际上调用的是ArrayList的构造方法

 

//描述：一元运算，接受一个T类型参数，输出一个与入参一模一样的值
System.out.println(UnaryOperator.identity().apply(10));     // 10
System.out.println(UnaryOperator.identity().apply(10.01));  // 10.01
System.out.println(UnaryOperator.identity().apply(false));  // false
System.out.println(UnaryOperator.identity().apply("10"));   // 10UnaryOperator<Integer> b = x->x.intValue();  // lambda表达式，这样就只能输入Integer类型了System.out.println(b.apply(10));

流多种形式：

//创建普通流
Stream<String> stream  = strs.stream();
//创建并行流
Stream<String> stream1 = strs.parallelStream();
//创建一个空的stream
Stream<Integer> stream  = Stream.empty();
//创建无限流，通过limit提取指定大小
Stream.generate(()->"number"+new Random().nextInt()).limit(100).forEach(System.out::println);
Stream.generate(()->new Student("name",10)).limit(20).forEach(System.out::println);Stream.iterate(0,x->x+1).limit(10).forEach(System.out::println);
Stream.iterate(0,x->x).limit(10).forEach(System.out::println);
//Stream.iterate(0,x->x).limit(10).forEach(System.out::println);与如下代码意思是一样的
Stream.iterate(0, UnaryOperator.identity()).limit(10).forEach(System.out::println);

基本数值型流： 

  1. IntStream
  2. LongStream
  3. DoubleStream

　　当然我们也可以用 Stream<Integer>、Stream<Long> >、Stream<Double>，但是 boxing 和 unboxing 会很耗时，所以特别为这三种基本数值型提供了对应的 Stream。

基本数值型流：

IntStream.of(new int[]{1, 2, 3}).forEach(System.out::println);
IntStream.range(1, 3).forEach(System.out::println);
IntStream.rangeClosed(1, 3).forEach(System.out::println);

流转换为其它数据结构 ：

// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();

常见操作分类：

当把一个数据结构包装成 Stream 后，就要开始对里面的元素进行各类操作了。常见的操作可以归类如下。注意：这些中间操作是惰性求值的，也就是说，只有在终止操作被调用时才开始执行。这种方式可以大大减少操作的开销，使得Stream的处理更加高效。

  • Intermediate（中间操作符）：

　　map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered

  • Terminal（最终操作符）：

　　forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

  • Short-circuiting（对符合条件的流元素进行最终操作）：

　　anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

 实例：

1）filter/**
* 功能描述:根据条件过滤集合数据
* @return : void
*/
@Test
public void filter(){
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
System.out.println(filtered);
}
2）distinct/**
* 功能描述:去除集合中重复数据
* @return : void
*/
@Test
public void distinct(){
List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
List<String> distincted = strings.stream().distinct().collect(Collectors.toList());
System.out.println(distincted);
}
3）limit/**
* 功能描述:指定获取集合前x条数据，重新构造一个新的集合
* @return : void
*/
@Test
public void limit(){
List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
List<String> limited = strings.stream().limit(3).collect(Collectors.toList());
System.out.println(limited);
}
4）skip/**
* 功能描述:排除集合前x条数据，把后面的数据重新构造一个新的集合
* @return : void
*/
@Test
public void skip(){
List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
List<String> skiped = strings.stream().skip(3).collect(Collectors.toList());
System.out.println(skiped);
}
5）map/**
* 功能描述:对集合中所有元素统一处理
* @return : void
*/
@Test
public void map(){
List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
List<String> mapped = strings.stream().map(str->str+"-itcast").collect(Collectors.toList());
System.out.println(mapped);
}
6）flatMap/**
* 功能描述:对集合中所有元素统一处理
* @return : void
*/
@Test
public void flatMap(){
List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
Stream<String> stringStream = strings.stream().map(x -> x);
Stream<String> stringStream1 = strings.stream().flatMap(x -> Arrays.asList(x.split(" ")).stream());
}
7）sorted/**
* 功能描述 : 对集合进行排序
* @return : void
*/
@Test
public void sorted(){
List<String> strings1 = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
List<String> strings2 = Arrays.asList("张三", "李四", "王五", "赵柳", "张哥","李哥", "王哥");
List<Integer> strings3 = Arrays.asList(10, 2, 30, 22, 1,0, -9);
List<String> sorted1 = strings1.stream().sorted().collect(Collectors.toList());
List<String> sorted2 = strings2.stream().sorted(Collections.reverseOrder(Collator.getInstance(Locale.CHINA))).collect(Collectors.toList());
List<Integer> sorted3 = strings3.stream().sorted().collect(Collectors.toList());
System.out.println(sorted1);
System.out.println(sorted2);
System.out.println(sorted3);
}

Map、flatMap区别

map：对流中每一个元素进行处理
flatMap：流扁平化，让你把一个流中的“每个值”都换成另一个流，然后把所有的流连接起来成为一个流
总结：map是对一级元素进行操作，flatmap是对二级元素操作。
本质区别：map返回一个值；flatmap返回一个流，多个值。

应用场景：map对集合中每个元素加工,返回加工后结果；flatmap对集合中每个元素加工后，做扁平化处理后（拆分层级，放到同一层）然后返回

/**
* 方法一
* 功能描述: 通过使用map、flatMap把字符串转换为字符输出对比区别
* @return : void
*/
@Test
public void flatMap2Map(){
List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
final Stream<Character> flatMap = strings.stream().flatMap(Java8StreamTest::getCharacterByString);
flatMap.forEach(System.out::println);
//----------------------------------------------
final Stream<Stream<Character>> mapStream = strings.stream().map(Java8StreamTest::getCharacterByString);
//mapStream.forEach(System.out::println);
System.out.println("------------------------------------------------");
mapStream.forEach(stream-> {stream.forEach(character->{System.out.println(character);});});}公共方法（字符串转换为字符流）/**
* 功能描述:字符串转换为字符流
* @param str
* @return : java.util.stream.Stream<java.lang.Character>
*/
public static Stream<Character> getCharacterByString(String str) {
List<Character> characterList = new ArrayList<>();
for (Character character : str.toCharArray()) {
characterList.add(character);
}
return characterList.stream();
}

 终止操作符：

1）anyMatch/**
* 功能描述 : 判断集合中是否至少存在一个元素满足条件
* @return : void
*/
@Test
public void anyMatch(){
List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
boolean b = strings.stream().anyMatch(s -> s == "abc");
System.out.println(b);
}
2）allMatch/**
* 功能描述 : 判断集合中是否所有元素都满足条件
* @return : void
*/
@Test
public void allMatch(){
List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
boolean b = strings.stream().allMatch(s -> s == "abc");
System.out.println(b);
}
3）noneMatch/**
* 功能描述 : 判断集合中是否所有元素都不满足条件
* @return : void
*/
@Test
public void noneMatch(){
List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
boolean b = strings.stream().noneMatch(s -> s == "abc");
System.out.println(b);
}
4）findAny/**
* 功能描述 : 返回当前流中任意元素
* @return : void
*/
@Test
public void findAny(){
List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
Optional<String> any = strings.stream().findAny();
if(any.isPresent()) out.println(any.get());
}
5）findFirst/**
* 功能描述 : 返回当前流中第一个元素
* @return : void
*/
@Test
public void findFirst(){
List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
Optional<String> first = strings.stream().findFirst();
if(first.isPresent()) System.out.println(first.get());
}
6）forEach java/**
* 功能描述 : 遍历流
* @return : void
*/
@Test
public void foreach(){
List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
strings.stream().forEach(s -> System.out.println(s));
}
7）collect/**
* 功能描述 : 流转换为其他形式
* @return : void
*/
@Test
public void collect(){
List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
Set<String> set = strings.stream().collect(Collectors.toSet());
List<String> list = strings.stream().collect(Collectors.toList());
Map<String, String> map = strings.stream().collect(Collectors.toMap(v ->v.concat("_name"), v1 -> v1, (v1, v2) -> v1));
System.out.println(set);
System.out.println(list);
System.out.println(map);
}
8）reduce/**
* 功能描述 : 将流中元素反复结合起来，得到一个值
* @return : void
*/
@Test
public void reduce(){
List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
//reduce方法一
Optional<String> reduce1 = strings.stream().reduce((acc,item) -> {return acc+item;});
//reduce方法二
String reduce2 = strings.stream().reduce("itcast", (acc, item) -> {
return acc + item;
});
//reduce方法三
ArrayList<String> reduce3 = strings.stream().reduce(
new ArrayList<String>(),
new BiFunction<ArrayList<String>, String, ArrayList<String>>() {
@Override
public ArrayList<String> apply(ArrayList<String> acc, String item) {
acc.add(item);
return acc;
}
},
new BinaryOperator<ArrayList<String>>() {
@Override
public ArrayList<String> apply(ArrayList<String> acc, ArrayList<String> item) {
return acc;
}
}
);
if(reduce1.isPresent())out.println(reduce1.get());
System.out.println(reduce2);
System.out.println(reduce3);
}9）count/**
* 功能描述 : 返回流中元素总数
* @return : void
*/
@Test
public void count(){
List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
long count = strings.stream().count();
System.out.println(count);
}

forEach

forEach 方法接收一个 Lambda 表达式，然后在 Stream 的每一个元素上执行该表达式。

// Java 8
roster.stream().filter(p -> p.getGender() == Person.Sex.MALE).forEach(p -> System.out.println(p.getName()));
// Pre-Java 8
for (Person p : roster) {if (p.getGender() == Person.Sex.MALE) {System.out.println(p.getName());}
}

map/flatMap

转换成大写字母：
List<String> output = wordList.stream().
map(String::toUpperCase).
collect(Collectors.toList());输出平方数：
List<Integer> nums = Arrays.asList(1, 2, 3, 4);
List<Integer> squareNums = nums.stream().
map(n -> n * n).
collect(Collectors.toList());flatMap一对多：
Stream<List<Integer>> inputStream = Stream.of(Arrays.asList(1),Arrays.asList(2, 3),Arrays.asList(4, 5, 6));
Stream<Integer> outputStream = inputStream.
flatMap((childList) -> childList.stream());

filter：

留下偶数：
Integer[] sixNums = {1, 2, 3, 4, 5, 6};
Integer[] evens =
Stream.of(sixNums).filter(n -> n%2 == 0).toArray(Integer[]::new);把单词挑出来：List<String> output = reader.lines().flatMap(line -> Stream.of(line.split(REGEXP))).filter(word -> word.length() > 0).collect(Collectors.toList());
peek：不是一个最终操作，不会影响“哪些元素会流过”，所以十分适合在调试的时候，用来打印出流经管道的元素。forEach 不能修改自己包含的本地变量值，也不能用 break/return 之类的关键字提前结束循环。
Stream.of("one", "two", "three", "four").filter(e -> e.length() > 3).peek(e -> System.out.println("Filtered value: " + e)).map(String::toUpperCase).peek(e -> System.out.println("Mapped value: " + e)).collect(Collectors.toList());

reduce：这个方法的主要作用是把 Stream 元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce

// 字符串连接，concat = "ABCD"
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat); 
// 求最小值，minValue = -3.0
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min); 
// 求和，sumValue = 10, 有起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
// 求和，sumValue = 10, 无起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
// 过滤，字符串连接，concat = "ace"
concat = Stream.of("a", "B", "c", "D", "e", "F").filter(x -> x.compareTo("Z") > 0).reduce("", String::concat);

sorted：对 Stream 的排序通过 sorted 进行，它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序，这能帮助程序明显缩短执行时间。

List<Person> persons = new ArrayList();for (int i = 1; i <= 5; i++) {Person person = new Person(i, "name" + i);persons.add(person);}
List<Person> personList2 = persons.stream().limit(2).sorted((p1, p2) -> p1.getName().compareTo(p2.getName())).collect(Collectors.toList());
System.out.println(personList2);

 min/max/distinct

找出字符最长的一行：
BufferedReader br = new BufferedReader(new FileReader("c:\\SUService.log"));
int longest = br.lines().mapToInt(String::length).max().getAsInt();
br.close();
System.out.println(longest);用distinct找出全文的单词，转小写，并排序：
List<String> words = br.lines().flatMap(line -> Stream.of(line.split(" "))).filter(word -> word.length() > 0).map(String::toLowerCase).distinct().sorted().collect(Collectors.toList());
br.close();
System.out.println(words);

limit和skip

这是一个有 10，000 个元素的 Stream，但在 short-circuiting 操作 limit 和 skip 的作用下，管道中 map 操作指定的 getName() 方法的执行次数为 limit 所限定的 10 次，而最终返回结果在跳过前 3 个元素后只有后面 7 个返回。
public void testLimitAndSkip() {List<Person> persons = new ArrayList();for (int i = 1; i <= 10000; i++) {Person person = new Person(i, "name" + i);persons.add(person);}
List<String> personList2 = persons.stream().
map(Person::getName).limit(10).skip(3).collect(Collectors.toList());System.out.println(personList2);
}
private class Person {public int no;private String name;public Person (int no, String name) {this.no = no;this.name = name;}public String getName() {System.out.println(name);return name;}
}

Stream 有三个 match 方法，从语义上说：

  • allMatch：Stream 中全部元素符合传入的 predicate，返回 true
  • anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true
  • noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

它们都不是要遍历全部元素才能返回结果。例如 allMatch 只要一个元素不满足条件，就 skip 剩下的所有元素，返回 false。对清单 13 中的 Person 类稍做修改，加入一个 age 属性和 getAge 方法。

List<Person> persons = new ArrayList();
persons.add(new Person(1, "name" + 1, 10));
persons.add(new Person(2, "name" + 2, 21));
persons.add(new Person(3, "name" + 3, 34));
persons.add(new Person(4, "name" + 4, 6));
persons.add(new Person(5, "name" + 5, 55));
boolean isAllAdult = persons.stream().allMatch(p -> p.getAge() > 18);
System.out.println("All are adult? " + isAllAdult);
boolean isThereAnyChild = persons.stream().anyMatch(p -> p.getAge() < 12);
System.out.println("Any child? " + isThereAnyChild);

 

Stream.generate

　　通过实现 Supplier 接口，你可以自己来控制流的生成。

Stream.generate(new PersonSupplier()).
limit(10).
forEach(p -> System.out.println(p.getName() + ", " + p.getAge()));
private class PersonSupplier implements Supplier<Person> {private int index = 0;private Random random = new Random();@Overridepublic Person get() {return new Person(index++, "StormTestUser" + index, random.nextInt(100));}
}

 Collectors 来进行分组操作：

groupingBy/partitioningBy

按照年龄进行分组：Map<Integer, List<Person>> personGroups = Stream.generate(new PersonSupplier()).limit(100).collect(Collectors.groupingBy(Person::getAge));
Iterator it = personGroups.entrySet().iterator();
while (it.hasNext()) {Map.Entry<Integer, List<Person>> persons = (Map.Entry) it.next();System.out.println("Age " + persons.getKey() + " = " + persons.getValue().size());
}按照未成年人和成年人归组：
Map<Boolean, List<Person>> children = Stream.generate(new PersonSupplier()).limit(100).collect(Collectors.partitioningBy(p -> p.getAge() < 18));
System.out.println("Children number: " + children.get(true).size());
System.out.println("Adult number: " + children.get(false).size());

 

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

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

相关文章

redis持久化与调优

redis持久化与调优

一 、Redis 高可用&#xff1a; 在web服务器中&#xff0c;高可用是指服务器可以正常访问的时间&#xff0c;衡量的标准是在多长时间内可以提供正常服务&#xff08;99.9%、99.99%、99.999%等等&#xff09;。但是在Redis语境中&#xff0c;高可用的含义似乎要宽泛一些&#x…
阅读更多...
POJ 2886 Who Gets the Most Candies? 树状数组+二分

POJ 2886 Who Gets the Most Candies? 树状数组+二分

一、题目大意 我们有N个孩子&#xff0c;每个人带着一张卡片&#xff0c;一起顺时针围成一个圈来玩游戏&#xff0c;第一回合时&#xff0c;第k个孩子被淘汰&#xff0c;然后他说出他卡片上的数字A&#xff0c;如果A是一个正数&#xff0c;那么下一个回合他左边的第A个孩子被淘…
阅读更多...
通过usb串口发送接收数据

通过usb串口发送接收数据

USB通信使用系统api&#xff0c;USB转串口通信使用第三方库usb-serial-for-android&#xff0c; 串口通信使用Google官方库android-serialport-api。x 引入包后在本地下载的位置&#xff1a;C:\Users\Administrator\.gradle\caches\modules-2\files-2.1 在 Android 中&#x…
阅读更多...
【python海洋专题十一】colormap调色

【python海洋专题十一】colormap调色

【python海洋专题十一】colormap调色 上期内容 本期内容 图像的函数包调用&#xff01; Part01. 自带颜色条Colormap 调用方法&#xff1a; cmap3plt.get_cmap(ocean)查询方法&#xff01; Part02. seaborn函数包 01&#xff1a;sns.cubehelix_palette cmap5 sns.cu…
阅读更多...
string类的模拟实现（万字讲解超详细）

string类的模拟实现（万字讲解超详细）

目录 前言 1.命名空间的使用 2.string的成员变量 3.构造函数 4.析构函数 5.拷贝构造 5.1 swap交换函数的实现 6.赋值运算符重载 7.迭代器部分 8.数据容量控制 8.1 size和capacity 8.2 empty 9.数据修改部分 9.1 push_back 9.2 append添加字符串 9.3 运算符重载…
阅读更多...
OpenCV利用Camshift实现目标追踪

OpenCV利用Camshift实现目标追踪

目录 原理 做法 代码实现 结果展示 原理 做法 代码实现 import numpy as np import cv2 as cv# 读取视频 cap cv.VideoCapture(video.mp4)# 检查视频是否成功打开 if not cap.isOpened():print("Error: Cannot open video file.")exit()# 获取第一帧图像&#x…
阅读更多...
SpringCloud Alibaba - Sentinel 微服务保护解决雪崩问题、Hystrix 区别、安装及使用

SpringCloud Alibaba - Sentinel 微服务保护解决雪崩问题、Hystrix 区别、安装及使用

目录 一、Sentinel 1.1、背景&#xff1a;雪崩问题 1.2、雪崩问题的解决办法 1.2.1、超时处理 缺陷&#xff1a;为什么这里只是 “缓解” 雪崩问题&#xff0c;而不是百分之百解决了雪问题呢&#xff1f; 1.2.2、舱壁模式 缺陷&#xff1a;资源浪费 1.2.3、熔断降级 1.…
阅读更多...
OK3568 forlinx系统编译过程及问题汇总

OK3568 forlinx系统编译过程及问题汇总

1. 共享文件夹无法加载&#xff1b;通过网上把文件夹加载后&#xff0c;拷贝文件很慢&#xff0c;任务管理器查看发现硬盘读写速率很低。解决办法&#xff1a;重新安装vmware tools。 2. 拷贝Linux源码到虚拟机&#xff0c;解压。 3. 虚拟机基本库安装 forlinxubuntu:~$ sudo…
阅读更多...
『力扣每日一题12』：只出现一次的数字

『力扣每日一题12』：只出现一次的数字

一、题目 给你一个 非空 整数数组 nums &#xff0c;除了某个元素只出现一次以外&#xff0c;其余每个元素均出现两次。找出那个只出现了一次的元素。 你必须设计并实现线性时间复杂度的算法来解决此问题&#xff0c;且该算法只使用常量额外空间。 示例 1 &#xff1a; 输入&…
阅读更多...
WVP-28181协议视频平台搭建教程

WVP-28181协议视频平台搭建教程

28181协议视频平台搭建教程 安装mysql安装redis安装ZLMediaKit安装28181协议视频平台安装依赖下载源码编译静态页面打包项目, 生成可执行jar修改配置文件启动WVP 项目地址&#xff1a; https://github.com/648540858/wvp-GB28181-pro 说明: wvp-GB28181-pro 依赖redis和mysql中…
阅读更多...
案例题--信息系统架构设计

案例题--信息系统架构设计

案例题--信息系统架构设计 概念 以扩展了解为主&#xff0c;主要关注图 概念 架构的组成&#xff1a;构件&#xff0c;连接件&#xff0c;约束 构件&#xff1a;组成元素 连接件&#xff1a;构件之间的连接方式 约束&#xff1a;构件和连接件之间的约束 上应&#xff0c;下技&a…
阅读更多...
Linux CentOS7 vim多窗口编辑

Linux CentOS7 vim多窗口编辑

我们在用vim编辑文件时&#xff0c;有各种需求。如有时需要在多个文件之间来回操作&#xff0c;一会关闭一个文件&#xff0c;一会再打开另外一个文件&#xff0c;这样来回操作显得太笨拙。有时&#xff0c;vim编辑多行的大文件&#xff0c;来回查看、编辑前面一部分及最后一部…
阅读更多...
【Axure】元件库和母版、常见的原型规范、静态原型页面制作

【Axure】元件库和母版、常见的原型规范、静态原型页面制作

添加现有元件库 点击元件库——载入 当然也可以创建元件库&#xff0c;自己画自己保存 建立京东秒杀母版 静态原型页面的制作 框架 选择以iphone8的界面大小为例&#xff0c;顶部状态栏高度为20 左侧类似于标尺&#xff0c;因为图标、文字离最左侧的间距是不一样的 信…
阅读更多...
基于Kylin的数据统计分析平台架构设计与实现

基于Kylin的数据统计分析平台架构设计与实现

目录 1 前言 2 关键模块 2.1 数据仓库的搭建 2.2 ETL 2.3 Kylin数据分析系统 2.4 数据可视化系统 2.5 报表模块 3 最终成果 4 遇到问题 1 前言 这是在TP-LINK公司云平台部门做的一个项目&#xff0c;总体包括云上数据统计平台的架构设计和组件开发&#xff0c;在此只做…
阅读更多...
深入了解 Linux 中的 AWK 命令：文本处理的瑞士军刀

深入了解 Linux 中的 AWK 命令：文本处理的瑞士军刀

简介 在Linux和Unix操作系统中&#xff0c;文本处理是一个常见的任务。AWK命令是一个强大的文本处理工具&#xff0c;专门进行文本截取和分析&#xff0c;它允许你在文本文件中查找、过滤、处理和格式化数据。本文将深入介绍Linux中的AWK命令&#xff0c;让你了解其基本用法和…
阅读更多...
Linux-Centos中配置docker

Linux-Centos中配置docker

1.安装yum工具 yum install -y yum-utils 2.配置yam源头 yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo 3.安装docker yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin 4. 查看d…
阅读更多...
ElasticSearch第四讲：ES详解：ElasticSearch和Kibana安装

ElasticSearch第四讲：ES详解：ElasticSearch和Kibana安装

ElasticSearch第四讲&#xff1a;ES详解&#xff1a;ElasticSearch和Kibana安装 本文是ElasticSearch第四讲&#xff1a;ElasticSearch和Kibana安装&#xff0c;主要介绍ElasticSearch和Kibana的安装。了解完ElasticSearch基础和Elastic Stack生态后&#xff0c;我们便可以开始…
阅读更多...
数据库的备份与恢复

数据库的备份与恢复

数据备份的重要性 备份的主要目的是灾难恢复。 在生产环境中&#xff0c;数据的安全性至关重要。 任何数据的丢失都可能产生严重的后果。 造成数据丢失的原因&#xff1a; 程序错误人为操作错误运算错误磁盘故障灾难&#xff08;如火灾、地震&#xff09;和盗窃 数据库备份…
阅读更多...
XC5013 马达驱动和充电集成一体的控制芯片 一档输出芯片

XC5013 马达驱动和充电集成一体的控制芯片 一档输出芯片

XC5013 是一款应用于马达驱动或 LED 驱动的控制芯片&#xff0c;集成了锂电池充电管理系统&#xff0c;设定一档高电平输 出&#xff0c;并带有对不同状态的 LED 指示功能。 XC5013 集成了涓流充电、恒流充电和恒压充电全过程的充电方式&#xff0c;浮充电压精度在全温度范…
阅读更多...
了解基于Elasticsearch 的站内搜索，及其替代方案

了解基于Elasticsearch 的站内搜索，及其替代方案

对于一家公司而言&#xff0c;数据量越来越多&#xff0c;如果快速去查找这些信息是一个很难的问题&#xff0c;在计算机领域有一个专门的领域IR&#xff08;Information Retrival&#xff09;研究如何获取信息&#xff0c;做信息检索。在国内的如百度这样的搜索引擎也属于这个…
阅读更多...
最新文章

Copyright @ 2022~2023