1. Object类
1)Object 类是类层次结构的根类,其他所有的类都直接或者间接地继承Object类。
2)Object类的构造方法只有一个且为无参构造方法。
3)方法:
a. toString() 返回对象的字符串表示,默认是由类的全路径+‘@’+hascode的十六进制表示。一般子类都会重写该方法。用eclipse可以自动生成toString方法。
class People{
private int age = 10;
@Override
public String toString() {
return "People [age=" + age + "]";
}
}
b. equals()
比较两个对象是否相同,默认比较的是地址值是否相等。一般子类也会重写该方法。
class People{
private int age = 10;
@Override
public String toString() {
return "People [age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
People other = (People) obj;//向下转型,将obj 转成 People的类对象,用于下面age参数的调用比较。
if (age != other.age)
return false;
return true;
}
}
c. hasCode() 返回对象的hashcode,类似于地址编号,但并不是实际地址值。
d. getClass() 返回对象的字节码文件对象。
e. finalize() 用于垃圾回收,再不确定的时间。
f. clone() 可以实现对象的克隆,包括成员变量的数据复制。它和两个引用指向同一个对象有区别。
2. == 和 equals()的区别
==:基本类型–值
引用类型–地址
equals():只能比较引用类型。默认比较的是地址值是否相同。子类中可以重写该方法以适应需求。
3. Scanner
构造方法:
InputStream is = System.in
Scanner(InputStream is)
常用格式:
Scanner sc = new Scanner(System.in);
基本方法格式:
1).hasNextXxx() 判断是否是某种类型的
2).nextXxx() 返回某种类型的元素
常用的方法:
nextInt(): 获取int类型的值
nextLine():获取一个String类型的值
nextInt() 和nextLine()使用时要注意:
先获取一个数值,再获取一个字符串,会出现问题。
解决:
1)先获取一个数值,再创建一个Scanner对象,再用新的Scanner对象获取字符串。
Scanner sc = new Scanner(System.in);
Scanner sc1 = new Scanner(System.in);
int a = sc.nextInt();
String b = sc1.nextLine();
System.out.println("a:"+a+"b:"+b);
输出:
11
asd
a:11b:asd
2)把所有的数据都先按照字符串获取,然后再对应转换
4. String类
字符串是由多个字符组成的一串数据。也可看做字符数组。
特点:
1)字符串是常量,创建后不可改变。
2)字符串字面值"abc"也可以看成是一个字符串对象。
常用构造方法:
public String()无参构造
public String(byte[ ] bytes)把字节数组转成字符串
public String(byte[ ] bytes,int offset,int length)把字节数组的一部分转成字符串(int offset代表从截取字符串的第一个字符的下标,int length代表截取的字符个数)
public String(char[ ] value)把字符数组转成字符串
public String(char[ ] value,int offset,int length)把字符数组的一部分转成字符串(int offset代表从截取字符串的第一个字符的下标,int length代表截取的字符个数)
public String(String original)把字符串常量值转成字符串
public int length() 返回此字符串的长度
byte[] byt = {101,102,123};
String s = new String(byt);
System.out.println(s);
输出:ef{
理解:
1)字符串赋值内存图解:
字符串不能被改变,指的是它的值不能被改变,比如“abc”,比如上图中的“hello”,“world”…
2)String s = new String(“hello”) 和 String s = "hello"的区别:
3)字符串如果是变量相加,先开空间,再拼接;字符串如果是常量相加,先拼接,然后到常量池找,如果有就直接返回,没有就创建再返回。
String s1 = "hello";
String s2 = "world";
String s3 = "helloworld";
System.out.println(s3 == s1 + s2);
System.out.println(s3.equals(s1+s2));
System.out.println(s3 == "hello" + "world");
System.out.println(s3.equals("hello" + "world"));
输出:
false
true
true
true
判断功能:
boolean equals(object obj) 比较字符串内容是否相同
boolean equalsIgnoreCase(String str) 比较字符串时不区分大小写
boolean contains(String str) 判断字符串中是否包含特定子字符串
boolean startsWith(String str)判断是否以某个子字符串开头
boolean endsWith(String str)判断是否以某个字符串结尾
boolean isEmpty()判断字符串内容是否为空(注意要区别字符串内容为空String s = ""和字符串对象为空String s = null; 如果字符串对象为空那么便不能调用方法,如果调用就会报错)
获取功能:
int length() 获取字符串长度
char charAt(int index) 获取某个索引的字符
int indexOf(int ch)获取某个字符在字符串中第一次出现的索引(‘a’和97都可以代表‘a’)
int indexOf(String str)获取某个子字符串在字符串中第一次出现的索引(包含指定索引)
int indexOf(int ch,int fromIndex)获取指定字符从指定位置往后第一次出现的索引(包含指定索引)
int indexOf(String str, int fromIndex)获取指定字符串从指定位置往后第一次出现的索引
String substring(int start)从指定位置开始截取字符串,默认到末尾(含start)
String substring(int start,int end)从指定位置开始到指定位置结束截取字符串。(含start,不含end)
转换功能:
byte[ ] getBytes() 把字符串转为字节数组
char[ ] toCharArray() 把字符串转为字符数组
static String valueOf(char[ ] chs) 把字符数组转为字符串(通过静态方法)
static String valueOf(int i)把整数转为字符串(通过静态方法)
String toLowerCase()将字符串中的字符转成小写的生成一个新的字符串
String toUpperCase()将字符串中的字符转成大写的生成一个新的字符串
String concat(String str)把字符串拼接
char[] chs = {'a','b','c'};
String newS = String.valueOf(chs);
System.out.println(newS);
System.out.println(newS.toUpperCase());
System.out.println(newS.concat("LOVE"));
byte[] byt0 = newS.getBytes();
for(int x = 0; x<byt.length;x++){
System.out.println(byt0[x]);
}
输出结果:
abc
ABC
abcLOVE
97
98
99
案例–将字符串首字母大写其他小写:
String s = "helloWORLD";
String newS = s.substring(0,1).toUpperCase().concat(s.substring(1).toLowerCase())
其他功能:
String replace(char old, char new)将字符串中的指定字符替换为新的字符
String replace(String old, String new)将字符串中的指定字符串替换为新的字符串
String trim()去除字符串两端的空格
int compareTo(String str) 按照字典顺序比较两个字符串,
int compareToIgnoreCase(String str)按照字典顺序比较两个字符串
注:compareTo先遍历两个字符串,如果其中一个已经遍历结束,还没有出现有不相同的字符,那么返回的就是两个字符串长度的差值,外字符串长-内字符(括号内被当做参数的字符串)串长,如果在此之前出现不同的字符,那么就比较这两个字符在字典中的大小(字母表中排序越靠后越大),并返回差值。
compareTo 源码:
public int compareTo(String anotherString) {
int len1 = value.length;
int len2 = anotherString.value.length;
int lim = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;
int k = 0;
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
return len1 - len2;
}
5. StringBuffer类
线程安全的可变字符串。
String和StringBuffer的区别:
String:长度和内容不可变。字符串拼接浪费空间。
StringBuffer:长度和内容可变。字符串拼接不会造成过多浪费。
安全–同步–数据不安全
不安全–不同步–效率高一些
构造方法:
public StringBuffer();
public StringBuffer(int capacity);指定容量的字符串缓冲去对象
public StringBuffer(String str);指定字符串内容的字符串缓冲区对象
方法:
public int capacity();返回当前容量,理论值
public int length();返回长度(字符数),实际值
StringBuffer sb = new StringBuffer("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
//sb = ;
System.out.println(sb.capacity());
System.out.println(sb.length());
输出:
47 //16+length();16+31 = 47
31
添加功能:
public StringBuffer append(String str):
可以把任意类型的数据添加到字符串缓冲区中,并返回字符串缓冲区本身。
public StringBuffer insert(int offset, String str) 在指定位置将指定类型的数据插入字符串缓冲区里面。返回字符串缓冲区本身。
删除功能:
public StringBuffer delete(int start, int end) 删除指定开始位置到指定结束位置的字符,并返回字符串缓冲区本身(包左不包右)
public StringBuffer deleteCharAt(int index) 删除指定位置的字符,并返回字符串缓冲区本身
替换功能:
StringBuffer replace(int start, int end, String str) 用指定的String中的字符替换此序列的子字符串中的String 。 子串开始于指定start并延伸到字符索引end - 1 ,或如果没有这样的字符存在的序列的结束。
反转功能:
StringBuffer reverse() 将字符串缓冲区中的字符倒序
截取功能:
String substring(int start) 返回一个截取的新的字符串,而字符串缓冲区本身不变,从start一直截取到末尾
String substring(int start, int end) 返回一个截取的新的字符串,而字符串缓冲区本身不变,从start一直截取到end-1
String和StringBuffer的相互转换:
String toString() 将StringBuffer转成String类型
StringBuffer(String str)将String转成StringBuffer类型
StringBuilder类
一个可变的字符序列。 此类提供与StringBuffer的API,但不保证同步。 此类设计用作简易替换为StringBuffer在正在使用由单个线程字符串缓冲区的地方(如通常是这种情况)。 在可能的情况下,建议使用这个类别优先于StringBuffer ,因为它在大多数实现中将更快。
String,StringBuffer和StringBuilder的区别:
String的内容是不可变的,而StringBuffer和StringBuilder都是内容可变的。
StringBuffer是同步的,数据安全,效率低;
StringBuilder是不同步的,数据不安全效率高。
StringBuffer和数组的区别:
两者都可以看做是一个容器,StringBuffer的数据最终是一个字符串数据。而数组可以放多种类型的数据,但必须是同一个数组中必须放同一种数据。
String和StringBuffer作为参数传递:
基本类型:形式参数的改变不影响实际参数
引用类型:形式参数的改变直接影响实际参数
注:String 作为参数传递,效果和基本类型作为参数传递是一样的。
public class StringBufferDemo {
public static void main(String[] args) {
StringBuffer sb0 = new StringBuffer("hello");
StringBuffer sb1 = new StringBuffer("world");
System.out.println("sb0:"+sb0+sb0.hashCode());
System.out.println("sb1:"+sb1+sb1.hashCode());
System.out.println("============================");
change(sb0,sb1);
System.out.println("============================");
System.out.println("sb0:"+sb0+sb0.hashCode());
System.out.println("sb1:"+sb1+sb1.hashCode());
}
public static void change(StringBuffer sb0, StringBuffer sb1){
sb0 = sb1;
sb1.append(sb0);
System.out.println("sb0:"+sb0+sb0.hashCode());
System.out.println("sb1:"+sb1+sb1.hashCode());
}
}
输出:
sb0:hello9949215
sb1:world14721926
============================
sb0:worldworld14721926
sb1:worldworld14721926
============================
sb0:hello9949215
sb1:worldworld14721926