精华内容
下载资源
问答
  • 设计模式GOF23 (GOF 四人帮) 》》》将设计者的思维融入大家的学习和工作中,更高层次的思考! 》》创建型模式: -单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。 》》结构型模式: -适配器模式...
    设计模式GOF23  (GOF 四人帮)
    
    
    》》》将设计者的思维融入大家的学习和工作中,更高层次的思考!
    
    
    》》创建型模式:
            -单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。
    》》结构型模式:
            -适配器模式、代理模式、桥接模式、组合模式、外观模式、享元模式。
    》》行为型模式:
            -模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。
    
    

     

    GitHub 项目路径持续更新中。。。https://github.com/songhaiboGitHub/GOF23

    展开全文
  • 策略模式:分别封装行为接口,实现算法族,超类里放行为接口对象,在子类里具体设定行为接口对象(初始化具体的行为对象)。原则就是分离变化部分,封装接口,基于接口编程各种功能。此模式让行为算法的变化独立于算法...

    策略模式:分别封装行为接口,实现算法族,超类里放行为接口对象,在子类里具体设定行为接口对象(初始化具体的行为对象)。原则就是分离变化部分,封装接口,基于接口编程各种功能。此模式让行为算法的变化独立于算法的使用者。实际上java编程思想也说过,继承和组合的选择,优先组合。

    个人见解:策略模式实际上是为了让子类能够随时更改他的行为,所以才使用了组合的方式,而如果使用继承的方式,将会受到很多的局限。

    转载于:https://www.cnblogs.com/pig-brother/p/7289612.html

    展开全文
  • 《151 trading strategies》中的3.12—strategy: two moving averages 这个策略的逻辑非常简单,入门级别。并且和上个单均线的策略逻辑很像,可以参考上个策略:《151 trading strategies》中的simple ...假设初始

    《151 trading strategies》中的3.12—strategy: two moving averages

    这个策略的逻辑非常简单,入门级别。并且和上个单均线的策略逻辑很像,可以参考上个策略:《151 trading strategies》中的simple moving average

    策略逻辑

    我们使用全市场的A股日数据进行测试,只做多头。

    资金管理方法和上个策略一样。

    首先,使用10日和60日均线,当10日均线金叉60日均线的时候,做多;当10日均线死叉60日均线的时候,平多。

    假设初始资金有1个亿。

    假设手续费为万分之二。

    策略代码

    import backtrader as bt
    import datetime
    import pandas as pd
    import numpy as np
    import os,sys
    import copy
    import talib
    import math 
    import warnings
    warnings.filterwarnings("ignore")
    import pyfolio as pf
    
    # 我们使用的时候,直接用我们新的类读取数据就可以了。
    class test_two_ma_strategy(bt.Strategy):
       
        params = (('short_period',10),
                  ("long_period",60),
                 )
    
        def log(self, txt, dt=None):
            ''' Logging function fot this strategy'''
            dt = dt or self.datas[0].datetime.date(0)
            print('{}, {}'.format(dt.isoformat(), txt))
    
        def __init__(self):
            # Keep a reference to the "close" line in the data[0] dataseries
            self.bar_num=0
            # 保存均线数据
            # self.stock_short_ma_dict={data._name:bt.talib.SMA(data.close,timeperiod=self.p.short_period) for data in self.datas}
            # self.stock_short_ma_dict={data._name:bt.talib.SMA(data.close,timeperiod=self.p.long_period) for data in self.datas}
            self.stock_ma_diff_dict = {data._name:bt.talib.SMA(data.close,timeperiod=self.p.short_period)-
                                       bt.talib.SMA(data.close,timeperiod=self.p.long_period) for data in self.datas}
            # 保存现有持仓的股票
            self.position_dict={}
            # 当前有交易的股票
            self.stock_dict={}
            
           
        def prenext(self):
            
            self.next()
            
            
        def next(self):
            # 假设有100万资金,每次成份股调整,每个股票使用1万元
            self.bar_num+=1
            
            # 前一交易日和当前的交易日
            pre_date = self.datas[0].datetime.date(-1).strftime("%Y-%m-%d")
            current_date = self.datas[0].datetime.date(0).strftime("%Y-%m-%d")
            # 总的价值
            total_value = self.broker.get_value()
            total_cash  = self.broker.get_cash()
            # 第一个数据是指数,校正时间使用,不能用于交易
            # 循环所有的股票,计算股票的数目
            for data in self.datas[1:]:
                data_date = data.datetime.date(0).strftime("%Y-%m-%d")
                # 如果两个日期相等,说明股票在交易
                if current_date == data_date:
                    stock_name = data._name
                    if stock_name not in self.stock_dict:
                        self.stock_dict[stock_name]=1
            total_target_stock_num = len(self.stock_dict)
            # 现在持仓的股票数目
            total_holding_stock_num = len(self.position_dict)
            # 计算理论上的手数
            if total_holding_stock_num<total_target_stock_num:
                now_value = total_cash/(total_target_stock_num-total_holding_stock_num)
                stock_value = total_value/total_target_stock_num
                now_value =min(now_value,stock_value)
            else:
                now_value = total_value/total_target_stock_num
        
            # 循环股票,开始交易
            for data in self.datas[1:]:
                data_date = data.datetime.date(0).strftime("%Y-%m-%d")
                # 如果两个日期相等,说明股票在交易
                if current_date == data_date:
                    ma_diff_info = self.stock_ma_diff_dict[data._name]
                    ma_diff = ma_diff_info[0]
                    pre_ma_diff = ma_diff_info[-1]
                    # 平多信号
                    if pre_ma_diff>0 and ma_diff<0:
                        # 已经下单并且成交了
                        if self.getposition(data).size>0:
                            self.close(data)
                            if data._name in self.position_dict:
                                self.position_dict.pop(data._name)
                            # self.buy_list.remove(stock)
                        # 已经下单,但是订单没有成交
                        if data._name in self.position_dict and self.getposition(data).size==0:
                            order = self.position_dict[data._name]
                            self.cancel(order)
                            self.position_dict.pop(data._name) 
                    # 开多信号,价格站到均线上方,并且持仓量为0 
                    if pre_ma_diff<0 and ma_diff>0 and self.getposition(data).size==0 :
                        lots = now_value/data.close[0]
                        lots = int(lots/100)*100 # 计算能下的手数,取整数
                        order = self.buy(data,size = lots)
                        self.position_dict[data._name] = order
                    
                            
            
        def notify_order(self, order):
            
            if order.status in [order.Submitted, order.Accepted]:
                return
            
            if order.status == order.Rejected:
                self.log(f"Rejected : order_ref:{order.ref}  data_name:{order.p.data._name}")
                
            if order.status == order.Margin:
                self.log(f"Margin : order_ref:{order.ref}  data_name:{order.p.data._name}")
                
            if order.status == order.Cancelled:
                self.log(f"Concelled : order_ref:{order.ref}  data_name:{order.p.data._name}")
                
            if order.status == order.Partial:
                self.log(f"Partial : order_ref:{order.ref}  data_name:{order.p.data._name}")
             
            if order.status == order.Completed:
                if order.isbuy():
                    self.log(f" BUY : data_name:{order.p.data._name} price : {order.executed.price} , cost : {order.executed.value} , commission : {order.executed.comm}")
    
                else:  # Sell
                    self.log(f" SELL : data_name:{order.p.data._name} price : {order.executed.price} , cost : {order.executed.value} , commission : {order.executed.comm}")
        
        def notify_trade(self, trade):
            # 一个trade结束的时候输出信息
            if trade.isclosed:
                self.log('closed symbol is : {} , total_profit : {} , net_profit : {}' .format(
                                trade.getdataname(),trade.pnl, trade.pnlcomm))
                # self.trade_list.append([self.datas[0].datetime.date(0),trade.getdataname(),trade.pnl,trade.pnlcomm])
                
            if trade.isopen:
                self.log('open symbol is : {} , price : {} ' .format(
                                trade.getdataname(),trade.price))
        def stop(self):
            
            pass 
                    
            
    # 初始化cerebro,获得一个实例
    cerebro = bt.Cerebro()
    # cerebro.broker = bt.brokers.BackBroker(shortcash=True)  # 0.5%
    data_root = "/home/yun/data/stock/day/"
    file_list =sorted(os.listdir(data_root))
    params=dict(
        
        fromdate = datetime.datetime(2005,1,4),
        todate = datetime.datetime(2020,7,31),
        timeframe = bt.TimeFrame.Days,
        dtformat = ("%Y-%m-%d"),
        compression = 1,
        datetime = 0,
        open = 1,
        high = 2,
        low =3,
        close =4,
        volume =5,
        openinterest=-1)
    
    # 加载指数数据
    feed = bt.feeds.GenericCSVData(dataname = "/home/yun/data/stock/index.csv",**params)
    # 添加数据到cerebro
    cerebro.adddata(feed, name = 'index')
    
    # 读取数据
    for file in file_list:
        #剔除不满一年的股票
        if len(pd.read_csv(data_root+file))<252:
            continue
        feed = bt.feeds.GenericCSVData(dataname = data_root+file,**params)
        # 添加数据到cerebro
        cerebro.adddata(feed, name = file[:-4])
    print("加载数据完毕")
    # 添加手续费,按照万分之二收取
    cerebro.broker.setcommission(commission=0.0002,stocklike=True)
    # 设置初始资金为100万
    cerebro.broker.setcash(1_0000_0000)
    # 添加策略
    cerebro.addstrategy(test_two_ma_strategy)
    cerebro.addanalyzer(bt.analyzers.TotalValue, _name='_TotalValue')
    cerebro.addanalyzer(bt.analyzers.PyFolio)
    # 运行回测
    results = cerebro.run()
    # 打印相关信息
    pyfoliozer = results[0].analyzers.getbyname('pyfolio')
    returns, positions, transactions, gross_lev = pyfoliozer.get_pf_items()
    pf.create_full_tear_sheet(
        returns,
        positions=positions,
        transactions=transactions,
        # gross_lev=gross_lev,
        live_start_date='2019-01-01',
        )
    

    测试结果

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    策略分析

    这个策略的结果和单均线策略差不多,并没有重大的改善。优化参数可能使得结果会好一些,但是相对来说,优化策略交易的逻辑,可能效果更好。可以考虑放弃这个策略。

    展开全文
  • 以下相关例子是源于HeadFIrst--设计模式这本书,写的真的很好,大家可以买来看看,我这里只是...//初始设计中鸭子有游泳和叫这两种功能行为,这是一个超类public abstract class Duck { public void swim(){ Syste...

    以下相关例子是源于HeadFIrst--设计模式这本书,写的真的很好,大家可以买来看看,我这里只是给需要了解的朋友看一下,

    然后写一些我的见解帮助大家理解:

    package domain.strategypattern.initial;
    //初始设计中鸭子有游泳和叫这两种功能行为,这是一个超类
    public abstract class Duck {

    public void swim(){
    System.out.println("鸭子在游泳");
    }
    public void jiao(){
    System.out.println("鸭子呱呱叫");
    }

    public abstract void display();

    }

    package domain.strategypattern.initial;
    //通过继承Duck鸭子类,能够复用代码,实现Duck的两种功能
    public class BlackHeadDuck extends Duck {

    public void display(){
    System.out.println("这是一只脑袋是黑色的鸭子");
    }

    }

    package domain.strategypattern.initial;


    public class RedHeadDuck extends Duck {


    public void display(){
    System.out.println("这是一只脑袋是红色的鸭子");
    }

    }

    接下来是调用展示各种鸭子相关功能

    package testmethod.strategypattern.initial;


    import domain.strategypattern.initial.BlackHeadDuck;
    import domain.strategypattern.initial.Duck;
    import domain.strategypattern.initial.RedHeadDuck;


    public class TestInitial {


    public static void main(String[] args) {
    Duck duck = new BlackHeadDuck();
    duck.swim();
    duck.jiao();
    duck.display();
    System.out.println("---------------------");
    duck = new RedHeadDuck();
    duck.swim();
    duck.jiao();
    duck.display();
    }


    }


    现在我们考虑新的问题,如果说需求告诉我们加一只泥鸭子,会游泳,会展示我是个泥巴,就是不会叫你怎么处理呢,如果继承Duck,那他相关的叫的方法我们也会继承,你可能考虑用重写这个方法进行设计,可是如果还有新的鸭子,他们也是不会叫或者叫法和呱呱不一样,你把所有的的都继承重写方法么?那不会叫这段代码是不是要被重复很多次呢?

    所以我们不妨把这个叫的从Duck功能拿出来,做成个接口,然后“呱呱叫”变成一个实现类,不叫变成一个实现类,“嗷嗷叫”也是一个。为了下边继续修改,我们这里再为鸭子添加个飞的功能,有能飞的,不能飞的,安装火箭翅膀飞的。

    package domain.strategypattern.first.fly;


    public interface Fly {

    abstract void fly();

    }

    package domain.strategypattern.first.fly;


    public class FlyWithHeart implements Fly {


    @Override
    public void fly() {
    System.out.println("只能用心飞翔了,看着别人飞");
    }


    }

    package domain.strategypattern.first.fly;


    public class FlyWithWings implements Fly {


    @Override
    public void fly() {
    System.out.println("这是一只用翅膀飞的鸭子");
    }


    }

    package domain.strategypattern.first.jiao;


    public interface Jiao {

    abstract void jiao();

    }

    package domain.strategypattern.first.jiao;


    public class NoJiao implements Jiao {


    @Override
    public void jiao() {
    System.out.println("这只鸭子不叫");
    }


    }

    package domain.strategypattern.first.jiao;


    public class GuaJiao implements Jiao {


    @Override
    public void jiao() {
    System.out.println("呱呱叫");
    }


    }

    package domain.strategypattern.first.jiao;


    public class AoAoJiao implements Jiao {


    @Override
    public void jiao() {
    System.out.println("嗷嗷叫的鸭子");
    }


    }

    package domain.strategypattern.first;


    import domain.strategypattern.first.Duck;
    import domain.strategypattern.first.fly.Fly;
    import domain.strategypattern.first.jiao.Jiao;


    public class NiBaDuck extends Duck {


    public NiBaDuck(Jiao jiao, Fly fly) {
    super(jiao, fly);
    }


    @Override
    public void display() {
    System.out.println("这是一只泥巴做的鸭子,头上是泥巴色");
    }


    }

    package testmethod.strategypattern.first;


    import domain.strategypattern.first.NiBaDuck;
    import domain.strategypattern.first.fly.FlyWithHeart;
    import domain.strategypattern.first.jiao.NoJiao;
    import domain.strategypattern.first.Duck;


    public class TestInitial {


    public static void main(String[] args) {
    Duck duck = new NiBaDuck(new NoJiao(),new FlyWithHeart());
    duck.swim();
    duck.jiao();
    duck.fly();
    //这个时候,不管你想加什么样的鸭子,乱七八糟的叫法,乱七八糟的飞法,都只需要实现那两个功能的接口,实现特有的方法,并在应用中
    //构造Duck这个类时指定飞和叫接口都是什么,就能实现对应的特有功能
    }


    }


    还有更好的方式,比如我现在

    package domain.strategypattern.second.fly;


    import domain.strategypattern.second.fly.Fly;


    public class FlyWithBigRocket implements Fly {


    @Override
    public void fly() {
    System.out.println("这哥们安了大宝剑,能上天!");
    }


    }

    有个上天的功能

    我在Duck中添加一个set方法,然后在运行里,模拟改变泥巴鸭子的飞行功能

    package testmethod.strategypattern.second;


    import domain.strategypattern.second.NiBaDuck;
    import domain.strategypattern.second.fly.FlyWithBigRocket;
    import domain.strategypattern.second.fly.FlyWithHeart;
    import domain.strategypattern.second.jiao.NoJiao;
    import domain.strategypattern.second.Duck;


    public class TestInitial {


    public static void main(String[] args) {
    Duck duck = new NiBaDuck(new NoJiao(),new FlyWithHeart());
    duck.swim();
    duck.jiao();
    //不行,我们要满足泥巴鸭子上天的梦想,实现这个新的功能需求,很简单的进行接口的修改(set一下)就可以了
    duck.setFly(new FlyWithBigRocket());
    duck.fly();
    }


    }


    如果一开始就这么设计,我相信有新的改动也不需要大动干戈了,这就是策略模式--来自于Head-First的例子,看书就困得可以看着玩一下。

    我理解的是,对于能够预测到在未来存在很多变化的功能,不要合并在主体当中,而要变成接口的形式实现随时可插拔操作,这样可以极大的改善以后的功能维护所要付出的代价。很可惜我还是没有更多自己的这个模式的应用,不然一定分享给大家,只能理论上理解一下。

    最后再次向这本书的作者们致敬,可能有人说这么简单的玩意你老推什么,但是我希望能对刚起步的人有所帮助


    展开全文
  • 2021-02-23

    2021-02-23 10:42:14
    目录策略1(MACD金叉+MA多头)策略2(RSI相对强弱指标)策略3(经典的QP优化)策略4(考虑Diversification的QP优化)策略5(考虑持仓股票数目的QP优化)比较和总结参考 策略1(MACD金叉+MA多头) 1. 初始化环境 ...
  • 聚宽源码23

    2019-12-11 11:06:23
    原文策略源码如下: #自选策略 from kuanke.wizard import * from jqdata import * import numpy as np ...初始化函数,设定要操作的股票、基准等等 def initialize(context): # 设定基准 set_benchmark(‘...
  • 23种设计模式

    2019-07-19 15:15:03
    观察者模式、策略模式、模板方法模式、命令模式、迭代器模式、中介者模式、备忘录模式、解释器模式、状态模式、责任链模式、访问者模式。 单例模式:类初始化 建造者(Builder)模式:Retrofit ...
  • 23种设计模式总结

    2017-01-01 17:31:21
    直接把一个初始化状态放到环境中 命令 想执行多个命令,但是不想了解命令的方法和内容。 把命令变成对象。命令接口。直接把命令扔进调用类中。 策略 有多个算法,不想了解算法的方法和内容。 算法变成对象。...
  • mysql基于Gtid做主从环境准备1.... 主从切换首先停掉从,并模拟数据产生新的主从搭建【154操作】【153操作】注意初始位置还是1!!!查验数据库同步 环境准备 centos7两台,关闭防火墙和selinux 主
  • 同时,优化算法晶态阶段中的初始化过程采用反向学习方法生成,其中,初始化概率采用动态惯性改变方式.经过国际上通用的23个基准函数测试,与一些流行的元启发式算法比较,并从平均收敛值、方差、Wilcoxon符号秩检验、收敛...
  • 安卓Webview网页秒开策略探索- https://juejin.im/post/5d2605f8f265da1bc23fa07c -- 网页加载缓慢,白屏,使用卡顿。 webview是怎么加载网页的呢? webview初始化->DOM下载→DOM解析→CSS请求+下载→CSS解析→...
  • 4.1 初始化配置 11 4.2 防火墙冗余NSRP设置 13 4.3 设置设备接口参数 20 4.4 设置路由 23 4.5 定义WAP中心主机及信息服务端口 25 4.6 配置NAT(DIP\NAT-Dst\MIP) 26 4.7 定义安全访问策略 31 4.8 用户账号管理 32 ...
  • /* 深度学习神经网络V1.0 made by xyt 2015/7/23 使用语言:C 本程序构建多层矩阵形神经网络多输入单输出 学习策略:随机梯度下降 ...使用前必须用srand((unsigned)time(NULL))取随机映射初始
  • 3.3.3 内容 23 3.3.4 风险 24 3.3.5 实施工具清单 24 3.3.6 案例 24 3.4 建立客户方项目组织 25 3.4.1 定义 25 3.4.2 目标与策略 26 3.4.3 内容 27 3.4.4 风险 27 3.4.5 实施工具清单 28 3.5 编制项目实施计划大纲 ...
  • Java设计模式

    2017-06-07 22:47:11
    *23种设计模式汇总整理&amp;amp;amp;gt;&amp;amp;amp;gt;内容来源 *单例模式 饿汉模式是线程绝对安全的,因为饿汉模式是在类加载的时候就已经初始化了(此时线程还没创建,实例化=初始化+赋值),同时这也是它...
  • 操作系统之磁盘调度算法

    千次阅读 2016-10-29 10:46:31
    1.先来先服务  是一种自然公平策略调度算法,即先来的先服务,谁也没有特权。...假设磁头的初始位置在10,磁盘请求序列0,23,6,16,2,21,8,9,12.寻道总数为:  10+23+17+   2.短任务优先  其核心思想是读取数据少
  • 设计模式总结

    2020-03-07 10:07:04
    如代理模式可以请求打印日志信息,工厂模式可以负责初始化一些,观察者模式可以对事件的监听,单例模式,一定会手写单例 策略设计模式 二、设计模式分类 设计模式总共23种,分为三类: 1.创建型:共五种:工厂...
  • 3-12 (2-23)4. 配置 FRA 时要用到哪两个初始化参数? 3-145. 如何确定 FRA 的大小? 3-166. 作为最佳实践原则,启用控制文件的自动备份的必要性在哪? 3-21 1. RMAN 预设的持久设置包含了哪些内容? 3-5 RMAN&
  • Vxworks资料

    2012-07-03 16:12:03
    任务调度策略  1.3.4. 抢占禁止  1.3.5. 异常处理  1.3.6. 任务管理 1.4.通信、同步和互斥机制 9 1.4.1. 共享存储区  1.4.2. 互斥  1.4.3. 信号量  1.4.4. 消息队列  1.4.5. 管道  1.4.6. 系统...
  • Problem G: 计数策略 Time Limit: 1 Sec Memory Limit: 128 MB Submit: 85 Solved: 14 [Submit][Status][Web Board] Description 来自遥远西方的迪奥斯在冒险的时候遇到了一个秘境,由于剧情需要,秘境的大门上有一...
  • 23 第二章 结构框架... 27 第一节 编程风格... 27 第二节 编程框架... 30 第三节 通用图像处理平台项目结构... 39 第四节 通用图像处理平台流程图... 44 第三章 功能函数与主程序... 47 第一节 功能函数与模块... ...
  • 23 第二章 结构框架... 27 第一节 编程风格... 27 第二节 编程框架... 30 第三节 通用图像处理平台项目结构... 39 第四节 通用图像处理平台流程图... 44 第三章 功能函数与主程序... 47 第一节 功能函数与模块... ...
  • 石老师的LABVIEW 宝典

    2017-11-12 19:58:35
    23 第二章 结构框架... 27 第一节 编程风格... 27 第二节 编程框架... 30 第三节 通用图像处理平台项目结构... 39 第四节 通用图像处理平台流程图... 44 第三章 功能函数与主程序... 47 第一节 功能函数与模块... ...
  • Java Concurrency in Practice Java并发编程实践 中英文版

    千次下载 热门讨论 2013-07-16 13:13:11
    17 2.2 Atomicity 19 2.3 Locking 23 2.4 Guarding state with locks 27 2.5 Liveness and performance 29 Chapter 3: Sharing Objects 33 3.1 Visibility 33 3.2 Publication and escape 39 3.3 Thread ...
  • 尚硅谷Shiro视频教程

    2019-02-17 09:07:00
    尚硅谷_Shiro_从数据表中初始化资源和权限 · 23.尚硅谷_Shiro_会话管理 · 24. 尚硅谷_Shiro_SessionDao · 25.尚硅谷_Shiro_缓存 · 26.尚硅谷_Shiro_认证和记住我的区别 · 27.尚硅谷_Shiro_实现Rememberme
  • 组织和策略问题 1 第0条 不要拘泥于小节(又名:了解哪些东西不应该标准化) 2 第1条 在高警告级别干净利落地进行编译 4 第2条 使用自动构建系统 7 第3条 使用版本控制系统 8 第4条 做代码审查 9设计...
  • 3.3.2 初始信息开发 15 3.3.3 栏目优化建议 15 3.4 网站前台基本功能 19 3.4.1 站内搜索 19 3.4.2 信访投诉 19 3.4.3 友情链接 20 3.5 网站后台管理功能 20 3.6 网站建设实施内容 21 第四章 内容管理系统介绍 22 4.1...
  • ◆详细讨论了递归编程的用法,包括大量难度各异的编程示例和练习,如简单的递归函数,分析双人游戏的最小最大(minimax)策略,等等; ◆帮助读者培养编写健壮、可重用代码的良好编程习惯 。 第Ⅰ部分 预备知识 1 第...
  • 1.2.2 集合初始值设定项 16 1.2.3 隐式行断续 16 1.2.4 Lambda表达式 17 1.2.5 等价类型支持 18 1.2.6 共变和逆变 18 1.2.7 定位到 18 1.2.8 突出显示引用 19 1.2.9 使用时生成 20 1.2.10 IntelliSense建议...
  • 23_集合类不安全之Map 24_TransferValue醒脑小练习 25_java锁之公平和非公平锁 26_java锁之可重入锁和递归锁理论知识 27_java锁之可重入锁和递归锁代码验证 28_java锁之自旋锁理论知识 29_java锁之自旋锁代码...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 421
精华内容 168
关键字:

初始策略23