Int 和 Inetger

int是我们常说的整形数字，是Java的8个原始数据类型（Primitive Types，boolean、byte 、short、char、int、foat、double、long）之一。Java语言虽然号称一切都是对象，但原始数据类型是例外。

原始数据类型

那么原始数据类型又是什么呢？故事其实这样的在Java设计之初，它保留了一些和面向过程语言的特性(如:C),原始数据类型不是对象，没有方法，但是可以简单快速处理数据。
原始数据类型分类 ：

• 整型：byte、short、int、long
• 浮点型：float、double
• 布尔型：boolean
• 字符：char

封箱类型

针对基本数据类型

Integer是int对应的包装类，它有一个int类型的字段存储数据，并且提供了基本操作，比如数学运算、int和字符串之间转换等。在Java 5中，引入了自动装箱和自动拆箱功能
（boxing/unboxing），Java可以根据上下文，自动进行转换，极大地简化了相关编程。
关于Integer的值缓存，这涉及Java 5中另一个改进。构建Integer对象的传统方式是直接调用构造器，直接new一个对象。但是根据实践，我们发现大部分数据操作都是集中在有
限的、较小的数值范围，因而，在Java 5中新增了静态工厂方法valueOf，在调用它的时候会利用一个缓存机制，带来了明显的性能改进。按照Javadoc，这个值默认缓存
是-128到127之间。

Integer中的缓存机制，废话不多先上代码

    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

从代码中我们可以看出来它是来自Integer类中的一个静态内部类，有自己默认的无参构造函数。在static 块中将自己的属性cache 构造了一缓存数组，默认的范围是从 -128 到 127 我们也可以通过虚拟机的参数-XX:AutoBoxCacheMax<high>来调整上限。

首先我们应该知道哪里用到了Cache ，我们才能分析出来如何很好的使用这个cache

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

到这里可能会有点奇怪辛辛苦苦构造的一个 cache 怎么就有了一个次 ？
其实当我们继续查看Inetger类所拥有的方法时，你会发现Inetger类他的主要功能有取最大值、最小值、位数、获取环境变量数值 、各种转换方法等；但是这些功能的前提到的各种静态工厂方法valueOf()；
举个栗子：

//从系统的property文件中拿出一个integer
public static Integer getInteger(String nm, int val) {
        Integer result = getInteger(nm, null);
        return (result == null) ? Integer.valueOf(val) : result;
 }
//返回一个指定进制 的数
  public static Integer valueOf(String s, int radix) throws NumberFormatException {
        return Integer.valueOf(parseInt(s,radix));
    }
//将String字符串解码
 public static Integer decode(String nm) throws NumberFormatException {
        int radix = 10;
        int index = 0;
        boolean negative = false;
        Integer result;

        if (nm.length() == 0)
            throw new NumberFormatException("Zero length string");
        char firstChar = nm.charAt(0);
        // Handle sign, if present
        if (firstChar == '-') {
            negative = true;
            index++;
        } else if (firstChar == '+')
            index++;

        // Handle radix specifier, if present
        if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
            index += 2;
            radix = 16;
        }
        else if (nm.startsWith("#", index)) {
            index ++;
            radix = 16;
        }
        else if (nm.startsWith("0", index) && nm.length() > 1 + index) {
            index ++;
            radix = 8;
        }

        if (nm.startsWith("-", index) || nm.startsWith("+", index))
            throw new NumberFormatException("Sign character in wrong position");

        try {
            result = Integer.valueOf(nm.substring(index), radix);
            result = negative ? Integer.valueOf(-result.intValue()) : result;
        } catch (NumberFormatException e) {
            // If number is Integer.MIN_VALUE, we'll end up here. The next line
            // handles this case, and causes any genuine format error to be
            // rethrown.
            String constant = negative ? ("-" + nm.substring(index))
                                       : nm.substring(index);
            result = Integer.valueOf(constant, radix);
        }
        return result;
    }

因此当遇到一些明确知道会涉及到较大数值的场景时，我们可以考虑尝试通过JVM 参数-XX:AutoBoxCacheMax<high>来修改Integer 默认cache上限来优化我们的程序

throw 和throws 的区别

throw 是在方法内，表示抛出具体异常，则由该方法的使用者来处理异常。

具体向外抛出的动作，所以它抛出的是一个异常实体类。若执行了Thow一定是抛出了某种异常

Throws：

1. 作用在方法的声明上，表示如果抛出异常，则由该方法的调用者来进行异常处理。
2. 主要的声明这个方法会抛出会抛出某种类型的异常，让它的使用者知道捕获异常的类型。
3. 出现异常是一种可能性，但不一定会发生异常。