复制代码`import random`
import math


#
# Shorthand:
#   "pd_" as a variable prefix means "partial derivative"
#   "d_" as a variable prefix means "derivative"
#   "_wrt_" is shorthand for "with respect to"
#   "w_ho" and "w_ih" are the index of weights from hidden to output layer neurons and input to hidden layer neurons respectively
#
# Comment references:
#
# [1] Wikipedia article on Backpropagation
#   http://en.wikipedia.org/wiki/Backpropagation#Finding_the_derivative_of_the_error
# [2] Neural Networks for Machine Learning course on Coursera by Geoffrey Hinton
#   https://class.coursera.org/neuralnets-2012-001/lecture/39
# [3] The Back Propagation Algorithm
#   https://www4.rgu.ac.uk/files/chapter3%20-%20bp.pdf
# [4] The original location of the code
# https://github.com/mattm/simple-neural-network/blob/master/neural-network.py

class NeuralNetwork:
    # 神经网络类
    LEARNING_RATE = 0.5

    # 设置学习率为0.5

    def __init__(self, num_inputs, num_hidden, num_outputs, hidden_layer_weights=None, hidden_layer_bias=None,
                 output_layer_weights=None, output_layer_bias=None):
        # 初始化一个三层神经网络结构
        self.num_inputs = num_inputs

        self.hidden_layer = NeuronLayer(num_hidden, hidden_layer_bias)
        self.output_layer = NeuronLayer(num_outputs, output_layer_bias)

        self.init_weights_from_inputs_to_hidden_layer_neurons(hidden_layer_weights)
        self.init_weights_from_hidden_layer_neurons_to_output_layer_neurons(output_layer_weights)

    def init_weights_from_inputs_to_hidden_layer_neurons(self, hidden_layer_weights):
        weight_num = 0
        for h in range(len(self.hidden_layer.neurons)):  # num_hidden,遍历隐藏层
            for i in range(self.num_inputs):  # 遍历输入层
                if not hidden_layer_weights:
                    # 如果hidden_layer_weights的值为空,则利用随机化函数对其进行赋值,否则利用hidden_layer_weights中的值对其进行更新
                    self.hidden_layer.neurons[h].weights.append(random.random())
                else:
                    self.hidden_layer.neurons[h].weights.append(hidden_layer_weights[weight_num])
                weight_num += 1

    def init_weights_from_hidden_layer_neurons_to_output_layer_neurons(self, output_layer_weights):
        weight_num = 0
        for o in range(len(self.output_layer.neurons)):  # num_outputs,遍历输出层
            for h in range(len(self.hidden_layer.neurons)):  # 遍历输出层
                if not output_layer_weights:
                    # 如果output_layer_weights的值为空,则利用随机化函数对其进行赋值,否则利用output_layer_weights中的值对其进行更新
                    self.output_layer.neurons[o].weights.append(random.random())
                else:
                    self.output_layer.neurons[o].weights.append(output_layer_weights[weight_num])
                weight_num += 1

    def inspect(self):  # 输出神经网络信息
        print('------')
        print('* Inputs: {}'.format(self.num_inputs))
        print('------')
        print('Hidden Layer')
        self.hidden_layer.inspect()
        print('------')
        print('* Output Layer')
        self.output_layer.inspect()
        print('------')

    def feed_forward(self, inputs):  # 返回输出层y值
        hidden_layer_outputs = self.hidden_layer.feed_forward(inputs)
        return self.output_layer.feed_forward(hidden_layer_outputs)

    # Uses online learning, ie updating the weights after each training case
    # 使用在线学习方式,训练每个实例之后对权值进行更新
    def train(self, training_inputs, training_outputs):
        self.feed_forward(training_inputs)
        # 反向传播
        # 1. Output neuron deltas输出层deltas
        pd_errors_wrt_output_neuron_total_net_input = [0]*len(self.output_layer.neurons)
        for o in range(len(self.output_layer.neurons)):
            # 对于输出层∂E/∂zⱼ=∂E/∂a*∂a/∂z=cost'(target_output)*sigma'(z)
            pd_errors_wrt_output_neuron_total_net_input[o] = self.output_layer.neurons[
                o].calculate_pd_error_wrt_total_net_input(training_outputs[o])

        # 2. Hidden neuron deltas隐藏层deltas
        pd_errors_wrt_hidden_neuron_total_net_input = [0]*len(self.hidden_layer.neurons)
        for h in range(len(self.hidden_layer.neurons)):
            # We need to calculate the derivative of the error with respect to the output of each hidden layer neuron
            # 我们需要计算误差对每个隐藏层神经元的输出的导数,由于不是输出层所以dE/dyⱼ需要根据下一层反向进行计算,即根据输出层的函数进行计算
            # dE/dyⱼ = Σ ∂E/∂zⱼ * ∂z/∂yⱼ = Σ ∂E/∂zⱼ * wᵢⱼ
            d_error_wrt_hidden_neuron_output = 0
            for o in range(len(self.output_layer.neurons)):
                d_error_wrt_hidden_neuron_output += pd_errors_wrt_output_neuron_total_net_input[o]* \
                                                    self.output_layer.neurons[o].weights[h]

            # ∂E/∂zⱼ = dE/dyⱼ * ∂zⱼ/∂
            pd_errors_wrt_hidden_neuron_total_net_input[h] = d_error_wrt_hidden_neuron_output*self.hidden_layer.neurons[
                h].calculate_pd_total_net_input_wrt_input()

        # 3. Update output neuron weights 更新输出层权重
        for o in range(len(self.output_layer.neurons)):
            for w_ho in range(len(self.output_layer.neurons[o].weights)):
                # 注意:输出层权重是隐藏层神经元与输出层神经元连接的权重
                # ∂Eⱼ/∂wᵢⱼ = ∂E/∂zⱼ * ∂zⱼ/∂wᵢⱼ
                pd_error_wrt_weight = pd_errors_wrt_output_neuron_total_net_input[o]*self.output_layer.neurons[
                    o].calculate_pd_total_net_input_wrt_weight(w_ho)

                # Δw = α * ∂Eⱼ/∂wᵢ
                self.output_layer.neurons[o].weights[w_ho] -= self.LEARNING_RATE*pd_error_wrt_weight

        # 4. Update hidden neuron weights 更新隐藏层权重
        for h in range(len(self.hidden_layer.neurons)):
            for w_ih in range(len(self.hidden_layer.neurons[h].weights)):
                # 注意:隐藏层权重是输入层神经元与隐藏层神经元连接的权重
                # ∂Eⱼ/∂wᵢ = ∂E/∂zⱼ * ∂zⱼ/∂wᵢ
                pd_error_wrt_weight = pd_errors_wrt_hidden_neuron_total_net_input[h]*self.hidden_layer.neurons[
                    h].calculate_pd_total_net_input_wrt_weight(w_ih)

                # Δw = α * ∂Eⱼ/∂wᵢ
                self.hidden_layer.neurons[h].weights[w_ih] -= self.LEARNING_RATE*pd_error_wrt_weight

    def calculate_total_error(self, training_sets):
        #  使用平方差计算训练集误差
        total_error = 0
        for t in range(len(training_sets)):
            training_inputs, training_outputs = training_sets[t]
            self.feed_forward(training_inputs)
            for o in range(len(training_outputs)):
                total_error += self.output_layer.neurons[o].calculate_error(training_outputs[o])
        return total_error


