作者:jason christ
链接:https://www.zhihu.com/question/37760140/answer/74523291
来源:知乎
著作权归作者所有,转载请联系作者获得授权。

想起了1+1=3的那个
代码大概是这个样子…
—————————————-

public static void main(String[] args) throws Exception {
		Class integer = Integer.class.getDeclaredClasses()[0];
		Field field = integer.getDeclaredField("cache");
		field.setAccessible(true);
		Integer[] array =  (Integer[]) field.get(integer);
		array[130] = array[131];
		System.out.printf("%d", 1 + 1);
}

———————————————————————————————-
解解释一下,前面几步是反射就不说了,java里面有一个int常量池,也就是field.get(integer);这句代码所拿到的,它的长度是256,里面存着[-128-127]之间的数字.这个有什么用?看了下面的代码你就会理解了

                Integer a = -128;
		Integer b = -128;
		Integer c = -129;
		Integer d = -129;
		System.out.println(a == b);
//true
		System.out.println(c == d);//false

然后,System.out.printf这个方法并没有做验证,而是如果值在这个范围就直接从池中拿出来.
也就是说,如果我这样写

                for (int i = 0; i < array.length; i++) {
			array[i] = 12450;
		}
		for (int i = -128; i <= 127; i++) {
			System.out.printf("%d\n", i);
		}

输出的将都会是12450.
println就不会用这个问题,因为它用的是String.valueOf(i).


1 关于Integer int
Integer t1 = 111;
Integer t2 = 111;
Integer t3 = new Integer(111);
Integer t4 = Integer.valueOf(111);
Integer s1 = 222;
Integer s2 = 222;
Integer s3 = new Integer(222);
Integer s4 = Integer.valueOf(222);
System.out.println(t1 == t2); //true
System.out.println(t1 == t3); //false
System.out.println(t1 == t4); //true
System.out.println(s1 == s2); //false
System.out.println(s1 == s3); //false
System.out.println(s1 == s4); //false

2 String
String a = "JAVA";
String b = "JAVA";
String c = new String("JAVA");
String d = "JA";
String e = "VA";
String f = "JA"+"VA";
String g = d+e;
String h = c ;
System.out.println(a==b); //true
System.out.println(a==c); //false
System.out.println(a==f); //true
System.out.println(a==g); //false
System.out.println(c==f); //false
System.out.println(c==g); //false
System.out.println(c==h); //true
3.数组,=
int a=0;
int b[]=new int[5];
int c=3;
b[a]=a=c;
System.out.println(b[0] + " " + b[3]); //3 0
4 static
static {
name = "B";
}
static String name = "A";
static {
System.out.println(name); //A
}
输出的name 是什么呢?
5.short
short a = 1;
a = a ++;//会报错吗? 不会
short a = 1;
a = a + 1;//会报错吗? 会
short a = 1;
a += 1;// 会报错吗? 不会

原地址http://user.qzone.qq.com/243404061/2

今天无聊刷诺莫瑞根,发现了一个机器人。。点卡之后发现了这个QQ20160823-0@2x

System.out.println((char)0b01000111+""+(char)0b01101110+""+(char)0b01101111+""+(char)0b01101101+""+(char)0b01100101
				+""+(char)0b01110010+""+(char)0b01100011+""+(char)0b01111001+""+(char)0b00100001);

输出之后:Gnomercy!

无聊的侏儒。。。

简要说明:改hosts,目前可用的hosts我保存了一份,在 hosts

正常步骤:

1.首先百度搜索“谷歌hosts”,找一个可用的hosts,注意更新日期,越新越好,下载到本地。

2. windows找到C:\Windows\System32\drivers\etc\hosts文件,右键属性设置文件权限可读写,用文本编辑器打开下载好的hosts文件,覆盖到系统的hosts文件中。mac和linux(包括安卓)的hosts文件在/etc/hosts,可以使用su root 命令然后vi /etc/hosts 编辑hosts覆盖粘贴,或者使用命令 “

cat 下载的hosts文件路径 >> /etc/hosts

” 把下载的hosts追加到源文件结尾。

3.测试是否生效,如果不生效请刷新dns或者重启。

特别注意:访问谷歌推特等网站请使用https加密协议,谷歌请访问谷歌加拿大 https://www.google.ca 或者 https://www.google.com/?ncr 禁止自动国别跳转。由于dns污染严重,非https协议无法打开。

