- String类
＊ 所属的包是：java.lang包，不需要导入；
＊ 没有继承的类，默认继承Object类；
＊ 有无参构造方法和有参构造方法，可以创建对象；
String s = new String(“123abc”);
String s1 = (“123abc”);
String类型可以象基本数据类型一样赋值，可以看成是一个常量；
＊ 常见的笔试题
==与equals（）区别：
== 看比较基本数据类型的值，也可以比较引用类型的地址；
equals（）比较的是对象引用的内容；
String的不可变特性：
String对象的长度和内容不能被改变；
长度---->final修饰的数组，数组本身的长度不能变，其地址也不能变；
内容----->private修饰的属性，不能再类的外部被访问；
String类中包含一个数组：
private final char[] value // 存储String中的每一个字符；
final不可被改变---->值和地址都不能改变；
private------>其他类访问不到；
String与StringBuffer的区别；
StringBuffer与StringBuilder的区别；
String对象的存储；
“abc”---->常量池中；
new String(“abc”)----->堆内存中；
“a”+“b”+"c+“d”
＊ 如何创建对象：
String str = “a,b,c”;//直接将字符串常量值赋值给str
String str = new String();//无参数构造方法创建空的对象；
String str = new String(“a,b,c”);//带String类型参数的构造方法创建对象；
String str = new String(byte[] )//将数组中每一个元素转化成对应的char类型，然后合并成String类型；
String str = new String(char[] )//将数组中每一个char字符最终拼接成一个String类型的元素；
＊ 常用的方法：
1.equals() ；
比较两个引用类型的内容是否一致，返回值是boolean型；
2. hashCode（）；
重写继承自Object类的hashCode方法，将元素拆分成一个个的char元素，然后乘以31求和；
返回值是int型；
3.toString（）；
重写了继承自Object类的toString方法，输出一个字符串；
返回值是String类型；
4.charAt(int index) ；
返回对应index位置的char元素；
返回值类型是char类型；
codePointAt(int index)
返回对应index位置上的char元素对应的Unicode值；
返回值类型是int型；
5. contains(CharSequence s);
判断给定的s是否在字符串里面存在；
返回值是boolean类型；
6. length()；
返回字符串的长度；
返回值是int型；
7. concat(String)；
将给定的字符串拼接到当前字符串之后；
返回值类型是String型；
8.startsWith(String prefix);
判断字符串是不是以给定的字符开始的，
返回值类型是boolean类型；
endswith(String suffix);
判断字符串是不是以给定的字符结尾的；
返回值类型是boolean类型；
9. getBytes();
将字符串编码成平台使用的默认字符集（ASCII码）；
最后返回byte[]类型;
toCharArray();
将字符串拆分成char类型的数组；
最后返回char类型的数组；
10.indexOf(int/String str,[int fromIndex]);四个方法重载；
找寻字符串中第一次出现给定元素的位置，并且返回这个索引；如果没有，就返回-1；
lastIndexOf(int/String str,[int fromIndex);
找寻给定元素在字符串中最后一次出现的位置；如果没有就返回-1；返回值类型是整数类型（int long）；
11.isEmpty();
判断一个字符串是否是个空的字符串（里面不含有任何元素，但是有引用地址）也就时判断length（）是否为空；返回值类型是boolean型；
注意：不是null；
12 .replace(String oldChar,String newChar);
newChar替换掉之前的oldChar；
replaceAll(String regex,String repalcement);
将字符串中所有给定的元素，都替换掉；
replaceFirst(String regex,String replcement);
替换掉字符串中第一次出现给定的元素；
返回值类型都是String；
13.split（String regex[,int limit限度界限]）;
按照给定的表达式将原来的字符串拆分；返回值是类型String[]；
14.subString(int beginIndex[,int endIndex])；
可以将字符串从给定的索引截取到给定的索引；
如果没有给出endIndex，那么默认截取到字符串结尾；
返回值类型是string型；
15.toUppercase();
将给定的字符串全部大写；
toLowercase();
将给定的字符串全部小写；
返回值类型是String型；
16.trim();
去掉字符串前后的空格，不去掉字符串中间的空格；
返回值是String类型；
17.matches(String regex)
返回值类型是boolean型；
regex正则表达式；
18. cpmpareTo(String)；
比较两个字符串的Unicode码（字典排布顺序），如果长度一样，那么就返回Unicode之差；如果长度不一样，就返回长度差；
返回值类型是int型；
String str = "abc";
String str1 = "b";
int result = str.compareTo(str1);
System.out.println(result); //-1
- Scanner类
＊ 所属的包：java.util包，需要import导入；
＊ 没有继承其他的父类，默认继承Object类；
＊ 通过一个带输入流的参数创建对象；
＊ 常用方法：
nextInt()，返回值一个int型整数；
nextDouble()，返回值是一个double类型的小数；
nextFloat()，返回值是一个float型的小数；
next() ，返回值是一个String型；
nextLine()，返回值是一个String型； - System类
＊ 所属的包：java.lang包，不需要导入包；
＊ 没有继承的父类，默认继承Object类；
＊ 三个static属性（err，in，out），可以直接用System调用；
＊ 没有自己的构造函数，方法和属性都是静态的，可以直接用类名访问；
＊ 常用方法：
gc() 调用垃圾回收器回收；
exit(0)停止一段程序的运行；
currentTimeMills(),返回从1970年1月1日0点0分0秒到现在的毫秒数；返回值是long类型； - Object类
＊ clone()方法：
有深克隆和浅克隆；
深克隆：一个对象克隆了另外一个对象，那么他们两个互相不影响；其中一个的属性改变，不会影响另外一个对象的属性；
浅克隆：一个对象克隆了另外一个对象，那么他们两个的基本类型的属性不会互相影响，引用类型的属性会因为其中一个对象改变而改变；
深克隆的例子：
public class DeepCloneClass implements Cloneable{
public int i;
public Address1 a;
public static void main (String[] args) throws CloneNotSupportedException{
Address1 a = new Address1(10);
DeepCloneClass c1 = new DeepCloneClass(1,a);
DeepCloneClass c2 = (DeepCloneClass)c1.clone();
c2.i = 2;
c2.a.setAge(1);//基本类型和引用类型互相不影响
//Class<? extends DeepCloneClass> aClass = c1.getClass();
int i = c1.hashCode();
System.out.println(i);
System.out.println(c2);
}
@Override
public String toString() {
return this.i +"------" +this.a.age;
}
public void setI(int i) {
this.i = i;
}
public void setA(Address1 a) {
this.a = a;
}
public int getI() {
return this.i;
}
public Address1 getA() {
return a;
}
public DeepCloneClass(int i, Address1 a) {
this.i = i;
this.a = a;
}
public Object clone() throws CloneNotSupportedException{
DeepCloneClass dcc = (DeepCloneClass)super.clone();
dcc.a = (Address1)a.clone();
return dcc;
}
}
class Address1 implements Cloneable{
public int age;
public void setAge(int age) {
this.age = age;
}
public Address1(int age) {
this.age = age;
}
public Address1() {
super();
}
public int getAge() {
return age;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
浅克隆的例子：
public class ShallowClone implements Cloneable{
public int i;
public Student s;
public ShallowClone(int i, Student s) {
super();
this.i = i;
this.s = s;
}
public static void main(String[] args) throws CloneNotSupportedException {
Student s = new Student(10);
ShallowClone sc1 = new ShallowClone(1,s);
ShallowClone sc2 = sc1.clone();
System.out.println(sc1);
sc2.setI(2);//基本类型不是一起改变
sc2.getS().setAge(5);//引用类型一起改变
System.out.println(sc1);
System.out.println(sc2);
}
@Override
public String toString() {
return i + "-----" + s;
}
@Override
protected ShallowClone clone() throws CloneNotSupportedException {
return (ShallowClone)super.clone();
}
public void setI(int i) {
this.i = i;
}
public void setS(Student s) {
this.s = s;
}
public int getI() {
return i;
}
public Student getS() {
return s;
}
public ShallowClone() {
}
}
class Student {
int age = 10;
/*@Override
protected Student clone() throws CloneNotSupportedException {
return (Student)super.clone();
}*/
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "------"+age;
}
public int getAge() {
return age;
}
public Student() {
}
public Student(int age) {
this.age = age;
}
}
＊ toString()方法：
返回一个对象的地址：包名.类名@32位16进制的元素；
返回值类型是String型；
＊ equals()方法；
比较两个元素的引用地址是否一致；
返回值类型是boolean型；
＊ getClass();
返回这个对象的类名和所在的包；
返回值类型是个类 类型；
＊ hashCode()；
将对象的地址转换成一个hashCode码；
返回值类型是int型；
277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
