精华内容
下载资源
问答
  • 利用反射机制实现创建动态对象。定义水果Fruit类,属性:brand(String)、unitPrice(double)、account(double),构造方法、getTotalPrice()计算水果的...
  • 为此,提出一种基于改进型拍卖的交换机迁移机制PASMM,将交换机的迁移问题优化成为控制器剩余资源的拍卖问题,通过提高处于供不应求状态的控制器资源的交易价格,完成拍卖过程,实现控制器和交换机的重新部署,提高...
  • 本章从c++的内存机制入手,首先介绍堆栈等内存机制,然后介绍指针、引用这两种核心的地址操作手段,最后介绍数组以及动态数组,在学习数组这种用户自定义类型的同时,加深对指针和内存机制的了解。【一】内存机制1、...

    本章从c++的内存机制入手,首先介绍堆栈等内存机制,然后介绍指针、引用这两种核心的地址操作手段,最后介绍数组以及动态数组,在学习数组这种用户自定义类型的同时,加深对指针和内存机制的了解。


    【一】内存机制


    内存可以将其简单理解为一个存数据的容器,内存中的数据在计算机关闭时将被清空。计算机中的内存一般是按照字节编址的,即一字节一地址,现在(2017-6)计算机的内存已经很大了,pc机最少也有4G了吧,手机至少也有2G了吧,内存支持程序的执行,用于执行时存放c++程序指令和数据。在C++程序中,内存主要分为如下5个存储区:
    (1)栈(Stack):该区用于存储函数内的动态变量空间,由编译器负责分配,也就是该区的变量在编译时就已经确定,函数结束栈变量失效。
    (2)堆(Heap):该区用于存储由new申请的变量空间,由delete或delete[]负责释放,如果程序员忘了释放,将造成内存泄漏,直到程序运行结束,才能有OS回收(对于小型程序,内存泄漏可能问题不大,但是对于服务器上那些需要持续运行的程序,内存泄漏可能会随着时间增加,最后造成程序崩溃)。
    (3)自由存储区(Free Storage):和堆类似,该区用于存储由malloc/calloc/realloc分配,用free释放。如果程序员忘记free了,将造成内存泄漏,直到程序运行结束,才能有OS回收。
    (4)全局区/静态区(Global Static Area): 全局变量和静态变量存放区,程序一经编译好,该区域便存在。在C++中,由于全局变量和静态变量编译器会给这些变量自动初始化赋值,所以没有区分了初始化变量和未初始化变量了。由于全局变量一直占据内存空间且不易维护,推荐少用。程序结束时释放。
    (5)常量存储区: 这是一块比较特殊的存储区,专门存储不能修改的常量,如const修饰的常数和字符串等(如果采用非正常手段更改当然也是可以的了)。


    【二】地址间接操作


    变量是直接访问存储空间的方式,关于变量之前已经写过一篇文章简单介绍,可以点击这里查看(传送门),指针和引用是两种间接访问存储单元的方式。

    1、指针

    不要把指针想的多神秘,其实它也是一个变量,指针也有指针名、指针(指向)类型、指针地址、指针值等属性,只是指针值只能是一个地址。指针的大小都是4个字节,无论它指向什么类型,没有例外。
    (1)、取指针内容符号*
    取指针内容符号*有两个作用,当它出现在数据类型和变量之间时,表示定义(或申明)指针变量,当它前面没有数据类型时,表示取指针变量指向的地址内容。
    (2)、取地址符号&
    指针值只能是一个地址,如何为指针赋值呢?你当然可以直接给它赋一个具体的地址值,但是这样意义不大,因为我们不知道你赋给它的地址指向什么地方,也就无法对它进行正确的操作。
    有两种方式为指针赋值,其中之一是使用取地址符号“&”取一个变量的地址为指针变量赋值,此时对指针变量的操作将影响原变量的值,因为都是对同一地址进行操作(另一种方式是使用new或者malloc等动态申请的空间地址为指针变量赋值,后面将动态数组时会说到),下面给出取指针内容符号和取变量地址符号的例子:

    int*ptr;//申明一个指针
    int a=10;
    ptr=&a;//取变量a的地址,并将其赋值给指针变量ptr
    cout<<*ptr;//取指针变量ptr指向的地址内容并输出

    (3)、指针的定义和使用
    如上面的例子所示,指针申明语法为:

    dataType *varibleName;//也就是:数据类型 *变量名;

    赋值:

    varibleName=&varibleName2;//用varibleName2的地址为指针赋值
    varibleName=new dataType;//用new申请的空间为指针赋值
    varibleName=new dataType[n];//new申请n个dataType类型的空间
    varibleName=(dataType *)malloc(sizeof(dataType));//使用malloc申请的空间为指针赋值
    varibleName=(dataType *)malloc(n*sizeof(dataType));//使用malloc申请n个dataType类型空间

    当然你也可以直接定义指针,关于申明和定义的区别,在前面变量和函数的章节就讲过了,就不再赘述。
    一个例子:

    #include <iostream>
    #include <cstdlib>
    using namespace std;
    
    int main(){
        int *ptr;
        int *ptr1;
        ptr=new int;
        ptr1=(int *)malloc(sizeof(int));
        *ptr=10;
        *ptr1=20;
        cout<<*ptr<<"\t"<<*ptr1<<endl;
        ptr=new int[2];
        *ptr=1;
        *(ptr+1)=2;
        ptr1=(int *)malloc(2*sizeof(int));
        *ptr1=3;
        *(ptr1+1)=4;
        cout<<*ptr<<"\t"<<*(ptr+1)<<"\t"<<*ptr1<<"\t"<<*(ptr1+1)<<endl;
        return 0;
    } 

    输出:

    10 20
    1 2 3 4

    2、引用

    引用是另一种间接操作地址的方法,引用相当于为变量取一个别名,对引用变量的操作就是对原变量的使操作。
    (1)、引用的定义
    引用在申明是就必须为其初始化,定义一个变量的引用,实际上就是把变量的地址赋给了引用变量,因此对引用变量的任何操作,实际上就是对原变量的操作,所以说引用就相当于为原变量取了个别名,和无论叫你的名字还是叫你的小名都是叫你本人一样,无论对原变量操作还是对引用变量(别名)操作,都是对同一个地址本身操作。
    引用变量是以&符号开始的,但在使用引用变量的时候不必要带着&使用,定义方式如下:

    dataType a;//定义一个dataType 类型的变量a
    dataType &b=a;//为a取了个别名叫b

    (2)、引用变量的初始化
    引用变量在定义时就必须完成初始化,一旦绑定了一个对象,就一直和该对象绑定,不能进行修改,这也是为什么一定要初始化的原因。
    只能使用一个对象为引用变量初始化,即不能为字面值(也就是常数如123),且对象类型必须与引用变量的类型严格相同,即就算能自动类型转换也不行。
    一个例子:

    #include <iostream>
    using namespace std;
    int main(){
        int a=1;
        double b=2;
        bool c=1;
        int &d=a;
        //int &e=b;//错误,b的类型不为int 
        //int &f=c;//错误,c的类型不为int 
        cout<<"a="<<a<<endl;
        cout<<"d="<<d<<endl;
        return 0; 
    } 

    输出:

    a=1
    d=1

    (3)、引用的使用
    引用的使用和变量一样。


    【三】动态数组


    1、内存动态分配

    在程序中的临时变量,静态变量,全局变量都是静态分配的,也就是在编译的时候就已经分配好存储空间的,这些变量是被分配到栈区、全局/静态区、常量区。动态分配,就是运行时才进行分配存储空间,这些变量将被分配到堆区,堆区是专门为程序应用动态分配空间而设置的,这个区才是我们程序员看得见摸得着的地方。

    其实它的功能和其他区一样,就是一个按字节编址的地址空间,用于存储数据,我们对存储空间的操作无非就是存取、删除,其他区都是由系统管理的,这个区很多时候都是由程序员管理的。

    我们怎么操作这快内存呢?c++中提供了两个运算符:new和delete

    new是一个单目符,右操作数为一种数据类型,而不是变量,运算结果为一个地址,使用这个地址的唯一方法是将它赋值给一个指针,指向的东西的大小为右操作数(数据类型)大小。
    delete也是一个单目运算符,右操作数为一个指向动态分配的内存的指针。结果为删除指针指向的内存(实质为将指针指向的内存标记为可用),如果不删除,则造成内存泄漏,下次使用new运算符时,这部分内存将不可用,在大量使用动态内存分配的大程序中,如果始终不删除,将可能造成堆内存满了而使程序意外中止。(堆RAM在程序结束运行后会置空,等待下一个程序运行)。
    下面以动态数组的定义和使用来说明new、delete以及指针的使用方法做一个综合。

    2、动态数组

    一般的数组申明只能申明已知长度的数组,也就是说数组长度只能是一个常量。如下:

    int a1=6;
    int arr1[a1];//错误,因为a不是常量
    
    int arr2[6];//正确
    coonst int a2=6;
    int arr3[a2];//正确

    所谓动态数组,就是在运行时候动态申请空间的数组。动态数组可以事先不知道数组长度,而在运行时才指定数组的长度,如下面的数组长度num可以动态指定。
    动态数组空间申请:

    int *ptr=new int;             //申请一个int大小的空间
    int num;
    cin>>num;  //运行是输入需要申请的空间大小
    float *ptrArr=new float[num];  //申请num个float大小的空间

    释放:

    delete ptr;                    //删除单个内存空间
    delete ptrArr;                 //删除数组第一个内存空间,其他内存将泄漏
    delete [ ] ptrArr;               //删除整个数组内存空间

    二维动态数组:
    创建:

    int **twoDarray:
    int xdim;int ydim;
    towDarray=new int *[xdim];
    for(int i=0;i<xdim;i++)
        twoDarray[i]=new int [ydim];

    使用:
    使用和赋值是一样的,都是通过下标进行 访问。

    for(int i=0;i<xdim;i++){
        for(int j=0;j<ydim;j++){
            twoDarray[i][j]=i*j;
        }
    }

    释放:

    for(int i=0;i<xdim;i++){
        delete [ ] twoDarray[i];
    }
    delete [ ] twoDarray;

    3、一个综合的例子

    在图书馆中经常会遇到图书信息录入的问题,在录入图书信息之前,通常不知道图书数目是多少,那么要申请多少空间来存储图书呢,你当然可以申请一个很大的空间来存储,但是这有两个问题,一是如果图书很少,那么很多空间将本浪费,二是随着后来新增图书,到了申请的空间都装不下的地步,你就不得不重新申请空间,将所有数据再录入一次(当然在实际中是不会遇到这样问题的,因为我们通常将信息存储到文件或者数据库中,这样就可以共享了,这个例子只是为了说明动态数组的作用)。有了动态数组,你将不用再担心这两个问题,你可以随着图书的增多动态申请更多空间去存储图书。一个简单的例子如下:

    #include <iostream>
    #include <string>
    
    #define stepLength 3  //定义图书仓库长度增长步长
    
    using namespace std;
    
    typedef struct{//定义图书结构,简单起见只简单包含图书名字和价格
        string name;
        int price;
    }book;
    
    int max = 3;   //定义当前图书仓库最大长度
    int counter = 0; //当前图书仓库中的图书数目
    book *storage;  //定义图书仓库
    
    void add(string name, int price);//定义添加图书的函数
    
    int main(){
        storage = new book[max];//初始化仓库,申请能存储max个图书的空间
        for (int i=0;i<=9;i++){//添加9本书
            string name = "book" + to_string(i);
            add(name, i);//简单地使用booki和i作为参数填充书本
        }
        cout << "+--------------book list------------+" << endl;
        for (int i = 0; i<counter; i++){   //打印添加的书单
            cout << "| " << storage[i].name << "    " << storage[i].price << endl;
        }
        system("pause");
    }
    
    void add(string name, int price){
        if (counter < max){   //判断当前书本数目,若小于仓库大小,说明还有空间,则直接添加书籍
            storage[counter].name = name;
            storage[counter].price = price;
            counter++;
            cout << "书籍-->name:  " << name << ",  price:  " << price << "添加完毕..." << endl;
        }
        else{//否则,说明空间不够了,添加不进去了
            cout << "空间不足,正在申请空间..." << endl;
            max += stepLength;//增大空间容量
            book *temp = new book[max];//申请更大空间
            for (int i = 0; i<counter; i++){//将原来的数据数据复制到新申请的空间中
                temp[i].name = storage[i].name;
                temp[i].price = storage[i].price;
            }
            delete[] storage;//别忘了释放原来的空间,否则将造成内存泄漏
            storage = temp;//将仓库指向新申请的空间
            cout << "空间申请完毕,正在添加书籍..." << endl;
            add(name, price);//再添加刚刚添加不进去那本书
        }
    }

    程序中初始空间大小为3本书大小,增长步长为3,当要录入9本书是,输出为:

    书籍–>name: book0, price: 0添加完毕…
    书籍–>name: book1, price: 1添加完毕…
    书籍–>name: book2, price: 2添加完毕…
    空间不足,正在申请空间…
    空间申请完毕,正在添加书籍…
    书籍–>name: book3, price: 3添加完毕…
    书籍–>name: book4, price: 4添加完毕…
    书籍–>name: book5, price: 5添加完毕…
    空间不足,正在申请空间…
    空间申请完毕,正在添加书籍…
    书籍–>name: book6, price: 6添加完毕…
    书籍–>name: book7, price: 7添加完毕…
    书籍–>name: book8, price: 8添加完毕…
    空间不足,正在申请空间…
    空间申请完毕,正在添加书籍…
    书籍–>name: book9, price: 9添加完毕…
    +————–book list————+
    | book0 0
    | book1 1
    | book2 2
    | book3 3
    | book4 4
    | book5 5
    | book6 6
    | book7 7
    | book8 8
    | book9 9
    请按任意键继续…

    可见,当录入3本书时,空间就被填满了,程序会自动申请更多空间(+3个),以满足需求,在实际中肯定不会将步长设置为3,这太短了,因为新申请一次空间的开销是很大的,需要将原来的数据从新填入新申请的空间中,步长多少还要看实际应用。

    展开全文
  • 利用java反射机制实现动态导出excel

    千次阅读 2014-12-08 09:45:08
     * 这是一个通用的方法,利用了JAVA的反射机制,可以将放置在JAVA集合中并且符号一定条件的数据以EXCEL 的形式输出到指定IO设备上  *  * @param title  * 表格标题名  * @param headers  * 表格...
    import java.io.IOException;
    
    import java.io.OutputStream;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Date;
    import java.util.Iterator;
    import java.util.List;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;

    import org.apache.poi.hssf.usermodel.HSSFCell;
    import org.apache.poi.hssf.usermodel.HSSFCellStyle;
    import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
    import org.apache.poi.hssf.usermodel.HSSFComment;
    import org.apache.poi.hssf.usermodel.HSSFFont;
    import org.apache.poi.hssf.usermodel.HSSFPatriarch;
    import org.apache.poi.hssf.usermodel.HSSFRichTextString;
    import org.apache.poi.hssf.usermodel.HSSFRow;
    import org.apache.poi.hssf.usermodel.HSSFSheet;
    import org.apache.poi.hssf.usermodel.HSSFWorkbook;
    import org.apache.poi.hssf.util.HSSFColor;

    /**
     * 利用开源组件POI3.0.2动态导出EXCEL文档 转载时请保留以下信息,注明出处!
     *
     * @author leno
     * @version v1.0
     * @param <T>
     *            应用泛型,代表任意一个符合javabean风格的类
     *            注意这里为了简单起见,boolean型的属性xxx的get器方式为getXxx(),而不是isXxx()
     *            byte[]表jpg格式的图片数据
     */
    public class ExportExcel<T> {

        public void exportExcel(Collection<T> dataset, OutputStream out) {
            exportExcel("导出EXCEL文档", null, dataset, out, "yyyy-MM-dd");
        }

        public void exportExcel(String[] headers, Collection<T> dataset,
                OutputStream out) {
            exportExcel("导出EXCEL文档", headers, dataset, out, "yyyy-MM-dd");
        }

        public void exportExcel(String title, String[] headers,
                Collection<T> dataset, OutputStream out) {
            exportExcel(title, headers, dataset, out, "yyyy-MM-dd");
        }

        public void exportExcel(String[] headers, Collection<T> dataset,
                OutputStream out, String pattern) {
            exportExcel("导出EXCEL文档", headers, dataset, out, pattern);
        }

        /**
         * 这是一个通用的方法,利用了JAVA的反射机制,可以将放置在JAVA集合中并且符号一定条件的数据以EXCEL 的形式输出到指定IO设备上
         *
         * @param title
         *            表格标题名
         * @param headers
         *            表格属性列名数组
         * @param dataset
         *            需要显示的数据集合,集合中一定要放置符合javabean风格的类的对象。此方法支持的
         *            javabean属性的数据类型有基本数据类型及String,Date,byte[](图片数据)
         * @param out
         *            与输出设备关联的流对象,可以将EXCEL文档导出到本地文件或者网络中
         * @param pattern
         *            如果有时间数据,设定输出格式。默认为"yyy-MM-dd"
         */
        @SuppressWarnings({ "unchecked", "deprecation", "rawtypes" })
        public void exportExcel(String title, String[] headers,
                Collection<T> dataset, OutputStream out, String pattern) {
            // 声明一个工作薄
            HSSFWorkbook workbook = new HSSFWorkbook();

            // 生成一个样式
            HSSFCellStyle style = workbook.createCellStyle();
            // 设置这些样式
            style.setFillForegroundColor(HSSFColor.WHITE.index);
            style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
            style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
            style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
            style.setBorderRight(HSSFCellStyle.BORDER_THIN);
            style.setBorderTop(HSSFCellStyle.BORDER_THIN);
            style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
            // 生成一个字体
            HSSFFont font = workbook.createFont();
            font.setColor(HSSFColor.BLACK.index);
            font.setFontHeightInPoints((short) 12);
            font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
            // 把字体应用到当前的样式
            style.setFont(font);
            // 生成并设置另一个样式
            HSSFCellStyle style2 = workbook.createCellStyle();
            style2.setFillForegroundColor(HSSFColor.WHITE.index);
            style2.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
            style2.setBorderBottom(HSSFCellStyle.BORDER_THIN);
            style2.setBorderLeft(HSSFCellStyle.BORDER_THIN);
            style2.setBorderRight(HSSFCellStyle.BORDER_THIN);
            style2.setBorderTop(HSSFCellStyle.BORDER_THIN);
            style2.setAlignment(HSSFCellStyle.ALIGN_CENTER);
            style2.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
            // 生成另一个字体
            HSSFFont font2 = workbook.createFont();
            font2.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
            // 把字体应用到当前的样式
            style2.setFont(font2);

            int sheetCount = 1000;
            if (dataset.size() > sheetCount) {
                Iterator<T> it = dataset.iterator();
                for (int i = 0; i <= 4; i++) {
                    int index = 0;
                    List<T> list = new ArrayList<T>();
                    while (it.hasNext()) {
                        index++;
                        if (index < sheetCount) {
                            list.add(it.next());
                        } else {
                            break;
                        }
                    }
                    generateSheet(list, style, style2, workbook, pattern, headers,
                            title + "_" + (i + 1));
                }
            } else {
                generateSheet(dataset, style, style2, workbook, pattern, headers,
                        title);
            }

            try {
                workbook.write(out);
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

        public void generateSheet(Collection<T> dataset, HSSFCellStyle style,
                HSSFCellStyle style2, HSSFWorkbook workbook, String pattern,
                String[] headers, String title) {
            // 生成一个表格
            HSSFSheet sheet = workbook.createSheet(title);
            // 设置表格默认列宽度为15个字节
            sheet.setDefaultColumnWidth((short) 15);
            // 声明一个画图的顶级管理器
            HSSFPatriarch patriarch = sheet.createDrawingPatriarch();
            // 定义注释的大小和位置,详见文档
            HSSFComment comment = patriarch.createComment(new HSSFClientAnchor(0,
                    0, 0, 0, (short) 4, 2, (short) 6, 5));
            // 设置注释内容
            comment.setString(new HSSFRichTextString("可以在POI中添加注释!"));
            // 设置注释作者,当鼠标移动到单元格上是可以在状态栏中看到该内容.
            comment.setAuthor("author");

            // 产生表格标题行
            HSSFRow row = sheet.createRow(0);
            for (short i = 0; i < headers.length; i++) {
                HSSFCell cell = row.createCell(i);
                cell.setCellStyle(style);
                HSSFRichTextString text = new HSSFRichTextString(headers[i]);
                cell.setCellValue(text);
            }
            // 遍历集合数据,产生数据行
            Iterator<T> it = dataset.iterator();
            int index = 0;
            while (it.hasNext()) {
                index++;
                row = sheet.createRow(index);
                T t = (T) it.next();
                // 利用反射,根据javabean属性的先后顺序,动态调用getXxx()方法得到属性值
                Field[] fields = t.getClass().getDeclaredFields();
                for (short i = 0; i < fields.length; i++) {
                    Field field = fields[i];
                    if (field.toString().contains("static")) {
                        continue;
                    }
                    HSSFCell cell = row.createCell(i);
                    cell.setCellStyle(style2);
                    String fieldName = field.getName();
                    String getMethodName = "get"
                            + fieldName.substring(0, 1).toUpperCase()
                            + fieldName.substring(1);
                    try {
                        Class tCls = t.getClass();
                        Method getMethod = tCls.getMethod(getMethodName,
                                new Class[] {});
                        Object value = getMethod.invoke(t, new Object[] {});
                        // 判断值的类型后进行强制类型转换
                        String textValue = null;
                        if (value instanceof Boolean) {
                            boolean bValue = (Boolean) value;
                            textValue = "男";
                            if (!bValue) {
                                textValue = "女";
                            }
                        } else if (value instanceof Date) {
                            Date date = (Date) value;
                            SimpleDateFormat sdf = new SimpleDateFormat(pattern);
                            textValue = sdf.format(date);
                        } else if (value instanceof byte[]) {
                            // 有图片时,设置行高为60px;
                            row.setHeightInPoints(60);
                            // 设置图片所在列宽度为80px,注意这里单位的一个换算
                            sheet.setColumnWidth(i, (short) (35.7 * 80));
                            // sheet.autoSizeColumn(i);
                            byte[] bsValue = (byte[]) value;
                            HSSFClientAnchor anchor = new HSSFClientAnchor(0, 0,
                                    1023, 255, (short) 6, index, (short) 6, index);
                            anchor.setAnchorType(2);
                            patriarch.createPicture(anchor, workbook.addPicture(
                                    bsValue, HSSFWorkbook.PICTURE_TYPE_JPEG));
                        } else {
                            // 其它数据类型都当作字符串简单处理
                            if (value == null) {
                                value = "";
                            }
                            textValue = value.toString();
                        }
                        // 如果不是图片数据,就利用正则表达式判断textValue是否全部由数字组成
                        if (textValue != null) {
                            Pattern p = Pattern.compile("^//d+(//.//d+)?{1}quot;");
                            Matcher matcher = p.matcher(textValue);
                            if (matcher.matches()) {
                                // 是数字当作double处理
                                cell.setCellValue(Double.parseDouble(textValue));
                            } else {
                                HSSFRichTextString richString = new HSSFRichTextString(
                                        textValue);
                                HSSFFont font3 = workbook.createFont();
                                font3.setColor(HSSFColor.BLACK.index);
                                richString.applyFont(font3);
                                cell.setCellValue(richString);
                            }
                        }
                    } catch (SecurityException e) {
                        e.printStackTrace();
                    } catch (NoSuchMethodException e) {
                        e.printStackTrace();
                    } catch (IllegalArgumentException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    } finally {
                        // 清理资源
                    }
                }

            }
        }

        // public static void main(String[] args) {
        // // 测试学生
        // ExportExcel<Student> ex = new ExportExcel<Student>();
        // String[] headers = { "学号", "姓名", "年龄", "性别", "出生日期" };
        // List<Student> dataset = new ArrayList<Student>();
        // dataset.add(new Student(10000001, "张三", 20, true, new Date()));
        // dataset.add(new Student(20000002, "李四", 24, false, new Date()));
        // dataset.add(new Student(30000003, "王五", 22, true, new Date()));
        // // 测试图书
        // ExportExcel<Book> ex2 = new ExportExcel<Book>();
        // String[] headers2 = { "图书编号", "图书名称", "图书作者", "图书价格", "图书ISBN",
        // "图书出版社", "封面图片" };
        // List<Book> dataset2 = new ArrayList<Book>();
        // try {
        // BufferedInputStream bis = new BufferedInputStream(
        // new FileInputStream("book.jpg"));
        // byte[] buf = new byte[bis.available()];
        // while ((bis.read(buf)) != -1) {
        // //
        // }
        // dataset2.add(new Book(1, "jsp", "leno", 300.33f, "1234567",
        // "清华出版社", buf));
        // dataset2.add(new Book(2, "java编程思想", "brucl", 300.33f, "1234567",
        // "阳光出版社", buf));
        // dataset2.add(new Book(3, "DOM艺术", "lenotang", 300.33f, "1234567",
        // "清华出版社", buf));
        // dataset2.add(new Book(4, "c++经典", "leno", 400.33f, "1234567",
        // "清华出版社", buf));
        // dataset2.add(new Book(5, "c#入门", "leno", 300.33f, "1234567",
        // "汤春秀出版社", buf));
        //
        // OutputStream out = new FileOutputStream("E://a.xls");
        // OutputStream out2 = new FileOutputStream("E://b.xls");
        // ex.exportExcel(headers, dataset, out);
        // ex2.exportExcel(headers2, dataset2, out2);
        // out.close();
        // JOptionPane.showMessageDialog(null, "导出成功!");
        // System.out.println("excel导出成功!");
        // } catch (FileNotFoundException e) {
        // e.printStackTrace();
        // } catch (IOException e) {
        // e.printStackTrace();
        // }
        // }
    }

    展开全文
  • 本文针对我国1997年上半年经济形势,对“供过于求”买方市场提出了质疑,用不等势宏观市场价格定义了需求主导的市场价格形成机制买方市场概念,并讨论了其平稳性、...
  • Java反射机制 详解

    千次阅读 2016-10-03 23:39:46
    这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。“程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言”。Java不是动态语言。但是Java有着一个非常突出的动态相关机制:...

    一、什么是反射机制

    JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

    “程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言”。Java不是动态语言。但是Java有着一个非常突出的动态相关机制:Reflection,用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说,Java程序可以加载一个运行时才得知名称的class,获悉其完整构造(但不包括methods定义),并生成其对象实体、或对其fields设值、或唤起其methods。

    二、初识Java反射机制

    反射之中包含了一个“反”的概念,要解释反射就必须先从“正”开始解释,一般而言,一定是先有类再产生实例化对象。如下:

    package com.wz.reflectdemo;
    
    import java.util.Date;//先有类
    
    public class ReflectTest {
    
        public static void main(String[] args) {
            Date date = new Date();//再产对象
            System.out.println(date);
        }
    }
    

    而所谓的“反”,是通过对象找到类。在Object类里面提供有一个方法,
    取得class对象:

    public final Class<?> getClass()

    注:反射之中的所有泛型都定义为?,返回值都是Object。

    实例如下:

    package com.wz.reflectdemo;
    
    import java.util.Date;//先有类
    
    public class ReflectTest {
    
        public static void main(String[] args) {
            Date date = new Date();//再产对象
            System.out.println(date.getClass());
        }
    }
    

    执行结果:

    class java.util.Date

    我们发现,调用getClass()后,得到了类的完整名称。也就找到了对象的出处。

    三、Class类对象实例化

    java.lang.Class是一个类,它和一般类一样继承自Objec。这个类是反射操作的源头,即所有的反射都要从此类开始进行,这个类有三种实例化方式:

    方式一:调用Object类的getClass()方法(很少用到):

    package com.wz.reflectdemo;
    
    import java.util.Date;
    
    public class ReflectTest {
    
        public static void main(String[] args) {
            Date date = new Date();
            Class<?> cls = date.getClass();
            System.out.println(cls);
        }
    }
    

    运行结果:

    class java.util.Date
    

    方式二:使用“类.class”取得:

    package com.wz.reflectdemo;
    
    import java.util.Date;
    
    public class ReflectTest {
    
        public static void main(String[] args) {
            //Date date = new Date();
            Class<?> cls = Date.class;
            System.out.println(cls);
        }
    }
    

    运行结果:

    class java.util.Date
    

    注意:先前取得Class类对象之前需要实例化,但此时并没有进行实例化。

    方式三:调用Class类提供的一个方法:

    public static Class<?> forName(String className) throws ClassNotFoundException

    实例如下:

    package com.wz.reflectdemo;
    
    //import java.util.Date;
    
    public class ReflectTest {
    
        public static void main(String[] args) throws Exception {
            Class<?> cls = Class.forName("java.util.Date");
            System.out.println(cls);
        }
    }
    

    运行结果:

    class java.util.Date
    

    此时,无需使用import语句导入一个明确的类,而类名称是采用字符串的形式进行描述的。

    四、反射实例化对象

    一般情况下,对象的实例化操作需要依靠构造方法和关键字new完成。可是有了Class类对象之后,可以利用反射来实现对象的实例化。
    通过反射实例化对象:

    public T newInstance() throws InstantiationException, IllegalAccessException

    实例:

    package com.wz.reflectdemo;
    
    class Book{
    
        public Book(){
            System.out.println("Book类的无参构造方法");
        }
    
        @Override
        public String toString() {
    
            return "This a book !";
        }
    }
    
    public class TestDemo {
    
        public static void main(String[] args) throws Exception {
    
            Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
            Object obj = cls.newInstance();//相当于使用new调用无参构造实例化对象
    
            Book book = (Book)obj;
            System.out.println(book);
        }
    
    }
    

    运行结果:

    Book类的无参构造方法
    This a book !

    如上,有了反射之后,进行实例化的操作不再只有依靠关键字new来完成了。但这个操作要比之前使用的new复杂一些,并且并不表示用new来进行实例化被完全取代了。为什么呢?

    对于程序的开发一直强调:尽量减少耦合。而减少耦合的最好做法是使用接口,但是就算使用了接口也逃不出关键字new,所以实际上new是造成耦合的关键元凶。

    先看一个简单的工厂设计模式:

    package com.wz.reflectdemo;
    
    
    interface Fruit{
        public void eat();
    }
    
    class Apple implements Fruit{
        @Override
        public void eat(){
            System.out.println("eat apple");
        }
    }
    
    class Factory{
        public static Fruit getInstance(String className){
            if("apple".equals(className)){
                return new Apple();
            }
            return null;
        }
    }
    
    public class FactoryDemo{
        public static void main(String[] args){
            Fruit f = Factory.getInstance("apple");
            f.eat();
        }
    }
    

    运行结果:

    eat apple

    以上是一个简单的工厂设计模式,但是在这个工厂设计模式之中有一个问题:如果增加了Fruit接口子类,那么就需要修改工厂类。

    增加了Fruit接口子类Orange :

    class Orange implements Fruit {
        public void eat() {
            System.out.println("eat orange");
        };
    }

    需要修改工厂类:

    class Factory{
        public static Fruit getInstance(String className){
            if("apple".equals(className)){
                return new Apple();
            }else if("orange".equals(className)){
                return new Orange();
            }
            return null;
    
        }
    }

    问题来了,每增加一个接口子类,就需要去修改工厂类,那么若随时可能增加多个子类呢?那么就要一直对工厂类进行修改!

    根本原因:工厂类中的对象都是通过关键字new直接实例化的。那么如果说现在不使用关键字new了,变为了反射机制呢?

    反射机制实例化对象的时候实际上只需要“包.类”就可以,于是根据此操作,修改工厂设计模式如下:

    package com.wz.reflectdemo;
    
    
    interface Fruit{
        public void eat();
    }
    
    class Apple implements Fruit{
        @Override
        public void eat(){
            System.out.println("eat apple");
        }
    }
    
    class Orange implements Fruit{
        @Override
        public void eat(){
            System.out.println("eat orange");
        }
    }
    
    class Factory{
        public static Fruit getInstance(String className){
            /*if("apple".equals(className)){
                return new Apple();
            }else if("orange".equals(className)){
                return new Orange();
            }
            return null;*/
            Fruit f = null;
            try {
                f = (Fruit)Class.forName(className).newInstance();
    
            } catch (Exception e) {
                e.printStackTrace();
            }
            return f;
    
        }
    }
    
    public class FactoryDemo{
        public static void main(String[] args){
            /*Fruit f = Factory.getInstance("apple");
            f.eat();
    
            Fruit f1 = Factory.getInstance("orange");
            f1.eat();*/
    
            Fruit f1= Factory.getInstance("com.wz.reflectdemo.Apple");
            f1.eat();
    
            Fruit f2 = Factory.getInstance("com.wz.reflectdemo.Orange");
            f2.eat();
    
        }
    }
    

    运行结果:

    eat apple
    eat orange

    这个时候即使增加了接口的子类,工厂类照样可以完成对象的实例化操作,这个才是真正的工厂类,可以应对于所有的变化。这就完成了解耦合的目的,而且扩展性非常强。

    五、反射调用构造方法

    之前我们通过反射实例化对象都是这么写的:

    Class<?> cls = Class.forName(“*****className*****”);
    Object  obj =  cls.newInstance();

    这只能调用默认的无参构造方法,那么,问题来了:若类中不提供无参构造方法呢?怎么解决?

    看一个范例:

    先写一个Book类:

    package com.wz.reflectdemo;
    
    public class Book {
    
        private String title;
        private double price;
    
        public Book(String title, double price) {
            this.title = title;
            this.price = price;
        }
    
        @Override
        public String toString() {
    
            return "图书名称:"+this.title + " ,价格:"+this.price;
        }
    
    }
    

    然后实例化对象:

    package com.wz.reflectdemo;
    
    public class ReflectTest {
    
        public static void main(String[] args) throws Exception {
    
            Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
            Object obj = cls.newInstance();//相当于使用new调用无参构造实例化对象
    
            Book book = (Book)obj;
            System.out.println(book);
    
        }
    }
    

    执行结果:

    Exception in thread "main" java.lang.InstantiationException: com.wz.reflectdemo.Book
        at java.lang.Class.newInstance(Unknown Source)
        at com.wz.reflectdemo.ReflectTest.main(ReflectTest.java:8)
    Caused by: java.lang.NoSuchMethodException: com.wz.reflectdemo.Book.<init>()
        at java.lang.Class.getConstructor0(Unknown Source)
        ... 2 more
    

    由此可见,由于此时Book类没有提供无参构造方法,而cls.newInstance()的时候又调用了无参构造方法,所以无法进行对象实例化。那么,怎么解决?只能明确的调用有参构造方法。

    在Class类里面,提供了方法来取得构造:
    (1)取得全部构造:

    public Constructor<?>[] getConstructors() throws SecurityException

    (2)取得一个指定参数顺序的构造:

    public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException

    以上两个方法返回的都是”java.lang.reflect.Constructor”类的对象。在这个类中提供有一个明确传递有参构造内容的实例化对象方法:

    public T newInstance(Object... initargs) throws InstantiationException, IllegalAccessException,
    IllegalArgumentException, InvocationTargetException

    改写上面范例的实例化对象方法,明确调用有参构造方法:

    package com.wz.reflectdemo;
    
    import java.lang.reflect.Constructor;
    
    public class ReflectTest {
    
        public static void main(String[] args) throws Exception {
    
            Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
            /*Object obj = cls.newInstance();//相当于使用new调用无参构造实例化对象
            Book book = (Book)obj;
            System.out.println(book);*/
    
            Constructor<?> con = cls.getConstructor(String.class,double.class);
            Object obj = con.newInstance("Java开发",79.8);//实例化对象
    
            System.out.println(obj);
    
        }
    }
    

    执行结果:

    图书名称:Java开发 ,价格:79.8

    很明显,调用无参构造方法实例化对象要比调用有参构造的更加简单、方便。so,简单的Java开发中不过提供有多少个构造方法,请至少保留有无参构造。

    六、反射调用普通方法

    我们都知道:类中的普通方法只有在一个类产生实例化对象之后才可以调用。

    先看一个例子。我们先定义一个类:

    package com.wz.reflectdemo;
    
    public class Book {
    
        private String title;
    
        public String getTitle() {
            return title;
        }
    
        public void setTitle(String title) {
            this.title = title;
        }
    
    }
    

    这个类有无参构造方法,所有实例化对象的时候可以直接利用Class类提供的newInstance()方法。

    在Class类里面提供以下取得类在Method的操作:
    (1)取得一个类中的全部方法:

    public Method[] getMethods() throws SecurityException

    (2)取得指定方法:

    public Method getMethod(String name, Class<?>... parameterTypes) throws
    NoSuchMethodException, SecurityException

    以上的方法返回的都是”java.lang.reflect.Method”类的对象,在这个类中有一个调用方法:

    public Object invoke(Object obj, Object... args) throws IllegalAccessException,
    IllegalArgumentException, InvocationTargetException

    我们接着上面的例子来看反射调用方法:

    package com.wz.reflectdemo;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Method;
    
    public class ReflectTest {
    
        public static void main(String[] args) throws Exception {
    
            Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
            Object obj = cls.newInstance();
    
            Method setMet = cls.getMethod("setTitle", String.class);
            setMet.invoke(obj, "Java开发");//等价于Book类的setTitle("Java开发")
    
            Method getMet = cls.getMethod("getTitle");
            System.out.println(getMet.invoke(obj));//等价于Book类的getTitle()
        }
    }
    

    执行结果:

    Java开发

    此时,我们完全看不见具体的操作类型,也就是说,利用反射可以实现任意类的指定方法的调用。

    七、反射调用成员

    我们都知道,类中的属性一定要在本类实例化对象之后才可以分配内存空间。在Class类里面提供有取得成员的方法:

    (1)取得全部成员:

    public Field[] getDeclaredFields() throws SecurityException

    (2)取得指定成员:

    public Field getDeclaredField(String name) throws NoSuchFieldException, SecurityException

    这两个方法的返回值类型是”java.lang.reflect.Field”类的对象。在这个类里面有两个重要的方法:

    (1)取得属性内容(类似于:对象.属性):

    public Object get(Object obj)
    throws IllegalArgumentException, IllegalAccessException

    (2)设置属性内容(类似于:对象.属性=内容):

    public void set(Object obj, Object value)
    throws IllegalArgumentException, IllegalAccessException

    接着看一个例子:
    先定义一个类:

    package com.wz.reflectdemo;
    
    public class Book {
    
        private String title;
    
    }
    

    这个类只定义了一个私有属性,按照之前的做法,它一定无法被外部所使用。但是,可以反射调用:

    package com.wz.reflectdemo;
    
    import java.lang.reflect.Field;
    
    public class ReflectTest {
    
        public static void main(String[] args) throws Exception {
    
            Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
            Object obj = cls.newInstance();
    
            Field titleField = cls.getDeclaredField("title");
            titleField.setAccessible(true);//解除封装
            titleField.set(obj, "Java开发");//相当于Book类对象.title = "Java开发"
            System.out.println(titleField.get(obj));//相当于Book类对象的.title
        }
    }
    

    执行结果:

    Java开发

    注:构造方法和普通方法一样可以解除封装,只是很少这么去做。而对于属性的访问还是建议使用setter和getter方法完成。

    展开全文
  • 广义第一定价机制(Generalized First Auction)3. 广义第二定价机制(Vickrey Auction)3.1 理解Vickrey Auction3.2 第一定价与第二定价之间的联系4. VCG机制(Vickrey-Clarke-Groves) 写在前面:目前在互联网的竞价...

    写在前面:目前在互联网的竞价广告里,常用的几种机制设计方案是必须要知道的。第一个机制设计叫做Pricing
    Model,即定价机制,就是要收广告主多少钱。

    在线广告中一般用的是实时竞价(RTB)交易模式,所以拍卖的本质不是广告位而是这一次展示本身,所以就会有以下的前提:

    • a. 同一个广告位会一次次的被拍卖;

    • b. 同一个广告主代理的需求方平台(DSP)很可能会对同一个广告位不断的出价;

    • c. 竞拍的人并不直接了解其他竞拍人的价格。

    1. 帕累托最优(Pareto Optimalitiy)

    星巴克咖啡遍布全球,目前在全球近50个国家都有销售,在英国有近千家分店,但是在意大利,你却找不到一家星巴克咖啡店。星巴克的回答是,星巴克的意式咖啡(Espresso)来源于意大利的咖啡文化,星巴克无意影响传统意式咖啡在意大利的发展,希望星巴克的粉丝们可以到意大利找到星巴克咖啡的灵感来源。

    这是一种伟大的平衡,资源分配的理想状态,星巴克不进入意大利市场,Espresso的文化原产地也得以保存发展,这是一种简单原始的帕累托最优(Pareto Optimalitiy)。帕累托最优是指一种资源分配的理想状态,在理想状态中,任何一种变化,都会损害一些人的利益,因此这种状体是一种最为高效的理想状态。互联网技术其实就是帮助整个社会向帕累托最优发展,去除信息的不对称,不透明,颠覆很多产业,提升整个产业效率,而且增加多方面的利益。

    互联网广告平台也是一个多方面利益博弈的领域,主要参与者有广告主,媒体,广告平台,互联网用户。其中的关系,看起来像一个四角恋爱:广告主追求媒体的目标用户,互联网用户追求媒体的内容和社区,媒体追求广告平台变现能力的最大化,广告平台追求广告主手中的预算。 在这种相互博弈的状态下,广告平台成为资源调整的的核心作用,它是整个循环的宏观调控中心。

    在这里插入图片描述

    2. 广义第一定价机制(Generalized First Auction)

    第一价格拍卖是一种“密封”式拍卖,并且买方出价是同时性,而非序惯性;众多买方以书面投标方式竞买拍卖品,出价最高者将以其出价水平获取拍卖品。第一价格拍卖的多单位同质商品的拍卖,称作“歧视性拍卖”,即不同单位的拍卖品由该单位的最高出价者以最高出价购买。在竞价过程中,竞买人不知道参加竞拍的总人数及标的价格,通常竞买人往往会比自己的估价要稍低一些。

    它的优势就是简单,收入可保证,但是稳定性较差。各个广告主为了获得最佳收益,可以通过频繁修改投放价格而获得。举例来说,一个广告主为了获得展现,它会不断的的增加价格,在获得展现后,它又会开始不断的减少价格而降低成本,这种竞争是相对武断的,而且很容易知晓竞争对手的出价。另外,当出价最高广告主停止投放后,容易对广告平台收入产生较大的波动。在2002年之前,所有的搜索引擎都是第一出价法则。
    在这里插入图片描述

    3. 广义第二定价机制(Vickrey Auction)

    3.1 理解Vickrey Auction

    第二价格密封拍卖,即维克里拍卖,也叫二级价格密封拍卖。在这种拍卖中,竞买者同样以密封的形式独立出价,商品也出售给出价最高的投标者。但是,获胜者支付的是所有投标价格中的第二高价,所以它被称为第二价格密封拍卖。

    Q:在第二价格密封拍卖中,每个投标者提交密封的交易价格,出价最高者赢得商品,但交易却以所有出价中的第二高价进行。针对这种拍卖方式的具体运作特点,投标者应该如何制定自己的竞拍策略?
    A:维克里指出,如果执行这种程序,每个投标者的最优战略就是使出价等于他自己对这件商品的完全估价,或者说,此时诚实才是最好的竞拍策略。因为在第二价格密封拍卖中,当一个投标人获胜时,他最后支付的成交价格独立于其出价。所以,在没有串通的情况下,每个投标者的最优战略就是依照自己对拍卖商品的估价据实竞标。当低于这个价格时,将减少投标者赢得商品的机率;而高于此价格,虽然可以提高投标者赢的概率,但他获得了一场无利润的交易,因为他必须支付的价格可能高于其对商品的估价。

    由于在第二价格拍卖中,诚实就是最好的竞拍策略,所以维克里进一步指出,用“第二价格”的方法解决密封式投标具有很多优点:

    第一,在很多情况下,由于投标者之间的不对称、错误的评估、战略错误,使得“最高价”或者说第一价格拍卖方法的结果不是最优。
    第二,在第二价格拍卖法中,投标者的最好竞拍策略就是依照自己对标的物 的评价而给出标价,因此不管是从个人收益还是从整体资源配置考虑,它使得对其他竞争对手的出价情况、投标策略和整体市场评估变得多余。每个投标者只需要将他的努力和注意力放在从自身方面评价商品价值上,因此大量节省了脑力劳动和费用支出。这种节约可以导致更好的资源配置,并增加可被买卖双方分享的总收益。因为投标者的信息搜寻费用减少了,收益就增加,这就会吸引更多人参与竞标,对卖者而言也可能产生更高的价格。

    那么,在第二价格密封拍卖的具体实践中,诚实是否真的是投标者的最优策略,此时,搜集其他竞争对手的需求信息以及评估整体市场形式是否真的不再必要?我们认为,维克里的结论只有在其假设条件下才是成立的。维克里认为,在第二价格拍卖法中,投标人的出价由他对拍卖商品的估价决定,而估价则产生于投标者各自相互独立的概率分布函数。由于每个投标人对拍卖商品的估价是与其他竞买者的相独立,所以就算知道竞争对手对该商品的估价,投标者也不会改变自己对竞拍品的评价,从而也不必要去搜集其他信息。但是在大多数竞拍中,投标者的估价极有可能会受到其他竞争对手估价的影响,或者说投标者估价的概率分布函数可能不是完全独立的。比如,当投标者认为有人出的价格会比自己高时,他们就可能将自己的心理价位进行上调。所以,现实中,维克里所指出的第二价格拍卖法下的竞拍策略和优点是否完全存在还值得进一步探讨。

    3.2 第一定价与第二定价之间的联系

    其实广义第一价格没有那么坏,对于大部分广告平台来说,至少收入在一定程度来说是最大的。那么如何更加吸引更多的广告主的投放?并且降低广告主投放的成本,减少优化的成本呢?谷歌在2002年,将广义第二价格的方式引入搜索引擎,基本原理就是按照下一位的出价,来实际扣费,为了鼓励广告主提高素材,广告点击率。实际计费的公式变成了

    收费 = 下一位价格*(下一位质量分/本位质量分)+0.01
    在这里插入图片描述

    4. VCG机制(Vickrey-Clarke-Groves)

    还有一种计费方法叫做VCG,名字来源于三个牛人的名字,其中最有名的 Vickrey是一个出生在加拿大的经济学家,1996年获得诺贝尔经济学奖,他在竞拍理论上有突出的贡献,他提出了第二价格的竞拍方法,广泛用于各种经济活动。VCG是一种比第二价格还要晦涩的一种方法,它的基本原理是计算竞价者赢得广告位后,给整个竞价收入带来的收益损失,理论上这种损失就是竞价获胜者应该支付的费用。

    在这里插入图片描述

    展开全文
  • DPOS机制

    万次阅读 2018-02-15 13:45:26
    前言共识机制是分布式应用软件特有的算法机制。在中心化的软件里,再复杂的问题都可以避开使用复杂的算法逻辑(当然,如果能用算法统领,代码会更加简洁、高效),在开发设计上可以省却一定的麻烦。但在分布式软件...
  • 最优机制 前文已经介绍到了,如果直接机制(P,M)是激励兼容的,则对所有的竞买人及真实估价vi,其预期支付只与分配...之前关于定价的讨论是:如果售卖者能够知道竞买者的真实估价的话,那直接就可以按照最高估价售卖即
  • 经济|通证经济学:机制设计、激励相容与VCG机制 通证经济学的主要研究方向大致分为三个: 以比特币为代表的区块链1.0时代的私营货币(Private Money)话题; 由博弈论引出的,用于研究通证经济体系中各方博弈...
  • 拍卖机制-源码

    2021-02-15 17:26:46
    拍卖机制 基于P2P网络的拍卖机制。 每个对等方都可以使用二次价格拍卖(EBay)买卖商品。 每个投标人下标。 最高出价者获得第一个广告位,但由第二高出价...AuctionMechanism:定义主要方法的界面 AuctionMechanismImp
  • 软件定义存储的定义与分类

    千次阅读 2017-02-16 09:20:04
    理想的SDS实现了存储基础架构的自动化机制,极大地降低了人工管理运维成本,数据请求需直接传达至自动化软件。它能够直接应对请求,分配应用人员所需的存储资源,而无需人工干预。存储管理员可以从枯燥重复的建卷、...
  • 前文介绍的拍卖是物品出售的众多方法之一,还有很多种定价方法,对于物品售卖方来说,需要确定的是以什么样的形式出售物品,使得利润最大化,这就是机制设计的问题。 机制定义 显示原理 激励兼容 收益等价 ...
  • 为未来企业而定义

    千次阅读 2014-03-04 13:14:58
    为未来企业而定义一、未来企业到底应该是什么样?我把企业简单粗暴分为:农业、制造业、零售与服务业。而世界也是经历了:农业从牛犁耕种到现代大农业、制造业从手工作坊到现代大工业制造、零售业从小卖店到商超MALL...
  • 运营有道:重新定义互联网运营

    千次阅读 2018-11-06 11:54:40
    内容简介 本书将帮助读者自上而下,体系化梳理互联网运营。从运营概念的重新定性,运营在...在逻辑上,本书分为两个层面:从道的层面解读和重新定义运营方法论;从术的层面围绕方法论提出行之有效的方法和解决案例。...
  • 2006.9.1 17:52 据中国政府官员称,中国计划启动原油、氧化铝、铜精矿等商品的联合对外谈判机制。在中国看来,它在谈判桌上的能力无法与其对原材料的强大需求相匹配。不过,中国有关企业联合谈判的坚决表态还...
  • QoE的定义及影响因素

    万次阅读 2013-10-07 22:10:11
    QoE标准的定义,摘自论文《用户体验质量(QoE)的模型与评价方法综述》(林闯,胡杰,孔祥震) 现有的文献给出了许多关于QoE定义和...QoE最初被理解为用户对提供给OSI模型不同层次的QoS机制整体感知的度量.例如在文献
  • JAVA动态代理详解

    2015-03-26 09:41:13
    这几天做项目的时候碰到了JAVA动态代理机制,之前只是知道这种机制,后来通过翻书,查资料对动态代理机制有了更进一步的了解。 第一次写博客,写得不好之处请见谅,废话不多说,我们首先来看一下什么是代理。 说到...
  • 003:模板加载和数据库定义

    万次阅读 2019-01-03 22:51:55
    price = models.FloatField(verbose_name = “商品价格”) shops = models.CharField(verbose_name = “商铺”) picture = models.ImageField(verbose_name = “商品图片”) def __str__(self): return self....
  • 边缘计算 — 起源与定义

    千次阅读 热门讨论 2020-11-04 00:15:05
    文章目录目录定义边缘场景的发展推动边缘计算发展的四个关键因素 定义 根据行业或用例的不同,边缘计算一词已经被用来描述从微型物联网设备执行的操作到类似数据中心等基础设施的一切内容。用于表示边缘计算的术语...
  • 我国辅助服务补偿机制与市场化——从配合计划机制到现货市场 回顾我国辅助服务补偿机制建设工作,现行全国性辅助服务补偿机制酝酿于2004年,《并网发电厂辅助服务管理暂行办法》出台于2006年,各区域实施细则印发于...
  • 【学习笔记】市场机制设计

    万次阅读 2020-10-10 13:22:59
    拍卖机制
  • 比特币的激励机制与理性个体

    万次阅读 2019-05-18 08:20:55
    剖析工作量证明比特币,概率与随机性密码学如何重新定义私有产权? 比特币主要由三个部分组成。其中,工作量证明和公钥密码学这两个部分均基于数学层面,第三个部分则是人类行为。说白了,比特币要想持续运行下去...
  • 区块链信用机制与应用场景介绍

    千次阅读 2018-07-30 11:41:08
    本文向大家介绍了区块链以及区块链信用机制,最后简要列举了区块链的商业应用。本文选自《区块链供应链金融》。 区块链简介 将有意义的事件记录下来,是形成人类文明的重要内容之一。《史记》生动地记录和展开了...
  • 无线局域网定义及原理

    千次阅读 2019-11-29 10:27:06
    有固定基站的WLAN类似于移动通信的机制,安装无线网卡的计算机通过基站(无线AP或者无线路由器)接入网络,这种网络的应用比较广泛,通常用于有线局域网覆盖范围的延伸或者作为宽带无线互联网的接入方式。...
  • 百度大牛讲机制设计和计算广告学

    千次阅读 2017-09-12 23:27:30
    声明:本系列是一般性介绍,多处引用了田国强老师的《经济机制设计和信息经济学》原文,恕不一一标识,特此声明。 【一般介绍“机制设计”的lecture往往以“所罗门的智慧”这个例子开始;或者从机制设计的要素开始...
  • ip_conntrack的extend机制以及扩展

    千次阅读 2014-04-06 22:22:10
    ip_conntrack为无状态无连接的IP增加了一个流记录机制,你可以把任何和一个流相关的东西放进去,但是放在哪里呢?原则上ip_conntrack应该是一个可以无限扩展的东西,但事实上,内核的设计者或者说Netfilter的ip_...
  • Solr学习笔记之在schema.xml中定义字段

    千次阅读 2015-01-30 23:22:11
    通过本文,你将学习到: solr中字段的概念 字段的必要属性 多值的字段 动态字段 复制字段

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 52,783
精华内容 21,113
关键字:

动态价格机制定义