1.Integer类成员方法
int类型和String类型的相互转换
- public int intValue()：返回当前对象包装的基本数据类型的int值
- public static int parseInt(String s)：将一个字符串转换成int值
- public static String toString(int i)：将一个int值转换成字符串
- public static Integer valueOf(int i)：用一个int值构建一个Integer对象
- public static Integer valueOf(String s)：用一个字符串构建一个Integer对象
后两种相当于调用了Integer类的构造方法，效果上是一样的
/*
* int类型和String类型的相互转换
*
* int -- String
* String.valueOf(number)
* String -- int
* Integer.parseInt(s)
*/
public class IntegerDemo {
public static void main(String[] args) {
// int -- String
int number = 100;
// 方式1
String s1 = "" + number;
System.out.println("s1:" + s1);
// 方式2，使用String类的静态方法valueOf
String s2 = String.valueOf(number);
System.out.println("s2:" + s2);
// 方式3，先转换成包装类对象，然后再转换成String
// int -- Integer -- String
Integer i = new Integer(number);
String s3 = i.toString();
System.out.println("s3:" + s3);
// 方式4，直接使用包装类的静态方法：toString
String s4 = Integer.toString(number);
System.out.println("s4:" + s4);
System.out.println("-----------------");
// String -- int
String s = "100";
// 方式1，将字符串转换成Integer包装类之后，再获取其中的值
// String -- Integer -- int
Integer ii = new Integer(s);
// public int intValue()
int x = ii.intValue();
System.out.println("x:" + x);
//方式2，直接使用包装类的解析方法
//public static int parseInt(String s)
int y = Integer.parseInt(s);
System.out.println("y:"+y);
}
}
常用Integer类成员方法
/*
* 常用的基本进制转换
* public static String toBinaryString(int i)
* public static String toOctalString(int i)
* public static String toHexString(int i)
* 十进制到其他进制
* public static String toString(int i,int radix)
*/
public class IntegerDemo {
public static void main(String[] args) {
// 十进制到二进制，八进制，十六进制
System.out.println(Integer.toBinaryString(100));
System.out.println(Integer.toOctalString(100));
System.out.println(Integer.toHexString(100));
System.out.println("-------------------------");
// 十进制到其他进制，返回值是字符串
System.out.println(Integer.toString(100, 10));
System.out.println(Integer.toString(100, 2));
System.out.println(Integer.toString(100, 8));
System.out.println(Integer.toString(100, 16));
System.out.println("-------------------------");
//其他进制到十进制，返回值是整型值
System.out.println(Integer.parseInt("100", 10));
System.out.println(Integer.parseInt("100", 2));
System.out.println(Integer.parseInt("100", 8));
System.out.println(Integer.parseInt("100", 16));
//NumberFormatException
//System.out.println(Integer.parseInt("123", 2));
}
}
2.JDK5的新特性：自动装箱
JDK1.5以后，简化了定义方式。
Integer x = new Integer(4);可以直接写成
Integer x = 4; //自动装箱。
x = x + 5; //自动拆箱。通过intValue方法。
需要注意：
在使用时，Integer x = null;
上面的代码就会出现NullPointerException。
/*
* JDK5的新特性
* 自动装箱：把基本类型转换为包装类类型
* 自动拆箱：把包装类类型转换为基本类型
*
* 注意一个小问题：
* 在使用时，Integer x = null;代码就会出现NullPointerException。
* 建议先判断是否为null，然后再使用。
*/
public class IntegerDemo {
public static void main(String[] args) {
// 定义了一个int类型的包装类类型变量i
// Integer i = new Integer(100);
Integer ii = 100;
ii += 200; //ii = ii + 200;
System.out.println("ii:" + ii);
Integer iii = null;
// NullPointerException
if (iii != null) {
iii += 1000;
System.out.println(iii);
}
}
}
3.引用数据类型变量的强制类型转换
前面在多态的时候讲过，多态的特点是父类引用指向子类的实例，但是父类的引用变量只能调用父类中有的方法，不能调用子类特有的方法，即：引用变量只能调用它编译时的类型的方法。
比如：
class Father{
public void show1(){
System.out.println("Father show1()");
}
}
class Son extends Father{
public void show1(){
System.out.println("Son show1()");
}
public void show2(){
System.out.println("Son show2()");
}
}
class InheritDemo{
public static void main(String[] args){
Father f = new Son();
f.show1();
//f.show2();此语句编译报错
// Son s = (Son)f;可以将f强制转换成子类类型，然后就可以调用show2方法了
// s.show2();
}
}
引用变量的强制类型转换需要注意的事项：
引用类型之间的转换只能用在具有继承关系的两个类型之间进行，如果是两个没有任何继承关系的类型，则无法进行类型转换。
如果试图将一个父类实例变量转换成子类类型，则这个对象必须实际上是子类的实例才行（即编译时为父类类型，而运行时为子类类型）否则将在运行时引发ClassCastException异常。
4.String/StringBuffer类概述
String类代表的是一串字符，例如，“abc”就是一个String类的实例，String的值是固定的，永恒的，即一个字符串一旦被创建了，包含在这个对象中的字符序列就是不可更改的，直到这个对象被销毁。
StringBuffer 这个类则代表了一个字符序列可变的字符串，当一个StringBuffer对象被创建后，可以通过其提供的append(),insert(),reverse(),setLength()等方法改变这个字符串对象的字符序列。一旦通过StringBuffer生成了最终的字符串，就可以通过调用它的toString()方法将其转换成一个String对象。
5.String类构造方法：
String(char[] value)
通过一个字符数组创建一个字符串对象
char[] data = {'a','b','c'};
String str = new String(data);
String(char[] value,int offset,int count)
将指定的字符数组从offset开始，长度为count的字符元素连成字符
String(String original)
根据一个字符串常量来创建一个String对象，也就是说，新创建的String对象是该参数字符串的副本
char ch = "abc".charAt(2); //返回指定索引位置的单个字符
boolean isEqu = "abcd".equals("ABCD");//false
boolean isEqual = "abcd".equalsIgnoreCase("ABCD");//true
6.String类常用方法：
截取子串：
String s2 = "abcd".substring(2,3);//c? cd?
substring返回的是从开始索引到结束索引-1 的位置之间的字符串，返回的字符串的长度是：endIndex - startIndex，例子中截取的子串的长度就是1
int compareTo(String anotherString)
比较两个字符串的大小，如果两个字符串的字符序列完全相等，则返回0；不相等时，从两个字符串的第0个字符开始比较，返回第一个不相等的字符差（即两个字符的编码的差），当一个较长的字符串的前面的部分恰巧是一个短的字符串，则返回它们的长度差
7.StringBuilder类
由于String对象是不可变的，所以，如下的语句将产生五个字符串常量：
String s1 = "hello";
s1 = s1 + "world";
s1 = s1 + "java";
除了三个字符串常量外，还将额外产生两个字符串常量"helloworld","helloworldjava"
为了避免产生过多的额外临时变量，可以使用StringBuffer或者是StringBuilder，前者是线程安全的，在使用方法上，两者都相同
StringBuffer 和StringBuilder有两个属性，length和capacity，前者表示的是当前对象中包含的字符序列的长度，可以通过length()和setLength(int len)方法来访问或者设置字符串序列的长度。后者表示的是容量，通常容量都比length要大一些。程序中无需关心capacity的值，会随着字符串长度的变化而变化
通过观察StringBuilder的构造方法发现，可以通过传递一个String类型的变量来构造一个StingBuilder对象，这说明可以将一个不变的String类型的对象转换成一个可变的StringBuilder对象。
StringBuffer StringBuilder用法类似，请自行去查看API文档或在IDE中查看javadoc