Java Se---常用类（包装类、String）

一．包装类

1. 概念：

I. 8种基本数据所对应的引用数据类型。

II. Object可统一所有数据，默认值为null。

2. 匹配：

byte ---> Byte

short ---> Short

int ---> Integer

long ---> Long

float ---> Float

double ---> Double

char ---> Character

boolean ---> Boolean

 

3. 类型转换：

I. Number父类中继承到的6个转型方法。

II. 构造方法。

III. parseXXX(String s) //静态方法，将字符串转换成基本类型

package encapsulate;public class TestEncapsulate {/** * @param args */public static void main(String[] args) {/*System.out.println(Byte.MAX_VALUE);System.out.println(Long.MAX_VALUE);System.out.println(Float.MAX_VALUE);*/byte b = 10;String s = "20";Byte bo1 = new Byte(b);Byte bo2 = new Byte(s);System.out.println(bo1);System.out.println(bo2);//------------------------------byte r1 = bo1.byteValue();System.out.println(r1);double r2 = bo2.doubleValue();System.out.println(r2);byte r3 = Byte.parseByte("112");System.out.println(r3);}}

IV. valueOf() //静态方法，将基本或字符串转换成包装类型

package encapsulate;public class TestAutoEncap {/** * @param args */public static void main(String[] args) {//Short s = 200;//Short.valueOf(200);//short s2 = s;//s.shortValue();Short s1 = 200;//超出缓存，独立创建地址Short s2 = 200;//超出缓存，独立创建地址System.out.println(s1 == s2);//地址不同Short s3 = 100;//在缓存之内，获取已存在的地址Short s4 = 100;//在缓存之内，获取已存在的地址System.out.println(s3 == s4);//地址相同}}

V. 注意兼容类型，避免NumberFormatException异常。

VI.JDK5之后，自动装箱、拆箱。包装类型与基本类型可自动转换。

package encapsulate;public class TestJDK5 {/** * 自动装箱 */public static void main(String[] args) {byte b1 = 123;Byte b2 = new Byte(b1);Byte b3 = Byte.valueOf(b1);Byte b4 = b1;Byte b5 = 123;//自动装箱，JDK5提供   Byte b5 = Byte.valueOf(123);byte b6 = b5.byteValue();//将包装类型转换成基本数据类型byte b7 = b5;//自动调用b5.byteValue();Object o = 123;//Object o = Integer.valueOf(123);method(123);byte a = Byte.parseByte("20");}public static void method(Object o){}}

package encapsulate;public class TestStudent {public static void main(String[] args) {Student s1 = new Student("tom",200,'男',100D);Student s2 = new Student("tom",200,'男',100D);System.out.println(s1 == s2);System.out.println(s1.equals(s2));}}class Student{String name;Integer age;Character sex;Double score;public Student(String name, Integer age, Character sex, Double score) {super();this.name = name;this.age = age;this.sex = sex;this.score = score;}@Overridepublic boolean equals(Object obj) {if(this == obj)return true;if(obj == null)return false;if(this.getClass() != obj.getClass())return false;Student s = (Student)obj;if(this.name.equals(s.name)&&this.age.equals(s.age)&&this.sex.equals(s.sex)&&this.score.equals(s.score)){return true;}return false;}}

二．String

1. 概念：

I. 字符串是常量，创建之后不可改变。

II. 字符串字面值存储在字符串池中，可以共享。

package string;public class TestBaseString {/** * @param args */public static void main(String[] args) {/*String s1 = "abc";//首次出现，则进入常量池，创建了一个对象String s2 = "abc";//字符串字面值存储在字符串池中，可以共享，创建0个对象String s3 = new String("abc");//引用，在堆空间创建了一个对象System.out.println(s1 == s2);System.out.println(s1 == s3);s1 += "def";System.out.println(s2);System.out.println(s1 == s2);*/String s3 = new String("abc");//引用，在堆空间创建了一个对象，第一次出现，在常量池也创建一个对象String s1 = "abc";//字符串字面值存储在字符串池中，可以共享，创建0个对象String s2 = "abc";//字符串字面值存储在字符串池中，可以共享，创建0个对象System.out.println(s1 == s2);System.out.println(s1 == s3);s1 += "def";System.out.println(s2);System.out.println(s1 == s2);}}

2. 创建：

String s1 = "abc";

String s2 = new String("abc");

3. 方法：

public char charAt(int index) //返回index所对应的字符

package Test;public class TestCharAt {public static void main(String[] args) {String s = "nsjfhjdfknkdsifdsijio";System.out.println(s.charAt(0));}}

public String concat(String str)//将另一段字符串拼接在字符串后面

package Test;public class TestConcat {public static void main(String[] args) {String s1 = "门前大桥下";String s2 = "游过一群鸭";String s3 = "快来快来数一数";String s4 = "二四六七八 ";String s5 = s1.concat(s2).concat(s3).concat(s4);System.out.println(s5);}}

public boolean contains(CharSequence s) //CharSequence就是字符串String，查找是否包含此字符串

package Test;public class TestContains {public static void main(String[] args) {String s1 = "寻不到花的折翼枯叶蝶，永远也看不见凋谢";String s2 = "永远";String s3 = "凋零";System.out.println(s1.contains(s2));System.out.println(s1.contains(s3));}}

public boolean endsWith(String suffix)//判断是否以该字符串结束

package Test;public class TestEndsWith {public static void main(String[] args) {String s1 = "我身骑白马走三关";String s2 = "三关";String s3 = "身骑白马";System.out.println(s1.endsWith(s2));System.out.println(s1.endsWith(s3));}}

public boolean startsWith(String suffix) //判断是否以该字符串开始

package Test;public class TestStartsWith {public static void main(String[] args) {String s1 = "Welcome to my house";String s2 = "Welcome";String s3 = "welcome";System.out.println(s1.startsWith(s2));System.out.println(s1.startsWith(s3));}}

public int indexOf(String str) //查找该字符首次出现的索引

package Test;public class TestIndexOf {public static void main(String[] args) {String s1 = "儿时凿壁偷了谁家的光";System.out.println(s1.indexOf('光'));}}

public int lastIndexOf(String str) //查找该字符最后一次出现的索引

package Test;public class TestLastIndexOf {public static void main(String[] args) {String s1 = "天空好想下雨，我好想住你隔壁";System.out.println(s1.lastIndexOf('想'));}}

public String replace(char oldChar,char newChar)  //用新的字符替换指定字符

package Test;public class TestReplace {public static void main(String[] args) {String s1 = "门前大桥下，游过一群鸭";System.out.println(s1.replace('鸭', '鸡'));}}

public String[] split(String regex) //拆分字符串

package Test;public class TestSplit {public static void main(String[] args) {String s1 = "你眉目如当年流转我心间";String[] s2 = s1.split("年|我");for (int i = 0; i < s2.length; i++) {System.out.println(s2[i]);}}}

public String substring(int beginIndex) //返回一个字符序列，索引从参数开始到最后。如果两个参数，则从第一个开始，第二个之前结束

package Test;public class TestSubString {public static void main(String[] args) {String s1 = "命运总是颠沛流离";String s2 = s1.substring(3);//从下标开始System.out.println(s2);String s3 = s1.substring(3, 6);//从下标三开始，到下标六之前结束System.out.println(s3);}}

public String toLowerCase() //将字符串转换成小写

package Test;public class TestToLowerCase {public static void main(String[] args) {String s1 = "Welcome to my house";String s2 = s1.toLowerCase();System.out.println(s2);}}

public String toUpperCase() //将字符串转换成大写

package Test;public class TestToUpperCase {/** * @param args */public static void main(String[] args) {String s1 = "Welcome to my house";String s2 = s1.toUpperCase();System.out.println(s2);}}

public String trim() //截去字符串开头空白和末尾空白

package Test;public class TestTrim {public static void main(String[] args) {String s1 = "    Welcome to my house     ";System.out.println(s1);String s2 = s1.trim();System.out.println(s2);}}

4. 可变字符串：

I. StringBuffer：JDK1.0推出，操作速度慢、线程安全。

II. StringBuilder：JDK5推出，操作速度快、线程不安全。

III. 常用方法：append(?); //追加

package string;public class TestChange {/** * 可变字符串 */public static void main(String[] args) {String s = "A";/*for (int i = 0; i < 100; i++) {//这种方式额外创建了100个对象s += i;}System.out.println(s);*/StringBuilder builder = new StringBuilder(s);//1.先将String包装成可变字符串for (int i = 0; i < 100; i++) {//2.进行多次的可变操作builder.append(i);}s = builder.toString();//3.转换回String类型System.out.println(s);}}