Java三大类

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); 

执行结果：

a==b：true， 当数值在[-127,128]之间， Integer对象会在Integer常量池产生，会复用已存在的对象。

a==new Integer(55)：false，"=="比较的是地址

a.equals(new Integer(55))：true，Integer a在赋值时会自动装箱

c==d：false，当数值在[-127,128]之外， 都会在堆上产生，不会复用对象

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;
	}
}

测试结果：