作者: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协议无法打开。

以前一直以为这种写法

String test = "123"+"345"+"456";

以前认为String + 效率是特别低的,每次都会创建一个新的字符串,应该用StringBuilder.append代替。最近偶然看了下jdk api文档

The Java language provides special support for the string concatenation operator ( + ), and for conversion of other objects to strings. String concatenation is implemented through the StringBuilder(or StringBuffer) class and its append method. String conversions are implemented through the method toString, defined by Object and inherited by all classes in Java. For additional information on string concatenation and conversion, see Gosling, Joy, and Steele, The Java Language Specification.


Java 语言提供对字符串串联符号(”+”)以及将其他对象转换为字符串的特殊支持。字符串串联是通过 StringBuilder(或 StringBuffer)类及其append 方法实现的。字符串转换是通过 toString 方法实现的,该方法由 Object 类定义,并可被 Java 中的所有类继承。有关字符串串联和转换的更多信息,请参阅 Gosling、Joy 和 Steele 合著的 The Java Language Specification

然而我看了一下StringBuildertoString方法

    @Override
    public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }

还是会每次创建一个新的字符串,所以如果这样写

                String test = "";
		for (Integer i : treeSet) {
			test += i;
		}

还是等于

                String test = "";
		for (Integer i : treeSet) {
			test = stringBuilder.append(i).toString();
		}

还是会每次创建一个新的对象。
所以说然并卵,还是用+没问题不要用+=…..

我的博客bgm默认是关不掉的。。想关的手动静音或者改代码吧。。
这个BGM的原曲是初音未来的dear miku-dear
这个钢琴版是触手猴弹奏的。触手猴-dear
初音就不多说了,一直以来一直追的本命。
第一次看到触手猴[twitter]的弹二小姐的时候我是震惊的[U.N. Owen was her? – 2分30秒开始高能]世界上怎么会有弹钢琴这么屌的人。后来越看越震惊。。自然也就成了触手猴的粉丝。
推荐几个触手猴的演奏视频吧【触手猴】初音ミクの消失【触手猴】《only my railgun》钢琴演奏【某科学的超电磁炮OP】【触手猴】Night Of Knights
有鬼畜向的也有正常向的,慢慢欣赏钢琴的艺术吧。
这个就是可柔可刚的触手猴

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的效率最高。