java map用二叉树_【课堂笔记分享】linkedlist、二叉树、hashmap

LinkedList序列分先进先出FIFO,先进后出FILO

FIFO在Java中又叫Queue 队列

FILO在Java中又叫Stack 栈

LinkedList 与 List接口与ArrayList一样，LinkedList也实现了List接口，诸如add,remove,contains等等方法。 详细使用，请参考 ArrayList 常用方法，在此不作赘述。

接下来要讲的是LinkedList的一些特别的地方

双向链表 - Deque除了实现了List接口外，LinkedList还实现了双向链表结构Deque，可以很方便的在头尾插入删除数据

什么是链表结构: 与数组结构相比较，数组结构，就好像是电影院，每个位置都有标示，每个位置之间的间隔都是一样的。 而链表就相当于佛珠，每个珠子，只连接前一个和后一个，不用关心除此之外的其他佛珠在哪里。

package collection;

import java.util.LinkedList;

import charactor.Hero;

public class TestCollection {

public static void main(String[] args) {

//LinkedList是一个双向链表结构的list

LinkedList ll =new LinkedList();

//所以可以很方便的在头部和尾部插入数据

//在最后插入新的英雄

ll.addLast(new Hero("hero1"));

ll.addLast(new Hero("hero2"));

ll.addLast(new Hero("hero3"));

System.out.println(ll);

//在最前面插入新的英雄

ll.addFirst(new Hero("heroX"));

System.out.println(ll);

//查看最前面的英雄

System.out.println(ll.getFirst());

//查看最后面的英雄

System.out.println(ll.getLast());

//查看不会导致英雄被删除

System.out.println(ll);

//取出最前面的英雄

System.out.println(ll.removeFirst());

//取出最后面的英雄

System.out.println(ll.removeLast());

//取出会导致英雄被删除

System.out.println(ll);

}

}

队列 - QueueLinkedList 除了实现了List和Deque外，还实现了Queue接口(队列)。

Queue是先进先出队列 FIFO，常用方法：

offer在最后添加元素

poll取出第一个元素

peek 查看第一个元素

package collection;

import java.util.LinkedList;

import java.util.List;

import java.util.Queue;

import charactor.Hero;

public class TestCollection {

public static void main(String[] args) {

//和ArrayList一样，LinkedList也实现了List接口

List ll =new LinkedList();

//所不同的是LinkedList还实现了Deque，进而又实现了Queue这个接口

//Queue代表FIFO 先进先出的队列

Queue q= new LinkedList();

//加在队列的最后面

System.out.print("初始化队列：\t");

q.offer(new Hero("Hero1"));

q.offer(new Hero("Hero2"));

q.offer(new Hero("Hero3"));

q.offer(new Hero("Hero4"));

System.out.println(q);

System.out.print("把第一个元素取poll()出来:\t");

//取出第一个Hero，FIFO 先进先出

Hero h = q.poll();

System.out.println(h);

System.out.print("取出第一个元素之后的队列:\t");

System.out.println(q);

//把第一个拿出来看一看，但是不取出来

h=q.peek();

System.out.print("查看peek()第一个元素:\t");

System.out.println(h);

System.out.print("查看并不会导致第一个元素被取出来:\t");

System.out.println(q);

}

}

使用LinkedList实现Stack栈与FIFO(先入先出的)队列类似的一种数据结构是FILO先入后出栈Stack

根据接口Stack ：

实现类：MyStack

public class MyStack implements Stack并向这个栈中，压入5个英雄，接着弹出5个英雄

package collection;

import charactor.Hero;

public interface Stack {

//把英雄推入到最后位置

public void push(Hero h);

//把最后一个英雄取出来

public Hero pull();

//查看最后一个英雄

public Hero peek();

}

package collection;

import java.util.LinkedList;

import charactor.Hero;

