包装类和String

针对八种基本数据类型定义相应的引用类型-包装类。
面向对象的好处 继承 多态 调用方法
import org.junit.Test;

//测试方法：类必须公共，不能有任何构造器
//方法必须公共无返回值，无参，不能被static修饰。
//必须加上@Test注解，必须引入第三方库
//运行程序：把光标定位在要执行的方法的方法名上

//包装类，把基本型数据包装成对象类型，对应的有8种包装类
/byte
short
int Integer
long
float
double
char Character
boolean/

public class WrapperTest{

@Test
public void test1() {
	int n = 100;
	Integer obj1 = new Integer(100);//手工装箱 Integer只有有参构造 且值是private static int
	Integer obj2 = 200;//自动装箱，编译器转换为new Integer(200);
	
	//拆箱 把对象中的数据获取出来
	int val1 = obj1.intValue();//手工拆箱
	int val2 = obj2;//自动拆箱，编译器转换为obj2.intValue()
	
	System.out.println("hello");
}

@Test
public void test2() {
//声明两个字符串，内容是整数
String s1 = “1342”;
String s2 = “89”;

	//把第一个转换为整数后装箱，
	int n1 = Integer.parseInt(s1);//就是从字符串转换成一个10进制的整数
	Integer obj1 = new Integer(n1);
	//把第二个直接变成Integer对象
	Integer obj2 = Integer.valueOf(s2);//Integer obj2 = Integer.decode(s2);//new Integer(s2);
	System.out.println(obj2.toString());//直接打obj2
	
	//使用手工拆箱求和，自动拆箱求积
	int sum = obj1.intValue() + obj2.intValue();//.intValue()不用也可以
	int mul = obj1 * obj2;
	
	System.out.println("sum ：" + sum);
	System.out.println("mul ：" + mul);
}

//把字符串变成基本值的方法：包装类.parseXxx(“xxx”);
//手工拆箱：包装类对象.xxxValue()
//手工装箱：构造器new Xxx(xxx), new Xxx(“xxx”), 包装类.valueOf（“xxx”);
//基本类型转换为字符串类型 String.valueOf(xxx)
@Test
public void test3() {
Double obj1 = new Double(3.22);
Double obj2 = 2.82;
String string = “234.223”;
double val2 = Double.parseDouble(string);

	double val3 = obj1.doubleValue();
	Double obj3 = new Double(string);
	Double obj4 = Double.valueOf(string);
	
	String string2= "false";
	boolean b = Boolean.parseBoolean(string2);
	Boolean boolean1 = new Boolean(string2);
	boolean1.booleanValue();
	
}

@Test
public void test3() {
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i==j);

	Integer m = 1;
	Integer n = 1;
	System.out.println(m==n);
	
	Integer x = 128;
	Integer y = 128;
	System.out.println(x==y);
}
结果：

false
true
false

import org.junit.Test;

/*
String字符串：内容不可以改变的Unicode字符序列，“abc”
可以看作是字符数组private final char value[];
所以任何对于字符串的修改操作，都会产生新的字符串对象。
*/
public class StringTest{

@Test
public void test1() {
	String s1 = "abc";//
	s1 = s1 + 100;//"abc100"
			
	//字符串对象的创建
	String s2 = new String();//和String s2 = " "不同于null
	char[] arr = {'a', '1', '2', '你', '好', '?'};//字符数组
	String s3 = new String(arr);
	System.out.println(s3);
	
	String s4 = new String(arr, 2, 3);//从第二个参数是数组的开始下标，第三个参数是取多少个字符
	System.out.println(s4);

//遍历
for(int i=0; i< s1.length(); i++) {
char ch = s1.charAt(i);
System.out.println(ch);
}

}	

}

//判断
@Test
public void test2() {
String s1 = “atguigu”;
String s2 = “java”;
String s4 = “java”;
String s3 = new String(“java”);

	String s5 = "atguigujava";
	String s6 = (s1+s2).intern();
	
	System.out.println(s2==s3);//一个在常量池 一个在堆区 地址不同了 f
	System.out.println(s2==s4);//t
	System.out.println(s2.equals(s3));//t
	System.out.println(s5==s6);//t
	System.out.println(s5.equals(s6));//t
	/*
	 * intern()方法在常量池中检测和s6满足equals条件的字符串是否存在， 如果存在则返回对常量池中的对象的引用，
	 * 如果不存在则添加一个新的常量，并返回新常量的引用。
	 */
	
}

//反转字符串 
String s1 = "abc";//
	s1 = s1 + 100;//"abc100"
	//方法一
	String s = " ";
	for(int i=s1.length()-1; i>=0; i--) {
		char ch = s1.charAt(i);
		s += ch;
	}
	System.out.println(s);
	//方法二
	for(int i=0; i< s1.length(); i++) {
		char ch = s1.charAt(i);
		s = ch + s;
	}
	System.out.println(s);
	//方法三 转换为字符数组再转换为字符串
	char[] array = s1.toCharArray();
	for(int i=0; i< s1.length()/2; i++) {
		char tmp = array[i];
		array[i] = array[array.length -1 -i];
		array[array.length - 1 - i] = tmp;
	}
	String string2 = new String(array);
	System.out.println(string2);

//将一个字符串进行部分反转,比如"abcdefg"反转为"abfedcg"
@Test
public void test1() {
String string = “abcdefghijk”;
int begin = 2;
int end = 6;//不包含

	// 把字符串切成3段
	String s1 = string.substring(0, begin);
	String s2 = string.substring(begin, end);
	String s3 = string.substring(end);
	
	char[] array = s2.toCharArray();
	for(int i=0; i< array.length / 2; i++) {
		char tmp = array[i];
		array[i] = array[array.length -1 -i];
		array[array.length - 1 - i] = tmp;
	}
	s2 = new String(array);
	String result = s1+s2+s3;
	System.out.println(result);
}

indexOf(String s)
搜索字符串第一次出现的位置下标
indexOf(String s,int startpoint)
指定位置
string.startWith(string s)
判断是否以s字符串开始
string.substring(int start,int end)
获取选定范围的字符串start<= <end
string.substring(int startpoint)
从startpoint开始到末尾
string.replace（char oldChar,char newChar)
示例String string = " abcdefghijk";
String string2 = string.replace(’ ', ‘$’);
System.out.println(string2);
string.replaceALL（String old,String new)
string.trum()消除不可见字符
string.concat(String str)连接传入的字符串
string.toUpperCase()大写
string.toLowerCase()小写
string.split(String str)分解
string.equals(String s)比较字符串内容
string.equalsIgnoreCase(String s)比较字符串内容 忽略大小写

/*
StringBuilder字符串：内容可以改变的Unicode字符序列，可增删
很多方法与String相同，但StringBuilder是可变长度的。
StringBuilder是一个容器
可变字符序列、效率高、线程不安全

StringBuffer有十三个构造方法： 可变字符序列、效率低、线程安全
StringBuffer()出事容量为16的字符串缓冲区
StringBuffer(int size)构造指定容量的字符串缓冲区
StringBuffer(String str)将内容初始化为指定字符串内容
常用方法：
StringBuffer.append(String str)追加任意内容
StringBuffer.length()
StringBuffer.insert(int index,String str)
StringBuffer.reverse()反转
StringBuffer.delete(int start,int end)
charAt setCharAt replace indexof substring
*/