java数组年终总结 第1篇
1、传统架构改造成微服务架构
问题说明：微服务拆分后，对应的数据库也会进行拆分。也就是原本很简单功能一个查询就解决，拆分后就得跨多个微服务查询。如果其中一张表数据较少可以代码循环的方式解决，如果每个微服务的数据都比较多就比较麻烦。
方案一：使用视图，通过视图把两个库的中表进行强关联。当然这样也就违避微服务的解耦
方案二：临时表或缓存，通过临时表或缓存构建临时关联数据，使用完就清理
方案三：数据冗余，牺牲空间换时间。类似索引，牺牲索引空间换查询速度。
建议使用方案三(尽量不要使用共享数据库)，数据同步的问题可以借助MQ来实现
微服务粒度问题，多次讨论拆分架构。拆分是一个迭代的过程，别试着一步到位拆成很细，一开始千万别拆太细。一般微服务划分越细，那么模块之前的集成就越复杂
java数组年终总结 第2篇
1.数组本身是引用数据类型，而数组中的元素尅是任何数据类型，包括基本数据类型和引用数据类型。 2.创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。 3.数组的长度一旦确定，就不能修改（长度在程序运行期间不可改变）。 4.我们可以直接通过下标（或索引）的方式调用指定位置的元素。速度很快。
java数组年终总结 第3篇
可用性指系统在给定时间内可以正常工作的概率，通常用SLA（服务等级协议，service level agreement）指标来表示。
这是这段时间的总体的可用性指标。
可靠性相关的几个指标如下：
即平均无故障时间，是指从新的产品在规定的工作环境条件下开始工作到出现第一个故障的时间的平均值。
MTBF越长表示可靠性越高，正确工作能力越强 。
即平均修复时间，是指可修复产品的平均修复时间，就是从出现故障到修复中间的这段时间。
MTTR越短表示易恢复性越好。
即平均失效时间。系统平均能够正常运行多长时间，才发生一次故障。
系统的可靠性越高，平均无故障时间越长。
java数组年终总结 第4篇
获取长度 & 访问元素
注意：
这样就会出现下标越界异常Exception in thread “main” :
遍历数组：是将数组中的所有元素都访问一遍, 不重不漏. 通常需要搭配循环语句。
使用 for-each 遍历数组：
执行结果与for语句相同； for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错。
java数组年终总结 第5篇
几个概念
1、文中的使用非对称加密对称密钥就是数字信封技术
2、https通讯全过程
TCP三次握手->建立SSL连接(验证双方证书身份、获取对称密钥)->建立https连接(使用对称密钥加密通讯)
3、https单向身份认证一般来说就是客户端验证服务器https证书是否是合法有效的。https双方身份认证就是客户端验证服务器身份，服务器也验证客户端的身份，一般在安全要求 比较高的双方接口对接时，验证双向的身份。
1）客户端向服务器发送https请求，基本包括SSL证书版本等信息给服务器端建立连接。
2）服务器端确认SSL证书版本、服务器公钥证书返回给客户端。
3）客户端校验服务器端证书是否合法(通过CA证书来验证服务器身份)。验证通过就继续下一步，验证不通过警告提示(如浏览器的警告提示)。一般CA证书的验证包括：证书信任链验证、证书有效期验证、证书是否吊销等。
4）客户端发送可支持的对称加密方案到服务器端供其选择。
5）服务器端将选择好的加密方案（算法）以明文方式发给客户端。
6）客户端收到采用的加密算法后，产生随机码作为对称加密的密钥。
7）客户端把对称密钥使用服务器端的公钥（非对称加密）加密后发送到服务器端。
8）服务器端使用私钥（非对称加密）解密后获得对称加密的密钥。
9）双方通过对称加密密钥(随机数)进行加密通讯。
以下是浏览器通过https访问百度服务器的具体实例：
1）客户端通过发送Client Hello报文开始SSL通信。报文中包含客户端支持的SSL的指定版本、加密组件列表、所使用的加密算法及密钥长度、随机数Random-A等。
2）服务器可进行SSL通信时，会以Server Hello报文作为应答。和客户端一样，在报文中包含SSL版本以及加密组件(客户端支持中筛选)、服务器生成的随机数Random-B、服务器公钥证书PublicKey-B。
3）客户端校验服务器端证书PublicKey-B是否合法(通过CA证书来验证服务器身份)。验证通过就继续下一步，验证不通过警告提示(如浏览器的警告提示)。一般CA证书的验证包括：证书信任链验证、证书有效期验证、证书是否吊销等。
4）客户端将自己的公钥证书PublicKey-A发送给服务器端，供服务器验证客户端身份。客户端事先也需申请相应的SSL证书。
5）服务器校验客户端证书PublicKey-A是否合法(通过CA证书来验证服务器身份)。验证通过就继续下一步，验证不通过警告提示(如浏览器的警告提示)。一般CA证书的验证包括：证书信任链验证、证书有效期验证、证书是否吊销等。
6）客户端发送可支持的对称加密方案到服务器端供其选择。
7）服务器端将选择好的加密方案（算法）发送给客户端，报文使用客户端公钥PublicKey-A进行非对称加密。
8）客户端使用自己的私钥PrivateKey-A解密报文，并通过Random-A、Random-B推算出Random-C，也就是对称加密的密钥。
9）客户端使用服务器公钥PublicKey-B非对称加密对称密钥Random-C，发送给服务器。
10）服务器使用自己的私钥PrivateKey-B解密报文，解决出对称密钥Random-C。
11）双方完成身份验证，并使用对称密钥Random-C进行加密通讯。
java数组年终总结 第6篇
1、微服务：SpringCloud/Dubbo、Gateway、Eureka/Nacos/Consul、Config/Apollo、Hystrix/Sentinel
2、分布式：SLB、LVS、KeepAlived、LCN/Seata、ELK/ES等；
3、缓存：Java本地缓存、Memcached、Redis、MongoDB；
4、消息：RabbitMQ、RocketMQ、Kafka等
5、存储：Minio/Fastdfs、 MySQL(MybatisPlus)、Oracle、DB2、SQL Server
6、测试：Jmeter、Loadrunner、JUnit、Mockjs
7、监控：Arthas、XRebel、Jconsole、Jvisualvm、MAT
8、自动化：Jenkins、Nexus、GIT、Sonaqube、Maven、Gradle；
9、项目管理：TAPD(敏捷)、Redmine、禅道、Jira、Worktile(OKR)等；
10、设计：常用设计模式、UML、PowerDesinger
11、前端：JavaScript、Jquery、Ajax、Nodejs、Vue 等；
12、后台：SpringSecurity/Shiro、Oauth2、okHttp、Swagger/Knife4j
13、大数据：熟悉 Spark、Hive、Hadoop(hdfs、hbase)；
14、容器：Docker/Podman；
15、其它：Python、Activiti、区块链技术、对称/非对称加密(RSA、SM2)
java数组年终总结 第7篇
【问题1】为什么需要三次握手?
相对UDP，TCP是可靠的通讯协议，是全双工通信。TCP三次握手的关键在于，序列号seq的交换确认，因为对于客户端和服务端来说，双方序列号的确认是可靠传输的关键。1、2步握手只能确定发送方发和收正常，并不能确定接收方也是发和收正常，增加了第3次握手，才能保证接收方也是发和收都正常。
【问题2】为什么连接的时候是三次握手，关闭的时候却是四次挥手？
由于服务器端回复已经响应完毕，此时客户端并不是立刻就收完了，所以服务器处于半关闭状态，等服务器完全处理完，客户端收到通知后才完全关闭，固为4次。
【问题3】怎么简单描述三次握手？
就像是小明与小红发微信一样
小明：我要给你发数据了
小红：好的，我准备好了，你发吧
小明：好的，收到
【问题4】为什么是四次挥手
小红：我的数据发完了。
小明：好的，收到，我看看收完了没。
小明：好的，已经收完了，你关闭吧。
小红：好的，我关闭了。
java数组年终总结 第8篇
（1）一维数组的声明和初始化 （2）如何调用数组的指定位置的元素 （3）如何获取数组的长度 （4）如何遍历数组 （5）数组元素的默认初始化值 （6）数组内存解析
分割线----------------------------------------------------------------------------------------------
数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。 两种常见的初始化方式：
格式： 数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
数组定义格式详解： 数组存储的数据类型： 创建的数组容器可以存储什么数据类型。 [] : 表示数组。 数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名 字操作数组。 new：关键字，创建数组使用的关键字。 数组存储的数据类型： 创建的数组容器可以存储什么数据类型。 [长度]：数组的长度，表示数组容器中可以存储多少个元素。 注意：数组有定长特性，长度一旦指定，不可更改。 和水杯道理相同，买了一个2升的水杯，总容量就是2升，不能多也不能少。 举例： 定义可以存储3个整数的数组容器，代码如下： int[] arr = new int[3];
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…}; 举例：int[] arr = new int[]{1,2,3,4,5}; 定义存储1，2，3，4，5整数的数组容器。
代码演示数组初始化:
格式：数据类型[] 数组名 = {元素1,元素2,元素3…}; 举例：int[] arr = {1,2,3,4,5}; 定义存储1，2，3，4，5整数的数组容器
总结三种定义方式：当带长度的时候，不能一起带数组的元素，当带数组元素的时候不能带数组的长度。 比较： int[] arr = new int[3]; int[] arr = new int[]{1,2,3,4,5}; int[] arr = {1,2,3,4,5};
java数组年终总结 第9篇
笔者对于常见的排序算法有过详细的讲解： 小白学六大排序算法（C语言版），思想都是一样的，这里笔者就不再讲解，选取冒泡排序，直接选择排序，反转排序这三个方面来用JAVA实现一下 :
冒泡排序
直接选择排序
反转排序
对于数组，这些基本就够用了，文中若有问题，欢迎大家在评论区留言
java数组年终总结 第10篇
增加管理的透明度
金鱼缸是玻璃做的，透明度很高，不论从哪个角度观察，里面的情况都一清二楚，这就是管理上的“金鱼缸”法则。“金鱼缸”法则运用到管理中，就是要求领导者必须增加规章制度和各项工作的透明度。各项规章制度和工作有了透明度，领导者的行为就会置于员工的监督之下，就会有效地防止领导者滥用权力，从而强化领导者的自我约束机制。同时，员工在履行监督义务的同时，自身的主人翁意识和责任感得到极大的提升，而敬业、爱岗和创新的精神也必将得到升华。
java数组年终总结 第11篇
数组（Array）:是多个相同数据类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
数组定义： 数组就是存储相同数据类型的，长度固定的数据 的容器。
理解数组： 容器：是将多个数据存储到一起，每个数据称为该容器的元素。 生活中的容器：水杯，衣柜，教室
java数组年终总结 第12篇
互联网用户数据过大，排行榜性能较差
redis zset 数据结构为 id、score、member。下面是具体实现的步骤
1）插入数据
2）获取范围内的排名
zrange game 0 -1 withscores //开始到集合结束的从小到大列表，-1代表结束
zrevrange game 0 -1 withscores //开始到集合结束的从大到小列表
3）获取某用户的排名
zrank game hanko
zrevrank game hanko
java数组年终总结 第13篇
竞争是提高效率的法宝
“ 鲶鱼效应”来自一个古老的传说：一个小渔村的渔民靠到深海捕捉沙丁鱼(一种比较懒的鱼)为生。但由于捕鱼点距离陆地比较远，渔民捕的鱼运回渔村时，往往死掉大半，很难卖出好价钱。只有一个渔翁，他运回陆地的鱼，都是活的，总能卖出好价钱，但是他从来不让人看他的鱼舱。直到他死后，好奇的村民才发现，原来他的鱼舱里总是放着一条鲶鱼。由于鲶鱼是以捕食沙丁鱼为生，所以鲶鱼在鱼舱里会不停地追逐沙丁鱼，结果一些老弱的沙丁鱼被吃掉，但其他的沙丁鱼由于总在不停游动，所以都活着到岸。而其他渔船所捕的沙丁鱼静止不动，结果一大半都会死掉。这个传说告诉我们一个浅显的道理：“生于忧患、死于安乐”，如果一个企业缺少活力与竞争意识，没有生存的压力，就如同“沙丁鱼”一样，在“鱼舱”里混吃混喝，必然会被日益残酷的市场竞争所淘汰。一个员工也是如此，长期安于现状、不思进取，必然会成为时代的弃儿。
领导者要成为“鲶鱼”， 有句俗话叫“兵熊熊一个，将熊熊一窝”。一家公司或一个部门，如果领导缺乏激情，要想手下的人有激情，那是白日做梦。最常见的情况是，领导工作不在状态，员工必然上行下效，人浮于事，缺乏创新和主动性，日复一日，年复一年，必然成了一潭死水。反之则是“强将手下无弱兵”。如果领导者本身是一条充满活力的“鲶鱼”，那么，通过整顿纪律，规范制度，改造流程，合理配置岗位和人、财、物，就能将那些无能的“沙丁鱼”吃掉、赶走，使有能耐的“沙丁鱼”得到正面的激励，从而使整个机构呈现欣欣向荣的景象。因此，作为领导者，如果自己的公司没有激情，首先不要怪员工，而是要去反思自己是不是有激情。只有自己先成为“鲶鱼”，才能影响员工，才能使整个组织的活力都被调动起来，从而使集体的力量更加强大，克敌制胜。
java数组年终总结 第14篇
参数传内置类型
修改形参 x 的值, 不影响实参的 num 值
参数传数组类型
在函数内部修改数组内容, 函数外部也发生改变. 此时数组名 arr 是一个 “引用” . 当传参的时候, 是按照引用传参。 什么是引用? 引用相当于一个 “别名”, 也可以理解成一个指针. 创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址.
** 写一个方法, 将数组中的每个元素都 * 2** class Test { public static void main(String[] args) { int[] arr = {1, 2, 3}; int[] output = transform(arr); printArray(output); }
这样的话就不会破坏原有数组了. 由于数组是引用类型, 返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效
数组转字符串
数组拷贝 for语句拷贝：
返回值： void arraycopy 速度快 int[] copyOf 数组名.clong() ->数组名为你要拷贝的数组 是Object的方法 返回一个副本 深拷贝：对于数组当中是简单类型 浅拷贝：对于数组类型当中是引用数组 数组排序 (array) 将数组进行排序
二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组. 数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };
二维数组的用法和一维数组并没有明显差别。
java数组年终总结 第15篇
top查内存->thread查cpu/死锁->dashboard内存
heapdump 查dump****
trace跟踪代码->watch查函数参数与返回值
tt -i 1001 //上面指令发现异常后，查看异常
tt -i 1001 -p //重新调用，重现异常
ognl '@' //查看
ognl '@(_test_)' //更新
java数组年终总结 第16篇
上面的结论没有完全理解的话也没关系，我们来看一个具体的案例！
浅拷贝
浅拷贝的示例代码如下，我们这里实现了 Cloneable 接口，并重写了 clone() 方法。
clone() 方法的实现很简单，直接调用的是父类 Object 的 clone() 方法。
测试 ：
从输出结构就可以看出， person1 的克隆对象和 person1 使用的仍然是同一个 Address 对象。
深拷贝
这里我们简单对 Person 类的 clone() 方法进行修改，连带着要把 Person 对象内部的 Address 对象一起复制。
测试 ：
从输出结构就可以看出，虽然 person1 的克隆对象和 person1 包含的 Address 对象已经是不同的了。
java数组年终总结 第17篇
使用一个Entry数组来存储数据，用key的hashcode取模来决定key会被放到数组里的位置，如果hashcode取模后的结果相同，那么这些key会被定位到Entry数组的同一个格子里，这些key会形成一个链表；这样数据遍历时间就过长。中hashmap链表插入的方式是使用头插法。
使用一个Node数组来存储数据，但是这个Node可能是链表结构，也可能是红黑树结构；如果插入的元素key的hashcode值相同，那么这些key也会被定位到Node数组的同一个格子里，如果不超过8个使用链表存储，超过8个且Node数组长度超过64，会将链表转换为红黑树。中hashmap链表插入的方式是使用尾插法。
【相关问题】
问题一：为什么后改为尾插法？
主要是因为头插法在多线程扩容情况下会引起链表环。那什么是链表环呢？
java数组年终总结 第18篇
1、缓存穿透 (缓存、DB均无，穿透)
缓存穿透是指查询一个一定不存在的数据，由于缓存是不命中时被动写的，并且出于容错考虑，如果从存储层查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。在流量大时，可能DB就挂掉了，要是有人利用不存在的key频繁攻击我们的应用，这就是漏洞。
有很多种方法可以有效地解决缓存穿透问题，最常见的则是采用布隆过滤器，将所有可能存在的数据哈希到一个足够大的bitmap中，一个一定不存在的数据会被这个bitmap拦截掉，从而避免了对底层存储系统的查询压力。另外也有一个更为简单粗暴的方法（我们采用的就是这种），如果一个查询返回的数据为空（不管是数据不存在，还是系统故障），我们仍然把这个空结果进行缓存，但它的过期时间会很短，最长不超过五分钟。
布隆过滤器缺点就是只能存不能直接删除，最近出来一个布谷鸟过滤器。
2、缓存击穿(缓存无、DB有，击穿)
对于一些设置了过期时间的key，如果这些key可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。这个时候，需要考虑一个问题：缓存被“击穿”的问题，这个和缓存雪崩的区别在于这里针对某一key缓存，前者则是很多key。
缓存在某个时间点过期的时候，恰好在这个时间点对这个Key有大量的并发请求过来，这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端DB压垮。
1）使用mutex key(互斥锁)
业界比较常用的做法，是使用mutex。简单地来说，就是在缓存失效的时候，不是立即去load db，而是先使用缓存工具的某些带成功操作返回值的操作（比如Redis的SETNX）去set一个mutex key(对缓存的逻辑加锁)，当操作返回成功时，再进行load db的操作并回设缓存。
2） _提前_使用互斥锁(mutex key)：
在value内部设置1个超时值(timeout1), timeout1比实际的memcache timeout(timeout2)小。当从cache读取到timeout1发现它已经过期时候，马上延长timeout1并重新设置到cache。然后再从数据库加载数据并设置到cache中。伪代码如下：
3） _永远不过期_：
这里的“永远不过期”包含两层意思：
(1) 从redis上看，确实没有设置过期时间，这就保证了，不会出现热点key过期问题，也就是“物理”不过期。(2) 从功能上看，如果不过期，那不就成静态的了吗？所以我们把过期时间存在key对应的value里，如果发现要过期了，通过一个后台的异步线程进行缓存的构建，也就是“逻辑”过期
从实战看，这种方法对于性能非常友好，唯一不足的就是构建缓存时候，其余线程(非构建缓存的线程)可能访问的是老数据，但是对于一般的互联网功能来说这个还是可以忍受。
3、缓存雪崩(一批过期的key)
缓存雪崩是指在我们设置缓存时采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到DB，DB瞬时压力过重雪崩。
缓存失效时的雪崩效应对底层系统的冲击非常可怕。大多数系统设计者考虑用加锁或者队列的方式保证缓存的单线程（进程）写，从而避免失效时大量的并发请求落到底层存储系统上。一个简单方案就是将缓存失效时间分散开(过期时间错开) ，比如我们可以在原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。
java数组年终总结 第19篇
equals源代码中可以看到：
JDK自带的equals有两种，针对Object对象及String对象
1、String中的equals
==判断是否相等，相等直接返回true->再判断是否为string类型，否直接返回false->是则继续判断对象length->循环判断char是否相等（jdk8使用的是char，高版本的jdk已使用效率更高的byte）
2、Object中的equals
直接return (this == obj)，一般业务对象比较要改造equals方法
.自定义对象需要重写equals