网站优化都是怎么做的/好的推广平台

网站优化都是怎么做的,好的推广平台,自己做的网站怎么发布win7,中山手机网站建设lambda与stream是java8中比较重要两个新特性，lambda表达式采用一种简洁的语法定义代码块，允许我们将行为传递到函数中。之前我们想将行为传递到函数中，仅有的选择是使用匿名内部类，现在我们可以使用lambda表达式替代匿名内部类。在…

lambda与stream是java8中比较重要两个新特性，lambda表达式采用一种简洁的语法定义代码块，允许我们将行为传递到函数中。之前我们想将行为传递到函数中，仅有的选择是使用匿名内部类，现在我们可以使用lambda表达式替代匿名内部类。在学习lambda表达式之前，建议各位看官先去学习一下匿名内部类（JAVA基础知识|内部类）。

stream提供了很多有用的api，方便了我们对集合的操作

一、lambda表达式

基本语法:
(parameters) -> expression
或
(parameters) ->{ statements; }

 

lambda表达式的重要特征:

  • 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
  • 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
  • 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
  • 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

 以下是一些简单的例子，便于我们理解这些特性：

        // 1. 不需要参数,返回值为5() -> 5// 2. 接收一个参数,()可以省略,返回其2倍的值x -> 2 * x// 3. 接受2个参数(数字),并返回他们的差值(x, y) ->x –y// 4. 接收2个int型整数,返回他们的和( int x, int y) ->x + y// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)(String s) ->System.out.print(s)

二、lambda表达式使用

2.1、在for循环中使用

package com.my.controller;import junit.framework.TestCase;
import org.junit.Test;import java.util.ArrayList;
import java.util.List;/*** description:{description}* author:jyy* date:2018-01-09 16:43* modify:{modify}*/
public class AppTest extends TestCase {@Testpublic void test() {List<String> list = new ArrayList<>();list.add("北京");list.add("上海");list.add("广州");list.add("深圳");for (String str : list) {System.out.println(str);}System.out.println("=================");list.forEach(str -> System.out.println(str));}}

执行结果：

北京
上海
广州
深圳
=================
北京
上海
广州
深圳

2.2、替代匿名内部类使用

我们使用JAVA基础知识|内部类中的try catch示例

package com.my.controller;import junit.framework.TestCase;
import org.junit.Test;import java.util.ArrayList;
import java.util.List;/*** description:{description}* author:jyy* date:2018-01-09 16:43* modify:{modify}*/
public class AppTest extends TestCase {@Testpublic void test() {//匿名内部类new ExceptionTemplate().execute(new CatchExceptionable() {@Overridepublic void catchException() {System.out.println("代码");}});//lambda表达式new ExceptionTemplate().execute(() -> System.out.println("代码"));}}

2.3、lambda表达式与Comparator类结合使用

package com.my.controller;import junit.framework.TestCase;
import org.junit.Test;import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;/*** description:{description}* author:jyy* date:2018-01-09 16:43* modify:{modify}*/
public class AppTest extends TestCase {@Testpublic void test() {List<String> list = new ArrayList<>();list.add("BeiJing");list.add("ShangHai");list.add("GuangZhou");list.add("ShenZhen");list.sort(new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {return o1.compareTo(o2);}});list.forEach(str -> System.out.println(str));System.out.println("==============");List<String> list2 = new ArrayList<>();list2.add("BeiJing");list2.add("ShangHai");list2.add("GuangZhou");list2.add("ShenZhen");//list2.sort((String o1,String o2) -> o1.compareTo(o2));Comparator<String> comparator =(String o1,String o2) -> o1.compareTo(o2);list2.sort(comparator);list2.forEach(str -> System.out.println(str));}
}

执行结果：

BeiJing
GuangZhou
ShangHai
ShenZhen
==============
BeiJing
GuangZhou
ShangHai
ShenZhen

 三、流stream

Java 8 中的stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。stream API 借助于同样新出现的 lambda 表达式，极大的提高编程效率和程序可读性。同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势

生成流的两种方式：

