java复制代码@Bean @ConditionalOnMissingBean  // RibbonClientConfiguration 被加载，从 IOC 容器中获取对应实例填充到 ZoneAwareLoadBalancer
public ILoadBalancer ribbonLoadBalancer(IClientConfig config,
                                        ServerList<Server> serverList, ServerListFilter<Server> serverListFilter,
                                        IRule rule, IPing ping, ServerListUpdater serverListUpdater) {
    ...
    return new ZoneAwareLoadBalancer<>(config, rule, ping, serverList,
            serverListFilter, serverListUpdater);
}

public ZoneAwareLoadBalancer(IClientConfig clientConfig, IRule rule,
                             IPing ping, ServerList<T> serverList, ServerListFilter<T> filter,
                             ServerListUpdater serverListUpdater) {
    // 调用父类构造方法
    super(clientConfig, rule, ping, serverList, filter, serverListUpdater);
}

java复制代码public DynamicServerListLoadBalancer(IClientConfig clientConfig, IRule rule, IPing ping,
                                     ServerList<T> serverList, ServerListFilter<T> filter,
                                     ServerListUpdater serverListUpdater) {
    // 调用父类 BaseLoadBalancer 初始化一些配置，包括 Ping（检查服务是否可用）Rule（负载均衡规则）
    super(clientConfig, rule, ping);  
    // 较重要，获取注册中心服务的接口
    this.serverListImpl = serverList;
    this.filter = filter;
    this.serverListUpdater = serverListUpdater;
    if (filter instanceof AbstractServerListFilter) {
        ((AbstractServerListFilter) filter).setLoadBalancerStats(getLoadBalancerStats());
    }
    // 初始化步骤分了两步走，第一步在上面，这一步就是其余的初始化
    restOfInit(clientConfig);
}

java复制代码public interface IPing {
    public boolean isAlive(Server server);
}

java复制代码void restOfInit(IClientConfig clientConfig) {
    boolean primeConnection = this.isEnablePrimingConnections();
    // turn this off to avoid duplicated asynchronous priming done in BaseLoadBalancer.setServerList()
    this.setEnablePrimingConnections(false);
    // 初始化服务列表，并启用定时器，对服务列表作出更新
    enableAndInitLearnNewServersFeature();
    // 更新服务列表，enableAndInitLearnNewServersFeature 中定时器的执行的就是此方法
    updateListOfServers();
    if (primeConnection && this.getPrimeConnections() != null) {
        this.getPrimeConnections()
                .primeConnections(getReachableServers());
    }
    this.setEnablePrimingConnections(primeConnection);
    LOGGER.info("DynamicServerListLoadBalancer for client {} initialized: {}", clientConfig.getClientName(), this.toString());
}

java复制代码public void updateListOfServers() {
    List<T> servers = new ArrayList<T>();
    if (serverListImpl != null) {
        // 获取服务列表数据
        servers = serverListImpl.getUpdatedListOfServers();
        LOGGER.debug("List of Servers for {} obtained from Discovery client: {}",
                getIdentifier(), servers);

        if (filter != null) {
            servers = filter.getFilteredListOfServers(servers);
            LOGGER.debug("Filtered List of Servers for {} obtained from Discovery client: {}",
                    getIdentifier(), servers);
        }
    }
    // 更新所有服务列表
    updateAllServerList(servers);
}

java复制代码public interface ServerList<T extends Server> {
    public List<T> getInitialListOfServers();
    public List<T> getUpdatedListOfServers();
}

diff复制代码+ DynamicServerListLoadBalancer#enableAndInitLearnNewServersFeature
+ BaseLoadBalancer#setupPingTask

java复制代码public interface ILoadBalancer {
    public Server chooseServer(Object key);
  	...
}

java复制代码public Server choose(ILoadBalancer lb, Object key) {
    ... 
    Server server = null;
    while (server == null) {
        ...
        List<Server> upList = lb.getReachableServers();  // 获取服务列表健康实例
        List<Server> allList = lb.getAllServers();  // 获取服务列表全部实例
        int serverCount = allList.size();  // 全部实例数量
        if (serverCount == 0) {  // 全部实例数量为空，返回 null，相当于错误返回
            return null;
        }
        int index = chooseRandomInt(serverCount);  // 考虑到效率问题，使用多线程 ThreadLocalRandom 获取随机数
        server = upList.get(index);  // 获取健康实例
        if (server == null) {
            // 作者认为出现获取 server 为空，证明服务列表正在调整，但是！这只是暂时的，所以当前释放出了 CPU
            Thread.yield();
            continue;
        }
        if (server.isAlive()) {  // 服务为健康，返回
            return (server);
        }
        ...
    }
    return server;
}

java复制代码@Slf4j
public class MyRule extends AbstractLoadBalancerRule {
    @Override
    public Server choose(Object key) {
        ILoadBalancer loadBalancer = getLoadBalancer();
        while (true && ) {
            Server server = null;
            // 获取已启动并且可访问的服务列表
            List<Server> reachableServers = loadBalancer.getReachableServers();
            if (CollectionUtils.isEmpty(reachableServers)) return null;
            int idx = ThreadLocalRandom.current().nextInt(reachableServers.size());
            server = reachableServers.get(idx);
            if (server == null || server.isAlive()) {
                log.warn("Ribbon 服务实例异常, 获取为空 || 状态不健康");
                Thread.yield();
                continue;
            }
            return server;
        }
    }

    ... initWithNiwsConfig 不用实现
}

ini复制代码//durable=true，实现queue的持久化

Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare("queue.persistent.name", true, false, false, null);

typescript复制代码//Channel类中queueDeclare的完整定义如下:
/**
 * Declare a queue
 * @see com.rabbitmq.client.AMQP.Queue.Declare
 * @see com.rabbitmq.client.AMQP.Queue.DeclareOk
 * @param queue(队列名称)the name of the queue 
 * @param durable(持久化)true if we are declaring a durable queue (the queue will survive a server restart) 
 * @param exclusive(排他队列) true if we are declaring an exclusive queue (restricted to this connection)
 * @param autoDelete(自动删除) true if we are declaring an autodelete queue (server will delete it when no longer in use)
 * @param arguments other properties (construction arguments) for the queue
 * @return a declaration-confirm method to indicate the queue was successfully declared
 * @throws java.io.IOException if an error is encountered
 */
