Object和String类

Object类

每个类都有父类 无论是extends写出 还是没写出 它们的最终父类是Object

1. getClass() 将该对象的所属类当做一个Class的对象进行返回
2. hashCode() 返回的是对象在真实物理内存中的地址（十进制表示）主要和哈希表结合
3. equals(Object obj) 将该对象与传入的对象obj进行对比 (默认比的是对象的地址)
4. clone() 将当前对象进行复制 返回副本
5. toString() 返回的是一个类名@十六进制对象的地址值 打印一个对象其实就是在调用该对象的toString()
6. finalize() 对象没有被更多的引用指向时，被垃圾回收器调用

equals()

1. 自己跟自己比
2. 传入的是否为空
3. 比类型 ；用getClass() / instanceOf 都可以
4. 比属性
   4.1)基本数据类型 不用判空 直接比
   4.2)引用数据类型 判空后 再比较

权限的问题

权限	同类	同包不同类	不同包但继承	不同包不继承
public	√	√	√	√
protected	√	√	√	×
默认	√	√	×	×
private	√	×	×	×

String类

String是final类 所以不能被继承

实现的接口：

1. Serializable：序列化接口 将内存中的数据存入硬盘或上传互联网
2. Comparable：对比接口 给字符串赋予了可比较性
3. CharSequence：字符队列 就是一个数据结构 从逻辑角度看字符串本质上就是一个队列

成员：

1. char[] value[] ：说明字符串从物理结构角度看 就是一个用字符数组实现的字符序列
2. public String(): 创建一个空字符串"" ->创建一个空字符序列""->创建一个字符数组new char[0]
3. public String(char[]):传入一个字符数组 得到一个字符串对象
4. int length():获取字符串的长度
5. boolean isEmpty():字符串判空
6. char charAt(int):获取字符串中指定角标的字符
7. void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin):
   在字符串中 从角标[srcBegin,srcEnd)放入到从dstBegin角标开始的dst字符数组中
8. byte[] getBytes(String):将字符串以指定的字符集进行编码
9. boolean equals(String):比较当前字符串与传入字符串的内容是否相等
10. boolean equalsIgnoreCase(String):忽略字母大小的equals()
11. int compareTo(String):比较两个字符串的字典顺序大小 负数 当前<传入 0 整数
12. int compareToIgnoreCase(String str):忽略字母大小写的compareTo
13. boolean startsWith(String prefix, int toffset)：从字符串的toffset角标开始，是否以prefix字符串开头
14. boolean endsWith(String suffix)
15. int indexOf(int ch):丛左到右获取ch这个字符第一次出现的角标
16. int indexOf(String str)
17. int lastIndexOf(int ch)：从右到左
18. String substring(int beginIndex, int endIndex):获取从beginIndex开始到结尾的字符串
19. String concat(String str)：字符串合并
20. String replace(char oldChar, char newChar)：在字符串忠将oldChar替换为newChar
21. boolean contains(CharSequence s):该字符串是否包含s
22. String[] split(String regex, int limit):切分 以regex为分隔符 将字符串拆分
23. String toLowerCase(Locale locale):转小写
24. String toUpperCase(Locale locale):转大写
25. String trim()：去掉两边的空格 返回新的字符串
26. char[] toCharArray()：返回该字符串的字符数组

MyString案例:

