我一一为你们解析解析,写一个程序判断整数的奇偶

图片 15

图片 1

.a
  .b
    .c,
    .d
      color: red

减小内存的占用问题——享元模式和单例模式的对比分析

Universal Image Loader

UIL aims to provide a powerful, flexible and highly customizable instrument for image loading, caching and displaying. 

    It provides a lot of configuration options and good control over the image loading and caching process.

Universal Image
Loader
最佳解析

  • (void)parser:(NSXMLParser *)parser didEndElement:(NSString
    *)elementName namespaceURI:(NSString *)namespaceURI
    qualifiedName:(NSString *)qName
    {
    //标签开始解析,其中elementName就是结束标签的名称,
    //在这里你可以做一些逻辑判断,看这个标签里的东西是不是自己需要的,然后进行操作
    }

中的星座女会喜欢哪种款式的鞋子呢?跟着小编往下看吧,我一一为你们解析解析。

{selector('.a', '.b', '.c, .d')}
  color: red

下面代码的输出结果是?

System.out.println(2.00 - 1.10);

图片 2图片 3

可能认为该程序打印0.90,但是编译器如何才能知道你想要打印小数点后两位小数呢?

实际它打印的是0.8999999999999999。问题在于1.1 这个数字不能被精确表示成为一个double,因此它被表示成为最接近它的double 值。该程序从2 中减去的就是这个值。更一般地说,问题在于并不是所有的小数都可以用二进制浮点数来精确表示的。如果你正在用的是JDK 5.0 或更新的版本,那么可以使用类似c的方式,Java的printf 工具来订正该程序:

System.out.printf("%.2f%n",2.00 - 1.10);

这条语句打印的是正确的结果,但是这并不表示它就是对底层问题的通用解决方案:它使用的仍旧是二进制浮点数的double 运算。浮点运算在一个范围很广的值域上提供了很好的近似,但是它通常不能产生精确的结果。二进制浮点对于货币计算是非常不适合的,因为它不可能将0.1,或者10的其它任何次负幂精确表示为一个长度有限的二进制小数。

解决该问题的一种方式是使用某种整数类型,例如int 或long,并且以分为单位来执行计算。注意这样做请确保该整数类型大到足够表示在程序中你将要用到的所有值。对本题int 就足够了。下面是用int 以分为单位表示货币值后重写的println 语句:
System.out.println((200 - 110) + "cents");

解决该问题的另一种方式是使用执行精确小数运算的BigDecimal工具类。它还可以通过 JDBC 与 SQL DECIMAL 类型进行互操作。这里要注意: 一定要用 BigDecimal(String) 构造器,而不用BigDecimal(double)。后一个构造器将用它的参数的“精确”值来创建一个实例:new BigDecimal(.1)将返回一个表示0.100000000000000055511151231257827021181583404541015625 的BigDecimal。通过正确使用BigDecimal,程序就可以打印出我们所期望的结果0.90:

import java.math.BigDecimal;
public class Change1{
  public static void main(String args[]){
    System.out.println(new BigDecimal("2.00").subtract(new BigDecimal("1.10")));
  }
}
这个版本并不是十分地完美,因为Java 并没有为BigDecimal 提供任何语言上的支持。使用BigDecimal 的计算很有可能比那些使用原始类型的计算要慢一些,对某些大量使用小数计算的程序来说,这可能会成为问题。总之, 在需要精确答案的地方,要避免使用float 和double,对于货币计算,要使用int、long 或BigDecimal。

解析

浮点数表示可以参考

Picasso

  1. powerful image downloading and caching library for Android

Picasso
最佳解析

好接下来就是我们的JSON解析了。
我感觉JSON解析的解析过程不重要,重要的是JSON解析之后对结果的处理
JSON解析后是个dictionary,但是字典中有可能包含字典和数组,数组中还可以包含字典。
新浪微博的请求微博返回的数据经过JSON解析结果就是这样的。
下面就简单介绍一下JSON解析过程
其实就一句话