class NeuronLayer:
    # 神经层类
    def __init__(self, num_neurons, bias):

        # Every neuron in a layer shares the same bias 一层中的所有神经元共享一个bias
        self.bias = bias if bias else random.random()
        random.random()
        # 生成0和1之间的随机浮点数float，它其实是一个隐藏的random.Random类的实例的random方法。
        # random.random()和random.Random().random()作用是一样的。
        self.neurons = []
        for i in range(num_neurons):
            self.neurons.append(Neuron(self.bias))
        # 在神经层的初始化函数中对每一层的bias赋值,利用神经元的init函数对神经元的bias赋值

    def inspect(self):
        # print该层神经元的信息
        print('Neurons:', len(self.neurons))
        for n in range(len(self.neurons)):
            print(' Neuron', n)
            for w in range(len(self.neurons[n].weights)):
                print('  Weight:', self.neurons[n].weights[w])
            print('  Bias:', self.bias)

    def feed_forward(self, inputs):
        # 前向传播过程outputs中存储的是该层每个神经元的y/a的值(经过神经元激活函数的值有时被称为y有时被称为a)
        outputs = []
        for neuron in self.neurons:
            outputs.append(neuron.calculate_output(inputs))
        return outputs

    def get_outputs(self):
        outputs = []
        for neuron in self.neurons:
            outputs.append(neuron.output)
        return outputs


class Neuron:
    # 神经元类
    def __init__(self, bias):
        self.bias = bias
        self.weights = []

    def calculate_output(self, inputs):
        self.inputs = inputs
        self.output = self.squash(self.calculate_total_net_input())
        # output即为输入即为y(a)意为从激活函数中的到的值
        return self.output

    def calculate_total_net_input(self):
        # 此处计算的为激活函数的输入值即z=W(n)x+b
        total = 0
        for i in range(len(self.inputs)):
            total += self.inputs[i]*self.weights[i]
        return total + self.bias

    # Apply the logistic function to squash the output of the neuron
    # 使用sigmoid函数为激励函数,一下是sigmoid函数的定义
    # The result is sometimes referred to as 'net' [2] or 'net' [1]
    def squash(self, total_net_input):
        return 1/(1 + math.exp(-total_net_input))

    # Determine how much the neuron's total input has to change to move closer to the expected output
    # 确定神经元的总输入需要改变多少，以接近预期的输出
    # Now that we have the partial derivative of the error(Cost function) with respect to the output (∂E/∂yⱼ)
    # 我们可以根据cost function对y(a)神经元激活函数输出值的偏导数和激活函数输出值y(a)对激活函数输入值z=wx+b的偏导数计算delta(δ).
    # the derivative of the output with respect to the total net input (dyⱼ/dzⱼ) we can calculate
    # the partial derivative of the error with respect to the total net input.
    # This value is also known as the delta (δ) [1]
    # δ = ∂E/∂zⱼ = ∂E/∂yⱼ * dyⱼ/dzⱼ 关键key
    #
    def calculate_pd_error_wrt_total_net_input(self, target_output):
        return self.calculate_pd_error_wrt_output(target_output)*self.calculate_pd_total_net_input_wrt_input()

    # The error for each neuron is calculated by the Mean Square Error method:
    # 每个神经元的误差由平均平方误差法计算
    def calculate_error(self, target_output):
        return 0.5*(target_output - self.output) ** 2

    # The partial derivate of the error with respect to actual output then is calculated by:
    # 对实际输出的误差的偏导是通过计算得到的--即self.output(y也常常用a表示经过激活函数后的值)
    # = 2 * 0.5 * (target output - actual output) ^ (2 - 1) * -1
    # = -(target output - actual output)BP算法最后隐层求cost function 对a求导
    #
    # The Wikipedia article on backpropagation [1] simplifies to the following, but most other learning material does not [2]
    # 维基百科关于反向传播[1]的文章简化了以下内容，但大多数其他学习材料并没有简化这个过程[2]
    # = actual output - target output
    #
    # Note that the actual output of the output neuron is often written as yⱼ and target output as tⱼ so:
    # = ∂E/∂yⱼ = -(tⱼ - yⱼ)
    # 注意我们一般将输出层神经元的输出为yⱼ,而目标标签(正确答案)表示为tⱼ.
    def calculate_pd_error_wrt_output(self, target_output):
        return -(target_output - self.output)

    # The total net input into the neuron is squashed using logistic function to calculate the neuron's output:
    # yⱼ = φ = 1 / (1 + e^(-zⱼ)) 注意我们对于神经元使用的激活函数都是logistic函数
    # Note that where ⱼ represents the output of the neurons in whatever layer we're looking at and ᵢ represents the layer below it
    # 注意我们用j表示我们正在看的这层神经元的输出,我们用i表示这层的后一层的神经元.
    # The derivative (not partial derivative since there is only one variable) of the output then is:
    # dyⱼ/dzⱼ = yⱼ * (1 - yⱼ)这是sigmoid函数的导数表现形式.
    def calculate_pd_total_net_input_wrt_input(self):
        return self.output*(1 - self.output)

    # The total net input is the weighted sum of all the inputs to the neuron and their respective weights:
    # 激活函数的输入是所有输入的加权权重的总和
    # = zⱼ = netⱼ = x₁w₁ + x₂w₂ ...
    # The partial derivative of the total net input with respective to a given weight (with everything else held constant) then is:
    # 总的净输入与给定的权重的偏导数(其他所有的项都保持不变)
    # = ∂zⱼ/∂wᵢ = some constant + 1 * xᵢw₁^(1-0) + some constant ... = xᵢ
    def calculate_pd_total_net_input_wrt_weight(self, index):
        return self.inputs[index]


