精华内容
下载资源
问答
  • 原来以为int(11)是指11字节,int(10)就是10字节。我错了。http://zhidao.baidu.com/link?url=puYWaGBQNKNHgffO5kdvXshF3KmX8OuB4Mor3HXapbNHa8m1CdlF8PJTqVuKa1eKcEd6Bv2NKUr3I-KJr5-7ISLhBsmf17L...

    原先对mysql不太理解,但也没有报错。但理解的不够深入。这次补上。

    原来以为int(11)是指11个字节,int(10)就是10个字节。我错了。

    http://zhidao.baidu.com/link?url=puYWaGBQNKNHgffO5kdvXshF3KmX8OuB4Mor3HXapbNHa8m1CdlF8PJTqVuKa1eKcEd6Bv2NKUr3I-KJr5-7ISLhBsmf17Lu69vxv2aR99_

    mysql的基本数据类型里几个int如下:

    类型 大小 范围(有符号) 范围(无符号) 用途

    TINYINT 1字节 (-128,127) (0,255) 小整数值

    SMALLINT 2 字节 ( -2^15 :-32 768,2^15 - 1:32 767) (0,65 535) 大整数值

    MEDIUMINT 3 字节 (-8 388 608,8 388 607) (0,16 777 215) 大整数值

    INT或INTEGER(int 的 SQL-92 同义字为 integer) 4 字节 (-2^31:-2 147 483 648, 2^31 - 1:2 147 483 647) (0,4 294 967 295) 大整数值

    BIGINT 8 字节 (-2^63:-9 233 372 036 854 775 808,2^63-1:9 223 372 036 854 775 807) (0,18 446 744 073 709 551 615) 极大整数值

    这些类型,是定长的,其容量是不会随着后面的数字而变化的,比如int(11)和int(8),都是一样的占4字节。tinyint(1)和tinyint(10)也都占用一个字节。

    那么后面的11和8,有啥用呢。

    http://zhidao.baidu.com/link?url=b0Z-WIhggaErl3uhMrAhoEXQG_3zotyd7r31O3RXSYiFJo1Cad-NeWN8cFXZFI50yVG_lpKooT7OjLhIa20ephKFJYD-fV9ZAv_o63AfyVq

    mysql数据库中以 :数据类型(m)  来约束数据,其中 数字m在不同的数据类型中表示含义是不同的。 咱们这里只讲整数。

    整型数系统已经限制了取值范围,tinyint占1个字节、int占4个字节。所以整型数后面的m不是表示的数据长度,而是表示数据在显示时显示的最小长度。

    tinyint(1) 这里的1表示的是 最短显示一个字符。tinyint(2) 这里的2表示的是 最短显示两个字符。

    当字符长度超过(m)时,相当于啥都没发生;

    当字符长度小于(m)时,就需要指定拿某个字符来填充,比如zerofill(表示用0填充),

    设置tinyint(2) zerofill 你插入1时他会显示01;设置tinyint(4) zerofill 你插入1时他会显示0001。

    所以,没有zerofill,(m)就是无用的。

    http://blog.csdn.net/phpwish/article/details/7845921

    综上整型的数据类型括号内的数字不管是多少,所占的存储空间都固定的。

    http://www.cnblogs.com/xiaochaohuashengmi/archive/2011/08/25/2153016.html

    mysql 中int(1)和tinyint(1)中的1只是指定显示长度,并不表示存储长度,只有字段指定zerofill时有用。

    位数限制基本没有意义。

    在mysql中我做过实验,对于一个tinyint类型的字段,不管它是tinyint(1)还是tinyint(2)还是tinyint(3),

    当你插入大于127的数,都会存入127。跟上文中的结论是一样的。

    总结:int(11),tinyint(1),bigint(20),后面的数字,不代表占用空间容量。而代表最小显示位数。这个东西基本没有意义,除非你对字段指定zerofill。

    所以我们在设计mysql数据库时,

    建表时,mysql会自动分配长度:int(11)、tinyint(4)、smallint(6)、mediumint(9)、bigint(20)。

    所以,就用这些默认的显示长度就可以了。不用再去自己填长度,比如搞个int(10)、tinyint(1)之类的,基本没用。而且导致表的字段类型多样化。

    http://blog.csdn.net/longyulu/article/details/7326581

    该文很好地总结了mysql所有的数据类型。

    我在建一个float类型的字段时,故意建成float(2,3)型,是错误的。报错如下。

    6e0e446570fcb13687087cbb64177a54.png

    第一个数字M,代表总长度限制(总长度包括小数位和整数位),2代表总长度不能超过2个字符,比如2.34,就超过了2位总长度;

    第二个数字D,代表小数位的长度限制。0.2表示占用了1个小数位。

    这样看,当然M必需大于等于D。

    比如设置为float(2,2),那么写入12.3这个数字时,实际插入的是0.99。

    比如设置为float(2,1),那么写入12.3这个数字时,实际插入的是9.9。

    mysql会自动截取该字段能接受的最大值存入。

    那么设置为float(0,0),则相当于不受限制,或者说受float本身的精度限制。

    对于mysql的浮点型,实在太复杂,没搞清,看这篇:http://www.jb51.net/article/31723.htm

    再来看看mysql的整型、浮点型,怎么跟oracle的数据类型NUMBER对应的。

    先来看看oracle的NUMBER类型的特点:

    参考http://www.linuxidc.com/Linux/2012-02/54603.htm

    Number(p, s) 声明一个定点数 p(precision)为精度,s(scale)表示小数点右边的数字个数,精度最大值为38,scale的取值范围为-84到127

    Number(p) 声明一个整数 相当于Number(p, 0)

    Number 声明一个浮点数 其精度为38,要注意的是scale的值没有应用,也就是说scale的值不能简单的理解为0,或者其他的数。

    定点数的精度(p)和刻度(s)遵循以下规则:

     当一个数的整数部分的长度 > p-s 时,Oracle就会报错。(可见s个位置是留给小数的;p-s个位置是留给整数部分的,这样很清晰啊。p代表整数位和小数位全部的长度限制,这一点跟mysql很像)

     当一个数的小数部分的长度 > s 时,Oracle就会舍入。(同上,实际上不会报错,oracle会四舍五入,比如NUMBER(4,2),插入99.248,保存为99.25;插入99.242,保存为99.24;插入99.2448,保存为99.24而不是99.25,注意他四舍五入的位置是s位。)

     当s(scale)为负数时,Oracle就对小数点左边的s个数字进行舍入。(暂时不管它)

     当s > p 时, p表示小数点后第s位向左最多可以有多少位数字,如果大于p则Oracle报错,小数点后s位向右的数字被舍入。(暂时不管它)

    经实验,比如定义一个字段为Number(3),那么写入该字段,最多不能超过3个数字。比如,你可以插入999(或-999),但是不能插入1000(或-1000)。以此类推。

    比如定义一个字段为Number(3,2),那么写入该字段,最多不能超过3位的整数,最多2位的小数。

    综上,我们可以看出mysql和oracle的对应关系:

    mysql

    oracle

    理由

    tinyint(1字节)

    以及tinyint unsigned

    NUMBER(3)

    范围(-128,127) (0,255),所以至少NUMBER(3)对应。

    但是不能NUBER(1),这样只能最大存9。

    smallint(2字节)

    以及smallint unsigned

    NUMBER(5)

    范围(-32 768,32 767) (0,65 535) ,所以至少NUMBER(5)对应。

    MEDIUMINT(3字节)

    以及

    MEDIUMINT unsigned

    NUMBER(7)

    以及

    NUMBER(8)

    范围(-8 388 608,8 388 607) (0,16 777 215),所以

    非unsigned用NUMBER(7)对应;

    unsigned用NUMBER(8)对应。

    int(4字节)

    以及

    int unsigned

    NUMBER(10)

    范围(-2 147 483 648, 2 147 483 647) (0,4 294 967 295),

    所以至少NUMBER(10)对应。

    bigint(5字节)

    以及bigint unsigned

    NUMBER(19)

    以及

    NUMBER(20)

    范围(-9 233 372 036 854 775 808,9 223 372 036 854 775 807)

    (0,18 446 744 073 709 551 615),

    所以非unsigned用NUMBER(19)对应;

    unsigned用NUMBER(20)对应。

    float(m,d)

    以及

    unsigned

    NUMBER(m,d)

    因为NUMBER(m,d)是定点数,精度超过浮点数。

    所以只需保持位数一致即可,精度也会更强。

    double(m,d)

    以及

    unsigned

    NUMBER(m,d)

    同上。

    decimal(m,d)

    以及

    unsigned

    NUMBER(m,d)

    Decimal(n,m)表示数值中共有n位数,其中整数n-m位,小数m位。

    例:decimal(10,6),数值中共有10位数,其中整数占4位,小数占6位。

    p (有效位数)必需是1~38之间的数。

    ORACLE中有SMALLINT,INT,INTEGER类型,不过这是NUMBER(38,0)的同义词。

    展开全文
  • 评注:匹配中文还真是头疼的事,有了这表达式就好办了 匹配双字节字符(包括汉字在内):[^\x00-\xff] 评注:可以用来计算字符串的长度(一双字节字符长度计2,ASCII字符计1) 匹配空白行的正则表达式:\n\s*\...

    匹配中文字符的正则表达式: [\u4e00-\u9fa5]

    评注:匹配中文还真是个头疼的事,有了这个表达式就好办了

    匹配双字节字符(包括汉字在内):[^\x00-\xff]
    评注:可以用来计算字符串的长度(一个双字节字符长度计2,ASCII字符计1)

    匹配空白行的正则表达式:\n\s*\r
    评注:可以用来删除空白行

    匹配HTML标记的正则表达式:<(\s*?)[^>]*>.*?|<.*?>
    评注:网上流传的版本太糟糕,上面这个也仅仅能匹配部分,对于复杂的嵌套标记依旧无能为力

    匹配首尾空白字符的正则表达式:^\s*|\s*$
    评注:可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等),非常有用的表达式

    匹配Email地址的正则表达式:\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
    评注:表单验证时很实用

    匹配网址URL的正则表达式:[a-zA-z]+://[^\s]*
    评注:网上流传的版本功能很有限,上面这个基本可以满足需求

    匹配帐号是否合法(字母开头,允许5-16字节,允许字母数字下划线):^[a-zA-Z][a-zA-Z0-9_]{4,15}$
    评注:表单验证时很实用

    匹配国内电话号码:\d{3}-\d{8}|\d{4}-\d{7}
    评注:匹配形式如 0511-4405222 或 021-87888822

    匹配腾讯QQ号:[1-9][0-9]{4,}
    评注:腾讯QQ号从10000开始

    匹配中国邮政编码:[1-9]\d{5}(?!\d)
    评注:中国邮政编码为6位数字

    匹配身份证:/^[1-9][0-9]{5}([1][9][0-9]{2}|[2][0][0|1][0-9])([0][1-9]|[1][0|1|2])([0][1-9]|[1|2][0-9]|[3][0|1])[0-9]{3}([0-9]|[X])$/;
    评注:中国的身份证为15位或18位

    匹配ip地址:\d+\.\d+\.\d+\.\d+
    评注:提取ip地址时有用

    匹配手机号:/^1(3[0-9]|4[5,7]|5[0,1,2,3,5,6,7,8,9]|6[2,5,6,7]|7[0,1,7,8]|8[0-9]|9[1,8,9])\d{8}$/

    评注:2019年

    匹配特定数字
    ^[1-9]\d*$    //匹配正整数
    ^-[1-9]\d*$   //匹配负整数
    ^-?[1-9]\d*$   //匹配整数
    ^[1-9]\d*|0$  //匹配非负整数(正整数 + 0)
    ^-[1-9]\d*|0$   //匹配非正整数(负整数 + 0)
    ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$   //匹配正浮点数
    ^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$  //匹配负浮点数
    ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$  //匹配浮点数
    ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$   //匹配非负浮点数(正浮点数 + 0)
    ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$  //匹配非正浮点数(负浮点数 + 0)
    评注:处理大量数据时有用,具体应用时注意修正

    匹配特定字符串
    ^[A-Za-z]+$  //匹配由26个英文字母组成的字符串
    ^[A-Z]+$  //匹配由26个英文字母的大写组成的字符串
    ^[a-z]+$  //匹配由26个英文字母的小写组成的字符串
    ^[A-Za-z0-9]+$  //匹配由数字和26个英文字母组成的字符串

    ^\w+$  //匹配由数字、26个英文字母或者下划线组成的字符串

    str为要去除空格的字符串:
    去除所有空格:
    str = str.replace(/\s+/g, "");
    去除两头空格:
    str = str.replace(/^\s+|\s+$/g, "");
    去除左空格:
    str = str.replace(/^\s*/, '');
    去除右空格:
    str = str.replace(/(\s*$)/g, "");

    var codeCheck = /^[^_IOZSVa-z\W]{2}\d{6}[^_IOZSVa-z\W]{10}$/;//统一社会信用代码

    Google浏览器下 默认字体,一个字宽16px,大写字母10px,小写字母8px(l,i,f,j)除外,数字8px

    展开全文
  • Java poi Excel xls数字转字母

    千次阅读 2016-12-02 16:24:42
    最近遇到导出的xls中 列是动态生成的,且单元格中需要用到公式,而xls公式不是用数字列号而是用列字母来表示的,这时需要把数字的列号转成该列对应的字母。因为是按月导出 一月最多31天,所以刚开始采用的办法是...

    最近遇到导出的xls中 列是动态生成的,且单元格中需要用到公式,而xls公式不是用数字列号而是用列字母来表示的,这时需要把数字的列号转成该列对应的字母。因为是按月导出 一个月最多31天,所以刚开始采用的办法是定义一个包含1到31列字母的数组。后来想想这样总不是个办法 万一列数更多 且是不确定的呢。于是研究了下 怎么把xls数字列号转成对应的字母。

    先来看xlsx中的字母规律。在xls中,1到26列是A~Z,从第27列开始 是2个以上的字母组合 AA AB ... AZ 然后到BA BB ... BZ 直到 ZA ZB ... ZZ 这时两个字母的组合完了 接下来到3个字母 AAA AAB ... AAZ 然后到ABA ABB ... ABZ 一直到AZZ 然后是BAA BAB ... BZZ最后到ZAA ... ZZZ,接下来又是4个字母的组合如此循环...  。

    于是发现了规律: AA~AZ是在A~Z前面加了A,BA~BZ是在A~Z前面加了B,... ZA~ZZ是在A~Z前面加了Z,这时两个字母组合完毕;到3个字母 AAA~AAZ是在AA~AZ前面加了A,ABA~ABZ是在BA~BZ前面加了A,... AZA~AZZ是在ZA~ZZ前面加了A,这时AA~ZZ遍历完了一次(这里的AA~ZZ是前面两个字母组合里出现过的);接下来到下一轮遍历 在前面加B,BAA~BAZ是在AA~AZ前面加了B,... BZA~BZZ是在ZA~ZZ前面加了B,这时AA~ZZ又遍历完了一次;再进行下一轮遍历 一直到在所有两个字母的组合前都加过A~Z,这时3个字母的组合就全部组合完毕了。接下来到4个字母的组合 跟前面的2个、3个字母的组合类似,都是在上一个组合的基础上分别在前面加上A~Z。如下图


    字母组合是从第27列开始,每次的组合都是在上一个组合的基础上分别在前面加上A~Z。比如计算n=3个字母的组合AAA~ZZZ(上图红色竖线箭头部分):2个字母组合所在的范围是AA~ZZ(上图红色的“currentLen”部分),当前数组的位置(比如AAB)i与currentLen进行取余运算(i%currentLen)得到的结果就是要与2个字母组合的哪个种组合进行字符串拼接(该值还要与“lastLen”(上图红色lastLen)相加才能定位到该位置对应的字母),比如当前是第一轮遍历 则是A与AB进行拼接成AAB,这也就是上面举例的当前数组位置对应的字母(AAB)。假设我们用变量letterIdx表示第几轮,每上个组合遍历完一次letterIdx都要+1,表示下一个要拼接在前面的字母。因为拼接在前面的字母是A~Z 所以每次取该轮字母时都要跟26取余(letterIdx%26),当letterIdx%26=0时 说明A~Z都与上个组合拼接过了 也就是当前n个字母组合所有情况都组合过了,再进行下一轮n+1个(4个)字母的组合(上图黑色竖线箭头部分),这时currentLen变成了上一个组合的长度(上图黑色的currentLen),而lastLen变成了“上个组合的currentLen+lastLen”(上图黑色的lastLen部分),接下来的循环遍历跟上个组合一样进行。

    上代码:(代码里的注释请结合上文来看,注释里说到的“组合的情形”是指该组合的某一种组合,如BK、AH、XI都是2个字母组合的一种情形。因为实在也不知道应该用哪个词来表达)

    public final class Columns {
    
    	private Columns() {}
    
    	private static String[] sources = new String[]{
    		"A","B","C","D","E","F","G","H",
    		"I","J","K","L","M","N","O","P",
    		"Q","R","S","T","U","V","W","X","Y","Z"
    	};
    
    	/**
    	 * (256 for *.xls, 16384 for *.xlsx)
    	 * @param columnNum 列的个数,至少要为1
    	 * @throws IllegalArgumentException 如果 columnNum 超出该范围 [1,16384]
    	 * @return 返回[1,columnNum]共columnNum个对应xls列字母的数组
    	 */
    	public static String[] getColumnLabels(int columnNum) {
    		if(columnNum<1||columnNum>16384)
    			throw new IllegalArgumentException();
    		String[] columns = new String[columnNum];
    		if(columnNum<27){	//小于27列 不用组合
    			System.arraycopy(sources, 0, columns, 0, columnNum);
    			return columns;
    		}		
    		System.arraycopy(sources, 0, columns, 0, 26);	//前26列不需要进行组合
    
    		//因为基于数组是从0开始,每到新一轮letterIdx 会递增,所以第一轮 在递增前是-1
    		int letterIdx = -1;
    		int currentLen = 26;//第一轮组合(2个字母的组合)是分别与A-Z进行拼接 所以是26
    		int remainder;
    		int lastLen = 0;	//用于定位上文提到的i%currentLen实际在数组中的位置		
    		int totalLen = 26;	//totalLen=currentLen+lastLen
    		int currentLoopIdx = 0; //用来记录当前组合所有情形的个数
    
    		for(int i=26;i<columnNum;i++){ //第27列(对应数组的第26个位置)开始组合
    
    	//currentLen是上个组合所有情形的个数,与它取余找到要与上个组合的哪种情形进行拼接
    			remainder = currentLoopIdx%currentLen;
    
    			if(remainder==0){
    				letterIdx++; //完成一次上个组合的遍历,转到下个字母进行拼接
    				int j = letterIdx%26;
    
    			//A-Z 26个子母都与上个组合所有情形都进行过拼接了,需要进行下个组合的拼接
    				if(j==0&&letterIdx!=0){ 
    					lastLen = totalLen; //下个组合的lastLen是上个组合的totalLen
    
    				/**
    	 		     * 下个组合的currentLen是上个组合的所有组合情形的个数
    	 		     * (等于上个组合的currentLen*26),26也就是拼接在前面的A-Z的个数
    	 		     */			 
    					currentLen = 26*currentLen;
    
    					totalLen = currentLen+lastLen; //为下一轮的开始做准备
    					currentLoopIdx = 0; //到下一轮了 因此需要重置
    				}
    			}
    			/**
    	 	     * sources[letterIdx%26]是该轮要拼接在前面的字母
    	 	     * columns[remainder+lastLen]是上个组合被拼接的情形
    	 	     */		
    			columns[i] = sources[letterIdx%26]+columns[remainder+lastLen];
    			currentLoopIdx++;
    		}
    		return columns;
    	}
    }
    测试:
    public static void main(String[] args) {
    	String[] columns = getColumnLabels(37 );
    	System.out.println("1到37列:"+Arrays.toString(columns));
    	System.out.println();
    	long start = System.nanoTime();
    	columns = getColumnLabels(256);
    	System.out.println("创建"+columns.length+"列用时(纳秒):"
    					   +(System.nanoTime()-start));
    	System.out.println("xls第"+columns.length+"列:"
    					   +columns[columns.length-1]);
    	System.out.println();
    	start = System.nanoTime();
    	columns = getColumnLabels(16384);
    	System.out.println("创建"+columns.length+"列用时(纳秒):"
    					   +(System.nanoTime()-start));
    	System.out.println("xlsx第"+columns.length+"列:"
    					   +columns[columns.length-1]);
    }

    打印:
    1到37列:[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, 
    U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK]
    
    创建256列用时(纳秒):192833
    xls第256列:IV
    
    创建16384列用时(纳秒):9574147
    xlsx第16384列:XFD

    ------------------------------------------------------分隔线-----------------------------------------------------------------

    后来有想到,如果是不需要(或者条件不允许)提前创建(这么大的)数组呢,这时需要通过列号直接获取该列对应的字母。于是又想 应该怎么转换。。。
    先看看从字母转数字的,比如BGQCV 转成数字(虽然xlsx最后一列是XFD,这里只讨论数字与字母的互转):该列标有5个字母,说明前面已经有4个字母、3、2、1个字母的全组合了 才会到5个字母的组合,于是W1=26^4+26^3+26^2+26^1,BGQCV 的第一个字母是B,说明前面有Axxxx的全组合了,于是有该组合数T1=1*(26^4)。再来看第二个字母是G,说明前面已经有BAxxx~BFxxx的全组合了,于是有该组合数T2=6*(26^3)。第三个字母是Q,说明前面已经有BGAxx~BGPxx的全组合了,于是有该组合数T3=16*(26^2)。第四个字母是C,说明前面已有BGQAx~BGQBx的全组合了,该组合数T4=2*(26^1)。最后一个字母是V,说明前缀是BGQC的组合BGQCA~BGQCV共有T5=22个。
    好了,BGQCV 所处的列数W=W1+T1+T2+T3+T4+T5=(26^4+26^3+26^2+26^1)+1*(26^4)+6*(26^3)+16*(26^2)+2*(26^1)+22 = 1048576。
    String[] sources = new String[]{"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
    数组sources作为我们解决问题的字母来源(当然也可以不定义数组而是用ASCII码)。
    现在知道了通过字母列标是如何求出其对应的第几列,我们把问题一般化:求第W列对应的列标。设第W列对应的字母有n个,根据上面的分析可知W1=26^(n-1)+26^(n-2)+26^(n-3)+...+26^2+26^1。我们规定A对应1,B对应2 ... Z对应26。设第1个字母对应数字是num_1,第二个字母对应的数字是num_2,...,第n个字母对应数字num_n。根据上面的分析 于是有T1=(num_1-1)*26^(n-1),T2=(num_2-1)*26^(n-2),...,Tn=(num_n-1)*26^0。
    整合起来,又因为26^0=1 于是有W=W1+T1+T2+...+Tn=(26^(n-1)+26^(n-2)+26^(n-3)+...+26^2+26^1)+(num_1-1)*26^(n-1)+(num_2-1)*26^(n-2)+...+(num_(n-1)-1)*26^1+(num_n-1)。
    除了最右边的字母(也就是第n个字母)对应的位置的数字num_n-1除外,其它字母对应的位置的数字均是26的倍数。于是  第一次W对26取余W%26的结果所对应的字母(还记得吗 我们用1代表A,2代表B,... ,26代表Z)就是最右边的字母。好了 现在已经求出了最右边的字母,还剩n-1个未知字母,采用同样的办法可求出次右边的字母:W-(num_n-1)然后再除以26,得到的结果再减去1(因为W1中存在26^1,其除以26后结果就是1,为了保证除了次右边字母对应的位置的数字外,其余各字母对应的位置的数字均是26的倍数),把结果赋回给W,这时求次右边的字母就跟求最右边的字母类似了:
    W-(num_n-1)=(26^(n-1)+26^(n-2)+26^(n-3)+...+26^2+26^1)+(num_1-1)*26^(n-1)+(num_2-1)*26^(n-2)+...+(num_(n-1)-1)*26^1
    然后两边除以26:(W-(num_n-1))/26=(26^(n-2)+26^(n-3)+26^(n-4)+...+26^1+1)+(num_1-1)*26^(n-2)+(num_2-1)*26^(n-3)+...+(num_(n-1)-1)
    然后两边再减去1:(W-(num_n-1))/26-1=(26^(n-2)+26^(n-3)+26^(n-4)+...+26^1)+(num_1-1)*26^(n-2)+(num_2-1)*26^(n-3)+...+(num_(n-1)-1)
    然后把左边的(W-(num_n-1))/26-1看成整体的W,是不是跟最开始求最右边字母的很类似?
    这样从右往左求出来的字符串 跟所要的结果恰好是相反的 所要需要反转。
    上代码:
    /**
     * 返回该列号对应的字母
     * @param columnNo (xls的)第几列(从1开始)
     */
    public static String getCorrespondingLabel(int columnNo){
    	if(columnNo<1/**||columnNo>16384**/)
    		throw new IllegalArgumentException();
    	String[] sources = new String[]{"A","B","C","D","E","F","G","H","I","J","K","L","M"
    		,"N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
    	StringBuilder sb = new StringBuilder(5);
    	int remainder = columnNo%26;	//求最右边的字母
    	if(remainder==0){	//说明(num_n-1)=26,第26个字母是Z
    		sb.append("Z");
    		remainder = 26;	//因为接下来W-(num_n-1)也就是columnNo-remainder,所以需要把remainder赋值回26
    	}
    	else{  //如果最右边字母不是Z的话,就去sources数组相应的位置取字母,remainder不用变
    	  sb.append(sources[remainder-1]);
    	}
    	columnNo = (columnNo-remainder)/26-1;	//用来判断接下来是否还有其他字母
    
    	//当 当前循环是求最后一个字母时(从右往左),(columnNo-remainder)/26就会是0,再减1也就是-1。
    	//因此通过判断(columnNo-remainder)/26-1是否大于-1来判断结束
    	while(columnNo>-1){
    		remainder = columnNo%26;
    		sb.append(sources[remainder]);
    		columnNo = (columnNo-remainder)/26-1;
    	}
    
    	return sb.reverse().toString();	//因为是从右往左解析的 所以需要反转
    }


    测试:
    public static void main(String[] args) {
    	String label = getCorrespondingLabel(37 );
    	System.out.println("第37列:"+label);
    	System.out.println();
    	long start = System.nanoTime();
    	label = getCorrespondingLabel(256);
    	System.out.println("查找第256列对应字母 用时(纳秒):"
    					   +(System.nanoTime()-start));
    	System.out.println("xls第256列:"+label);
    	System.out.println();
    	
    	label = getCorrespondingLabel(16384);
    	
    	System.out.println("xlsx第16384列:"+label);
    }
    打印:
    第37列:AK
    
    查找第256列对应字母 用时(纳秒):7776
    xls第256列:IV
    
    xlsx第16384列:XFD
    这时又想到,求n列列标 用方法1好一点呢 还是用方法2循环n次好呢。。。
    方法1求数组的 对于26+26*26=702列以下,可以将求组合部分抽出来,减少不必要的求余运算multiple%26,因为这时multiple不会超过26。方法2也可以改成从0开始的 毕竟poi列数是从0开始的。不预定义字母数组的话 也可以用ASCII码来转换。
    -----------------------------------------------分隔线-----------------------------------------------------

    最终代码:

    /**
     * 
     * Excel列号转字母工具类
     * 
     */
    public final class Columns {
    
    	private Columns() {
    	}
    
    	private static String[] sources = new String[] { "A", "B", "C", "D", "E",
    			"F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R",
    			"S", "T", "U", "V", "W", "X", "Y", "Z" };
    
    	/**
    	 * (256 for *.xls, 16384 for *.xlsx)
    	 * 
    	 * @param columnNum
    	 *            列的个数,从1开始
    	 * @throws IllegalArgumentException
    	 *             如果 columnNum 超出该范围 [1,16384]
    	 * @return 返回[1,columnNum]共columnNum个对应xls列字母的数组
    	 */
    	public static String[] getColumnLabels(int columnNum) {
    		if (columnNum < 1 || columnNum > 16384)
    			throw new IllegalArgumentException();
    		String[] columns = new String[columnNum];
    		if (columnNum < 27) {
    			System.arraycopy(sources, 0, columns, 0, columnNum);
    			return columns;
    		}
    		int multiple = -1;
    		int remainder;
    		System.arraycopy(sources, 0, columns, 0, 26);
    		int currentLoopIdx = 0;
    		if (columnNum < 703) {
    			for (int i = 26; i < columnNum; i++) {
    				remainder = currentLoopIdx % 26;
    				if (remainder == 0) {
    					multiple++;
    				}
    				columns[i] = sources[multiple] + columns[remainder];
    				currentLoopIdx++;
    			}
    		} else {
    			int currentLen = 26;
    			int totalLen = 26;
    			int lastLen = 0;
    			for (int i = 26; i < columnNum; i++) {
    				remainder = currentLoopIdx % currentLen;
    				if (remainder == 0) {
    					multiple++;
    					int j = multiple % 26;
    					if (j == 0 && multiple != 0) {
    						lastLen = totalLen;
    						currentLen = 26 * currentLen;
    						totalLen = currentLen + lastLen;
    						currentLoopIdx = 0;
    					}
    				}
    				columns[i] = sources[multiple % 26]
    						+ columns[remainder + lastLen];
    				currentLoopIdx++;
    			}
    		}
    
    		return columns;
    	}
    
    	/**
    	 * 返回该列号对应的字母
    	 * 
    	 * @param columnNo
    	 *            (xls的)第几列(从1开始)
    	 */
    	private static String getCorrespondingLabel(int columnNo) {
    		if (columnNo < 1/** ||columnNo>16384 **/
    		)
    			throw new IllegalArgumentException();
    
    		StringBuilder sb = new StringBuilder(5);
    		int remainder = columnNo % 26;
    		if (remainder == 0) {
    			sb.append("Z");
    			remainder = 26;
    		} else {
    			sb.append(sources[remainder - 1]);
    		}
    
    		while ((columnNo = (columnNo - remainder) / 26 - 1) > -1) {
    			remainder = columnNo % 26;
    			sb.append(sources[remainder]);
    		}
    
    		return sb.reverse().toString();
    	}
    
    	/**
    	 * 列号转字母
    	 * 
    	 * @param columnIndex
    	 *            poi里xls的列号(从0开始)
    	 * @throws IllegalArgumentException
    	 *             if columnIndex less than 0
    	 * @return 该列对应的字母
    	 */
    	public static String getIndexLabel(int columnIndex) {
    		return getCorrespondingLabel(columnIndex + 1);
    	}
    
    }
    展开全文
  • 这也算个思考吧,通过redis-trib.rb可创建redis集群,然后通过--replicas后面接的数字,表示1个主节点对应几个从节点,那么我就做了如下的测试,想达到的效果就是有6个节点,然后2个master节点,每个master节点...

    描述

      这也算个思考吧,通过redis-trib.rb可创建redis集群,然后通过--replicas后面接的数字,表示1个主节点对应几个从节点,那么我就做了如下的测试,想要达到的效果就是有6个节点,然后2个master节点,每个master节点对应2个slave节点,不就正好是6个节点了吗,但是在执行的时候报错:

    [aiprd@hadoop2 src]$ ./redis-trib.rb create --replicas 2 192.168.30.10:7000 192.168.30.11:7003 192.168.30.10:7002 192.168.30.10:7001 192.168.30.11:7004 192.168.30.11:7005
    >>> Creating cluster
    *** ERROR: Invalid configuration for cluster creation.
    *** Redis Cluster requires at least 3 master nodes.
    *** This is not possible with 6 nodes and 2 replicas per node.  #解释了,对于6个节点,不可能是3个master,每个有2个副本节点。因为,那样的结构需要9个节点。
    *** At least 9 nodes are required.                              #至少需要9个节点。

     以上信息的意思是:Redis集群至少需要3个master节点,所以现在总共有6个节点,就只能是1master对应1slave这种方式。

    所以:

      1master-1slave,redis集群需要6个节点

      1master-2slave,redis集群需要9个节点,以此类推。

     

    文档创建时间:2019年8月2日12:40:04

    转载于:https://www.cnblogs.com/chuanzhang053/p/11287936.html

    展开全文
  •   在日常的编程中,经常会遇到求一组数据中是否有相同数字的情况,这问题其实还是相对比较棘手的,我将用一道很经典的题来探讨这问题。 5位运动员参加了10米台跳水比赛,有人让他们预测比赛结果 A选手说...
  • LetCode力扣的数据库练习题。 题目描述: 题解: select distinct l1.Num as ConsecutiveNums from Logs l1, Logs l2, Logs l3 where l1.Id = l2.Id-1 and l2.Id = l3.Id-1 and l1.Num=l2.Num ......
  • 几个数字正则表达式

    千次阅读 2016-08-08 10:42:30
    只能输入1个数字   表达式 ^\d$  描述 匹配一个数字  匹配的例子 0,1,2,3  不匹配的例子  只能输入n个数字   表达式 ^\d{n}$ 例如^\d{8}...描述 匹配8个数字  ...只能输入至少n个数字   表
  • ^((?=\S*?[A-Z])(?=\S*?[a-z])(?=\S*?[0-9]).{6,})\S$ 转载于:https://www.cnblogs.com/shark1100913/p/10081448.html
  • 全渠道零售中台与数字化转型(1)-中台的前世今身

    千次阅读 多人点赞 2019-06-25 15:37:59
    本系列博客的目标是计划使用近半年时间创造: ... 全渠道零售中台与数字化转型(2)-中台给企业业务带来什么实际的价值 全渠道零售中台与数字化转型(3)-中台给企业技术带来什么实际的价值? 全渠...
  • 数字化转型是开发数字化技术及支持能力以新建一富有活力的数字化商业模式。数字化转型表明,只有企业对其业务进行系统性、彻底的(或重大和完全的)重新定义——而不仅仅是IT,而是对组织活动、流程、业务模式和...
  • 2020数字逻辑期末知识点总结

    千次阅读 多人点赞 2020-12-19 23:20:34
    数字逻辑期末知识点总结 1.若ABCDE为最小项,则它的逻辑相邻项有5 解析:逻辑相邻项有:A’ BCDE、AB’ CDE、ABC’ DE、ABCD’ E、ABCDE’ 2.目前我们所学的双极型集成电路和单极型集成电路的典型电路分别是TTL门...
  • var reg = /^(?![A-Za-z]+$)(?![A-Z\d]+$)(?![A-Z\W]+$)(?![a-z\d]+$)(?![a-z\W]+$)(?![\d\W]+$)\S{8,}$/ var value='123456' ... console.log('密码应为数字、大小写字母、特殊字符中的至少3种组成') }
  • 在中国,数字货币交易所受到严格的监管政策,曾经风光一时的数字交易所面临要么转型,要么出海去打造一国际化的数字货币交易所的选择,在国外,很多地方同样如此,比如,在美国境内打造数字货币交易所是非常困难的...
  • 把一个数分解成任意几个数的和,把所有的可能性出来 4=1+3 4=2+2 4=1+1+2 4=1+1+1+1 类似于有4个苹果放入n个篮子 通过创建二维数组将数字分别放进去 分别考虑 当都为一的情况 在考虑至少有有两个的情况 public ...
  • 怎么样生成两0~100的整数,并且两数的和和差也是0~100范围内的
  • 在网上找了好几个,测试之后都有多多少少的问题,自己一个小时终于憋出来的正则表达,纪念我的处女作!!! /** * 校验密码格式 8-16个字符,不包含空格,必须包含数字,字母或字符至少两种 * * @param value * @...
  • 1234组成的数字一共多少?...从题目的问题来说,解答1234组成什么数字的问题用到的方法是排列组合。小学阶段可以通过枚举法解决,初中或高中则用到加法原理和乘法原理。用1234可以组成一位数1、2、3、4...
  • JS正则表达式的语法,而test则是用来检测字符串是否匹配某一正则表达式,如果匹配就会返回true,反之则返回false
  • 作者:杜平本文约12000字,建议阅读25分钟本文带你认识关于数字化的点思考。[ 导读 ]清华大学109周年校庆之际,清华校友总会软件学院分会、大数据系统软件国家工程实验室和清华大学大...
  • 一开始写了正则表达式,如下,发现并没有满足条件,下面这是只能包含字母和数字 +(BOOL)judgePassWordLegal:(NSString *)pass{ BOOL result = false; if ([pass length] >= 8 && [pass length] &...
  • 我的数字IC学习路线

    千次阅读 多人点赞 2020-03-28 20:08:06
    这只是一段历程,经历,学习IC并非一两天,几个月的事。尤其是网上视频资源模糊、各种资源都是英文,但我觉得不应该受到这些限制而退步,甚至任何东西都不应该成为阻挡的借口,且lab也不像互联网那样顺畅,更需要一...
  • C语言判断输入的数字位数

    千次阅读 2019-11-29 21:45:52
    #include <stdio.h> int main() { long long n; int count=0; printf("请输入一整数:"); scanf("%lld",&n); while(a!=0) { n/=10; count++; } printf("输入的...
  • 浮点数的有效数字位数

    千次阅读 多人点赞 2019-01-28 01:49:54
    过去有一种很普遍的说法是单精度浮点数的有效数字是6到7位。...如果一个数字用10进制表示时有效数字位数大于等于7位,那么用单精度浮点数记录的话,能确保至少正确记录前7位。 为什么说“至少”?比如,...
  • 如果一函数满足图像像素间距离度量的定义,则该函数就是一距离函数或距离度量,常见的距离有欧式距离、D4距离、D8距离。 通过这些内容的介绍,可以使得大家了解像素间的邻域、邻接、连通关系以及区域和边界的...
  • 数字音频分析和处理系统

    万次阅读 2018-01-04 22:47:15
    设计一基于MATLAB的数字音频分析与处理系统,能够实现对数字音频的测试分析与处理。要求: 1) 输入语音信号源为实际环境采集语音; 2)至少实现1种音效测试分析功能(频率响应,瀑布频谱图,相位响应曲线,抗...
  • UTF-8编码占几个字节?

    万次阅读 2019-01-29 16:18:00
    占2字节的:带有附加符号的拉丁文、希腊文、西里尔字母、亚美尼亚语、...一utf8数字占1字节 一utf8英文字母占1字节 少数是汉字每占用3字节,多数占用4字节。   占用3字节的范围     ...
  • Libra数字货币的全面解读

    千次阅读 2019-08-23 03:40:04
    可能在一六年啊,是在一五年的时候,圈儿里就已经是一。在科技领域比较火热的一领域了,但是大家都没有想到,一七年的时候,跟随比特币的一波。爆炸,然后呢,获得社会这么大的关注,当然说,在中国一八年年初的...
  • [4G&5G专题-3]:RRU 数字预失真DPD详解

    千次阅读 多人点赞 2021-01-05 20:52:02
    数字预失真技术DPD是RU中一非常重要的功能,它在不改变放大器特性的情况下,扩大了射频放大器的线性区间,对于提升功率放大器的的放大效率,起到极其关键的作用。
  • Js 在字符串中提取数字

    万次阅读 2019-03-22 19:21:08
    js提取字符串中的数字方法很多,今天讲种常用的方法。 js提供的方法获取 js字符串转换数字。方法主要有三种 转换函数、强制类型转换、利用js变量弱类型转换。 parseInt方法 var str ="4500元"; var num = ...
  • C语言基础 求输入的数字位数

    万次阅读 2018-10-15 13:45:23
    问题:任意输入一整数,求这是一个几数字? 思路:每次除以10,则去掉一位数,统计一次。经过循环,直到最后一位数,除以10为0,停止循环,停止统计。 代码: (1)使用for循环 #include&amp;amp;lt;stdio...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 282,479
精华内容 112,991
关键字:

列数字至少要几个数字