package part1.string;
import java.lang.Character;
public class MyString{
	private char[] arrayValue;
	public MyString(){
	}
	public MyString(char[] arrayValue){
		this.arrayValue=arrayValue;
	}
	public char[] getArrayValue(){
		//访问器
		return this.arrayValue;
	}
	public int length(){
		//获取字符串长度
		return arrayValue.length;
	}
	public boolean isEmpty(){
		//判空
		return arrayValue.length==0;
	}
	public char charAt(int in){
		//获取字符串in角标的字符
		if(isEmpty()){
			return '0';
		}
		if(in<0||in>=arrayValue.length){
			return '0';
		}
		return arrayValue[in];
	}
	public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin){
		//获取arrayValue[srcBegin]到arrayValue[srcEnd]的值，并从dst[dstBegin]开始写入
		if(srcBegin<0){
			System.out.println("角标过小");
		}
		if(srcEnd>=arrayValue.length){
			System.out.println("角标过大 ");
		}
		if(srcBegin>srcEnd){
			System.out.println("输入角标范围错误");
		}
		int k=dstBegin;
		for(int i=srcBegin;i<srcEnd;i++){
			dst[k]=arrayValue[i];
			k++;
		}
	}
	public boolean equals(MyString str){
		//判断两个字符串是否相等
		if(this.arrayValue.length!=str.arrayValue.length){
			return false;
		}
		for(int i=0;i<this.arrayValue.length;i++){
			if(this.arrayValue[i]!=str.arrayValue[i]){
				return false;
			}
		}
		return true;
	}
	public boolean equalsIgnoreCase(MyString str){
		//不区分大小写判断两个字符串是否相等
		if(this.arrayValue.length!=str.arrayValue.length){
			return false;
		}
		for(int i=0;i<this.arrayValue.length;i++){
			this.arrayValue[i]=Character.toLowerCase(this.arrayValue[i]);
			str.arrayValue[i]=Character.toLowerCase(str.arrayValue[i]);
		}
		return equals(str);
	}
	public int compareTo(MyString str){
		//比较两个字符串中字典顺序的大小
		if(this.arrayValue.length!=str.arrayValue.length){
			return -1;
		}
		for(int i=0;i<this.arrayValue.length;i++){
			if(this.arrayValue[i]!=str.arrayValue[i]){
				return this.arrayValue[i]-str.arrayValue[i];
			}
		}
		return 0;
	}
	public int compareToIgnoreCase(MyString str){
		//不区分大小写比较两个字符串中字典顺序的大小
		if(this.arrayValue.length!=str.arrayValue.length){
			return -1;
		}
		for(int i=0;i<this.arrayValue.length;i++){
			this.arrayValue[i]=Character.toLowerCase(this.arrayValue[i]);
			str.arrayValue[i]=Character.toLowerCase(str.arrayValue[i]);
		}
		for(int i=0;i<this.arrayValue.length;i++){
			if(this.arrayValue[i]!=str.arrayValue[i]){
				return this.arrayValue[i]-str.arrayValue[i];
			}
		}
		return 0;
	}
	public boolean startsWith(MyString prefix, int toffset){
		//判断从字符串的toffset角标开始，是否以prefix字符串开头
		if(toffset>=this.arrayValue.length||toffset<0){
			return false;
		}
		int j=0;
		char[] po=this.arrayValue;
		char[] pa=prefix.arrayValue;
		int i=prefix.arrayValue.length;
		int k=toffset;
		while(--i>=0){
			if(po[k++]!=pa[j++]){
				return false;
			}
		}
		return true;
	}
	public int indexOf(int ch){
		//找出ch字符在字符串中的角标
		for(int i=0;i<this.arrayValue.length;i++){
			if(this.arrayValue[i]==ch){
				return i;
			}
		}
		return -1;
	}
	public int indexOf(MyString str){
		//判断一个字符串是否在另一个字符串中，并且输出字符串的第一个角标
		int index=0;
		for(int i=0;i<this.arrayValue.length;i++){
			for(int j=0;j<str.arrayValue.length;j++){
				if(this.arrayValue[i+j]!=str.arrayValue[j]){
					break;
				}else{
					if(j==0){
						index=i;
					}else if(j==str.arrayValue.length-1){
						return index;
					}
				}
			}
			
		}
		return -1;
	}
	public MyString substring(int beginIndex, int endIndex){
		//获取从beginIndex开始到endIndex结尾的字符串
		char[] ch=new char[10];
		MyString ms=new MyString(ch);
		int j=0;
		for(int i=beginIndex;i<=endIndex;i++){
			ms.arrayValue[j++]=this.arrayValue[i];
		}
		return ms;
	}
	public  MyString replace(char oldChar, char newChar){
		//新字符替换旧字符
		if(oldChar==newChar){
			return this;
		}
		for(int i=0;i<this.length();i++){
			if(this.arrayValue[i]==oldChar){
				this.arrayValue[i]=newChar;
				break;
			}
		}
		return this;
	}
	public MyString trim(){
		int begin=0;
		for(int i=0;i<this.length();i++){
			if(this.arrayValue[i]!=' '){
				begin=i;
				break;
			}
		}
		int end=0;
		for(int i=this.length()-1;i>=0;i--){
			if(this.arrayValue[i]!=' '){
				end=i;
				break;
			}
		}
		char[] ch=new char[end-begin+1];
		MyString string=new MyString(ch);
		for(int i=0;i<string.length();i++){
			string.arrayValue[i]=this.arrayValue[i+begin];
		}
		return string;
	}
	public char[] toCharArray(){
		return this.arrayValue;
	}
}