million 10^ 6
billion 10^ 9
trillion 10^ 12
quadrillion 10^ 15
quintillion 10^ 18
sextillion 10^ 21
septillion 10^ 24
octillion 10^ 27
nonillion 10^ 30
decillion 10^ 33
undecillion 10^ 36
duodecillion 10^ 39
tredecillion 10^ 42
quattuordecillion 10^ 45
quindecillion 10^ 48
sexdecillion 10^ 51
septendecillion 10^ 54
octodecillion 10^ 57
novemdecillion 10^ 60
vigintillion 10^ 63
unvigintillion 10^ 66
duovigintillion 10^ 69
trevigintillion 10^ 72
quattuorvigintillion 10^ 75
quinvigintillion 10^ 78
sexvigintillion 10^ 81
septenvigintillion 10^ 84
octovigintillion 10^ 87
novemvigintillion 10^ 90
trigintillion 10^ 93
untrigintillion 10^ 96
duotrigintillion 10^ 99
tretrigintillion 10^102
quattuortrigintillion 10^105
quintrigintillion 10^108
sextrigintillion 10^111
septtrigintillion 10^114
octotrigintillion 10^117
novemtrigintillion 10^120
quardragintillion 10^123
unquardragintillion 10^126
duoquardragintillion 10^129
trequardragintillion 10^132
quattuorquardragintillion 10^135
quinquardragintillion 10^138
sexquardragintillion 10^141
septquardragintillion 10^144
octoquardragintillion 10^147
novemquardragintillion 10^150
quinquagintillion 10^153
unquinquagintillion 10^156
duoquinquagintillion 10^159
trequinquagintillion 10^162
quattuorquinquagintillion 10^165
quinquinquagintillion 10^168
sexquinquagintillion 10^171
septquinquagintillion 10^174
octoquinquagintillion 10^177
novemquinquagintillion 10^180
sexagintillion 10^183
unsexagintillion 10^186
duosexagintillion 10^189
tresexagintillion 10^192
quattuorsexagintillion 10^195
quinsexagintillion 10^198
sexsexagintillion 10^201
septsexagintillion 10^204
octosexagintillion 10^207
novemsexagintillion 10^210
septuagintillion 10^213
unseptuagintillion 10^216
duoseptuagintillion 10^219
treseptuagintillion 10^222
quattuorseptuagintillion 10^225
quinseptuagintillion 10^228
sexseptuagintillion 10^231
septseptuagintillion 10^234
octoseptuagintillion 10^237
novemseptuagintillion 10^240
octogintillion 10^243
unoctogintillion 10^246
duooctogintillion 10^249
treoctogintillion 10^252
quattuoroctogintillion 10^255
quinoctogintillion 10^258
sexoctogintillion 10^261
septoctogintillion 10^264
octooctogintillion 10^267
novemoctogintillion 10^270
nonagintillion 10^273
unnonagintillion 10^276
duononagintillion 10^279
trenonagintillion 10^282
quattuornonagintillion 10^285
quinnonagintillion 10^288
sexnonagintillion 10^291
septnonagintillion 10^294
octononagintillion 10^297
novemnonagintillion 10^300
centillion 10^303

QQ20160519-0@2x

最后。。。大家千万不要去玩 adventure capitalist

最近好奇做了一个测试,使用spring + mybatis 对mysql插入百条数据。
第一种,通过调用service一条一条插入,出错没有回滚。
结果耗时非常长,这也是很正常的。
第二种,在100w条sql跑在同一个事物中,好处就是这一百万条数据是原子性的。统一成功或者失败。
数据生成代码

                List<Log> logs = new ArrayList<Log>(100_0000);
		for (int i = 0; i < 100_0000; i++) {
			Log log = new Log();
			log.setAddress(Math.random()+"");
			log.setJingdu(Math.random()*100);
			log.setWeidu(Math.random()*100);
			log.setTokenId(UUID.randomUUID().toString().split("-")[0]);
			log.setSignDate(new Date());
			logs.add(log);
		}

批量插入代码

        public void insert(Iterable<Log> logs) {
		for (Log l : logs) {
			baseDao.insert(l);
		}
		
	}

结果:百万次,十次测试[679, 703, 620, 564, 698, 700, 678, 686, 711, 619]单位秒
第三种 拼接sql. insert into … values (…),(…),(….)
这种方式直接卡死。
第四种 batch update

@Override
	public void addBatch(final List<Log> item) {
		String sql = "insert into log (id, token_id, sign_date,jingdu, weidu, address)values (null,?,?,?,?, ?)";
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
		jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {  
            // 为prepared statement设置参数。这个方法将在整个过程中被调用的次数  
            public void setValues(PreparedStatement pst, int i)  
                    throws SQLException {  
            	Log log = item.get(i);
                pst.setString(1, log.getTokenId());  
                pst.setDate(2,new java.sql.Date(log.getSignDate().getTime()) );
                pst.setDouble(3, log.getJingdu());
                pst.setDouble(4, log.getWeidu());
                pst.setString(5, log.getAddress());  
            }  
  
            // 返回更新的结果集条数  
            public int getBatchSize() {  
                return item.size();  
            }  	
        });  
	}

结果[211, 216, 243, 234, 235, 238, 237, 224, 222, 226]秒
目前来看还是batchUpdate的效率最高。

今天测试了下插入性能发现用注解配置的事物不回滚,仔细找了找原因。
首先确认了下配置是对的。

	<!-- 配置事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 使用annotation定义事务 -->
	<tx:annotation-driven transaction-manager="transactionManager"
		proxy-target-class="true" />

然后检查注解

@Service
@Transactional(propagation=Propagation.REQUIRED) 
public interface LogService extends BaseService<Log>{
	Log dataToLog(Data data);
	
	Log selectLostContact(Date date);
	
	void insert(Iterable<Log> logs);
	
	void addBatch(List<Log> item);
}

发现都没啥问题。然后把propagation改成了只读,发现还能提交。说明事物根本没配置成功。然后把注解放到实现类上试了下。发现可以了,事物正常了,回滚也正常了。md….原来接口上的注解不继承。。。
spring版本4.0.1

备案终于下来了,可以使用国内的服务器了,以后aws就专心做vpn好了,服务器大部分已经迁移完毕了。还有一些java项目没有挪过来,也会尽快挪过来。不知道证书续期还麻不麻烦,到时候再说吧。

经过这么长时间,我发现,博客,就应该,少写点没用的。

本服务器架构 nginx做反向代理php + tomcat以后也可能用jetty。数据库使用的是mysql。没有做redius。

本站依然可以使用 https和http两种协议访问