public class MyStack implements Stack{

LinkedList heros = new LinkedList();

@Override

public void push(Hero h) {

heros.addLast(h);

}

@Override

public Hero pull() {

return heros.removeLast();

}

@Override

public Hero peek() {

return heros.getLast();

}

public static void main(String[] args) {

MyStack heroStack = new MyStack();

for (int i = 0; i < 5; i++) {

Hero h = new Hero("hero name " + i);

System.out.println("压入 hero:" + h);

heroStack.push(h);

}

for (int i = 0; i < 5; i++) {

Hero h =heroStack.pull();

System.out.println("弹出 hero" + h);

}

}

}

二叉树

二叉树概念二叉树由各种节点组成

二叉树特点：每个节点都可以有左子节点，右子节点

每一个节点都有一个值

package collection;

public class Node {

// 左子节点

public Node leftNode;

// 右子节点

public Node rightNode;

// 值

public Object value;

}

二叉树排序-插入数据假设通过二叉树对如下10个随机数进行排序

67,7,30,73,10,0,78,81,10,74

排序的第一个步骤是把数据插入到该二叉树中

插入基本逻辑是，小、相同的放左边，大的放右边

1. 67 放在根节点

2. 7 比 67小，放在67的左节点

3. 30 比67 小，找到67的左节点7，30比7大，就放在7的右节点

4. 73 比67大， 放在67的右节点

5. 10 比 67小，找到67的左节点7，10比7大，找到7的右节点30，10比30小，放在30的左节点。

...

...9. 10比67小，找到67的左节点7，10比7大，找到7的右节点30，10比30小，找到30的左节点10，10和10一样大，放在左边

package collection;

public class Node {

// 左子节点

public Node leftNode;

// 右子节点

public Node rightNode;

// 值

public Object value;

// 插入 数据

public void add(Object v) {

// 如果当前节点没有值，就把数据放在当前节点上

if (null == value)

value = v;

// 如果当前节点有值，就进行判断，新增的值与当前值的大小关系

else {

// 新增的值，比当前值小或者相同

if ((Integer) v -((Integer)value) <= 0) {

if (null == leftNode)

leftNode = new Node();

leftNode.add(v);

}

// 新增的值，比当前值大

else {

if (null == rightNode)

rightNode = new Node();

rightNode.add(v);

}

}

}

public static void main(String[] args) {

int randoms[] = new int[] { 67, 7, 30, 73, 10, 0, 78, 81, 10, 74 };

Node roots = new Node();

for (int number : randoms) {

roots.add(number);

}

}

}

二叉树排序-遍历通过上一个步骤的插入行为，实际上，数据就已经排好序了。 接下来要做的是看，把这些已经排好序的数据，遍历成我们常用的List或者数组的形式

二叉树的遍历分左序，中序，右序左序即： 中间的数遍历后放在左边

中序即： 中间的数遍历后放在中间

右序即： 中间的数遍历后放在右边如图所见，我们希望遍历后的结果是从小到大的，所以应该采用中序遍历

package collection;

import java.util.ArrayList;

import java.util.List;

public class Node {

// 左子节点

public Node leftNode;

// 右子节点

public Node rightNode;

// 值

public Object value;

// 插入 数据

public void add(Object v) {

// 如果当前节点没有值，就把数据放在当前节点上

if (null == value)

value = v;

// 如果当前节点有值，就进行判断，新增的值与当前值的大小关系

else {

// 新增的值，比当前值小或者相同

if ((Integer) v -((Integer)value) <= 0) {

if (null == leftNode)

leftNode = new Node();

leftNode.add(v);

}

// 新增的值，比当前值大

else {

if (null == rightNode)

rightNode = new Node();

rightNode.add(v);

}

}

}

// 中序遍历所有的节点

public List values() {

List values = new ArrayList<>();

// 左节点的遍历结果

if (null != leftNode)

values.addAll(leftNode.values());

// 当前节点

values.add(value);

// 右节点的遍历结果

if (null != rightNode)

values.addAll(rightNode.values());

return values;

}

public static void main(String[] args) {

int randoms[] = new int[] { 67, 7, 30, 73, 10, 0, 78, 81, 10, 74 };

Node roots = new Node();

for (int number : randoms) {

roots.add(number);

}

System.out.println(roots.values());

}

}案例：英雄二叉树