# Blog post example:

nn = NeuralNetwork(2, 2, 2, hidden_layer_weights=[0.15, 0.2, 0.25, 0.3], hidden_layer_bias=0.35,
                   output_layer_weights=[0.4, 0.45, 0.5, 0.55], output_layer_bias=0.6)
for i in range(10000):
    nn.train([0.05, 0.1], [0.01, 0.99])
    print(i, round(nn.calculate_total_error([[[0.05, 0.1], [0.01, 0.99]]]), 9))  # 截断处理只保留小数点后9位

# XOR example:

# training_sets = [
#     [[0, 0], [0]],
#     [[0, 1], [1]],
#     [[1, 0], [1]],
#     [[1, 1], [0]]
# ]

# nn = NeuralNetwork(len(training_sets[0][0]), 5, len(training_sets[0][1]))
# for i in range(10000):
#     training_inputs, training_outputs = random.choice(training_sets)
#     nn.train(training_inputs, training_outputs)
#     print(i, nn.calculate_total_error(training_sets))

复制代码request(method, path, params, callback) {
  return new Promise((_resolve, _reject) => {

    const resolve = ret => {
      _resolve(ret);
      callback && callback(null, ret);
    };

    const reject = err => {
      _reject(err);
      callback && callback(err);
    };

    // 以下部分不变
    // ...
  });
}

复制代码request(method, path, params, callback) {
  if (callback) {
    doRequest(method, path, params, callback);
  } else {
    return new Promise((resolve, reject) => {
      doRequest(method, path, params, (err, ret) => {
        err ? reject(err) : resolve(ret);
      });
    });
  }

  function doRequest(method, path, params, callback) {
    // 以下部分不变
    // ...
  }
}

复制代码request(method, path, params, callback) {
  if (!callback) {
    return new Promise((resolve, reject) => {
      // 重新调用当前函数
      request(method, path, params, (err, ret) => {
        err ? reject(err) : resolve(ret);
      });
    });
  }

  // 以下部分不变
  // ...
}

复制代码function promiseToCallback(fn) {
  return function () {
    const args = Array.prototype.slice.apply(arguments);
    const callback = args.pop();
    fn.apply(null, args)
      .then(function (result) {
        callback(null, result);
      })
      .catch(function (err) {
        console.error(err);
        callback(err);
      });
  };
}

复制代码'use strict';

process.on('unhandledRejection', err => {
  console.log('unhandledRejection', err);
});

function hello(msg) {
  return new Promise((resolve, reject) => {
    setImmediate(() => {
      resolve(`hello, ${ msg }`);
    });
  });
}

promiseToCallback(hello)('test', (err, ret) => {
  console.log(err, ret);
  throw new Error('haha');
});

复制代码null 'hello, test'
[Error: haha]
[Error: haha] undefined
unhandledRejection [Error: haha]

复制代码function promiseToCallback(fn) {
  return function () {
    const args = Array.prototype.slice.apply(arguments);
    const callback = args.pop();

    // 包装 callback，在此函数中保证 callback 只会调用一次
    // 再次调用会直接忽略
    const cb = (err, ret) => {
      if (cb.isCalled) return;
      cb.isCalled = true;
      callback(err, ret);
    };

    fn.apply(null, args)
      .then(function (result) {
        cb(null, result);
      })
      .catch(function (err) {
        console.error(err);
        cb(err);
      });
  };
}

