Java基础（六）——常用类

Object类

所有类的父类(没有构造方法的除外)
常用方法：
hashCode()：返回该对象的哈希码值（用算法将对象的实际地址值换算成一个数值）
			同一个对象的hash值是一致的
getClass()：返回该Object的运行时类,返回class对象
			可以配合反射获取类的信息
toString()： 返回该对象的字符串表示,一般都会重写,也可以用eclipse自动生成
equals()：指示其他对象与此对象是否相等，默认条件下比较的是地址值，
		一般用于重写，用于比较成员变量的值，
		字符串的equals()就是重写了Object，
		比较的是String的内容是否相同
finalize()：当垃圾回收器确定不存在该对象的更多引用时，由对象的垃圾回收期调用此方法，用于垃圾回收

重写equals

object类的源码

public boolean equals(Object obj) {
        return (this == obj);//object默认是比较对象的地址
    }

重写

public class Student {
	private String name;
	private int age;

	@Override
	public boolean equals(Object obj) {
		if (null == obj) {
			return false;
		}

		if (this == obj) {// 内存地址一致,值也是一致的
			return true;
		}

		if (this.getClass() != obj.getClass()) {// 类型不一致,值一定不同
			return false;
		}

		Student stu = (Student) obj;// 类型一致
		if (this.name.equals(stu.name) && this.age == stu.age) {// 内容一致
		//字符串的equals重写过,比较的是内容
			return true;
		}
		return false;// 类型一致但是内部不同

	}
}

重写toString

System.out.println(student);来输出一个对象的时候默认是调用对象的toString方法
没有重写toString默认调用Object的toString,输出类名+hash值

object类的源码

 public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

未重写

Student student = new Student("张三", 23);
System.out.println(student);//javaee.Student@7852e922

重写

public class Student {
	private String name;
	private int age;

	public Student() {
		super();
	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {//重写toString
		return "Student [name=" + name + ", age=" + age + "]";
	}

}
main()://调用
Student student = new Student("张三", 23);
System.out.println(student);
//Student [name=张三, age=23]

String类

字符串的值是常量,不能修改
字符串的本质是一个char数组
字符的length()实际就是获取这个数组的长度来得到字符串的长度
堆中开辟常量池存储常量
对String对象的任何改变都不影响到原对象，
相关的任何change操作都会生成新的对象

		String string = "abc";//创建字符串对象方式一
		String str = new String("abc");//创建字符串对象方式二
		System.out.println(string == str);// false
		System.out.println(string.equals(str));// true

		//String str = new String("abc")
		//本质上创建了2个对象,一个new String对象,一个"abc"对象
		//str 引用指向的是new String对象的地址,它的值是"abc"对象
		//String类的equals重写过,比较的是对象的内容是否相等

字符串的构造方法

		byte[] b = { 65, 66, 67, 68 };
		String string = new String(b);//以byte数组作为参数的构造方法
		//查询编码表,输出对应字符,负数表示汉字
		System.out.println(string);//ABCD	

		String str = new String(b, 1, 2);
		//以byte数组的一部分作为参数的构造方法,起始下标x,输出y个元素
		System.out.println(str);//BC

		char[] c = { 'a', 'b', 'c', 'd' };
		String string = new String(c);//将char数组作为参数的构造方法
		//不查询编码表
		System.out.println(string);//abcd
		//将char数组一部分作为参数的构造方法
		String str = new String(c, 1, 2);
		System.out.println(str);//bc

字符串的常用方法

		String string = "abcdefg";
		int len = string.length();//获取字符串的长度 7
		//截取字符串长度,起始下标x，结束下标y,取值范围[x,y)
		//重新生成了一个新的字符串对象
		String sub = string.substring(1, 3);//bc
		//判断以什么字符串开头
		boolean b = string.startsWith("ab");
		//判断以什么字符串结尾
		boolean g = string.endsWith("g");
		//判断是否包含一个子串
		boolean e = string.contains("bc");
		//返回字符串第一次出现的索引,没有返回-1
		int indexOf = string.indexOf("de");
		//返回字符串最后一次出现的索引,没有返回-1
		int lastIndexOf = string.lastIndexOf("g");
		//将字符串转为bytes数组,查询编码表转为数字
		byte[] bytes = string.getBytes();
		//将字符串转为字节数组
		char[] charArray = string.toCharArray();
		//判断两个字符串的内容是否相等
		boolean equals = string.equals("dafh");
		//判断两个字符串的内容是否相等,忽略大小写
		boolean equalsIgnoreCase = string.equalsIgnoreCase("sfaf");
		//去除字符串前后空格
		String trim = string.trim();
		//字符串的替换
		//重新生成了一个新的字符串对象
		String replace = string.replace("abc", "f");
		//字符串的拼接
		//重新生成了一个新的字符串对象
		String r = s.concat("cd")
		//根据字典顺序,比较字符串的unicode值大小
		//负数是小于,0是等于,整数是大于
		int compareTo = string.compareTo("abcf");
		//将字符串全部转为小写
		String lowerCase = string.toLowerCase();
		//将字符串全部转为大写
		String upperCase = string.toUpperCase();
		//按照指定字符串分割,可以指定多个分割字符串"a|b"
		String[] split = string.split("f");
	

示例

计算一个数字的长度

		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一个数字: ");
		int num = scanner.nextInt();
		String numString = num + "";//将数字转为字符串
		//利用字符串的length方法来获取长度
		System.out.println(numString.trim().length());

StringBuffer类