下面代码的输出结果是?

        double a = 0;
        int b = 1;
        System.out.println(b / a);

图片 4图片 3

Infinity

浮点数除以0之所以不会抛出异常的一个最重要的原因是浮点数0不同于整数0,是不能准确表示的。实际上浮点数0指的是一个无限趋近于0的数,一个正数除以一个无限趋近于0的数结果就是无限趋近于正无穷大,也就是infinity。

infinity通常也称之为非数(NaN,not a number),是浮点数的一种特殊形态。

解析

根据上图我们依次说明:

要解析数据首先创建一个xml解析器

解析后

下面代码的输出结果是?

        for (byte b = Byte.MIN_VALUE; b < Byte.MAX_VALUE; b++) {
            if (b == 0x90)
                System.out.print("Joy!");
        }

图片 6图片 3

0x90 是一个int 常量,它超出了byte 数值的范围。因为0x90 是一个两位的十六进制字面常量,每一个十六进制位都占据4 个比特的位置,所以整个数值也只占据8 个比特,即1 个byte。问题在于byte 是有符号类型。常量0x90 是一个正的最高位被置位的8 位int 数值。合法的byte数值是从-128 到+127,但是int 常量0x90 等于+144。拿一个byte 与一个int 进行的比较是一个混合类型比较(mixed-type comparison)。

如果把byte 数值想象为苹果,把int 数值想象成为桔子,那么该程序就是在拿苹果与桔子比较。为了比较byte 数值(byte)0x90 和int 数值0x90,Java 通过拓宽原始类型转换将byte 提升为一个int,然后比较这两个int 数值。因为byte 是一个有符号类型,所以这个转换执行的是符号扩展,将负的byte 数值提升为了在数字上相等的int数值。在本例中,该转换将(byte)0x90提升为int数值-112,它不等于int 数值0x90,即+144。

可以将int 转型为byte,之后就可以进行比较了:

if (b == (byte)0x90)
  System.out.println("Joy!");

或者,可以用一个屏蔽码来消除符号扩展的影响,从而将byte 转型为int:

if ((b & 0xff) == 0x90)
  System.out.print("Joy!");

上面的两个解决方案都可以正常运行,但是避免这类问题的最佳方法还是将常量值移出到循环的外面,并将其在一个常量声明中定义它。

解析

Logger

Simple, pretty and powerful logger for android

Logger provides :
   Thread information
   Class information
   Method information
   Pretty-print for json content
   Pretty-print for new line "\n"
   Clean output
   Jump to source

Logger

  • (void)parser:(NSXMLParser *)parser didStartElement:(NSString
    *)elementName namespaceURI:(NSString *)namespaceURI
    qualifiedName:(NSString *)qName attributes:(NSDictionary
    *)attributeDict
    {
    //标签开始解析,其中elementName就是开始标签的名称
    }

下面代码的输出结果是?

        int a = 0;
        int b = 1;
        System.out.println(b / a);

图片 8图片 3

没什么好说的吧,抛出除数为0的算术异常

Exception in thread "main" java.lang.ArithmeticException: / by zero

解析

fastjson

Fastjson是一个Java语言编写的JSON处理器,由阿里巴巴公司开发。

    1、遵循http://json.org标准,为其官方网站收录的参考实现之一。
    2、功能qiang打,支持JDK的各种类型,包括基本的JavaBean、Collection、Map、Date、Enum、泛型。
    3、无依赖,不需要例外额外的jar,能够直接跑在JDK上。
    4、开源,使用Apache License 2.0协议开源。http://code.alibabatech.com/wiki/display/FastJSON/Home
    5、具有超高的性能,java世界里没有其他的json库能够和fastjson可相比了。

fastjson
最佳解析

这一段主要接触的就是数据解析,就说一下数据解析
现在数据解析一般解析两种数据 xml 和 JSON
那就从xml解析说起吧
xml解析需要用到一个类 NSXMLParser 以及一个协议 NSXMLParserDelegate
首先NSXMLParser是一个 xml 解析器

解析后

 

ORMLite

暂缺,欢迎补充