  • stream() − 为集合创建串行流。
  • parallelStream() − 为集合创建并行流。

下面我们就来使用stream提供的各种API：

3.1、筛选和切片

方法描述
filter从流中过滤元素
distinct通过流所生成的元素的hashCode()和equals()方法去重
limit截断流，选取前n个元素
skip跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足n个，则返回一个空流

 

package com.my.po;/*** description:{description}* author:jyy* date:2018-02-11 11:06* modify:{modify}*/
public class Employee {private String id;private String name;private double salary;private String sex;public Employee(String id, String name, double salary,String sex) {this.id = id;this.name = name;this.salary = salary;this.sex=sex;}public String getId() {return id;}public void setId(String 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 String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}@Overridepublic String toString() {return "Employee{" +"id='" + id + '\'' +", name='" + name + '\'' +", salary=" + salary +", sex='" + sex + '\'' +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Employee employee = (Employee) o;return id.equals(employee.id);}@Overridepublic int hashCode() {return id.hashCode();}
}
View Code
package com.my.controller;import com.my.po.Employee;
import junit.framework.TestCase;
import org.junit.Test;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;/*** description:{description}* author:jyy* date:2018-01-09 16:43* modify:{modify}*/
public class AppTest extends TestCase {@Testpublic void test() {Employee[] employees = {new Employee("1001", "李明", 5000, "male"),new Employee("1002", "王明", 7000, "male"),new Employee("1003", "张丽", 10000, "female"),new Employee("1004", "谢楠", 11000, "female"),new Employee("1004", "谢楠", 11000, "female")};List<Employee> list = Arrays.asList(employees);//forEach,查询所有数据list.stream().forEach(e -> System.out.println(e.toString()));//filter,查询集合中所有的女性list.stream().filter(e -> Objects.equals(e.getSex(), "female")).forEach(e -> System.out.println(e.toString()));//查询集合中薪资大于6000的雇员list.stream().filter(e -> e.getSalary() > 7000).forEach(e -> System.out.println(e));//limit,查询前两条数据list.stream().limit(2).forEach(e -> System.out.println(e.toString()));//distinct,去重,利用Employee对象中的hashCode()和equals()方法list.stream().distinct().forEach(e -> System.out.println(e));//skip,跳过前两个list.stream().skip(2).forEach(e -> System.out.println(e));}
}
View Code

3.2、映射

方法描述
 map(Function f) 接受一个函数作为参数，并将函数应用到每一个元素上，返回新的元素
 mapToDouble(ToDoubleFunction f) 返回的新元素为double类型
 mapToInt(ToIntFunction f) 返回的新元素为int类型
 mapToLong(ToLongFunction f) 返回的新元素为long类型
 flatMap(Function f) 操作多层嵌套的流，使其扁平化

 3.2.1、map

        Employee[] employees = {new Employee("1001", "李明", 5000, "male"),new Employee("1002", "王明", 7000, "male"),new Employee("1003", "张丽", 10000, "female"),new Employee("1004", "谢楠", 11000, "female"),new Employee("1004", "谢楠", 11000, "female")};List<Employee> list = Arrays.asList(employees);//maplist.stream().map(e -> e.getSalary()).forEach(e -> System.out.println(e));

执行结果：

5000.0
7000.0
10000.0
11000.0
11000.0

可以看出，集合list经过map操作之后，类型已经改变。具体什么类型，由返回值决定

3.2.2、mapToDouble、mapToInt、mapToLong

        Employee[] employees = {new Employee("1001", "李明", 5000, "male"),new Employee("1002", "王明", 7000, "male"),new Employee("1003", "张丽", 10000, "female"),new Employee("1004", "谢楠", 11000, "female"),new Employee("1004", "谢楠", 11000, "female")};List<Employee> list = Arrays.asList(employees);list.stream().mapToDouble(e -> e.getSalary()).forEach(e -> System.out.println(e));

执行结果：

5000.0
7000.0
10000.0
11000.0
11000.0

3.2.3、flatMap

