<span>import<span> java.util.Scanner;
<span>/*<span>
-
统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
-
-
分析：
-
A:定义三个统计变量。
-
int bigCont=0;
-
int smalCount=0;
-
int numberCount=0;
-
B:键盘录入一个字符串。
-
C:把字符串转换为字符数组。
-
D:遍历字符数组获取到每一个字符
-
E:判断该字符是
-
大写 bigCount++;
-
小写 smalCount++;
-
数字 numberCount++;
-
F:输出结果即可
<span>*/
<span>public <span>class<span> CharacterTest {
<span>public <span>static <span>void<span> main(String[] args) {
<span>//<span> 定义三个统计变量。
<span>int bigCount = 0<span>;
<span>int smallCount = 0<span>;
<span>int numberCount = 0<span>;
</span><span>//</span><span> <a href="https://www.jb51.cc/tag/jianpan/" target="_blank">键盘</a>录入<a href="https://www.jb51.cc/tag/yige/" target="_blank">一个</a>字符串。</span>
Scanner sc = <span>new</span><span> Scanner(<a href="https://www.jb51.cc/tag/systemin/" target="_blank">system.in</a>);
Sy<a href="https://www.jb51.cc/tag/stem/" target="_blank">stem</a>.out.println(</span>"请输入<a href="https://www.jb51.cc/tag/yige/" target="_blank">一个</a>字符串："<span>);
String line </span>=<span> sc.nextLine();
</span><span>//</span><span> 把<a href="https://www.jb51.cc/tag/zifuchuanzhuanhuan/" target="_blank">字符串转换</a>为字符数组。</span>
<span>char</span>[] chs =<span> line.<a href="https://www.jb51.cc/tag/toch/" target="_blank">toch</a><a href="https://www.jb51.cc/tag/ara/" target="_blank">ara</a>rray();
</span><span>//</span><span> 历字符数组<a href="https://www.jb51.cc/tag/huoqu/" target="_blank">获取</a>到每<a href="https://www.jb51.cc/tag/yige/" target="_blank">一个</a>字符</span>
<span>for</span> (<span>int</span> x = 0; x < chs.length; x++<span>) {
</span><span>char</span> ch =<span> chs[x];
</span><span>//</span><span> 判断该字符</span>
<span>if</span><span> (Ch<a href="https://www.jb51.cc/tag/ara/" target="_blank">ara</a>cter.isUpperCase(ch)) {
bigCount</span>++<span>;
} </span><span>else</span> <span>if</span><span> (Ch<a href="https://www.jb51.cc/tag/ara/" target="_blank">ara</a>cter.isLowerCase(ch)) {
smallCount</span>++<span>;
} </span><span>else</span> <span>if</span><span> (Ch<a href="https://www.jb51.cc/tag/ara/" target="_blank">ara</a>cter.isDigit(ch)) {
numberCount</span>++<span>;
}
}
</span><span>//</span><span> <a href="https://www.jb51.cc/tag/shuchu/" target="_blank">输出</a>结果即可</span>
Sy<a href="https://www.jb51.cc/tag/stem/" target="_blank">stem</a>.out.println("大写字母：" + bigCount + "个"<span>);
Sy<a href="https://www.jb51.cc/tag/stem/" target="_blank">stem</a>.out.println(</span>"小写字母：" + smallCount + "个"<span>);
Sy<a href="https://www.jb51.cc/tag/stem/" target="_blank">stem</a>.out.println(</span>"数字字符：" + numberCount + "个"<span>);
}
}
int 类型与 Integer 对象转换，其他基本类型转换方式相同。
int 对应的是 Integer，char 对应的 Character，其他 6 个都是基本类型首字母大写。
parseXXX(String s); 其中 XXX 表示基本类型，参数为可以转成基本类型的字符串。
System.out.println(Integer.parseInt("123") + 2);
// 打印结果为 125
// 字符串 -> 基本数据类型
String str="12";// 字符串，必须时整型字符串
int num=Integer.parseInt (str);// 直接用类名调
double num2=Double.parseDouble(str);
System.out.println(num+1);
System.out.println(num2);
// 基本类型 -> 字符串
System.out.println(""+12+1);
String s1=String.valueOf(88);
String s2=String.valueOf(1.2);
System.out.println(s1+1);
System.out.println(s2+1);
String s3=Integer.toString(99);
System.out.println(s3+1);
Integer.valueOf、 Integer.parseInt 、 new Integer
先看一下下面的结果
1.System.out.println(127==127); //true , int type compare2.System.out.println(128==128); //true , int type compare3.System.out.println(new Integer(127) == new Integer(127)); //false, object compare4.System.out.println(Integer.parseInt("128")==Integer.parseInt("128")); //true, int type compare5.System.out.println(Integer.valueOf("127")==Integer.valueOf("127")); //true ,object compare, because IntegerCache return a same object6.System.out.println(Integer.valueOf("128")==Integer.valueOf("128")); //false ,object compare, because number beyond the IntegerCache7.System.out.println(Integer.parseInt("128")==Integer.valueOf("128")); //true , int type compare登录后复制
解释
int整型常量比较时，== 是值比较，所以1,2返回true。1，2是值比较。
new Integer() 每次构造一个新的Integer对象，所以3返回false。3是对象比较。
Integer.parseInt每次构造一个int常量，所以4返回true。4是值比较。
Integer.valueOf返回一个Integer对象，默认在-128~127之间时返回缓存中的已有对象（如果存在的话），所以5返回true，6返回false。5，6是对象比较。
第7个比较特殊，是int 和 Integer之间的比较，结果是值比较，返回true。
总结
对于整型的比较，首先判断是值比较还是对象比较，值比较肯定返回true，有一个是值就是值比较。对象比较，则看对象是怎么构造出来的，如果是采用new Integer方式，则每次产生新对象，两个new出来的Integer比较肯定返回false，如果是Integer.valueOf方式的话，注意值的区间是否在-128～127之间，如果在，则构造的相同值的对象是同一个对象，==比较后返回true,否则返回false。
所以，对于值比较==放心没问题，对于Integer的比较最好用equals方法比较对象内容，当然注意先判断Integer是否不为null。
知识扩展
针对Integer.valueOf源码分析一下
1.我们调用的Integer.valueOf方法, 它先调用parseInt转成int型数值，再调它自己的重载方法
public static Integer valueOf(String s) throws NumberFormatException {return Integer.valueOf(parseInt(s, 10));
}登录后复制
2.Integer.valueOf重载方法，根据数值i的大小，决定是否从缓存中取一个Integer对象
public static Integer valueOf(int i) {if (i >= IntegerCache.low && i 登录后复制
3.Integer的构造函数，非常简单
public Integer(int value) {this.value = value;
}登录后复制
4.IntegerCache静态类，是Integer的内部类，三个属性（一个缓存的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"); //读取VM参数if (integerCacheHighPropValue != null) {try {int i = parseInt(integerCacheHighPropValue); //配置值转换成int数值i = Math.max(i, 127); //和127比较，取较大者// Maximum array size is Integer.MAX_VALUE(控制缓存数组的大小，最大为整型的最大值，这样一来，h值就必须小于整型最大值，因为要存 -128～0这129个数嘛)h = Math.min(i, Integer.MAX_VALUE - (-low) -1); //实际就是 h=Math.min(i,Integer.MAX_VALUE-129),正整数能缓存的个数} 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 = 127; //如果小于127，抛异常}private IntegerCache() {}
}登录后复制
看完上述Integer.valueOf源码后，你就会发现，默认的Integer缓存int常量池是可以配置的，配置方法是添加VM参数，加： -Djava.lang.Integer.IntegerCache.high=200
Intellij IDEA 运行配置的VM Options选项中添加参数即可。
以上就是Integer.valueOf、 Integer.parseInt 、 new Integer的详细内容，更多请关注php中文网其它相关文章！
Integer、Long等基本类型的包装类比较时的注意点
先来看一段代码：
Integer a = 1;
Integer b = 1;
System.out.println(a == b); // true
Integer aa = 128;
Integer bb = 128;
System.out.println(aa == bb); // false
为什么输出结果是这样？这就跟Integer创建对象的方式有关了。在使用 Integer 创建对象的过程中，首先会调用valueOf()方法，源码如下
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
Integer会对传入的参数进行了一个判断，在-128<i<127时直接从IntegerCache缓存中取，而当超出这个范围时，则在堆中新建了一个对象。
因此，上面代码中a 和 b 实际上都指向了IntegerCache中的同一个地址，而aa 和 bb 超过了-128~127这个范围，它们指向了堆中不同的对象。
Long.vlaueOf()源码
public static Long valueOf(long l) {
final int offset = 128;
if (l >= -128 && l <= 127) { // will cache
return LongCache.cache[(int)l + offset];
}
return new Long(l);
}
可以看到，Long同样如此
所以，当我们在对这些包装类进行比较时，应该使用equals进行比较，这样就能避免这些意外情况发生。
Integer aa = 128;
Integer bb = 128;
System.out.println(aa.equals(bb)); // true
参考博客:
http://www.51gjie.com/java/592.html
关于Java基本类型：int vs. Integer和java基本类型有哪八种的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于13-03 Java 基本类型包装类概述，Integer类，Character、int 类型与 Integer 对象转换，其他基本类型转换方式相同。、Integer.valueOf、 Integer.parseInt 、 new Integer、Integer、Long等基本类型的包装类比较时的注意点的相关信息，请在本站寻找。