复制代码function promiseOrCallback(fn, argc) {
  return function () {
    const args = Array.prototype.slice.apply(arguments);
    // 判断调用函数时实际传过来的参数数量
    if (args.length > argc) {
      // 这是 callback 方式调用的
      return fn.apply(null, args);
    }
    // 这是 promise 方式调用的
    return new Promise((resolve, reject) => {
      // 创建一个 callback 函数用来对接 promise 的 resolve 和 reject
      args.push((err, ret) => {
        err ? reject(err) : resolve(ret);
      });
      fn.apply(null, args);
    });
  };
}

复制代码'use strict';

process.on('unhandledRejection', err => {
  console.log('unhandledRejection', err);
});

function hello(msg, callback) {
  setImmediate(() => {
    callback(null, `hello, ${ msg }`);
  });
}

promiseOrCallback(hello, 1)('test', (err, ret) => {
  console.log(err, ret);
  throw new Error('haha');
});

复制代码null 'hello, test'
/tmp/test.js:45
  throw new Error('haha');
  ^

Error: haha
    at /tmp/test.js:45:9
    at Immediate._onImmediate (/tmp/test.js:39:5)
    at processImmediate [as _immediateCallback] (timers.js:383:17)

复制代码promiseOrCallback(hello, 1)('test').then(ret => {
  console.log(null, ret);
  throw new Error('haha');
}).catch(err => {
  console.log(err);
});

复制代码null 'hello, test'
[Error: haha]

复制代码public static void main(String[] args) {
    int x = 1;
    int y = 2;
    System.out.print("Values of x & y before primitive modification: ");
    System.out.println(" x = " + x + " ; y = " + y );
    modifyPrimitiveTypes(x,y);
    System.out.print("Values of x & y after primitive modification: ");
    System.out.println(" x = " + x + " ; y = " + y );
}
private static void modifyPrimitiveTypes(int x, int y)
{
    x = 5;
    y = 10;
}

复制代码Values of x & y before primitive modification:  x = 1 ; y = 2
Values of x & y after primitive modification:  x = 1 ; y = 2

复制代码public static void main(String[] args) {
    Integer obj1 = new Integer(1);
    Integer obj2 = new Integer(2);
    System.out.print("Values of obj1 & obj2 before wrapper modification: ");
    System.out.println("obj1 = " + obj1.intValue() + " ; obj2 = " + obj2.intValue());
    modifyWrappers(obj1, obj2);
    System.out.print("Values of obj1 & obj2 after wrapper modification: ");
    System.out.println("obj1 = " + obj1.intValue() + " ; obj2 = " + obj2.intValue());
}
private static void modifyWrappers(Integer x, Integer y)
{
    x = new Integer(5);
    y = new Integer(10);
}

复制代码Values of obj1 & obj2 before wrapper modification: obj1 = 1 ; obj2 = 2
Values of obj1 & obj2 after wrapper modification: obj1 = 1 ; obj2 = 2

复制代码public static void main(String[] args) {
    List<Integer> lstNums = new ArrayList<Integer>();
    lstNums.add(1);
    System.out.println("Size of list before List modification = " + lstNums.size());
    modifyList(lstNums);
    System.out.println("Size of list after List modification = " + lstNums.size());
}
private static void modifyList(List<Integer> lstParam)
{
    lstParam.add(2);
}

复制代码Size of list before List modification = 1
Size of list after List modification = 2

复制代码public static void main(String[] args) {
    Student student = new Student();
    System.out.println("Value of name before Student modification = " + student.getName());
    modifyStudent(student);
    System.out.println("Value of name after Student modification = " + student.getName());
}
private static void modifyStudent(Student student)
{
    student.setName("Alex");
}

复制代码Value of name before Student modification = null
Value of name after Student modification = Alex

php复制代码spl_autoload_register ( function ( $class )  {
     $file  = __DIR__ . '/lib/Predis/' . $class . '.php' ;
     if  ( file_exists ( $file ) )  {
         require  $file ;
         return  true ;
     }
} ) ;

ini复制代码$server  =  array (
     'host'      =>  '127.0.0.1' ,
     'port'      =>  6379 ,
     'database'  =>  15
) ;
$redis  =  new Client ( $server ) ;

bash复制代码$redis -> set ( 'foo' , 0 ) ;
$redis -> sinterstore ( 'foo' , 'set1' ) ;  //这边等同于将'set1'的内容copy到'foo'中，并将'foo'转为set表
$redis -> sinterstore ( 'foo' , array ( 'set1' , 'set2' ) ) ;  //将'set1'和'set2'中相同的元素copy到'foo'表中,覆盖'foo'原有内容

sql复制代码$redis -> zadd ( 'zset1' , 3 , 'ef' ) ;
$redis -> zadd ( 'zset1' , 5 , 'gh' ) ;
$redis -> zrangebyscore ( 'zset1' , 2 , 9 ) ;  //返回索引值2-9之间的元素 array('ef','gh')
//参数形式
$redis -> zrangebyscore ( 'zset1' , 2 , 9 , 'withscores' ) ;  //返回索引值2-9之间的元素并包含索引值 array(array('ef',3),array('gh',5))
$redis -> zrangebyscore ( 'zset1' , 2 , 9 , array ( 'withscores'  => true , 'limit' => array ( 1 ,  2 ) ) ) ;  //返回索引值2-9之间的元素,'withscores' =>true表示包含索引值; 'limit'=>array(1, 2),表示最多返回2条,结果为array(array('ef',3),array('gh',5))