        Employee[] employees1 = {new Employee("1001", "李明", 5000, "male"),new Employee("1002", "王明", 7000, "male"),new Employee("1003", "张丽", 10000, "female"),new Employee("1004", "谢楠", 11000, "female")};Employee[] employees2 = {new Employee("1005", "Marry", 5000, "male"),new Employee("1006", "Linda", 7000, "male"),new Employee("1007", "Cris", 10000, "female")};List<Employee[]> list = new ArrayList<>();list.add(employees1);list.add(employees2);list.stream().flatMap(e -> Arrays.stream(e)).forEach(e -> System.out.println(e.toString()));

执行结果：

Employee{id='1001', name='李明', salary=5000.0, sex='male'}
Employee{id='1002', name='王明', salary=7000.0, sex='male'}
Employee{id='1003', name='张丽', salary=10000.0, sex='female'}
Employee{id='1004', name='谢楠', salary=11000.0, sex='female'}
Employee{id='1005', name='Marry', salary=5000.0, sex='male'}
Employee{id='1006', name='Linda', salary=7000.0, sex='male'}
Employee{id='1007', name='Cris', salary=10000.0, sex='female'}

 3.3、排序

方法描述
sorted()产生一个新流，其中按自然顺序排序
sorted(Comparator comp)产生一个新流，其中按比较器顺序排序
        Employee[] employees = {new Employee("1001", "李明", 5000, "male"),new Employee("1002", "王明", 7000, "male"),new Employee("1003", "张丽", 10000, "female"),new Employee("1005", "Marry", 6000, "male"),new Employee("1006", "Linda", 9000, "male"),new Employee("1007", "Cris", 10000, "female"),new Employee("1004", "谢楠", 11000, "female")};List<Employee> list = Arrays.asList(employees);list.stream().map(e -> e.getSalary()).sorted().forEach(e -> System.out.println(e.toString()));System.out.println("=======");Comparator<String> comparator = (String o1, String o2) -> o1.compareTo(o2);list.stream().map(e -> e.getId()).sorted(comparator).forEach(e -> System.out.println(e.toString()));

执行结果：

5000.0
6000.0
7000.0
9000.0
10000.0
10000.0
11000.0
=======
1001
1002
1003
1004
1005
1006
1007

3.4、查找与匹配

方法描述
allMatch(Predicate p)检查是否匹配所有元素
anyMatch(Predicate p)检查是否至少匹配一个元素
noneMatch(Predicate p)检查是否没有匹配所有元素
findFirst()返回第一个元素
findAny()返回当前流中的任意元素
count()返回流中元素总数
max(Comparator c)返回流中最大值
min(Comparator c)返回流中最小值
forEach(Consumer c)内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)
        Employee[] employees = {new Employee("1001", "李明", 5000, "male"),new Employee("1002", "王明", 7000, "male"),new Employee("1003", "张丽", 10000, "female"),new Employee("1005", "Marry", 6000, "male"),new Employee("1006", "Linda", 9000, "male"),new Employee("1007", "Cris", 10000, "female"),new Employee("1004", "谢楠", 11000, "female")};List<Employee> list = Arrays.asList(employees);System.out.println("===allMatch===");Boolean b1 = list.stream().allMatch(e -> e.getSalary() > 4000);Boolean b2 = list.stream().allMatch(e -> e.getSalary() > 5000);System.out.println(b1);System.out.println(b2);System.out.println("===anyMatch===");Boolean b3 = list.stream().anyMatch(e -> e.getSalary() > 10000);Boolean b4 = list.stream().anyMatch(e -> e.getSalary() > 11000);System.out.println(b3);System.out.println(b4);System.out.println("===noneMatch===");Boolean b5 = list.stream().noneMatch(e -> e.getSalary() > 10000);Boolean b6 = list.stream().noneMatch(e -> e.getSalary() > 11000);System.out.println(b5);System.out.println(b6);System.out.println("===findFirst===");System.out.println(list.stream().findFirst().toString());System.out.println("===findAny===");System.out.println(list.stream().findAny().toString());System.out.println("===count===");System.out.println(list.stream().count());System.out.println("===max===");System.out.println(list.stream().max((Employee o1, Employee o2) -> {if (o1.getSalary() > o2.getSalary()) return 1;else return -1;}).toString());System.out.println("===min===");System.out.println(list.stream().min((Employee o1, Employee o2) -> {if (o1.getSalary() > o2.getSalary()) return 1;else return -1;}).toString());

执行结果：

===allMatch===
true
false
===anyMatch===
true
false
===noneMatch===
false
true
===findFirst===
Optional[Employee{id='1001', name='李明', salary=5000.0, sex='male'}]
===findAny===
Optional[Employee{id='1001', name='李明', salary=5000.0, sex='male'}]
===count===
7
===max===
Optional[Employee{id='1004', name='谢楠', salary=11000.0, sex='female'}]
===min===
Optional[Employee{id='1001', name='李明', salary=5000.0, sex='male'}]

