1、总结String、Object、包装类的常用方法以及注意点；
String类
String类的两种实例化方法
直接赋值
String str = "hello";//字符串常量，为字符串的匿名对象
1、只开辟一个"hello"空间
2、在JVM底层会自动维护一个对象池（字符串对象池），该对象会自动保存在对象池中；
3、当下次采用该方式时，先会比较对象池之中有无指定内容，有则直接引用，无则新开辟空间保存
传统方法(new 操作)
String str = new String("hello");
1、采用构造方法产生的字符串对象不会自动入池，str保存在栈上，内容保存在堆上，
2、开辟两个"hello"空间，其中一个"hello"为垃圾空间，str指向第二个（new出来的内容为"hello"的对象）
3、String提供手工入池操作intern()；String str = new String("hello").intern();//将new的地址入池
字符串比较
"=="
本身是进行数值比较的，如果现在用于对象比较，比较的是两个对象所保存的内存地址
System.out.println(str == str1);//false，比较的是str 与str1保存的内容，即为对象地址
equals()方法
比较对象内容，则必须采用String类提供的equals方法。
str.equals(str1);//null不能调用equals()方法，所以一般是将 指定字符串.equals(用户输入)
比较String类"=="和equals的区别：
1、"=="进行数值的比较，比较的是两个字符串对象的内存地址数值
2、equals()比较字符串内容
字符串常量不可变更
在定义字符串常量时，它的内容不可改变。变得是引用指向，不是对象。使用字符串时，尽量少变更。（+操作最多执行三次）JVM底层会将String变为StringBuilder(可变)，equalsIgnoreCase();//忽略大小写
字符(char)与字符串(String)常用操作方法：
1、char[] -> String（将数组变为字符串）
public String(char[])//构造方法
2、取得指定索引字符（！！！）
public char charAt(int index):取的字符串索引的字符
3、String -> char[]（将字符串变为char数组）（！！！）
public char[] toCharArray();
所有越界都属于运行时异常
字节(byte)与字符串(String)的常用方法
1、byte[] -> String（将指定字节数组转为String）
public String(byte[])//构造方法
//重载构造
public String(byte[], String charSetName);将指定字节数组按指定编码格式转为字符串
2、String -> byte[]（字符串转为字节数组）（！！！）
public byte[] getBytes();
3、String -> byte[]（可指定编码格式）
public byte[] getBytes(String charSetName);
String转double：
Double.parseDouble(str);
String转int：
Integer.parseInt(str);
toUpperCase()：小写字符转大写字符方法
字符串比较
1、boolean equals()：区分大小写
2、boolean equalsIgnoreCase()：不区分大小写
3、int compareTo(String str);
返回值>0：表示本字符串>指定字符串
返回值=0：表示两个字符串相等
返回值<0：表示本字符串<指定字符串
字符串查找：从完整字符串中判断指定字符串是否存在（！！！）
1、public boolean contains(String str);（！！！）
判断指定字符串str是否存在于本字符串
2、public int indexOf(String str);
从头开始查找str的位置，找到返回下标，否则返回-1
3、public int lastIndexOf(String str);
从后开始查找str的位置，找到返回下标，否则返回-1
4、public boolean startsWith(String str);
判断是否以指定字符串开头
5、public boolean endsWith(String str);
判断是否以指定字符串结尾
字符串替换：
replaceFirst(String reg)：将本字符串中第一个出现reg元素替换
replace(String reg);/replaceAll(String reg);将所有用reg换掉
字符串拆分：
public String[] split();
字符串截取：
public String substring(int startIndex, int endIndex);
首字母大写：
str.substring(0,1).toUpperCase()+str.substring(1);
截取首字母转为大写+截取后部分内容
判断是否有内容：两点操作，是否为空对象，是否为空
if(!(str == null || str.isEmpty())){
//str有内容
}
去掉字符串中的空格：
trim();去掉字符串左右两边空格，中间空格保留
StringBuffer类、StringBuilder类
使用原则：
为了方便字符串的修改，而不会产生大量的垃圾空间，有了StringBuffer类、StringBuilder类
修改内容：
public StringBuffer append(各种数据类型);
StringBuffer -> String：
public String toString();//将StringBuffer转为String
String -> StringBuffer：（两种方式）
1、append();
2、new StringBuffer(String str);
StringBuffer类和StringBuilder类独有方法：
1、reverse()：字符串反转
2、delete();
3、insert();
请解释String类与两个SB类的区别
1、String类内容不可变，两个SB内容可变
2、StringBuffer采用同步处理，线程安全，效率较低；
StringBuilder采用异步处理，线程不安全，效率较高；
3、String类的修改操作“+”，JVM底层会将String类变为StringBulider类处理，会去掉用append()方法进行拼接，以减小大量垃圾空间
Object类（！！！）
1、Object类是所有类的默认父类
使用Object类可以接收所有类的对象（向上转型）
2、方法
toString()取得对象信息
System.out.println(obj);默认调用对象的toString()方法
Object类toString()默认返回对象所在类名以及地址信息
如果子类对输出内容有要求，则需要去重写toString()方法
3、对象比较（！！！）
equals()：
public boolean equals(Object obj);//接收Object对象
4、Object类接收数组对象
5、Object类接收接口对象
使用Object类可以接收所有引用数据类型（是方法参数最高统一类型）
包装类（！！！）
基本数据类型无法通过Object类接收，包装类就是将基本数据类型值封装在类中
对象型包装类（Object的直接子类）：
Boolean、Character
数值型包装类（Number类的直接子类）：
Byte、Short、Integer、Long、Float、Double
装箱：
将基本数据类型变为包装类的对象，利用包装类提供的构造方法实现装箱处理
拆箱：
将包装类中包装的基本数据类型取出，利用包装类提供的xxValue()方法
JDK1.5以后提供自动装箱拆箱功能，使用包装类和使用int一模一样
规范：所有相同类型的包装类对象值比较，一律使用equals方法比较
对于Integer = ？（自动装箱）[-127,128]之间的赋值，Integer对象会在Integer常量池产生，会复用已存在的对象。
这个区间以外的值，都会在堆上产生，不会复用对象，使用equals方法比较
使用int还是Integer？规范：
所有POJO类必须使用包装类对象；（简单JAVA类）
所有RPC方法的返回值和参数必须使用包装类；
所有局部变量使用基本数据类型
String转为基本数据类型（使用包装类提供的 类名.parseXX() 方法）
String->Number(数值类型)会有转换异常（包含非数字都会有数值转换异常）
String->对象型包装类不存在转换异常
Boolean中，非true都为false
基本数据类型转为String
1、"+"
2、new String(所有数据类型)
2、编程题:
要求:
1).Person类有name,age,salary属性，要求实现至少两个构造方法，并且属性私有，提供对应的getter、setter。
2).覆写toString方法，要求在System.out.println()函数中传递Person对象能打印出三个属性值而不是对象地址。
3).覆写equals方法，要求两个Person类对象的值相同时返回true。
package one;
class Person{
private String name;
private int age;
private double salary;
public Person() {
super();
}
public Person(String name, int age, double salary) {
super();
this.name = name;
this.age = age;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", salary=" + salary + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
long temp;
temp = Double.doubleToLongBits(salary);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
return false;
return true;
}
}
public class Test1 {
public static void main(String[] args) {
Person person = new Person("zhang", 20, 10000);
Person person1 = new Person("zhang", 20, 10000);
System.out.println(person);
System.out.println(person1);
System.out.println(person.equals(person1));
}
}
3、说出下列程序的执行结果，并说明原因:
Integer a = 55;
Integer b = 55;
System.out.println(a==b);
System.out.println(a==new Integer(55));
System.out.println(a.equals(new Integer(55)));
Integer c = 129;
Integer d = 129;
System.out.println(c==d);
执行结果：
当数值在[-127,128]之间， Integer对象会在Integer常量池产生，会复用已存在的对象。
a==new Integer(55)：false，"=="比较的是地址
a.equals(new Integer(55))：true，Integer a在赋值时会自动装箱
都会在堆上产生，不会复用对象
4 、写出懒汉式单例模式
package one;
//懒汉式单例
class Singleton{
private static Singleton singleton;
private Singleton() {};
public static Singleton getInstance() {
if(singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
public class Test3 {
public static void main(String[] args) {
Singleton singleton = Singleton.getInstance();
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton);
System.out.println(singleton1);
System.out.println(singleton2);
}
}
5、算法)
题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个 第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
package one;
public class Test4 {
public static void main(String[] args) {
int day = 10;//第10天只剩一个
System.out.println(getSum(day));
}
public static int getSum(int day) {
int n = day;
int sum = 1;
while(n > 1) {//最后一天只剩一个
sum = (sum + 1) * 2;
n--;
}
return sum;
}
}测试结果：