根据上面的学习和理解，设计一个Hero二叉树，HeroNode.

可以向这个英雄二叉树插入不同的Hero对象，并且按照Hero的血量倒排序。

随机生成10个Hero对象，每个Hero对象都有不同的血量值，插入这个HeroNode后，把排序结果打印出来。Hero

package charactor;

public class Hero {

public String name;

public float hp;

public int damage;

public Hero() {

}

public Hero(String name) {

this.name = name;

}

public String toString() {

return String.format("[name:%s hp:%.0f]%n", name,hp);

}

}HeroNode

package collection;

import java.util.ArrayList;

import java.util.List;

import charactor.Hero;

public class HeroNode {

public HeroNode leftHero;

public HeroNode rightHero;

// 声明为Hero类型

public Hero value;

public void add(Hero v) {

if (null == value)

value = v;

else {

// 如果新英雄血量，比本节点大，就放在左边

if (v.hp > value.hp) {

if (null == leftHero)

leftHero = new HeroNode();

leftHero.add(v);

}

else {

if (null == rightHero)

rightHero = new HeroNode();

rightHero.add(v);

}

}

}

public List values() {

List values = new ArrayList<>();

if (null != leftHero)

values.addAll(leftHero.values());

values.add(value);

if (null != rightHero)

values.addAll(rightHero.values());

return values;

}

public static void main(String[] args) {

List hs = new ArrayList<>();

for (int i = 0; i < 10; i++) {

Hero h = new Hero();

h.name = "hero " + i;

h.hp = (float) (Math.random() * 900 + 100); // 100-1000的随机血量

hs.add(h);

}

System.out.println("初始化10个Hero");

System.out.println(hs);

HeroNode heroTree = new HeroNode();

for (Hero hero : hs) {

heroTree.add(hero);

}

System.out.println("根据血量倒排序后的Hero");

List treeSortedHeros = heroTree.values();

System.out.println(treeSortedHeros);

}

}创建4万个随机数，然后用分别用冒泡法，选择法，二叉树3种排序算法进行排序，比较哪种更快

package collection;

import java.util.Arrays;

import java.util.List;