 3.5、归约

map-reduce模式，在mongoDB、spark、hadoop等都有它的身影，因google使用它进行网络搜索而出名

方法描述
reduce(T iden, BinaryOperator b)可以将流中元素反复结合起来，得到一个值。返回T
reduce(BinaryOperator b)可以将流中元素反复结合起来，得到一个值。返回Optional<T>
        Employee[] employees = {new Employee("1001", "李明", 5000, "male"),new Employee("1002", "王明", 7000, "male"),new Employee("1003", "张丽", 10000, "female"),new Employee("1005", "Marry", 6000, "male"),new Employee("1006", "Linda", 9000, "male"),new Employee("1007", "Cris", 10000, "female"),new Employee("1004", "谢楠", 11000, "female")};List<Employee> list = Arrays.asList(employees);String result1 = list.stream().map(e -> e.getName()).reduce("", (x, y) -> x + "," + y);System.out.println(result1.substring(1));Optional<String> result2 = list.stream().map(e -> e.getName()).reduce((x, y) -> x + "," + y);System.out.println(result2.get());

执行结果：

李明,王明,张丽,Marry,Linda,Cris,谢楠
李明,王明,张丽,Marry,Linda,Cris,谢楠

3.6、收集

方法描述
collect(Collector c)将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
        Employee[] employees = {new Employee("1001", "李明", 5000, "male"),new Employee("1002", "王明", 7000, "male"),new Employee("1003", "张丽", 10000, "female"),new Employee("1005", "Marry", 6000, "male"),new Employee("1006", "Linda", 9000, "male"),new Employee("1007", "Cris", 10000, "female"),new Employee("1004", "谢楠", 11000, "female")};List<Employee> list = Arrays.asList(employees);List<String> collect = list.stream().map(e -> e.getName()).collect(Collectors.toList());collect.forEach(System.out::println);System.out.println("-------------------");Set<String> set = list.stream().map(e -> e.getName()).collect(Collectors.toSet());set.forEach(System.out::println);System.out.println("-------------------");HashSet<String> hashSet = list.stream().map(e -> e.getName()).collect(Collectors.toCollection(HashSet::new));hashSet.forEach(System.out::println);System.out.println("-------------------");//分组Map<Double, List<Employee>> group = list.stream().collect(Collectors.groupingBy(e -> e.getSalary()));System.out.println(group);

执行结果：

李明
王明
张丽
Marry
Linda
Cris
谢楠
-------------------
张丽
Cris
李明
王明
Linda
Marry
谢楠
-------------------
张丽
Cris
李明
王明
Linda
Marry
谢楠
{9000.0=[Employee{id='1006', name='Linda', salary=9000.0, sex='male'}], 10000.0=[Employee{id='1003', name='张丽', salary=10000.0, sex='female'}, Employee{id='1007', name='Cris', salary=10000.0, sex='female'}], 5000.0=[Employee{id='1001', name='李明', salary=5000.0, sex='male'}], 11000.0=[Employee{id='1004', name='谢楠', salary=11000.0, sex='female'}], 6000.0=[Employee{id='1005', name='Marry', salary=6000.0, sex='male'}], 7000.0=[Employee{id='1002', name='王明', salary=7000.0, sex='male'}]}

以上内容只是对lambda表达式和stream的简单介绍，在实际使用中要复杂的多

 

转载于:https://www.cnblogs.com/maikucha/p/8435906.html

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

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

相关文章

数据库:存储过程_数据科学过程：摘要

数据库:存储过程_数据科学过程：摘要

数据库:存储过程Once you begin studying data science, you will hear something called ‘data science process’. This expression refers to a five stage process that usually data scientists perform when working on a project. In this post I will walk through ea…
阅读更多...
svm和k-最近邻_使用K最近邻的电影推荐和评级预测

svm和k-最近邻_使用K最近邻的电影推荐和评级预测

svm和k-最近邻Recommendation systems are becoming increasingly important in today’s hectic world. People are always in the lookout for products/services that are best suited for them. Therefore, the recommendation systems are important as they help them ma…
阅读更多...
Oracle：时间字段模糊查询

Oracle：时间字段模糊查询

需要查询某一天的数据&#xff0c;但是库里面存的是下图date类型 将Oracle中时间字段转化成字符串&#xff0c;然后进行字符串模糊查询 select * from CAINIAO_MONITOR_MSG t WHERE to_char(t.CREATE_TIME,yyyy-MM-dd) like 2019-09-12 转载于:https://www.cnblogs.com/gcgc/p/…
阅读更多...
cnn对网络数据预处理_CNN中的数据预处理和网络构建

cnn对网络数据预处理_CNN中的数据预处理和网络构建

cnn对网络数据预处理In this article, we will go through the end-to-end pipeline of training convolution neural networks, i.e. organizing the data into directories, preprocessing, data augmentation, model building, etc.在本文中&#xff0c;我们将遍历训练卷积神…
阅读更多...
leetcode 554. 砖墙

leetcode 554. 砖墙

你的面前有一堵矩形的、由 n 行砖块组成的砖墙。这些砖块高度相同&#xff08;也就是一个单位高&#xff09;但是宽度不同。每一行砖块的宽度之和应该相等。 你现在要画一条 自顶向下 的、穿过 最少 砖块的垂线。如果你画的线只是从砖块的边缘经过&#xff0c;就不算穿过这块砖…
阅读更多...
递归 和 迭代 斐波那契数列

递归 和 迭代 斐波那契数列

#include "stdio.h"int Fbi(int i) /* 斐波那契的递归函数 */ { if( i < 2 ) return i 0 ? 0 : 1; return Fbi(i - 1) Fbi(i - 2); /* 这里Fbi就是函数自己&#xff0c;等于在调用自己 */ }int main() { int i; int a[40]; printf("迭代显示斐波那契数列…
阅读更多...
飞行模式的开启和关闭

飞行模式的开启和关闭

2019独角兽企业重金招聘Python工程师标准>>> if(Settings.System.getString(getActivity().getContentResolver(),Settings.Global.AIRPLANE_MODE_ON).equals("0")) { Settings.System.putInt(getActivity().getContentResolver(),Settings.Global.AIRPLA…
阅读更多...
消解原理推理_什么是推理统计中的Z检验及其工作原理？

消解原理推理_什么是推理统计中的Z检验及其工作原理？

消解原理推理I Feel:我觉得&#xff1a; The more you analyze the data the more enlightened, data engineer you will become.您对数据的分析越多&#xff0c;您将变得越发开明。 In data engineering, you will always find an instance where you need to establish whet…
阅读更多...
pytest+allure测试框架搭建

pytest+allure测试框架搭建

https://blog.csdn.net/wust_lh/article/details/86685912 https://www.jianshu.com/p/9673b2aeb0d3 定制化展示数据 https://blog.csdn.net/qw943571775/article/details/99634577 环境说明&#xff1a; jdk 1.8 python 3.5.3 allure-commandline 2.13.0 文档及下载地址&…
阅读更多...
大学生信息安全_给大学生的信息

大学生信息安全_给大学生的信息

大学生信息安全You’re an undergraduate. Either you’re graduating soon (like me) or you’re in the process of getting your first college degree. The process is not easy and I can only assume how difficult the pressures on Masters and Ph.D. students are. Ho…
阅读更多...
特斯拉最安全的车_特斯拉现在是最受欢迎的租车选择

特斯拉最安全的车_特斯拉现在是最受欢迎的租车选择

特斯拉最安全的车Have you been curious to know which cars are most popular in US and what are their typical rental fares in various cities? As the head of Product and Data Science at an emerging technology start-up, Ving Rides, these were some of the quest…
阅读更多...
WebSocket入门

WebSocket入门

WebSocket前言　　WebSocket是HTML5的重要特性&#xff0c;它实现了基于浏览器的远程socket&#xff0c;它使浏览器和服务器可以进行全双工通信&#xff0c;许多浏览器&#xff08;Firefox、Google Chrome和Safari&#xff09;都已对此做了支持。 在WebSocket出现之前&#xff…
阅读更多...
ml dl el学习_DeepChem —在生命科学和化学信息学中使用ML和DL的框架

ml dl el学习_DeepChem —在生命科学和化学信息学中使用ML和DL的框架

ml dl el学习Application of Machine Learning and Deep Learning for Drug Discovery, Genomics, Microsocopy and Quantum Chemistry can create radical impact and holds the potential to significantly accelerate the process of medical research and vaccine developm…
阅读更多...
2017-2018-1 20179215《Linux内核原理与分析》第二周作业

2017-2018-1 20179215《Linux内核原理与分析》第二周作业

20179215《Linux内核原理与分析》第二周作业 这一周主要了解了计算机是如何工作的&#xff0c;包括现在存储程序计算机的工作模型、X86汇编指令包括几种内存地址的寻址方式和push、pop、call、re等几个重要的汇编指令。主要分为两部分进行这周的学习总结。第一部分对学习内容进…
阅读更多...
Gradle复制文件/目录方法

Gradle复制文件/目录方法

2019独角兽企业重金招聘Python工程师标准>>> gradle复制文件/文件夹方法 复制文件 //复制IDE生成的classes.jar文件到build/libs中&#xff0c;并改名为FileUtils.jar. task copyFile(type:Copy) {delete build/libs/FileUtils.jarfrom(build/intermediates/bundles…
阅读更多...
用户参与度与活跃度的区别_用户参与度突然下降

用户参与度与活跃度的区别_用户参与度突然下降

用户参与度与活跃度的区别disclaimer: I don’t work for Yammer, this is a public data case study, I’ve written it in a narrative format to make this case study more engaging to read.免责声明&#xff1a;我不为Yammer工作&#xff0c;这是一个公共数据案例研究&am…
阅读更多...
重学TCP协议（6） 四次挥手

重学TCP协议（6） 四次挥手

1. 四次挥手 客户端进程发出连接释放报文&#xff0c;并且停止发送数据。释放数据报文首部&#xff0c;FIN1&#xff0c;其序列号为sequ&#xff08;等于前面已经传送过来的数据的最后一个字节的序号加1&#xff09;&#xff0c;此时&#xff0c;客户端进入FIN-WAIT-1&#xff…
阅读更多...
UML建模图实战笔记

UML建模图实战笔记

一、前言 UML&#xff1a;Unified Modeling Language&#xff08;统一建模语言&#xff09;&#xff0c;使用UML进行建模的作用有哪些&#xff1a; 可以更好的理解问题可以及早的发现错误或者被遗漏的点可以更加方便的进行组员之间的沟通支持面向对象软件开发建模&#xff0c;可…
阅读更多...
数据草拟：使您的团队热爱数据的研讨会

数据草拟：使您的团队热爱数据的研讨会

Learn the rules to Data Draw Up; a fun way to get your teams invested in data.了解数据收集的规则&#xff1b; 一种让您的团队投入数据的有趣方式。 Let’s keep things short. Metrics are one of the most important things in Product Management. They help us to u…
阅读更多...
深入理解InnoDB（5）-文件系统

深入理解InnoDB（5）-文件系统

1. 数据库和文件系统的关系 像 InnoDB 、 MyISAM 这样的存储引擎都是把表存储在文件系统上的。当我们想读取数据的时候&#xff0c;这些存储引擎会从文件系统中把数据读出来返回给我们&#xff0c;当我们想写入数据的时候&#xff0c;这些存储引擎会把这些数据又写回文件系统。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023