perl复制代码$redis -> zunionstore ( 'zset3' , array ( 'zset1' , 'zset2' , 'zset0' ) ) ;  //将'zset1','zset2','zset0'的并集存入'zset3'
//其它参数 
$redis -> zunionstore ( 'zset3' , array ( 'zset1' , 'zset2' ) , array ( 'weights'  =>  array ( 5 , 0 ) ) ) ; //weights参数表示权重，其中表示并集后值大于5的元素排在前，大于0的排在后
$redis -> zunionstore ( 'zset3' , array ( 'zset1' , 'zset2' ) , array ( 'aggregate'  =>  'max' ) ) ; //'aggregate' => 'max'或'min'表示并集后相同的元素是取大值或是取小值

perl复制代码$redis -> rpush ( 'tab' , 3 ) ;
$redis -> rpush ( 'tab' , 2 ) ;
$redis -> rpush ( 'tab' , 17 ) ;
$redis -> sort ( 'tab' ) ;   //返回array(2,3,17)
//使用参数,可组合使用 array('sort' => 'desc','limit' => array(1, 2))
$redis -> sort ( 'tab' , array ( 'sort'  =>  'desc' ) ) ;   //降序排列,返回array(17,3,2)
$redis -> sort ( 'tab' , array ( 'limit'  =>  array ( 1 ,  2 ) ) ) ;   //返回顺序位置中1的元素2个(这里的2是指个数,而不是位置),返回array(3,17)
$redis -> sort ( 'tab' , array ( 'limit'  =>  array ( 'alpha'  =>  true ) ) ) ;  //按首字符排序返回array(17,2,3),因为17的首字符是'1'所以排首位置
$redis -> sort ( 'tab' , array ( 'limit'  =>  array ( 'store'  =>  'ordered' ) ) ) ;  //表示永久性排序,返回元素个数
$redis -> sort ( 'tab' , array ( 'limit'  =>  array ( 'get'  =>  'pre_*' ) ) ) ;  //使用了通配符'*'过滤元素,表示只返回以'pre_'开头的元素

ini复制代码$mkv  =  array (
     'usr:0001'  =>  'First user' ,
     'usr:0002'  =>  'Second user' ,
     'usr:0003'  =>  'Third user'
) ;
$redis -> mset ( $mkv ) ;  //存储多个key对应的value
$retval  =  $redis -> mget ( array_keys ( $mkv ) ) ;  //获取多个key对应的value
print_r ( $retval ) ;

perl复制代码$replies  =  $redis -> pipeline ( function ( $pipe )  {
     $pipe -> ping ( ) ;
     $pipe -> flushdb ( ) ;
     $pipe -> incrby ( 'counter' ,  10 ) ;  //增量操作
     $pipe -> incrby ( 'counter' ,  30 ) ;
     $pipe -> exists ( 'counter' ) ;
     $pipe -> get ( 'counter' ) ;
     $pipe -> mget ( 'does_not_exist' ,  'counter' ) ;  
} ) ;
print_r ( $replies ) ;

php复制代码function zpop ( $client ,  $zsetKey )  {
     $element  =  null ;
     $options  =  array (
         'cas'    =>  true ,      // Initialize with support for CAS operations
         'watch'  =>  $zsetKey ,  // Key that needs to be WATCHed to detect changes
         'retry'  =>  3 ,         // Number of retries on aborted transactions, after
                              // which the client bails out with an exception.
     ) ;

     $txReply  =  $client -> multiExec ( $options ,  function ( $tx )
         use  ( $zsetKey ,  & $element )  {
         @ list ( $element )  =  $tx -> zrange ( $zsetKey ,  0 ,  0 ) ;
         if  ( isset ( $element ) )  {
             $tx -> multi ( ) ;      // With CAS, MULTI *must* be explicitly invoked.
             $tx -> zrem ( $zsetKey ,  $element ) ;
         }
     } ) ;
     return  $element ;
}
$zpopped  = zpop ( $redis ,  'zset' ) ;
echo  isset ( $zpopped ) ?  "ZPOPed $zpopped"  :  "Nothing to ZPOP!" ,  "\n" ;

php复制代码$redis -> getProfile ( ) -> setPreprocessor ( new KeyPrefixPreprocessor ( 'nrk:' ) ) ;

php复制代码$multiple_servers  =  array (
     array (
        'host'      =>  '127.0.0.1' ,
        'port'      =>  6379 ,
        'database'  =>  15 ,
        'alias'     =>  'first' ,
     ) ,
     array (
        'host'      =>  '127.0.0.1' ,
        'port'      =>  6380 ,
        'database'  =>  15 ,
        'alias'     =>  'second' ,
     ) ,
) ;

use Predis\Distribution\IDistributionStrategy ;

class NaiveDistributionStrategy implements IDistributionStrategy  {
     private  $_nodes ,  $_nodesCount ;

     public  function __constructor ( )  {
         $this ->_nodes  =  array ( ) ;
         $this ->_nodesCount  =  0 ;
     }

     public  function add ( $node ,  $weight  =  null )  {
         $this ->_nodes [ ]  =  $node ;
         $this ->_nodesCount ++;
     }

     public  function remove ( $node )  {
         $this ->_nodes  =  array_filter ( $this ->_nodes ,  function ( $n )  use ( $node )  {
             return  $n  !==  $node ;
         } ) ;
         $this ->_nodesCount  =  count ( $this ->_nodes ) ;
     }

     public  function get ( $key )  {
         $count  =  $this ->_nodesCount ;
         if  ( $count  ===  0 )  {
             throw  new RuntimeException ( 'No connections' ) ;
         }
         return  $this ->_nodes [ $count  >  1 ?  abs ( crc32 ( $key )  %  $count )  :  0 ] ;
     }