Queue.DeclareOk queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,
                             Map<String, Object> arguments) throws IOException;
                             
exclusive：排他队列，如果一个队列被声明为排他队列，该队列仅对首次申明它的连接可见，并在连接断开时自动删除。
这里需要注意三点：
1. 排他队列是基于连接可见的，同一连接的不同信道是可以同时访问同一连接创建的排他队列；
2.“首次”，如果一个连接已经声明了一个排他队列，其他连接是不允许建立同名的排他队列的，这个与普通队列不同；
3.即使该队列是持久化的，一旦连接关闭或者客户端退出，该排他队列都会被自动删除的，这种队列适用于一个客户端发送读取消息的应用场景。

autoDelete：自动删除，如果该队列没有任何订阅的消费者的话，该队列会被自动删除。这种队列适用于临时队列。

bash复制代码//durable=true，持久化
channel.exchangeDeclare(exchangeName, “direct/topic/header/fanout”, true);

typescript复制代码//exchangeDeclare的完整定义如下：
Exchange.DeclareOk exchangeDeclare(String exchange, String type, boolean durable) throws IOException;
Exchange.DeclareOk exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete,
                                   Map<String, Object> arguments) throws IOException;
Exchange.DeclareOk exchangeDeclare(String exchange, String type) throws IOException;
Exchange.DeclareOk exchangeDeclare(String exchange,
                                          String type,
                                          boolean durable,
                                          boolean autoDelete,
                                          boolean internal,
                                          Map<String, Object> arguments) throws IOException;
void exchangeDeclareNoWait(String exchange,
                           String type,
                           boolean durable,
                           boolean autoDelete,
                           boolean internal,
                           Map<String, Object> arguments) throws IOException;
Exchange.DeclareOk exchangeDeclarePassive(String name) throws IOException;

less复制代码//MessageProperties.PERSISTENT_TEXT_PLAIN 为消息持久化
channel.basicPublish("exchange.persistent", "persistent", MessageProperties.PERSISTENT_TEXT_PLAIN, "persistent_test_message".getBytes());

typescript复制代码//basicPublish完整定义如下：
void basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body) throws IOException;
void basicPublish(String exchange, String routingKey, boolean mandatory, BasicProperties props, byte[] body)
        throws IOException;
void basicPublish(String exchange, String routingKey, boolean mandatory, boolean immediate, BasicProperties props, byte[] body)
        throws IOException;
        
exchange表示exchange的名称
routingKey表示routingKey的名称
body代表发送的消息体

//BasicProperties定义如下，deliveryMode=1代表不持久化，deliveryMode=2代表持久化
public BasicProperties(
            String contentType,//消息类型如：text/plain
            String contentEncoding,//编码
            Map<String,Object> headers,
            Integer deliveryMode,//1:nonpersistent 2:persistent
            Integer priority,//优先级
            String correlationId,
            String replyTo,//反馈队列
            String expiration,//expiration到期时间
            String messageId,
            Date timestamp,
            String type,
            String userId,
            String appId,
            String clusterId)

//MessageProperties.PERSISTENT_TEXT_PLAIN定义如下：其中deliveryMode=2表示持久化
public static final BasicProperties PERSISTENT_TEXT_PLAIN =new BasicProperties("text/plain",null,null,2,0, null, null, null,null, null, null, null,null, null);

ini复制代码try {
    channel.txSelect();
    channel.basicPublish(exchange, routingKey, MessageProperties.PERSISTENT_TEXT_PLAIN, msg.getBytes());
    int result = 1 / 0;
    channel.txCommit();
} catch (Exception e) {
    e.printStackTrace();
    channel.txRollback();
}

scss复制代码\\普通confirm模式最简单，publish一条消息后，等待服务器端confirm,如果服务端返回false或者超时时间内未返回，客户端进行消息重传。

channel.basicPublish(ConfirmConfig.exchangeName, ConfirmConfig.routingKey, MessageProperties.PERSISTENT_TEXT_PLAIN, ConfirmConfig.msg_10B.getBytes());
if(!channel.waitForConfirms()){
	System.out.println("send message failed.");
}

scss复制代码channel.confirmSelect();
for(int i=0;i<batchCount;i++){
	channel.basicPublish(ConfirmConfig.exchangeName, ConfirmConfig.routingKey, MessageProperties.PERSISTENT_TEXT_PLAIN, ConfirmConfig.msg_10B.getBytes());
}
if(!channel.waitForConfirms()){
	System.out.println("send message failed.");
}

csharp复制代码SortedSet<Long> confirmSet = Collections.synchronizedSortedSet(new TreeSet<Long>());
channel.confirmSelect();
channel.addConfirmListener(new ConfirmListener() {
    public void handleAck(long deliveryTag, boolean multiple) throws IOException {
        if (multiple) {
            confirmSet.headSet(deliveryTag + 1).clear();
        } else {
            confirmSet.remove(deliveryTag);
        }
    }
    public void handleNack(long deliveryTag, boolean multiple) throws IOException {
    	System.out.println("Nack, SeqNo: " + deliveryTag + ", multiple: " + multiple);
        if (multiple) {
            confirmSet.headSet(deliveryTag + 1).clear();
        } else {
            confirmSet.remove(deliveryTag);
        }
    }
});

while (true) {
   long nextSeqNo = channel.getNextPublishSeqNo();
   channel.basicPublish(ConfirmConfig.exchangeName, ConfirmConfig.routingKey, MessageProperties.PERSISTENT_TEXT_PLAIN, ConfirmConfig.msg_10B.getBytes());
   confirmSet.add(nextSeqNo);
}

scss复制代码   QueueingConsumer consumer = new QueueingConsumer(channel);
   channel.basicConsume(ConfirmConfig.queueName, false, consumer);
   
   while(true){
       QueueingConsumer.Delivery delivery = consumer.nextDelivery();
       String msg = new String(delivery.getBody());
// do something with msg. 
       channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
   }

sql复制代码update table set count=count-1,version=version+1 where id=2 and version=1

sql复制代码Select count(id) from table where id = 唯一ID+指纹码

css复制代码给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  
写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

提示：
你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。

csharp复制代码[left , mid - 1]
[mid , right]

csharp复制代码[left , mid]
[mid + 1, right]