public class SortCompare {

public static void main(String[] args) {

//初始化随机数

int total = 40000;

System.out.println("初始化一个长度是"+total+"的随机数字的数组");

int[] originalNumbers = new int[total];

for (int i = 0; i < originalNumbers.length; i++) {

originalNumbers[i] = (int)(Math.random()*total);

}

System.out.println("初始化完毕");

System.out.println("接下来分别用3种算法进行排序");

//从初始化了的随机数组复制过来，以保证，每一种排序算法的目标数组，都是一样的

int[] use4sort;

use4sort= Arrays.copyOf(originalNumbers, originalNumbers.length);

int[] sortedNumbersBySelection= performance(new SelectionSort(use4sort),"选择法");

use4sort= Arrays.copyOf(originalNumbers, originalNumbers.length);

int[] sortedNumbersByBubbling=performance(new BubblingSort(use4sort),"冒泡法");

use4sort= Arrays.copyOf(originalNumbers, originalNumbers.length);

int[] sortedNumbersByTree=performance(new TreeSort(use4sort),"二叉树");

System.out.println("查看排序结果，是否是不同的数组对象");

System.out.println(sortedNumbersBySelection);

System.out.println(sortedNumbersByBubbling);

System.out.println(sortedNumbersByTree);

System.out.println("查看排序结果，内容是否相同");

System.out.println("比较 选择法 和 冒泡法 排序结果：");

System.out.println(Arrays.equals(sortedNumbersBySelection, sortedNumbersByBubbling));

System.out.println("比较 选择法 和 二叉树 排序结果：");

System.out.println(Arrays.equals(sortedNumbersBySelection, sortedNumbersByTree));

}

interface Sort{

void sort();

int[] values();

}

static class SelectionSort implements Sort{

int numbers[];

SelectionSort(int [] numbers){

this.numbers = numbers;

}

@Override

public void sort() {

for (int j = 0; j < numbers.length-1; j++) {

for (int i = j+1; i < numbers.length; i++) {

if(numbers[i]

int temp = numbers[j];

numbers[j] = numbers[i];

numbers[i] = temp;

}

}

}

}

@Override

public int[] values() {

// TODO Auto-generated method stub

return numbers;

}

}

static class BubblingSort implements Sort{

int numbers[];

BubblingSort(int [] numbers){

this.numbers = numbers;

}

@Override

public void sort() {

for (int j = 0; j < numbers.length; j++) {

for (int i = 0; i < numbers.length-j-1; i++) {

if(numbers[i]>numbers[i+1]){

int temp = numbers[i];

numbers[i] = numbers[i+1];

numbers[i+1] = temp;

}

}

}

}

@Override

public int[] values() {

// TODO Auto-generated method stub

return numbers;

}

}

static class TreeSort implements Sort{

int numbers[];

Node n;

TreeSort(int [] numbers){

n =new Node();

this.numbers = numbers;

}

@Override

public void sort() {

for (int i : numbers) {

n.add(i);

}

}

@Override

public int[] values() {

List list = n.values();

int sortedNumbers[] = new int[list.size()];

for (int i = 0; i < sortedNumbers.length; i++) {

sortedNumbers[i] = Integer.parseInt(list.get(i).toString());

}

return sortedNumbers;

}

}

private static int[] performance(Sort algorithm, String type) {

long start = System.currentTimeMillis();

algorithm.sort();

int sortedNumbers[] = algorithm.values();

long end = System.currentTimeMillis();

System.out.printf("%s排序，一共耗时 %d 毫秒%n",type,end-start);

return sortedNumbers;

}

}

HashMap

HashMap的键值对HashMap储存数据的方式是—— 键值对

package collection;

import java.util.HashMap;

public class TestCollection {

public static void main(String[] args) {

HashMap dictionary = new HashMap<>();

dictionary.put("adc", "物理英雄");

dictionary.put("apc", "魔法英雄");

dictionary.put("t", "坦克");

System.out.println(dictionary.get("t"));

}

}

键不能重复，值可以重复对于HashMap而言，key是唯一的，不可以重复的。

所以，以相同的key 把不同的value插入到 Map中会导致旧元素被覆盖，只留下最后插入的元素。

不过，同一个对象可以作为值插入到map中，只要对应的key不一样

package collection;

import java.util.HashMap;

import charactor.Hero;

public class TestCollection {

public static void main(String[] args) {

HashMap heroMap = new HashMap();

heroMap.put("gareen", new Hero("gareen1"));

System.out.println(heroMap);

//key为gareen已经有value了，再以gareen作为key放入数据，会导致原英雄，被覆盖

//不会增加新的元素到Map中

heroMap.put("gareen", new Hero("gareen2"));

System.out.println(heroMap);

//清空map

heroMap.clear();

Hero gareen = new Hero("gareen");

//同一个对象可以作为值插入到map中，只要对应的key不一样

heroMap.put("hero1", gareen);

heroMap.put("hero2", gareen);

System.out.println(heroMap);

}

}查找内容性能比较

准备一个ArrayList其中存放3000000(三百万个)Hero对象，其名称是随机的,格式是hero-[4位随机数]

hero-3229

hero-6232

hero-9365

...

因为总数很大，所以几乎每种都有重复，把名字叫做 hero-5555的所有对象找出来

要求使用两种办法来寻找

1. 不使用HashMap，直接使用for循环找出来，并统计花费的时间

2. 借助HashMap，找出结果，并统计花费的时间

package collection;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import charactor.Hero;