	String一旦创建不可修改,过于浪费内存
	对于String来说		"ab" + "cd" 生成"abcd" 这就是3个字符串对象
	对于StringBuffer		"ab" + "cd" 会创建一个新的加长的数组再将两者的值存入
	StringBuffer类也是表示字符串的,只是内部实现方式和String不同
	在内存使用上要优于String类
	StringBuffer是一个可变的char[] 数组
	StringBuffer类是线程安全的
	经常需要对一个字符串进行修改，例如插入、删除等操作，
	使用StringBuffer要更加适合一些
	StringBuffer和String没有关系,不能强制转换

StringBuffer stringBuffer = new StringBuffer("ab");//StringBuffer的创建
//添加字符串
stringBuffer.append("cd");
//删除指定下标的字符
stringBuffer.deleteCharAt(2);
//删除指定下标范围的字符串, [x,y)
stringBuffer.delete(1, 3)
//在指定位置处添加数据,可以字符,布尔,char等
stringBuffer.insert(1, true);
//将stringBuffer的内容反转
stringBuffer.reverse();
//修改指定下标的字符
stringBuffer.setCharAt(2, 'f');
//将StringBuffer对象的中存储空间缩小到和字符串长度一样的长度，减少空间的浪费
stringBuffer.trimToSize();

//String转StringBuffer
StringBuffer stringBuffer = new StringBuffer("ab");
//StringBuffer转String
stringBuffer.toString();

String与StringBuffer的参数传递

public static void main(String[] args) {
		String a = "abc";
		String b = "def";
		System.out.println(a + b);// abcdef
		change(a, b);
		System.out.println(a + b);// abcdef
		StringBuffer c = new StringBuffer("abc");
		StringBuffer d = new StringBuffer("def");
		System.out.println(c.toString() + d.toString());// abcdef
		change(c, d);
		System.out.println(c.toString() + d.toString());// abcdefdef
	}
	//引用类型传递的是值,这个值是引用的复制
	private static void change(StringBuffer a, StringBuffer b) {
		a = b;//a = def 变量a引用地址已改变
		b = a.append(b);//b = defdef 变量b引用地址未改变
	}

	private static void change(String a, String b) {
		a = b;
		b = a + b;
	}

判断字符串是否对称

String s = "abccba";
boolean b = new StringBuffer(s).reverse().toString().equals(s);
System.out.println(b);

StringBuilder类

和StringBuffer类一样的类,只是非线程安全的,速度较StringBuffer类快
用法和StringBuffer一致
只是StringBuffer类的成员方法前面多了一个关键字：synchronized
这个关键字是在多线程访问时起到安全保护作用的
也就是说StringBuffer是线程安全的

String，StringBuilder，StringBuffer三者的区别

大量字符串操作时:
String、StringBuilder、StringBuffer三者的执行效率：
StringBuilder > StringBuffer > String

String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，
即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，
是可以更改的

在线程安全上，StringBuilder是线程不安全的，
而StringBuffer是线程安全的

String：适用于少量的字符串操作的情况
StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况
少量字符串操作时
String str = "hello"+ "world"的效率就比 
StringBuilder st  = new StringBuilder().append("hello").append("world")要高

字符串相关面试题

		String string = "hh2";
		String str = "hh" + 2;
		System.out.println(str == string);// true
		String st = "hh";
		String s = st + 2;
		System.out.println(s == string);// false
		final String s1 = "hh";
		String s2 = s1 + 2;
		System.out.println(s2 == string);// true

字符串的拼接

1.string.concat(string2)适合于小数据拼接
	先判断string2长度是否为0,为0直接返回string
	否则利用char数组进行拼接
	用char数组作为参数new一个字符串对象作为返回值
2.+符号拼接 str += "ab";速度比concat方法快,只适合小规模数据
	新建一个stringBuilder对象,用它的append方法一个一个字符拼接后
	再toString转为String
3.StringBuffer和stringBuilder的append方法
	两者都是继承自AbstractStringBuilder
	只做了数组的加长和拷贝,再tonString转为String
	到最后也没有创建新的字符串对象
	速度较快,适合于大规模的数据拼接
4.StringUtils.join()适用于将ArrayList转换为字符串,也适合大规模数据
	速度比1,2快,比3慢