     public  function generateKey ( $value )  {
         return  crc32 ( $value ) ;
     }
}

perl复制代码$options  =  array (
     'key_distribution'  =>  new NaiveDistributionStrategy ( ) ,
) ;

$redis  =  new Predis\Client ( $multiple_servers ,  $options ) ;

for  ( $i  =  0 ;  $i set ( "key:$i" ,  str_pad ( $i ,  4 ,  '0' ,  0 ) ) ;
     $redis -> get ( "key:$i" ) ;
}

$server1  =  $redis -> getClientFor ( 'first' ) -> info ( ) ;
$server2  =  $redis -> getClientFor ( 'second' ) -> info ( ) ;

printf ( "Server '%s' has %d keys while server '%s' has %d keys.\n" ,
     'first' ,  $server1 [ 'db15' ] [ 'keys' ] ,  'second' ,  $server2 [ 'db15' ] [ 'keys' ]
) ;

复制代码type User struct {
    Id    int    
    Name  string 
    Bio   string 
    Email string 
}

复制代码user := User{
        Id:    0,
        Name:  "superlongstring",
        Bio:   "",
        Email: "foobar",
}

if user.Id < 1 && user.Id > 1000 {
    return false
}
if len(user.Name) < 2 && len(user.Name) > 10 {
    return false
}
if !validateEmail(user.Email) {
    return false
}

复制代码type User struct {
    Id    int    `validate:"number,min=1,max=1000"`
    Name  string `validate:"string,min=2,max=10"`
    Bio   string `validate:"string"`
    Email string `validate:"email"`
}

复制代码
type User struct {
    Id        int       `json:"id"`
    Name      string    `json:"name"`
    Bio       string    `json:"about,omitempty"`
    Active    bool      `json:"active"`
    Admin     bool      `json:"-"`
    CreatedAt time.Time `json:"created_at"`
}

复制代码if tagIsOfNumber(){
        validator := NumberValidator{}
}else if tagIsOfString() {
        validator := StringValidator{}
}else if tagIsOfEmail() {
        validator := EmailValidator{}
}else if tagIsOfDefault() {
        validator := DefaultValidator{}
}

复制代码type Writer interface {
    Write(p []byte) (n int, err error)
}

复制代码func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
    p := newPrinter()
    p.doPrintf(format, a)
    n, err = w.Write(p.buf)      //调用Write方法
    p.free()
    return
}

//调用
Fprintf(os.Stdout, format, a...)    //标准输出
Fprintf(os.Stderr, msg+"\n", args...)   //标准错误输出

var buf bytes.Buffer
Fprintf(&buf, "[")    //写入到Buffer的缓存中

复制代码package main

import (
    "fmt"
    "reflect"
    "regexp"
    "strings"
)

const tagName = "validate"

//邮箱验证正则
var mailRe = regexp.MustCompile(`\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z`)

//验证接口
type Validator interface {
    Validate(interface{}) (bool, error)
}

type DefaultValidator struct {
}

func (v DefaultValidator) Validate(val interface{}) (bool, error) {
    return true, nil
}

type StringValidator struct {
    Min int
    Max int
}

func (v StringValidator) Validate(val interface{}) (bool, error) {
    l := len(val.(string))

    if l == 0 {
        return false, fmt.Errorf("cannot be blank")
    }

    if l < v.Min {
        return false, fmt.Errorf("should be at least %v chars long", v.Min)
    }

    if v.Max >= v.Min && l > v.Max {
        return false, fmt.Errorf("should be less than %v chars long", v.Max)
    }

    return true, nil
}


type NumberValidator struct {
    Min int
    Max int
}

func (v NumberValidator) Validate(val interface{}) (bool, error) {
    num := val.(int)

    if num < v.Min {
        return false, fmt.Errorf("should be greater than %v", v.Min)
    }

    if v.Max >= v.Min && num > v.Max {
        return false, fmt.Errorf("should be less than %v", v.Max)
    }

    return true, nil
}

type EmailValidator struct {
}

func (v EmailValidator) Validate(val interface{}) (bool, error) {
    if !mailRe.MatchString(val.(string)) {
        return false, fmt.Errorf("is not a valid email address")
    }
    return true, nil
}

func getValidatorFromTag(tag string) Validator {
    args := strings.Split(tag, ",")

    switch args[0] {
    case "number":
        validator := NumberValidator{}
        //将structTag中的min和max解析到结构体中
        fmt.Sscanf(strings.Join(args[1:], ","), "min=%d,max=%d", &validator.Min, &validator.Max)
        return validator
    case "string":
        validator := StringValidator{}
        fmt.Sscanf(strings.Join(args[1:], ","), "min=%d,max=%d", &validator.Min, &validator.Max)
        return validator
    case "email":
        return EmailValidator{}
    }

    return DefaultValidator{}
}

func validateStruct(s interface{}) []error {
    errs := []error{}

    v := reflect.ValueOf(s)

    for i := 0; i < v.NumField(); i++ {
        //利用反射获取structTag
        tag := v.Type().Field(i).Tag.Get(tagName)

        if tag == "" || tag == "-" {
            continue
        }

        validator := getValidatorFromTag(tag)

        valid, err := validator.Validate(v.Field(i).Interface())
        if !valid && err != nil {
            errs = append(errs, fmt.Errorf("%s %s", v.Type().Field(i).Name, err.Error()))
        }
    }

    return errs
}

type User struct {
    Id    int    `validate:"number,min=1,max=1000"`
    Name  string `validate:"string,min=2,max=10"`
    Bio   string `validate:"string"`
    Email string `validate:"email"`
}