kotlin复制代码fun search(nums: IntArray, target: Int): Int {
    if (nums.size == 0) {
        return -1
    }
    var left = 0
    var right = nums.size - 1
    while (left < right) {
        写法 1：尝试排除左区间
        val mid = (left + right) ushr 1
        if (nums[mid] < target) {
            // [mid]严格小于目标值，不是解
            // 那么，下次搜索区间为[mid + 1,right]
            left = mid + 1
        } else {
            // [mid]可能是解
            // 那么，下次搜索区间为[left,mid]
            right = mid
        }
    }
    return if (nums[left] == target) left else -1
}

kotlin复制代码fun search(nums: IntArray, target: Int): Int {
    if (nums.size == 0) {
        return -1
    }
    var left = 0
    var right = nums.size - 1
    while (left < right) {
        写法 2：尝试排除右区间
        val mid = (left + right + 1) ushr 1
        if (nums[mid] > target) {
            // [mid]严格大于目标值，不是解
            // 那么，下次搜索区间为[left,mid - 1]
            right = mid - 1
        } else {
            // [mid]可能是解
            // 那么，下次搜索区间为[mid,right]
            left = mid
        }
    }
    return if (nums[left] == target) left else -1
}

css复制代码mid = left + (right - left) / 2

css复制代码mid = (left + right) ushr 1

ini复制代码[left , mid - 1] 尝试抛弃
[mid , right]

即：
left = mid
right = mid - 1

ini复制代码[left , mid]
[mid + 1, right] 尝试抛弃

即：
left = mid + 1
right = mid

css复制代码向下取整：
(left + right) ushr 1
left + (right - left) / 2
向上取整：
(left + right + 1) ushr 1
left + (right - left + 1) / 2

kotlin复制代码class Solution {
    fun searchInsert(nums: IntArray, target: Int): Int {
        if (nums.isEmpty()) {
            return 0
        }
        // 如果中位数严格小于 target，那么左区间一定不是插入位置
        var left = 0
        var right = nums.size - 1
        while (left < right) {
            val mid = (left + right) ushr 1
            if (nums[mid] < target) {
                left = mid + 1
            } else {
                right = mid
            }
        }
        return if (nums[left] < target) left + 1 else left
    }
}

kotlin复制代码class Solution {
    fun mySqrt(x: Int): Int {
        if (x < 0) {
            return -1
        }
        if (x <= 1) {
            return x
        }
        // 中位数平方严格大于 x，那么右区间一定不是解
        var left: Long = 0L
        var right: Long = (x ushr 1).toLong()
        while (left < right) {
            val mid: Long = ((left + right + 1) ushr 1).toLong()
            if (mid * mid > x) {
                right = mid - 1
            } else {
                left = mid
            }
        }
        return left.toInt()
    }
}

kotlin复制代码class Solution {
    fun findPeakElement(nums: IntArray): Int {
        if (nums.isEmpty()) {
            return -1
        }
        if (nums.size == 1) {
            return 0
        }
        var left = 0
        var right = nums.size - 1

    while (left < right) {
        val mid = (left + right + 1) ushr 1
        // 如果中位数严格小于前驱，那么右区间一定不是解
        if (nums[mid] < nums[mid - 1]) {
            right = mid - 1
        } else {
            left = mid
        }
    }
    return left
}




}
`}`

kotlin复制代码class Solution : GuessGame() {
    override fun guessNumber(n: Int): Int {
        // 中位数严格小于目标数，那么左区间一定不是解
        var left = 0
        var right = n
        while (left < right) {
            val mid = (left + right) ushr 1
            if (1 == guess(mid)) {
                left = mid + 1
            } else {
                right = mid
            }
        }
        return left
    }
}