ORMLite
最佳解析

data就是解析数据
//IOS5自带解析类NSJSONSerialization从data中解析出数据放到字典中
NSDictionary *weatherDic = [NSJSONSerialization
JSONObjectWithData:Data options:NSJSONReadingMutableLeaves
error:&error];

写成一行之后就需要加上逗号

用命令行:  java xxx a b c 方式运行以下代码的结果是?

图片 10 

图片 11图片 3

这里java xxx a b c 表示运行java字节码文件xxx,参数为 a b c,因为只输入了三个参数,且args是数组下标从0开始,而程序中使用到agrs[3]显然数组越界。抛出数组越界异常。

解析

EventBus

EventBus是一个Android端优化的publish/subscribe消 息总线,简化了应用程序内各组件间、组件与后台线程间的通信。

比如请求网络,等网络返回时通过Handler或Broadcast通知UI,两个 Fragment之间需要通过Listener通信,这些需求都可以通过EventBus实现。

EventBus
最佳解析

//这里附带一个把data转化为NSString类型的方法
NSString *string = [[NSString alloc]initWithData:data
encoding:NSUTF8StringEncoding];

foo bar baz
> input
  border 1px solid

下面代码的输出结果是?

System.out.println((int) (char) (byte) -1);

图片 13图片 3

以int 数值-1 开始,然后从int转型为byte,之后转型为char,最后转型回int。第一个转型将数值从32 位窄化到了8 位,第二个转型将数值从8 位拓宽到了16 位,最后一个转型又将数值从16 位拓宽回了32 位。

运行该程序,打印65535。

因为Java 使用了基于2 的补码的二进制运算,因此int 类型的数值-1 的所有32 位都是置位的,补码表示就是全f的16进制。从int 到byte 的转型是很简单的,它执行了一个窄化原始类型转化(narrowing primitiveconversion),直接将除低8 位之外的所有位全部砍掉。这样做留下的是一个8位都被置位了的byte,它仍旧表示-1。

从byte 到char 的转型稍微麻烦一点,因为byte 是一个有符号类型,而char是一个无符号类型。在将一个整数类型转换成另一个宽度更宽的整数类型时,通常是可以保持其数值的,但是却不可能将一个负的byte 数值表示成一个char。因此,从byte 到char 的转换有些复杂。

有一条很简单的规则能够描述从较窄的整型转换成较宽的整型时的符号扩展行为:

如果最初的数值类型是有符号的,那么就执行符号扩展;
如果它是char,那么不管它将要被转换成什么类型,都执行零扩展。
了解这条规则可以使我们很容易地解决这个题。因为byte 是一个有符号的类型,所以在将byte 数值-1 转换成char 时,会发生符号扩展。作为结果的char 数值的16 个位就都被置位了,因此它等于2^16-1,即65535。从char 到int 的转型也是一个拓宽原始类型转换,它将执行零扩展而不是符号扩展。作为结果的int 数值也就成了65535。

尽管这条简单的规则描述了在有符号和无符号整型之间进行拓宽原始类型时的符号扩展行为,但是最好还是不要编写出依赖于它的程序。最好将你的意图明确地表达出来。

如果在将一个char 数值 c 转型为一个宽度更宽的类型,并且不希望有符号扩展,那么为清晰表达意图,可以考虑使用一个位掩码,即使它并不是必需的:
int i = c & 0xffff;

或者,书写一句注释来描述转换的行为:

int i = c; //不会执行符号扩展

如果在将一个char 数值c 转型为一个宽度更宽的整型,并且希望有符号扩展,那么就先将char 转型为一个short,它与char 具有同样的宽度,但是它是有符号的。在给出了这种细微的代码之后,应也为它书写一句注释:

int i = (short) c; //转型将引起符号扩展

如果在将一个byte 数值b 转型为一个char,并且不希望有符号扩展,那么必须使用一个位掩码来限制它。这是一种通用做法,所以不需要任何注释:

char c = (char) (b & 0xff);

解析

LeakCanary

  1. memory leak detection library for Android and Java.