func main() {
    user := User{
        Id:    0,
        Name:  "superlongstring",
        Bio:   "",
        Email: "foobar",
    }

    fmt.Println("Errors:")
    for i, err := range validateStruct(user) {
        fmt.Printf("\t%d. %s\n", i+1, err.Error())
    }
}

复制代码package main

import (
    "github.com/asaskevich/govalidator"
    "fmt"
    "strings"
)

type Server struct {
    ID         string `valid:"uuid,required"`
    Name       string `valid:"machine_id"`
    HostIP     string `valid:"ip"`
    MacAddress string `valid:"mac,required"`
    WebAddress string `valid:"url"`
    AdminEmail string `valid:"email"`
}

func main() {
    server := &Server{
        ID:         "123e4567-e89b-12d3-a456-426655440000",
        Name:       "IX01",
        HostIP:     "127.0.0.1",
        MacAddress: "01:23:45:67:89:ab",
        WebAddress: "www.example.com",
        AdminEmail: "admin@exmaple.com",
    }

    //自定义tag验证函数
    govalidator.TagMap["machine_id"] = govalidator.Validator(func(str string) bool {
        return strings.HasPrefix(str, "IX")
    })

    if ok, err := govalidator.ValidateStruct(server); err != nil {
        panic(err)
    } else {
        fmt.Printf("OK: %v\n", ok)
    }
}

复制代码public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

复制代码transient int size = 0;
transient Node<E> first;
transient Node<E> last;

复制代码private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;  //当前节点值
            this.next = next; //后继节点
            this.prev = prev;//前驱节点
        }
    }

复制代码public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }

复制代码public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }

复制代码public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

复制代码Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {  //判断index是在链表偏左侧还是偏右侧
            Node<E> x = first;
            for (int i = 0; i < index; i++)  //从左边往右next
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)  //从右往左prev
                x = x.prev;
            return x;
        }
    }

复制代码public int indexOf(Object o) {
        int index = 0;
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                index++;
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
    }

复制代码   public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }

复制代码public void addFirst(E e) {
        linkFirst(e);
    }

public void addLast(E e) {
        linkLast(e);
    }

复制代码private void linkFirst(E e) {
        final Node<E> f = first;  //现将原有的first节点保存在f中
        final Node<E> newNode = new Node<>(null, e, f); //将新增节点包装成一个Node节点，同时该节点的next指向之前的first
        first = newNode;  //将新增的节点设成first
        if (f == null)
            last = newNode;   //如果原来的first就是空，那么新增的newNode同时也是last节点
        else
            f.prev = newNode;  //如果不是空，则原来的first节点的前置节点就是现在新增的节点
        size++;  //插入元素后，节点个数加1
        modCount++;  //还记得上一篇讲述的快速失败吗？这边依然是这个作用
    }

复制代码void linkLast(E e) {
        final Node<E> l = last;   //将尾节点保存到l中
        final Node<E> newNode = new Node<>(l, e, null); //把e包装成Node节点，同时把该节点的前置节点设置为l
        last = newNode; //把新插的节点设置为last节点
        if (l == null)
            first = newNode;  //如果原来的last节点为空，那么新增的节点在意义上也是first节点
        else
            l.next = newNode; //否则的话还要将newNode设为原有last节点的后继节点，所以newNode现在是新的Last节点
        size++;
        modCount++;
    }

复制代码public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

复制代码void linkBefore(E e, Node<E> succ) {  //在succ节点前插入newNode
        // assert succ != null;
        final Node<E> pred = succ.prev;   //将succ的前置节点记为pred
        final Node<E> newNode = new Node<>(pred, e, succ);   以pred为前置节点，以succ为后继节点建立newNode
        succ.prev = newNode;   //将new Node设为succ的前置节点
        if (pred == null)
            first = newNode;   //如果原有的succ的前置节点为空，那么新插入的newNode就是first节点
        else
            pred.next = newNode;  // 否则，要把newNode设为原来pred节点的后置节点
        size++;
        modCount++;
    }

复制代码public boolean add(E e) {
        linkLast(e);
        return true;
    }

复制代码public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }

复制代码public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index);  // 检查index位置是否超出范围

        Object[] a = c.toArray();   //将集合c转变成Object数组 同时计算数组长度
        int numNew = a.length;
        if (numNew == 0)
            return false;

        Node<E> pred, succ;
        if (index == size) {   //如果插入位置为尾部，succ则为null，原来链表的last设置为此刻的pred节点
            succ = null;
            pred = last;
        } else {
            succ = node(index);   //否则，index所在节点设置为succ，succ的前置节点设为pred
            pred = succ.prev;
        }

        for (Object o : a) { //循环遍历数组a
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);   //以a为element元素构造Node节点
            if (pred == null)
                first = newNode;     //如果pred为空，此Node就为first节点
            else
                pred.next = newNode;   //否则就往pred后插入该Node
            pred = newNode;       //newNode此刻成为新的pred, 这样不断循环遍历，把这个数组插入到链表中
        }

        if (succ == null) { //如果succ为空，就把插入的最后一个节点设为last
            last = pred;
        } else {
            pred.next = succ;   //否则，把之前保存的succ接到pred后面
            succ.prev = pred;  //并且把succ的前向指针指向插入的最后一个元素
        }

        size += numNew;   //记录增长的尺寸
        modCount++;  //记录修改次数
        return true;
    }

复制代码public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

