目录
一.String方法
1.1 char charAt(int index)
1.2 String concat (String s)
1.3 startwith( String s)和endswith(String s)
1.4 getBytes()和getChars()
1.5 indexOf(String s)
1.6 Boolean match(String s)
1.7 String intern(String s)
1.8 String replace(char a,char b)
1.9 String[] split(String s)
1.10 static String valueOf(参数)
1.11 String substring(int begin,int end)
二.Object类
2.1 toString方法
2.2 equals方法
2.3 hashCode方法
三.习题
1.秋招面试题:
2.地址问题
一.String方法
String长度一定，当长度变化地址一定发生变化
看一个类先看类的继承体系
所有的引用数据类型都继承Object
常见的异常：
java.lang.NullPointerException 空指针异常
java.lang.StringIndexOutOfBoundsException 字符串索引
越界异常
构造方法：
String(String url);
String(char[] c, int offset,int length);
String(StringBuffer sb);
String(StringBuilder sb);
public static void main(String[] args) {
byte []a=new byte[]{1,2,3};
char []b=new char[]{'1','2','3'};
String a1=new String(a,0,a.length);
String b1=new String(b,0,b.length);
System.out.println(a1);//byte类型转字符串类型这时候是无法打印的 因为编码字符集的不同
System.out.println(b1);
}
123
两者不相同，前者是空值没有任何意义，后者是空串相当于String s2=" "。
String s=null; 使用charAT(0),会报错（空指针异常）。
String s1=new String(); 使用charAT(0),会报错（字符串索引越界）。
1.1 char charAt(int index)返回索引处的char类型值
s.charAt(0);1.2 String concat (String s)
字符串是定长的，长度改变地址改变。
public static void main(String[] args) {
String s="123";
String s7=s.concat("9");
String s8=s.concat("9");
char []a=new char[]{'4','5','6'};
char []a1=new char[]{'4','5','6'};
System.out.println(s7==s8);//false
}
1.3 startswith( String s)和endswith(String s)
boolean startwith( String s) 以s开头返回true
boolean endswith(String s)以s结尾返回true
1.4 getBytes()和getChars()public class Test {
public static void main(String[] args) {
String s="123";
byte a[]=s.getBytes(StandardCharsets.UTF_8);
System.out.println(Arrays.toString(a));
}
}
[49, 50, 51]//ascll码
1.5 indexOf(String s)
返回字符串第一次出现索引的位置
s.indexOf("a")
1.6 Boolean match(String s)
匹配正则
：参考：
1.7 String intern()返回字符串的规范表达形式，相同的字符串，通过intern方法，地址是相同的不管是通过赋值 *** 作还是new *** 作实现的。
public class Test {
public static void main(String[] args) {
String s="123";
String s1=new String("123");
String s11=s.intern();
String s12=s1.intern();
System.out.println(s==s1);
System.out.println(s11==s12);
}
}
false
true
1.8 String replace(char a,char b)
替换 前面的参数是旧的，后面的参数是新的
1.9 String[] split(String s)拆分字符串为String型数组
public class Test {
public static void main(String[] args) {
String key="钢铁侠，蜘蛛侠，蝙蝠侠";
String [] result=key.split("，");
for (int i=0;i
1.10 static String valueOf(参数)
将其他类型转换为字符串的形式
1.11 String substring(int begin,int end)
返回一个新的字符串，他是该字符串的子串
public class Test {
public static void main(String[] args) {
String key = "123456";
System.out.println(key.substring(2,5));
}
}
345
二.Object类
所有的引用数据类型都继承Object，其是所有类的父类
其中所有方法都要背下来
2.1 toString方法
toString方法重写前输出的是一段地址
println() 方法中调用了valueOf()方法，而后者其中调用了toString() 方法
而toString中写的是
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
其中调用了hashCode()方法 因此输出的是乱码
public class test {
public static void main(String[] args) {
Person p=new Person("张三疯",99);
System.out.println(p);
}
}
//执行结果
Test.Person@4554617c
2.2 equals方法
只是某个其他对象是否与此对象相等
public class test {
public static void main(String[] args) {
Person p=new Person("张三疯",99);
Person p1=new Person("张三疯",99);
System.out.println(p.equals(p1));
}
}
//执行结果为
false
不同的地址相同的对象，但是equals方法比较的是地址所以返回false（Object认为equals给出方法并无意义，需要自行给出比较的标准）
注意一点：字符串的equals方法是重写过的，专门用于比较字符串是否相等。
因此要重写equals() 方法（定义标准）
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return num == person.num && Objects.equals(name, person.name);
}
2.3 hashCode方法
hashCode 的常规协定是：
- 在 Java 应用程序执行期间，在同一对象上多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
- 如果根据 equals(Object) 方法，两个对象是相等的，那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。
- 以下情况不 是必需的：如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么在两个对象中的任一对象上调用 hashCode 方法必定会生成不同的整数结果。但是，程序员应该知道，为不相等的对象生成不同整数结果可以提高哈希表的性能。
Object中的hashCode是通过系统返回的，所以每次结果不一样，但是如果是String，integer这样的方法返回值是相同的，因为两者都重写了此方法，我们自己定义的类如果没有重写该方法，那么吊用的都是object的方法，如果重写以后，创建对象返回的方法是相同的
所以hashCode可以判断两个数据是否是同一个数据
public class test {
public static void main(String[] args) {
Person p=new Person("张三疯",99);
Person p1=new Person("张三疯",99);
System.out.println(p.hashCode());
System.out.println(p.hashCode());
System.out.println(p1.hashCode());
System.out.println("张三疯".hashCode());
}
}
//执行结果
1163157884
1163157884
1956725890
24051686
重写hashCode()
prime是阈值
重写后： 值是相同的
public class test {
public static void main(String[] args) {
Person p=new Person("张三疯",99);
Person p1=new Person("张三疯",99);
System.out.println(p.hashCode());
System.out.println(p1.hashCode());
System.out.println("张三疯".hashCode());
}
}
==比较的是地址而hashCode不是地址，所以即使重写后hashCode值相同，输出的仍然是false。
每次创建新的对象时（new），地址都不相同。
public class test {
public static void main(String[] args) {
Person p=new Person("张三疯",99);
Person p1=new Person("张三疯",99);
Person p2=p;
System.out.println(p.hashCode());
System.out.println(p1.hashCode());
System.out.println(p==p1);
System.out.println(p==p2);
}
}
//运行结果
false
true
三.习题
1.秋招面试题:
== 和equals之间的区别？
== 比较的地址 equals 方法定义上 两个对象相同---true
为什么在重写hashcode方法时 要重写equals方法，两者有什么关系？
- 为了保证同一个对象 ，如果重写equals方法 没有重写hashcode的话，就会出现equals相等，而hashcode不相等， 重写hashcode方法为了避免这种情况发生。
- 使用了hashcode方法可以提前校验，可以避免每一次比较都用equals方法从而提高效率。
2.地址问题
public class Test {
public static void main(String[] args) {
String s="123";
String s1="123";
String s2=new String("123");
String s3=new String("123");
char []a=new char[]{'4','5','6'};
char []a1=new char[]{'4','5','6'};
System.out.println(s==s1);//true
System.out.println(s==s2);//false
System.out.println(s2==s3);//false
System.out.println(a==a1);//false
// new 出来的对象经过堆 char数组也是在堆中 而 String s="123";是在常量池中未经过堆
// String s="123"; String s1="123"; 其实不是引用出来的，而是通过的赋值 *** 作，栈空间中储存的地址是相同的。
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）