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