复制代码private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        final E element = f.item;   //把f.item的值保存到element
        final Node<E> next = f.next;   //把f.next的值记住
        f.item = null;    
        f.next = null; // help GC   //把item和next的都指向null
        first = next;    //next成为实际的first节点
        if (next == null)  //next为空的话，因为next是第一个节点，所以链表都是空的，last也为空
            last = null;
        else
            next.prev = null;  //next不为空，也要将它的前驱节点记为null，因为next是第一个节点
        size--;  //节点减少一个
        modCount++;  //操作次数加1
        return element;
    }

复制代码public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

复制代码private E unlinkLast(Node<E> l) {
        // assert l == last && l != null;
        final E element = l.item;   //保存最后一个节点的值
        final Node<E> prev = l.prev;   //把最后一个节点的前驱节点记为prev，它将成为last节点
        l.item = null;
        l.prev = null; // help GC  //l节点的item和prev都记为空
        last = prev;    //此时设置刚才记录的前驱节点为last
        if (prev == null) //prev为空的话，说明要删除的l前面原来没节点，那么删了l，整个链表为空
            first = null;
        else
            prev.next = null;   //prev成为最后一个节点，没有后继节点
        size--;
        modCount++;
        return element;
    }

复制代码public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

复制代码E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

复制代码public boolean remove(Object o) {
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

复制代码public void clear() {
        // Clearing all of the links between nodes is "unnecessary", but:
        // - helps a generational GC if the discarded nodes inhabit
        //   more than one generation
        // - is sure to free memory even if there is a reachable Iterator
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        first = last = null;
        size = 0;
        modCount++;
    }

复制代码public ListIterator<E> listIterator(int index) {
        checkPositionIndex(index);
        return new ListItr(index);
    }

复制代码private class ListItr implements ListIterator<E> {
        private Node<E> lastReturned;
        private Node<E> next;    //用于记录当前节点
        private int nextIndex;   //用于记录当前节点所在索引
        private int expectedModCount = modCount;

        ListItr(int index) {
            // assert isPositionIndex(index);
            next = (index == size) ? null : node(index);   //返回index处的节点，记录为next
            nextIndex = index;  //记录当前索引
        } 

        public boolean hasNext() {
            return nextIndex < size;   //通过判断nextIndex是否还在size范围内
        }

        public E next() {
            checkForComodification();
            if (!hasNext())
                throw new NoSuchElementException();

            lastReturned = next;   //记录上一次的值
            next = next.next;  //往后移动一个节点
            nextIndex++; //索引值也加1
            return lastReturned.item;   //next会返回上一次的值
        }

        public boolean hasPrevious() {  //通过哦按段nextIndex是否还大于0，如果<=0，就证明没有前驱节点了
            return nextIndex > 0;
        }

        public E previous() {
            checkForComodification();
            if (!hasPrevious())
                throw new NoSuchElementException();

            lastReturned = next = (next == null) ? last : next.prev;  //往前移动
            nextIndex--;
            return lastReturned.item;
        }

        public int nextIndex() {
            return nextIndex;
        }

        public int previousIndex() {
            return nextIndex - 1;
        }

        public void remove() {
            checkForComodification();
            if (lastReturned == null)
                throw new IllegalStateException();

            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
            if (next == lastReturned)
                next = lastNext;
            else
                nextIndex--;
            lastReturned = null;
            expectedModCount++;
        }

        public void set(E e) {
            if (lastReturned == null)
                throw new IllegalStateException();
            checkForComodification();
            lastReturned.item = e;
        }

        public void add(E e) {
            checkForComodification();
            lastReturned = null;
            if (next == null)
                linkLast(e);
            else
                linkBefore(e, next);
            nextIndex++;
            expectedModCount++;
        }

        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            while (modCount == expectedModCount && nextIndex < size) {
                action.accept(next.item);
                lastReturned = next;
                next = next.next;
                nextIndex++;
            }
            checkForComodification();
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

复制代码public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

复制代码transient Object[] elementData;  //存放元素的数组
private int size; //ArrayList实际存放的元素数量

复制代码/**
     * Constructs an empty list with the specified initial capacity.
     *
     * @param  initialCapacity  the initial capacity of the list
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

复制代码/**
 * Constructs an empty list with an initial capacity of ten.
*/
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

复制代码/**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

复制代码public int size() {
        return size;
    }

复制代码public boolean isEmpty() {
        return size == 0;
    }

复制代码public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

复制代码public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

复制代码@SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

复制代码public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

复制代码public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

复制代码public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
}

复制代码private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

复制代码private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

复制代码private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1); //扩充为原来的1.5倍
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

复制代码public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

复制代码public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

复制代码public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

复制代码/**
     * Removes all of the elements from this list.  The list will
     * be empty after this call returns.
     */
    public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

复制代码public boolean addAll(Collection<? extends E> c);
public boolean addAll(int index, Collection<? extends E> c);
protected void removeRange(int fromIndex, int toIndex) ;
public boolean removeAll(Collection<?> c) ;

复制代码private class Itr implements Iterator<E> {
        int cursor;       // 记录下一个返回元素的index，一开始为0
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;  //这边确保产生迭代器时，就将当前modCount赋给expectedModCount

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor; //访问元素的index
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1; //不断加1，只要不断调用next，就可以遍历List
            return (E) elementData[lastRet = i];  //lastRet在这里会记录最近返回元素的位置
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);  //调用List本身的remove函数，删除最近返回的元素
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount; //上面的Remove函数会改变modCount，所以这边expectedModCount需要更新
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

复制代码public Iterator<E> iterator() {
        return new Itr();
    }