LeakCanary
最佳解析

其实还有一种xml解析的方法,就是dom解析,它是把XML看成树型结构,先找到根节点,
然后利用循环嵌套,遍历根节点的子节点,遍历子节点的子节点,一直遍历到叶子节点,当然叶子节点
是最后一层了,里面就是我们要得数据。
这种方法我感觉不好用,太麻烦,循环嵌套太多。所以不推荐使用
而且需要导入libxml2.dylib这个类库,最后还得修改路径
/usr/include/libxml2
但是在这里我还是把这个第三方类给出来吧


下面代码的输出结果是?

图片 15 

图片 16图片 3

首先,我们要知道,静态的方法也是可以通过对象来访问的,这一点很奇怪,但是确实是可以。其次,null可以被强制类型转换成任意类型的对象,于是可以通过它来执行静态方法。输出testMethod

解析

Agera

Agera is a set of classes and interfaces to help write functional, asynchronous, and reactive applications for Android.

Agera
最佳解析

//解析出来的标签值


下面代码的输出结果是?

System.out.println(12345 + 5432l);

图片 18图片 3

表面上看,这是一个很简单的题,打印66666。

实际上,当运行该程序时,它打印的是17777。仔细看 + 操作符的两个操作数,我们是将一个int 类型的12345 加到了 long 类型的5432l 上。请注意左操作数开头的数字1 和右操作数结尾的小写字母l 之间的细微差异。数字1 的水平笔划 和 垂直笔划 之间是一个锐角,而与此相对照的是,小写字母 l 是一个直角。

这个写法确实已经引起了混乱,这里有一个教训:在 long 型字面常量中,一定要用大写的L,千万不要用小写的l。这样就可以完全避免混乱。

System.out.println(12345 + 5432L);

类似的,要避免使用单独的一个 l 字母作为变量名。因为很难通过观察来判断它到底是 l 还是数字 1。属于编程不规范。

System.out.println(1);

总之,小写字母 l 和数字1 在大多数字体中几乎是一样的。为避免程序的读者对二者产生混淆,千万不要使用小写的 l 来作为 long 型字面常量的结尾或是作为变量名。Java 从C 编程语言中继承良多,包括long 型字面常量的语法。也许当初允许用小写的 l 来编写long 型字面常量本身就是一个错误。

解析

RxAndroid: Reactive Extensions for Android

Android specific bindings for RxJava.

This module adds the minimum classes to RxJava that make writing reactive components in Android applications easy and hassle-free. More

specifically, it provides a Scheduler that schedules on the main thread or any given Looper.

RxAndroid
最佳解析

其中data就是我们要解析的数据

body #login {
  -webkit-box-shadow: 1px 1px 3px #eee;
  -moz-box-shadow: 1px 1px 3px #eee;
  box-shadow: 1px 1px 3px #eee;
}
html.ie8 body #login,
html.ie7 body #login,
html.ie6 body #login {
  border: 2px solid #eee;
}

下面代码的输出结果是?

        int distance = 1;
        distance <<= 1;
        System.out.println(distance);
        distance <<= -1;
        System.out.println(distance);

图片 20图片 3

可能会猜想:负的移位长度的右移操作符可以起到左移操作符的作用,反之亦然。但是情况并非如此。

铭记:右移操作符总是起到右移的作用,而左移操作符也总是起到左移的作用。负的移位长度通过只保留低5 位而剔除其他位的方式被转换成了正的移位长度——如果左操作数是long 类型的,则保留低6 位。因此,如果要将一个int数值左移,其移位长度为-1,那么移位的效果是它被左移了31 位。

总之,移位长度是对32 取余的,或者如果左操作数是long 类型的,则对64 取余。因此,使用任何移位操作符和移位长度,都不可能将一个数值的所有位全部移走。同时,我们也不可能用右移操作符来执行左移操作,反之亦然。请使用常量的移位长度,如果移位长度不能设为常量,那么就要当心。

答案:

2
0

解析

Dagger2