public class TestCollection {

public static void main(String[] args) {

List hs =new ArrayList<>();

System.out.println("初始化开始");

for (int i = 0; i < 3000000; i++) {

Hero h = new Hero( "hero-" + random());

hs.add(h);

}

//名字作为key

//名字相同的hero，放在一个List中，作为value

HashMap> heroMap =new HashMap();

for (Hero h : hs) {

List list= heroMap.get( h.name);

if(list==null){

list = new ArrayList<>();

heroMap.put(h.name, list);

}

list.add(h);

}

System.out.println("初始化结束");

System.out.println("开始查找");

findByIteration(hs);

findByMap(heroMap);

}

private static List findByMap(HashMap> m) {

long start =System.currentTimeMillis();

List result= m.get("hero-5555");

long end =System.currentTimeMillis();

System.out.printf("通过map查找，一共找到%d个英雄，耗时%d 毫秒%n",result.size(),end-start);

return result;

}

private static List findByIteration (List hs) {

long start =System.currentTimeMillis();

List result =new ArrayList<>();

for (Hero h : hs) {

if(h.name.equals("hero-5555")){

result.add(h);

}

}

long end =System.currentTimeMillis();

System.out.printf("通过for查找，一共找到%d个英雄，耗时%d 毫秒%n", result.size(),end-start);

return result;

}

public static int random(){

return ((int)(Math.random()*9000)+1000);

}

}

感谢你看到这里，我是程序员麦冬，一个java开发从业者，深耕行业六年了，每天都会分享java相关技术文章或行业资讯

欢迎大家关注和转发文章，后期还有福利赠送！

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

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

相关文章

六年打磨！阿里开源混沌工程工具 ChaosBlade

六年打磨！阿里开源混沌工程工具 ChaosBlade

阿里妹导读&#xff1a;减少故障的最好方法就是让故障经常性的发生。通过不断重复失败过程&#xff0c;持续提升系统的容错和弹性能力。今天&#xff0c;阿里巴巴把六年来在故障演练领域的创意和实践汇浓缩而成的工具进行开源&#xff0c;它就是 “ChaosBlade”。如果你想要提升…
阅读更多...
jmeter-5.3 测试http接口动态数据 windows+Linux双环境

jmeter-5.3 测试http接口动态数据 windows+Linux双环境

文章目录一、基础组件1. 企业需求2. 创建线程组&#xff1a;3. 创建HTTP请求4. CSV 数据文件组件5. 响应断言二、添加监听器2.1. 添加察看结果树2.2. 添加聚合报告2.3. 监听每秒事务数2.4. 监听 随时间变化的响应时间三、HTTP请求配置3.1. 基础参数四、 响应断言配置四、 CSV 数…
阅读更多...
阿里达摩院又火了！引入AI确诊肺炎提速16倍，仅需半小时！网友神回复了

阿里达摩院又火了！引入AI确诊肺炎提速16倍，仅需半小时！网友神回复了

针对新型冠状病毒的确诊&#xff0c;全国大多数医院基本都采用核酸检测。果壳网发文称&#xff1a;从病人样本送到实验室即刻开始测试&#xff0c;到出检测报告&#xff0c;差不多需要8个小时。但是8个小时太长&#xff0c;在现在这种病毒传播速度下&#xff0c;让人焦急万分。…
阅读更多...
用java写ods系统_基于数据库的代码自动生成工具，生成JavaBean、生成数据库文档、生成前后端代码等(TableGo v7.0.0版)...

用java写ods系统_基于数据库的代码自动生成工具，生成JavaBean、生成数据库文档、生成前后端代码等(TableGo v7.0.0版)...

TableGo是基于数据库的代码自动生成工具&#xff0c;低代码编程技术的实现&#xff0c;可以零代码自动生成SpringBoot项目工程、生成JavaBean、生成前后端分离的CRUD代码、生成MyBaits的Mapper映射配置文件、生成数据库设计文档(Word、Excel)、生成Swagger2离线API文档、生成前…
阅读更多...
Node.js 应用故障排查手册 —— 冗余配置传递引发的内存溢出

Node.js 应用故障排查手册 —— 冗余配置传递引发的内存溢出