kotlin复制代码class Solution {
    fun searchRange(nums: IntArray, target: Int): IntArray {
        if (nums.isEmpty()) {
            return intArrayOf(-1, -1)
        }

    val leftIndex = nums.firstOf(target)
    if (-1 == leftIndex) {
        return intArrayOf(-1, -1)
    }
    val rightIndex = nums.lastOf(target)
    return intArrayOf(leftIndex, rightIndex)
}

private fun IntArray.firstOf(target: Int): Int {
    var left = 0
    var right = size - 1
    while (left < right) {
        val mid = (left + right) ushr 1
        // 中位数严格小于目标数，那么一定不是开始位置
        if (this[mid] < target) {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return if (this[left] == target) left else -1
}

private fun IntArray.lastOf(target: Int): Int {
    var left = 0
    var right = size - 1
    while (left < right) {
        val mid = (left + right + 1) ushr 1
        // 中位数严格大于目标数，那么一定不是结束位置
        if (this[mid] > target) {
            right = mid - 1
        } else {
            left = mid
        }
    }
    return left
}




}
`}`

kotlin复制代码class Solution {
    fun search(nums: IntArray, target: Int): Int {
        if (nums.isEmpty()) {
            return -1
        }
        var left = 0
        var right = nums.size - 1
        while (left < right) {
            val mid = (left + right + 1) ushr 1
            if (nums[0] < nums[mid]) {
                // 区间 [left,mid] 严格升序，尝试抛弃左区间
                // 有 [left,mid - 1] 也是升序的，所以可以直接使用 mid - 1 对应的前中位数
                val mid2 = mid - 1
                if (nums[mid2] < target || nums[0] > target) {
                    left = mid2 + 1 // 下次搜索[mid2,right]
                } else {
                    right = mid2 // 下次搜索[left,mid2]
                }
            } else {
                // 区间 [mid,right] 严格升序，尝试抛弃右区间
                if (nums[mid] > target || nums[nums.size - 1] < target) { // nums[0] < target 在 [3,1] 1 出错
                    right = mid - 1 // 下次搜索[left,mid-1]
                } else {
                    left = mid // 下次搜索[mid,right]
                }
            }
        }
        return if (nums[left] == target) left else -1
    }
}

kotlin复制代码class Solution {
    fun search(nums: IntArray, target: Int): Int {
        if (nums.isEmpty()) {
            return -1
        }
        var left = 0
        var right = nums.size - 1
        while (left < right) {
            val mid = (left + right + 1) ushr 1
            // 因为数组存在重复数字，如果中点和左端的数字相同，我们并不能确定是左区间全部相同，还是右区间完全相同。
            // 此时，我们将 left++ ，相当于去掉一个重复的干扰项
            if(nums[left] == nums[mid]){
                left ++
                continue
            }
            if (nums[0] < nums[mid]) {
                // 区间 [left,mid] 严格升序，尝试抛弃左区间
                // 有 [left,mid - 1] 也是升序的，所以可以直接使用 mid - 1 对应的前中位数
                val mid2 = mid - 1
                if (nums[mid2] < target || nums[0] > target) {
                    left = mid2 + 1 // 下次搜索[mid2,right]
                } else {
                    right = mid2 // 下次搜索[left,mid2]
                }
            } else {
                // 区间 [mid,right] 严格升序，尝试抛弃右区间
                if (nums[mid] > target || nums[nums.size - 1] < target) { // nums[0] < target 在 [3,1] 1 出错
                    right = mid - 1 // 下次搜索[left,mid-1]
                } else {
                    left = mid // 下次搜索[mid,right]
                }
            }
        }
        return if (nums[left] == target) left else -1
    }
}

kotlin复制代码class Solution {
    fun findMin(nums: IntArray): Int {
        if (nums.isEmpty()) {
            return -1
        }
        if (nums.size == 1) {
            return nums[0]
        }
        // 寻找比左边小的点
        var left = 0
        var right = nums.size - 1
        while (left < right) {
            val mid = (left + right) ushr 1
            if (nums[mid] > nums[right]) { // nums[mid] > nums[nums.size - 1] 在 [3,1,3] 错
                left = mid + 1
            } else {
                right = mid
            }
        }
        return nums[left]
    }
}

kotlin复制代码class Solution {
    fun findMin(nums: IntArray): Int {
        if (nums.isEmpty()) {
            return -1
        }
        if (nums.size == 1) {
            return nums[0]
        }
        // 寻找比左边小的点
        var left = 0
        var right = nums.size - 1
        while (left < right) {
            val mid = (left + right) ushr 1
            // 排除一个元素
            if (nums[right] == nums[mid]) {
                right--
                continue
            }

        if (nums[mid] > nums[right]) { // nums[mid] > nums[nums.size - 1] 在 [3,1,3] 错
            left = mid + 1
        } else {
            right = mid
        }
    }
    return nums[left]
}




}
`}`

kotlin复制代码class Solution {
    fun findInMountainArray(target: Int, mountainArr: MountainArray): Int {
        if (0 == mountainArr.length()) {
            return -1
        }
        // 先找到山脉数组的峰值，再分别在两个区间内搜索目标值
        val topIndex = findTopIndex(mountainArr, target)
        if (mountainArr.get(topIndex) == target) {
            return topIndex
        }
        val targetIndex = findInAsc(mountainArr, target, 0, topIndex)
        if (-1 != targetIndex) {
            return targetIndex
        }
        return findInDesc(mountainArr, target, topIndex, mountainArr.length() - 1)
    }

private fun findInAsc(mountainArr: MountainArray, target: Int, start: Int, end: Int): Int {
    // 中位数严格小于目标数，那么左区间一定不是解
    var left = 0
    var right = end
    while (left < right) {
        val mid = (left + right) ushr 1
        if (mountainArr.get(mid) < target) {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return if (mountainArr.get(left) == target) left else -1
}

private fun findInDesc(mountainArr: MountainArray, target: Int, start: Int, end: Int): Int {
    // 中位数严格小于目标数，那么右区间一定不是解
    var left = 0
    var right = end
    while (left < right) {
        val mid = (left + right + 1) ushr 1
        if (mountainArr.get(mid) < target) {
            right = mid - 1
        } else {
            left = mid
        }
    }
    return if (mountainArr.get(left) == target) left else -1
}

private fun findTopIndex(mountainArr: MountainArray, target: Int): Int {
    // 如果中位数严格小于前驱，那么右区间一定不是解
    var left = 0
    var right = mountainArr.length()
    while (left < right) {
        val mid = (left + right + 1) ushr 1
        if (mountainArr.get(mid) < mountainArr.get(mid - 1)) {
            right = mid - 1
        } else {
            left = mid
        }
    }
    return left
}




}
`}`

复制代码给定一个非负整数数组 nums 和一个整数 m ，你需要将这个数组分成 m 个非空的连续子数组。

设计一个算法使得这 m 个子数组各自和的最大值最小。

kotlin复制代码class Solution {
    fun splitArray(nums: IntArray, m: Int): Int {
        // 最大数组和决定分隔数组个数，并符合单调性，使用二分法找出最小数组和和最大数组和的区间内，满足数组个数 m 的最小值
        // 最大数组和：整个数组和
        // 最小数组和：数组中最大的数
        var maxSum = 0
        var minSum = Integer.MIN_VALUE
        for (num in nums) {
            maxSum += num
            minSum = Math.max(minSum, num)
        }
        // 中位数对应的分隔数组大于严格小于 m，那么左区间一定不是解（需要调大最大数组和）
        var left = minSum
        var right = maxSum
        while (left < right) {
            val mid = (left + right) ushr 1
            if (nums.split(mid) > m) {
                left = mid + 1
            } else {
                right = mid
            }
        }
        return left
    }

private fun IntArray.split(maxSum: Int): Int {
    var count = 1 // 最少分割为 1 个数组
    var curSum = 0
    for (num in this) {
        if (curSum + num > maxSum) {
            count++
            curSum = 0
        }
        curSum += num
    }
    return count
}




}
`}`

kotlin复制代码class Solution {
    fun minEatingSpeed(piles: IntArray, H: Int): Int {
        if (piles.size > H) {
            return H
        }
        // 速度决定时长，并符合单调性，使用二分法找出最小速度和最大速度区间内，满足时长 H 的最小值
        // 最大速度：香蕉最多的堆
        // 最小速度：1
        val minSpeed = 1
        var maxSpeed = piles.let {
            var max = 1
            for (pile in it) {
                max = Math.max(max, pile)
            }
            max
        }
        var left = minSpeed
        var right = maxSpeed
        while (left < right) {
            // 中位数时长大于 H，那么左区间一定不是解
            val mid = (left + right) ushr 1
            val hour = piles.getHour(mid)
            if (hour > H) {
                left = mid + 1
            } else {
                right = mid
            }
        }
        return left
    }

/**
 * 获取当前速度需要的时间
 */
private fun IntArray.getHour(speed: Int): Int {
    var hour = 0
    for (pile in this) {
        // hour += (pile - 1) / speed + 1 // 向上取整
        hour += (pile + speed - 1) / speed // 向上取整
    }
    return hour
}




}
`}`

kotlin复制代码class Solution {
    fun findBestValue(arr: IntArray, target: Int): Int {
        // value 决定数组和，并符合单调性，使用二分法找出 value 和 value 区间内，最接近 target 的最小值
        // 最大 value：数组的最大值
        // 最小 value：0
        val minValue = 0
        val maxValue = arr.let {
            var max = Integer.MIN_VALUE
            for (num in arr) {
                max = Math.max(max, num)
            }
            max
        }
        // “最接近”的判断条件不好写，因为选定了一个 value 求和以后，value 变小，接近程度可能变大也可能变小，所以需要寻找别的方案。
        // 如果选择一个 value ，对应的数组和是第一个大于等于 target 的，那么目标值可能在 value 也可能在 value - 1（也可以找最后一个小于等于target的）

    // 如果中位数对应的数组和严格小于 target，那么左区间一定不是解
    var left = minValue
    var right = maxValue
    while (left < right) {
        val mid = (left + right) ushr 1
        if (arr.sum(mid, target) < target) {
            left = mid + 1
        } else {
            right = mid
        }
    }
    val diff1 = Math.abs(arr.sum(left - 1, target) - target)
    val diff2 = Math.abs(arr.sum(left, target) - target)
    return if (diff1 <= diff2) left - 1 else left
}

private fun IntArray.sum(value: Int, target: Int): Int {
    var sum = 0
    for (num in this) {
        sum += Math.min(value, num)
    }
    return sum
}




}
`}`

kotlin复制代码class Solution {
    fun minDays(bloomDay: IntArray, m: Int, k: Int): Int {
        // 天数决定花束，并符合单调性，使用二分法找出最小天数和最大天数区间内，满足花束 m 的最小值
        // 最大天数：最后盛开的花
        // 最小天数：1
        val minDay = 1
        val maxDay = bloomDay.let {
            var max = 0
            for (bloom in bloomDay) {
                max = Math.max(max, bloom)
            }
            max
        }

    // 如果中位数可以采集的花束严格小于 m，那么左区间一定不是解
    var left = minDay
    var right = maxDay
    while (left < right) {
        val mid = (left + right) ushr 1
        if (bloomDay.collect(mid, k) < m) {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return if (bloomDay.collect(left, k) >= m) left else -1
}

private fun IntArray.collect(day: Int, k: Int): Int {
    var bouquets = 0
    var collected = 0
    var index = 0

    while (index < size) {
        if (this[index] <= day) {
            if (++collected == k) {
                // 完成一束
                bouquets++
                collected = 0
            }
        } else {
            collected = 0
        }
        index++
    }
    return bouquets
}




}
`}`

kotlin复制代码class Solution {
    fun minTime(time: IntArray, m: Int): Int {
        // 一天做题时间决定完成天数，并符合单调性，使用二分法找出最小做题时间和最大做题时间区间内，满足 m 天的最小值
        // 最大做题时间：所有题目的和
        // 最小做题时间：每天都将题目交给小杨，0（如果不能求助，就是最难题目的完成题目时间）

    val minTime = 0
    val maxTime = time.let {
        var sum = 0
        for (theTime in time) {
            sum += theTime
        }
        sum
    }

    fun IntArray.puzzle(dayTime: Int): Int {
        var count = 1 // 最少需要花费一天
        var today = 0 // 大于 dayTime 隔一天
        var todayDifficult = -1 // 找出当天内最难的题目交给小杨
        var isTodayHelped = false // 当前是否已经求助过
        var index = 0
        while (index < time.size) {
            // 最难一题
            todayDifficult = if (-1 == todayDifficult || time[index] >= time[todayDifficult]) index else todayDifficult
            if (today + time[index] > dayTime) {
                if (isTodayHelped) {
                    count++
                    isTodayHelped = false
                    todayDifficult = -1
                    today = 0
                } else {
                    isTodayHelped = true
                    today -= time[todayDifficult]
                }
            } else {
                today += time[index++]
            }
        }
        return count
    }

    // 如果中位数对应的完成天数严格大于 m，那么只有增大做题时间，左区间一定不是解
    var left = minTime
    var right = maxTime
    while (left < right) {
        val mid = (left + right) ushr 1
        if (time.puzzle(mid) > m) {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return if (time.puzzle(left) <= m) left else 0
}




}
`}`

xml复制代码<?xml version="1.0" encoding="UTF-8"?>
<class id="1">
	<student>
		<num>0001</num>
		<name>张三</name>
		<age>19</age>
	</student>
	
	<student>
		<num>0002</num>
		<name>李四</name>
		<age>21</age>
		<hobby>
			<name>足球</name>
			<name>篮球</name>
		</hobby>
	</student>
	
	<teacher>
		<name>王老师</name>
		<age>40</age>
		<course>Java</course>
	</teacher>
</class>

java复制代码package cn.javacodes.dom4j;

import java.io.File;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

public class TestDom4j {

	public static void main(String[] args) throws Exception {
		// 获取SAX阅读器
		SAXReader reader = new SAXReader();
		// 获取Document对象
		Document doc = reader.read(new File("d:/DemoXML.xml"));
		// 获取根节点
		Element root = doc.getRootElement();
		// 输出测试
		System.out.println("根节点：" + root.getName() + ",id="
				\+ root.attributeValue("id"));
	}

}

java复制代码// 迭代root元素的所有子元素
for (Iterator i = root.elementIterator(); i.hasNext(); ) {
      Element element = (Element) i.next();
      System.out.println(element.getName());
}

java复制代码// 通过元素名称“student”迭代子元素
for ( Iterator i = root.elementIterator( "student" ); i.hasNext(); ) {
    Element foo = (Element) i.next();
    System.out.println(foo.getName());
}

java复制代码// 迭代root元素的所有属性
for ( Iterator i = root.attributeIterator(); i.hasNext(); ) {
      Attribute attribute = (Attribute) i.next();
      System.out.println(attribute.getName() + ":" + attribute.getValue());
}

java复制代码public  static void showAllElementText(Element e){
      for (Iterator i = e.elementIterator(); i.hasNext(); ) {
           Element element = (Element) i.next();
           if (!element.elements().isEmpty()) {
            	showAllElementText(element);
           } else {
                System.out.println(element.getName()+"="+element.getTextTrim());
           }            
      }
}

java复制代码// 获取SAX阅读器
SAXReader reader = new SAXReader();
// 获取Document对象
Document doc = reader.read(new File("d:/DemoXML.xml"));
// 获取student元素的name节点
Node node = doc.selectSingleNode("//student/name");
// 输出测试
System.out.println(node.getName() + "=" + node.getText());

java复制代码// 获取所有student元素的name节点
List<Node> list = doc.selectNodes("//student");
// 输出测试
for (Node node : list) {
    System.out.println(node.getName() 
                 \+ ":" \+ node.valueOf("name"));
}

java复制代码    public void findLinks(Document document) throws DocumentException {
        List list = document.selectNodes( "//a/@href" );
        for (Iterator iter = list.iterator(); iter.hasNext(); ) {
            Attribute attribute = (Attribute) iter.next();
            String url = attribute.getValue();
        }
    }

java复制代码    public void treeWalk(Document document) {
        treeWalk( document.getRootElement() );
    }

    public void treeWalk(Element element) {
        for ( int i = 0, size = element.nodeCount(); i < size; i++ ) {
            Node node = element.node(i);
            if ( node instanceof Element ) {
                treeWalk( (Element) node );
            }
            else {
                // 这里写你想要做的操作
            }
        }
    }

java复制代码import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;

public class Foo {

    public Document createDocument() {
        Document document = DocumentHelper.createDocument();
        Element root = document.addElement( "root" );

        Element author1 = root.addElement( "author" )
            .addAttribute( "name", "James" )
            .addAttribute( "location", "UK" )
            .addText( "James Strachan" );
        
        Element author2 = root.addElement( "author" )
            .addAttribute( "name", "Bob" )
            .addAttribute( "location", "US" )
            .addText( "Bob McWhirter" );

        return document;
    }
}

java复制代码document.write( new FileWriter( "foo.xml" ));

java复制代码import org.dom4j.Document;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

public class Foo {

    public void write(Document document) throws IOException {

        // 写入到一个文件
        XMLWriter writer = new XMLWriter(
            new FileWriter( "output.xml" )
        );
        writer.write( document );
        writer.close();


        // 更加美观的排版
        OutputFormat format = OutputFormat.createPrettyPrint();
        writer = new XMLWriter( System.out, format );
        writer.write( document );

        // 更加紧凑的排版
        format = OutputFormat.createCompactFormat();
        writer = new XMLWriter( System.out, format );
        writer.write( document );
    }
}

java复制代码        Document document = ...;
        String text = document.asXML();

java复制代码        String text = "<person> <name>James</name> </person>";
        Document document = DocumentHelper.parseText(text);

java复制代码import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;

import org.dom4j.Document;
import org.dom4j.io.DocumentResult;
import org.dom4j.io.DocumentSource;

public class Foo {

    public Document styleDocument(
        Document document, 
        String stylesheet
    ) throws Exception {

        // 使用JAXP加载transformer
        TransformerFactory factory = TransformerFactory.newInstance();
        Transformer transformer = factory.newTransformer( 
            new StreamSource( stylesheet ) 
        );

        // 样式化document
        DocumentSource source = new DocumentSource( document );
        DocumentResult result = new DocumentResult();
        transformer.transform( source, result );

        // 返回转换后的document
        Document transformedDoc = result.getDocument();
        return transformedDoc;
    }
}

ini复制代码Native Memory Tracking:

Total: reserved=6308603KB, committed=4822083KB
-                 Java Heap (reserved=4194304KB, committed=4194304KB)
                            (mmap: reserved=4194304KB, committed=4194304KB) 
 
-                     Class (reserved=1161041KB, committed=126673KB)
                            (classes #21662)
                            (  instance classes #20542, array classes #1120)
                            (malloc=3921KB #64030) 
                            (mmap: reserved=1157120KB, committed=122752KB) 
                            (  Metadata:   )
                            (    reserved=108544KB, committed=107520KB)
                            (    used=105411KB)
                            (    free=2109KB)
                            (    waste=0KB =0.00%)
                            (  Class space:)
                            (    reserved=1048576KB, committed=15232KB)
                            (    used=13918KB)
                            (    free=1314KB)
                            (    waste=0KB =0.00%)
 
-                    Thread (reserved=355251KB, committed=86023KB)
                            (thread #673)
                            (stack: reserved=353372KB, committed=84144KB)
                            (malloc=1090KB #4039) 
                            (arena=789KB #1344)
 
-                      Code (reserved=252395KB, committed=69471KB)
                            (malloc=4707KB #17917) 
                            (mmap: reserved=247688KB, committed=64764KB) 
 
-                        GC (reserved=199635KB, committed=199635KB)
                            (malloc=11079KB #29639) 
                            (mmap: reserved=188556KB, committed=188556KB) 
 
-                  Compiler (reserved=2605KB, committed=2605KB)
                            (malloc=2474KB #2357) 
                            (arena=131KB #5)
 
-                  Internal (reserved=3643KB, committed=3643KB)
                            (malloc=3611KB #8683) 
                            (mmap: reserved=32KB, committed=32KB) 
 
-                     Other (reserved=67891KB, committed=67891KB)
                            (malloc=67891KB #2859) 
 
-                    Symbol (reserved=26220KB, committed=26220KB)
                            (malloc=22664KB #292684) 
                            (arena=3556KB #1)
 
-    Native Memory Tracking (reserved=7616KB, committed=7616KB)
                            (malloc=585KB #8238) 
                            (tracking overhead=7031KB)
 
-               Arena Chunk (reserved=10911KB, committed=10911KB)
                            (malloc=10911KB) 
 
-                   Tracing (reserved=25937KB, committed=25937KB)
                            (malloc=25937KB #8666) 
 
-                   Logging (reserved=5KB, committed=5KB)
                            (malloc=5KB #196) 
 
-                 Arguments (reserved=18KB, committed=18KB)
                            (malloc=18KB #486) 
 
-                    Module (reserved=532KB, committed=532KB)
                            (malloc=532KB #3579) 
 
-              Synchronizer (reserved=591KB, committed=591KB)
                            (malloc=591KB #4777) 
 
-                 Safepoint (reserved=8KB, committed=8KB)
                            (mmap: reserved=8KB, committed=8KB)

csharp复制代码public static void gc() {
    Runtime.getRuntime().gc();
}

csharp复制代码public native void gc();

scss复制代码JVM_ENTRY_NO_ENV(void, JVM_GC(void))
  JVMWrapper("JVM_GC");
  //如果没有将JVM启动参数 DisableExplicitGC 设置为 false，则执行 GC，GC 原因是 System.gc 触发，对应 GCCause::_java_lang_system_gc
  if (!DisableExplicitGC) {
    Universe::heap()->collect(GCCause::_java_lang_system_gc);
  }
JVM_END

scss复制代码//是否应该并行 GC，也就是较为轻量的 GC，对于 GCCause::_java_lang_system_gc，这里就是判断 ExplicitGCInvokesConcurrent 这个 JVM 是否为 true
if (should_do_concurrent_full_gc(cause)) {
    return try_collect_concurrently(cause,
                                    gc_count_before,
                                    old_marking_started_before);
}// 省略其他这里我们不关心的判断分支
 else {
    //否则进入 full GC
    VM_G1CollectFull op(gc_count_before, full_gc_count_before, cause);
    VMThread::execute(&op);
    return op.gc_succeeded();
}

php复制代码void ZDriver::collect(GCCause::Cause cause) {
  switch (cause) {
  //注意这里的 _wb 开头的 GC 原因，这代表是 WhiteBox 触发的，后面我们会用到，这里先记一下
  case GCCause::_wb_young_gc:
  case GCCause::_wb_conc_mark:
  case GCCause::_wb_full_gc:
  case GCCause::_dcmd_gc_run:
  case GCCause::_java_lang_system_gc:
  case GCCause::_full_gc_alot:
  case GCCause::_scavenge_alot:
  case GCCause::_jvmti_force_gc:
  case GCCause::_metadata_GC_clear_soft_refs:
    // Start synchronous GC
    _gc_cycle_port.send_sync(cause);
    break;

  case GCCause::_z_timer:
  case GCCause::_z_warmup:
  case GCCause::_z_allocation_rate:
  case GCCause::_z_allocation_stall:
  case GCCause::_z_proactive:
  case GCCause::_z_high_usage:
  case GCCause::_metadata_GC_threshold:
    // Start asynchronous GC
    _gc_cycle_port.send_async(cause);
    break;

  case GCCause::_gc_locker:
    // Restart VM operation previously blocked by the GC locker
    _gc_locker_port.signal();
    break;

  case GCCause::_wb_breakpoint:
    ZBreakpoint::start_gc();
    _gc_cycle_port.send_async(cause);
    break;

  //对于其他原因，不触发GC，GCCause::_java_lang_system_gc 会走到这里
  default:
    // Other causes not supported
    fatal("Unsupported GC cause (%s)", GCCause::to_string(cause));
    break;
  }
}

ruby复制代码void ShenandoahControlThread::request_gc(GCCause::Cause cause) {
  assert(GCCause::is_user_requested_gc(cause) ||
         GCCause::is_serviceability_requested_gc(cause) ||
         cause == GCCause::_metadata_GC_clear_soft_refs ||
         cause == GCCause::_full_gc_alot ||
         cause == GCCause::_wb_full_gc ||
         cause == GCCause::_scavenge_alot,
         "only requested GCs here");
  //如果是显式GC（即如果是GCCause::_java_lang_system_gc，GCCause::_dcmd_gc_run，GCCause::_jvmti_force_gc，GCCause::_heap_inspection，GCCause::_heap_dump中的任何一个）
  if (is_explicit_gc(cause)) {
    //如果没有关闭显式GC，也就是 DisableExplicitGC 为 false
    if (!DisableExplicitGC) {
      //请求 GC
      handle_requested_gc(cause);
    }
  } else {
    handle_requested_gc(cause);
  }
}

scss复制代码void ShenandoahControlThread::handle_requested_gc(GCCause::Cause cause) {
  MonitorLocker ml(&_gc_waiters_lock);
  //获取当前全局 GC id
  size_t current_gc_id = get_gc_id();
  //因为要进行 GC ，所以将id + 1
  size_t required_gc_id = current_gc_id + 1;
  //直到当前全局 GC id + 1 为止，代表 GC 执行了
  while (current_gc_id < required_gc_id) {
    //设置 gc 状态位，会有其他线程扫描执行 gc
    _gc_requested.set();
    //记录 gc 原因，根据不同原因有不同的处理策略，我们这里是 GCCause::_java_lang_system_gc
    _requested_gc_cause = cause;
    //等待 gc 锁对象 notify，代表 gc 被执行并完成
    ml.wait();
    current_gc_id = get_gc_id();
  }
}

scss复制代码bool explicit_gc_requested = _gc_requested.is_set() &&  is_explicit_gc(_requested_gc_cause);

//省略一些代码

else if (explicit_gc_requested) {
  cause = _requested_gc_cause;
  log_info(gc)("Trigger: Explicit GC request (%s)", GCCause::to_string(cause));

  heuristics->record_requested_gc();
  // 如果 JVM 参数 ExplicitGCInvokesConcurrent 为 true，则走默认轻量 GC
  if (ExplicitGCInvokesConcurrent) {
    policy->record_explicit_to_concurrent();
    mode = default_mode;
    // Unload and clean up everything
    heap->set_unload_classes(heuristics->can_unload_classes());
  } else {
    //否则，执行 FullGC
    policy->record_explicit_to_full();
    mode = stw_full;
  }
}

scss复制代码public static void main(String[] args) throws Exception {
        WhiteBox whiteBox = WhiteBox.getWhiteBox();
        //执行young GC
        whiteBox.youngGC();
        System.out.println("---------------------------------");
        whiteBox.fullGC();
        //执行full GC
        whiteBox.fullGC();
        //保持进程不退出，保证日志打印完整
        Thread.currentThread().join();
}

ini复制代码[0.036s][info][gc] Using G1
[0.048s][info][gc,init] Version: 17-internal+0-adhoc.Administrator.jdk (fastdebug)
[0.048s][info][gc,init] CPUs: 16 total, 16 available
[0.048s][info][gc,init] Memory: 16304M
[0.048s][info][gc,init] Large Page Support: Disabled
[0.048s][info][gc,init] NUMA Support: Disabled
[0.048s][info][gc,init] Compressed Oops: Enabled (32-bit)
[0.048s][info][gc,init] Heap Region Size: 1M
[0.048s][info][gc,init] Heap Min Capacity: 512M
[0.048s][info][gc,init] Heap Initial Capacity: 512M
[0.048s][info][gc,init] Heap Max Capacity: 512M
[0.048s][info][gc,init] Pre-touch: Disabled
[0.048s][info][gc,init] Parallel Workers: 13
[0.048s][info][gc,init] Concurrent Workers: 3
[0.048s][info][gc,init] Concurrent Refinement Workers: 13
[0.048s][info][gc,init] Periodic GC: Disabled
[0.049s][info][gc,metaspace] CDS disabled.
[0.049s][info][gc,metaspace] Compressed class space mapped at: 0x0000000100000000-0x0000000140000000, reserved size: 1073741824
[0.049s][info][gc,metaspace] Narrow klass base: 0x0000000000000000, Narrow klass shift: 3, Narrow klass range: 0x140000000
[1.081s][info][gc,start    ] GC(0) Pause Young (Normal) (WhiteBox Initiated Young GC)
[1.082s][info][gc,task     ] GC(0) Using 12 workers of 13 for evacuation
[1.089s][info][gc,phases   ] GC(0)   Pre Evacuate Collection Set: 0.5ms
[1.089s][info][gc,phases   ] GC(0)   Merge Heap Roots: 0.1ms
[1.089s][info][gc,phases   ] GC(0)   Evacuate Collection Set: 3.4ms
[1.089s][info][gc,phases   ] GC(0)   Post Evacuate Collection Set: 1.6ms
[1.089s][info][gc,phases   ] GC(0)   Other: 1.3ms
[1.089s][info][gc,heap     ] GC(0) Eden regions: 8->0(23)
[1.089s][info][gc,heap     ] GC(0) Survivor regions: 0->2(4)
[1.089s][info][gc,heap     ] GC(0) Old regions: 0->0
[1.089s][info][gc,heap     ] GC(0) Archive regions: 0->0
[1.089s][info][gc,heap     ] GC(0) Humongous regions: 0->0
[1.089s][info][gc,metaspace] GC(0) Metaspace: 6891K(7104K)->6891K(7104K) NonClass: 6320K(6400K)->6320K(6400K) Class: 571K(704K)->571K(704K)
[1.089s][info][gc          ] GC(0) Pause Young (Normal) (WhiteBox Initiated Young GC) 7M->1M(512M) 7.864ms
[1.089s][info][gc,cpu      ] GC(0) User=0.00s Sys=0.00s Real=0.01s
---------------------------------
[1.091s][info][gc,task     ] GC(1) Using 12 workers of 13 for full compaction
[1.108s][info][gc,start    ] GC(1) Pause Full (WhiteBox Initiated Full GC)
[1.108s][info][gc,phases,start] GC(1) Phase 1: Mark live objects
[1.117s][info][gc,phases      ] GC(1) Phase 1: Mark live objects 8.409ms
[1.117s][info][gc,phases,start] GC(1) Phase 2: Prepare for compaction
[1.120s][info][gc,phases      ] GC(1) Phase 2: Prepare for compaction 3.031ms
[1.120s][info][gc,phases,start] GC(1) Phase 3: Adjust pointers
[1.126s][info][gc,phases      ] GC(1) Phase 3: Adjust pointers 5.806ms
[1.126s][info][gc,phases,start] GC(1) Phase 4: Compact heap
[1.190s][info][gc,phases      ] GC(1) Phase 4: Compact heap 63.812ms
[1.193s][info][gc,heap        ] GC(1) Eden regions: 1->0(25)
[1.193s][info][gc,heap        ] GC(1) Survivor regions: 2->0(4)
[1.193s][info][gc,heap        ] GC(1) Old regions: 0->3
[1.193s][info][gc,heap        ] GC(1) Archive regions: 0->0
[1.193s][info][gc,heap        ] GC(1) Humongous regions: 0->0
[1.193s][info][gc,metaspace   ] GC(1) Metaspace: 6895K(7104K)->6895K(7104K) NonClass: 6323K(6400K)->6323K(6400K) Class: 571K(704K)->571K(704K)
[1.193s][info][gc             ] GC(1) Pause Full (WhiteBox Initiated Full GC) 1M->0M(512M) 84.846ms
[1.202s][info][gc,cpu         ] GC(1) User=0.19s Sys=0.63s Real=0.11s

sql复制代码INSERT INTO table (column_list)
VALUES (value_list)
ON DUPLICATE KEY UPDATE
c1 = v1, 
c2 = v2,
...;

java复制代码public class StringSorting {
    public static void main(String[] args) {
        Stream.of("Java", "Python", "C++",
                "C", "Shell", "Ruby",
                "Scala", "Groovy", "Kotlin",
                "Clojure", "Jython", "C#",
                "JavaScript", "SQL")
                .sorted()   // 自然序排序
                .forEach(s -> System.out.printf("%s ", s));  // 打印输出
    }
}

shell复制代码C C# C++ Clojure Groovy Java JavaScript Jython Kotlin Python Ruby SQL Scala Shell

java复制代码public class Arrays {
	...省略...
	public static <T> Stream<T> stream(T[] array) {...}
    public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive) {...}
    public static IntStream stream(int[] array) {...}
    public static IntStream stream(int[] array, int startInclusive, int endExclusive) {...}
    public static LongStream stream(long[] array) {...}
    public static LongStream stream(long[] array, int startInclusive, int endExclusive) {...}
    public static DoubleStream stream(double[] array) {...}
    public static DoubleStream stream(double[] array, int startInclusive, int endExclusive) {...}
    ...省略...
}

java复制代码public class ArraysStream {
    public static void main(String[] args) {
        Arrays.stream(new double[] {3.1415926, 9.8, 3.3333})
                .forEach(System.out::println);
    }
}

java复制代码public interface Stream<T> extends BaseStream<T, Stream<T>> {
	...省略...
    @SafeVarargs
    @SuppressWarnings("varargs") // Creating a stream from an array is safe
    public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }
    ...省略...
}

java复制代码public class StreamOf {
    public static void main(String[] args) {
    	// 将一组数字转换为流
        Stream.of(9.8, 3.1415926, 3.33333)
                .forEach(System.out::println);
    }
}