Dagger2 是一个Android依赖注入框架,由谷歌开发,最早的版本Dagger1由Square公司开发。

    依赖注入框架主要用于模块间解耦,提高代码的健壮性和可维护性。

    Dagger这个库的取名不仅仅来自它的本意“匕首”,同时也暗示了它的原理。

    Jake Wharton 在对 Dagger 的介绍中指出,Dagger 即DAG-er,这里的 DAG 即数据结构中的 DAG——有向无环图(Directed Acyclic Graph)。

    也就是说,Dagger是一个基于有向无环图结构的依赖注入库,因此Dagger的使用过程中不能出现循环依赖。

Dagger2
最佳解析

NSXMLParser *XMLParser = [[NSXMLParser alloc]initWithData:data];


下面代码的输出结果是?

public class Test1 {
    public static void main(String[] args) {
        int i = 0;
        while (-1 << i != 0)
            i++;
        System.out.println(i);
    }
}

图片 22图片 3

常量-1 是所有32 位都被置位的int 数值(0xffffffff)。左移操作符将最右边的 i 位设置为0,并保持其余的32 - i 位为1。很明显,这个循环将完成32 次迭代,因为-1 << i 对任何小于32 的i 来说都不等于0。故推断打印32。

实际上,它不会打印任何东西,而是进入了一个死循环。

因为(-1 << 32)等于-1 而不是0。如果左值是int,移位长度总是介于0 到31 之间,如果左操作数是long ,介于0 到63 之间。这个长度是对32取余的,如果左操作数是long 类型的,则对64 取余。如果对一个int 数值移位32 位,或者是对一个long 数值移位64 位,都只能返回这个数值自身的值。这条规则作用于全部的三个移位操作符:<<、>>和>>>。没有任何移位长度可以让一个int 数值丢弃其所有的32 位,或者是让一个long数值丢弃其所有的64 位。

修改:不让-1 重复地移位,而是将前一次移位操作的结果保存起来,并且让它在每次迭代时左移 1 位,这样避免了移位32,出现死循环,下面打印32:

public class Shifty {
  public static void main(String[] args) {
    int distance = 0;
    for (int val = -1; val != 0; val <<= 1)
      distance++;
    System.out.println(distance);
  }
}

记住原则:如果可能的话,移位长度应该是常量。虽然并不可能总是可以使用常量的移位长度,但是当必须使用一个非常量的移位长度时,请确保程序可以应付这种问题。

解析

WilliamChart

WilliamChart is an Android Library to help the implementation of charts in android applications. 

    For the ones that would like to contribute, my idea is not only to implement the conventional chart features but instead something that could be pleasant and intuitive while representing and visualizing data. 

    I would prefer to keep charts simple and clean rather than overfeatured.

WilliamChart
最佳解析

好了今天就到这里,把最近学的知识分享给大家,如有错误欢迎指正 —— LC

body {
  color: #fff;
}

下面代码的输出结果是?

public class Test1 {
    public static final int END = Integer.MAX_VALUE;
    public static final int START = END - 100;

    public static void main(String[] args) {
        int count = 0;
        for (int i = START; i <= END; i++)
            count++;
        System.out.println(count);
    }
}

图片 24图片 3

死循环

这个循环会在循环索引(i)小于或等于Integer.MAX_VALUE 时持续运行,当i 达到Integer.MAX_VALUE,并且再次被执行增量操作时,它就有绕回到了Integer.MIN_VALUE。

如果循环会迭代到int 数值的边界附近时,最好是使用一个long 变量作为循环索引。只需将循环索引的类型从int 改变为long 就可以解决该问题,从而使程序打印出期望的101:

更一般地讲,这里的教训就是int 不能表示所有的整数。无论何时使用了一个整数类型,都要意识到其边界条件。所以通常最好是使用一个取之范围更大的类型。(整数类型包括byte、char、short、int 和long)

解析

Mockito

Tasty mocking framework for unit tests in Java

Mockito
最佳解析

下面附上TouchJSON,SBJSON 和 JSONKit的第三方类的链接

Leave a Comment.