楔子 前面一小节我们以一个真实的压测案例来给大家讲解如何利用 Node.js 性能平台 生成的 CPU Profile 分析来进行压测时的性能调优。那么与 CPU 相关的问题相比&#xff0c;Node.js 应用中由于不当使用产生的内存问题是一个重灾区&#xff0c;而且这些问题往往都是出现在生产…
阅读更多...
一分钟在Linux 环境 搭建 SFTP服务器

一分钟在Linux 环境 搭建 SFTP服务器

文章目录一、实战1. 创建sftp组&#xff1a;2. 创建一个用户sftpuser&#xff1a;3. 设置sftpuser用户的密码&#xff0c;会要求你输入两次密码确认&#xff1a;4. 创建一个sftp的上传目录&#xff1a;5. 修改用户sftpuser所在的目录&#xff1a;6. 配置sshd_config&#xff1a…
阅读更多...
微服务架构何去何从？

微服务架构何去何从？

戳蓝字“CSDN云计算”关注我们哦&#xff01;作者 | 孙玄本文经授权转载自架构之美前言微服务架构模式经过5年多的发展&#xff0c;在各行各业如火如荼地应用和实践。如何在企业中优雅地设计微服务架构&#xff1f;是企业面对的一个重要问题。本文将讲述微服务架构1.0设计与实践…
阅读更多...
寻找 K8s 1.14 Release 里的“蚌中之珠”

寻找 K8s 1.14 Release 里的“蚌中之珠”

Kubernetes 1.14.0 Release 已经于3月25日正式发布。相信你也已经注意到&#xff0c;相比于1.13 和 1.12 版本&#xff0c;这次发布包含的重要变更非常多&#xff0c;其对应的 Release Note 的篇幅长度也创下了“新高”。 面对这样一份“海量信息”的 Release Note&#xff0c…
阅读更多...
appium java 点击事件_“按钮点击”在Appium Android测试中给出“处理命令时出现未知的服务器端错误 . ”...

appium java 点击事件_“按钮点击”在Appium Android测试中给出“处理命令时出现未知的服务器端错误 . ”...

info&#xff1a;[debug]将命令推送到appium工作队列&#xff1a;[“element&#xff1a;getSize”&#xff0c;{“elementId”&#xff1a;“2”}] info&#xff1a;[debug] [BOOTSTRAP] [debug]从客户端获取数据&#xff1a;{“cmd” &#xff1a;“action”&#xff0c;“ac…
阅读更多...
天马行空脚踏实地，阿里巴巴有群百里挑一的天才应届生

天马行空脚踏实地，阿里巴巴有群百里挑一的天才应届生

阿里巴巴有一群天马行空脚踏实地的阿里星。 天下网商记者 王安忆 阿里巴巴的春季校招已经启动。在阿里的技术大咖储备团队中&#xff0c;有三分之一是来自高校招聘&#xff0c;这当中&#xff0c;有一项名为阿里星的神秘计划。这是校招中专门针对高校顶尖大学生的一个培养计划&…
阅读更多...
linux Nas挂载

linux Nas挂载

文章目录一、NAS服务端1. 首先查看服务器上是否有nfs和rpc相关软件2. 设置共享3. 使配置生效:4. 查看所有可挂载5. rpcbind启和动nfs6.配置防火墙7. 查看防火墙的状态8. 启动防火墙9. 开放端口10. 重新启动防火墙11. 查看已开放的端口二、客户端(应用服务器)2.1.查看空间分布2.…
阅读更多...
GitHub 标星 14000+，阿里开源的 SEATA 如何应用到极致？

GitHub 标星 14000+，阿里开源的 SEATA 如何应用到极致？

戳蓝字“CSDN云计算”关注我们哦&#xff01;作者简介&#xff1a;袁鸣凯&#xff0c;家乐福技术总监&#xff0c; 高知特有限技术公司中国区架构师&#xff0c;HP上海研发技术专家&#xff0c;夸客金融首席架构师&#xff0c;现任家乐福中国区技术总监。多年互联网、企业级SOA…
阅读更多...
阿里小二的日常工作要被TA们“接管”了！

阿里小二的日常工作要被TA们“接管”了！

昨天有人偷偷告诉我说 阿里巴巴其实是一家科技公司&#xff01; 我想了整整一夜 究竟是谁走漏了风声 那么重点来了&#xff0c;阿里到底是如何在内部的办公、生活中&#xff0c;玩转“黑科技”的呢&#xff1f; AI取名&#xff1a;给你专属的“武侠”花名 花名是阿里巴巴独…
阅读更多...
java超时结束程序_java本机进程超时

java超时结束程序_java本机进程超时

java本机进程超时目前&#xff0c;我使用以下命令执行本机进程&#xff1a;java.lang.Process process Runtime.getRuntime().exec(command);int returnCode process.waitFor();假设我希望在经过一定时间后终止&#xff0c;而不是等待程序返回。 我该怎么做呢&#xff1f;del…
阅读更多...
oracle 修改表字段的长度

oracle 修改表字段的长度

alter table 表名 modify 列名 数据类型&#xff1b; alter table bl_yhsz modify zcmc varchar2(120); alter table sys_job_log modify EXCEPTION_INFO VARCHAR2(3000);
阅读更多...
对话Ruby创始人松本行弘、阿里高级技术专家朴灵！

对话Ruby创始人松本行弘、阿里高级技术专家朴灵！

4月25日&#xff0c;云栖社区联合阿里云国际站&#xff0c;特别邀请了Ruby创始人Matz&#xff08;松本行弘&#xff09;、阿里云高级技术专家朴灵&#xff0c;来为开发者们分享干货。 在本次活动上可以了解到Ruby语言最新的动态&#xff0c;Ruby和新语言golang在性能方面的差别…
阅读更多...
Serverless 终结 Kubernetes？

Serverless 终结 Kubernetes？

戳蓝字“CSDN云计算”关注我们哦&#xff01;Kubernetes 是基础架构管理的终极解决方案吗&#xff1f;还是说我们更加需要 Serverless&#xff1f;究竟哪种技术能够解救运维团队&#xff1f;不要忘记&#xff0c;NoOps 的世界即将到来。作者 | Daniele Fontani译者 | 弯月封图 …
阅读更多...
代号“凤凰”，阿里新零售秘密武器，今年要打入100个城市

代号“凤凰”，阿里新零售秘密武器，今年要打入100个城市

2019年&#xff0c;淘鲜达要在100个城市完成1000个门店的新零售改造。 天下网商记者 张文政 过去一年&#xff0c;初平三分之二的时间在出差&#xff0c;足迹遍及山东、河南、江西、湖南等地。 初平是天猫超市事业群战略合作部总经理&#xff0c;负责天猫超市旗下“淘鲜达”…
阅读更多...
VS Code 批量操作

VS Code 批量操作

文章目录1. 关键词批量选中2. 末尾批量编辑3. 垂直批量编辑4. 垂直批量选中5. 批量选中整行6. 批量复制整行1. 关键词批量选中 Ctrld 选中相同的词句&#xff0c;批量编辑 2. 末尾批量编辑 shirtalti移动到最后&#xff0c;批量编辑 3. 垂直批量编辑 Ctrlalt↓垂直批量编…
阅读更多...
Node.js 应用故障排查手册 —— 利用 CPU 分析调优吞吐量

Node.js 应用故障排查手册 —— 利用 CPU 分析调优吞吐量

楔子 在我们想要新上线一个 Node.js 应用之前&#xff0c;尤其是技术栈切换的第一个 Node.js 应用&#xff0c;由于担心其在线上的吞吐量表现&#xff0c;肯定会想要进行性能压测&#xff0c;以便对其在当前的集群规模下能抗住多少流量有一个预估。本案例实际上正是在这样的一…
阅读更多...
最新文章

Copyright @ 2022~2023