黑马程序员——java-几个常用的类（Object，Scanner，String，StringBuffer/StringBuilder）

Object类层次结构的根类，所有的类都直接或间接的继承自该类

Object类中常用的方法

public String toString()---//返回该对象的字符串表示
public final Class  getClass()---返回的是字节码对象//反射时候用到
public boolean equals(Object obj)--指示其他某个对象是否与此对象“相等”。
protected void finalize()-----当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法
public int hashCode()----返回地址值

重要的方法:

---public String toString()

返回对象的字符串表达形式--getClass().getName() + '@' + Integer.toHexString(hashCode())

一般输出对象（s）的引用的时候，默认输出的都是该引用调用的toString()方法 （s.toString() )

一般都重写此方法。重写的时候，不用自己添加，快捷键Alt+Shift+s，然后点击toString()即可。

package importMethod;

class Persion// 定义一个Persion类
{
public String name;
public int age;

public Persion(String name, int age)// 带参数的构造方法
{
this.name = name;
this.age = age;
}

@Override
public String toString()//重写Object类的该方法
{
return "Persion [name=" + name + ", age=" + age + "]";
}

}

public class ObjectDemo
{
public static void main(String[] args)
{
Persion persion = new Persion("袁郎", 25);// 创建Persion对象
//System.out.println(persion);// 打印Persion对象（看结果）
// 输出的结果是：importMethod.Persion@56bf1a4a（说明给Persion类没有重写toString()方法）

System.out.println(persion);// 打印Persion对象（看结果）
//输出结果为：Persion [name=袁郎, age=25]（因为Persion类重写了toString()方法）
}

}

---public boolean equals(Object obj)

==的作用
--比较基本类型，比较的是基本类型的值是否相同
--比较引用类型，比较的是引用类型的地址值是否相同
默认情况下Object的equals方法比较的是对象的地址值是否相同
所以如果要比较对象的值是否相同，需要重写equals方法，也不用手动添加，有快捷键

---对象 instanceof 类名（判断，该对象是否是该类的一个对象）

用法：用于接受用户键入的数据
构造方法：--public Scanner(InputStream source)

Scanner in =new Scanner(System.in)；

解释这个构造方法中的参数问题：
System类中有一个成员变量in，是静态修饰的：如下
public static final InputStream in；
所以：System.in调用后返回的是一个InputStream 字节输入流的对象（详情看IO流那一节）

Scanner类中的重要方法：

--public byte nextByte()//接受字节
--public int nextInt()//接受int类型
--public long nextLong()//接受long类型
--public float nextFloat()//接受float类型
--public double nextDouble()//接受double类型
--public short nextShort()//接受short类型
--public String nextLine()//接受String类型

package importMethod;

import java.util.Scanner;

public class ScannerDemo
{
private void mian()
{
Scanner in =new Scanner(System.in);//定义一个扫面器对象
System.out.println("请输入一个整数");

int a=in.nextInt();//接受数据
System.out.println("输入的数是："+a);//输出数据
}

}

小问题----连续的先接受一个int在接受一个String时候在输入一个int值后，int值默认后边还有\n,此时 会\n当做String赋值
int i=sc.nextInt();String s=sc.nextLine();
解决方法；
---A在int值接受结束后再，重新定义一个Scanner 对象用于接受String

package importMethod;

import java.util.Scanner;

public class Scannerproblem
{
public static void main(String[] args)
{
Scanner s=new Scanner(System.in);

int a=s.nextInt();
Scanner i=new Scanner(System.in);//接受一个int类型的数据后，重新定义扫描器
String string=i.nextLine();//在接受一个String类型的数据

System.out.println(a);
System.out.println(string);
}

}

---B 把所有的数据都用字符串接受，然后要什么类型就转成什么类型（用到String类）

package importMethod;

import java.util.Scanner;

public class Scannerproblem
{
public static void main(String[] args)
{
Scanner i =new Scanner(System.in);

String s=i.nextLine();
//在接受一个String类型的数据，把所有数据都用String接受
//在输出的时候，需要什么类型，就转成什么类型

System.out.println(s.valueOf(s));

}

}

构造方法：
A--String()
B--String(byte[] bytes) 把字节数组转成字符串
C--String(byte[] bytes, int index, int length)把字节数组的一部分转成字符串
D--String(char[] value) 把字符数组转成字符串
E--String(char[] value, int indexint count) 把字符数组的一部分转成字符串
F--String(String original) 把字符串转成字符串

package com.itheima;

/*
* 构造方法：
A--String()
B--String(byte[] bytes) 把字节数组转成字符串
C--String(byte[] bytes, int index, int length)把字节数组的一部分转成字符串
D--String(char[] value) 把字符数组转成字符串
E--String(char[] value, int indexint count) 把字符数组的一部分转成字符串
F--String(String original) 把字符串转成字符串
*/
public class string_Demo {
public static void main(String[] args) {
// A--String()
String s = new String();
System.out.println("s 对象的长度为：" + s.length());

// String(char[] value) 把字符数组转成字符串
char[] ch = new char[] { 'e', 'd', 'c', 'b', 'a' };
String bs = new String(ch);// 把字符数组转成字符串
String bs1 = new String(ch, 0, 2);// 把字符数组的一部分转成字符串
System.out.println(bs);

// String(String original) 把字符串转成字符串
System.out.println(new String(new String("赵云！")));// 把字符串转成字符串

}

}

字符串的特点：一但被赋值，它的值就不能被改变（但是字符对象的引用所指向的地址是可以改变的）
字符串的本质就是一个字符数组（数组的特点，长度是固定的）
例子：
String s="hello";
s+="world";
System.out.println(s);//输出的值是：helloworld

面试题1
String s=new String("hello")和String s1="hello"的区别？
s==s1(false)比较的是地址 s.equals(s1)(true)比较的是内容
画内存图可以解释
![这里写图片描述](https://img-blog.csdn.net/20150428103348930)

面试题2
String s1="hello"
String s2="world"
String s3="helloworld"
s3.equals(s1+s2)//true

s3==s1+s2//false  字符变量相加，先开空间在相加存储
s3=="hello"+"world"//true  字符常量相加，先相加，再在常量池中找如果有，就返回常量池的地址，否则在开空间，返回地址

String的方法（判断方法）
A--public boolean equals(Object anObject)
比较字符串的内容是否相同，区分大小写
B--public boolean equalsIgnoreCase(String anotherString)
按字典顺序比较两个字符串，不考虑大小写

C--public boolean contains(CharSequence s)
判断字符串中是否包含指定的字符
D--public boolean endsWith(String suffix)
判断是否是以指定的字符结尾
E--public boolean startsWith(String prefix,int toffset)
判断是否是以指定的字符开头

F--public boolean isEmpty()
判断字符串是否为空
String s=""
s.idEmpty()//结果为true
String s="null"
s.idEmpty()//这样写要报错，空对象，就是没有对象，没有对象就不能调用方法

package com.itheima;

/*String 的判断方法：
*  A--public boolean equals(Object anObject)
比较字符串的内容是否相同，区分大小写
B--public boolean equalsIgnoreCase(String anotherString)
按字典顺序比较两个字符串，不考虑大小写
C--public boolean contains(CharSequence s)
判断字符串中是否包含指定的字符
D--public boolean endsWith(String suffix)
判断是否是以指定的字符结尾
E--public boolean startsWith(String prefix,int toffset)
判断是否是以指定的字符开头
F--public boolean isEmpty()
判断字符串是否为空
*/
public class string2 {
public static void main(String[] args) {
String s1 = "Hello";
String s2 = "hello";

System.out.println(s1.equals(s2));// 结果为false，次方法比较大小写
System.out.println(s1.equalsIgnoreCase(s2));// 结果为true。次方法不区分大小写
System.out.println(s1.contains("ello"));//结果为true ,包含指定的字符
System.out.println(s1.startsWith("He"));//结果为true,以指定的字符开头
System.out.println(s1.endsWith("lo"));//结果为true,以指定的字符结尾
System.out.println(s1.isEmpty());//结果为false,字符串为空

}

}

String的方法（获取功能）
A--public int length()//返回字符串的长度
B--public char charAt(int index)//返回指定索引处的字符
C--public int indexOf(int ch)//返回指定字符在字符串中第一次出现的索引
D--public int indexOf(int ch,int fromIndex)
//获取ch这个字符在该字符串中的指定索引后第一次出现的索引
E--public int indexOf(String str,int fromIndex)
//获取str字符串在该字符串中从指定索引后第一次出现的索引

F--public int indexOf(String str)//获取指定字符串在字符串中第一次出现的索引

G--public String substring(int beginIndex)
//获取字串，从指定索引到结尾
H--public String substring(int beginIndex,int endIndex)
//获取字
e1bb
串，从beginIndex到endIndex（牢记，获取的字串包括左边，不包括右边）

package com.itheima;

/*
*    A--public int length()//返回字符串的长度
B--public char charAt(int index)//返回指定索引处的字符
C--public int indexOf(int ch)//返回指定字符在字符串中第一次出现的索引
D--public int indexOf(int ch,int fromIndex)
//获取ch这个字符在该字符串中的指定索引后第一次出现的索引
E--public int indexOf(String str,int fromIndex)
//获取str字符串在该字符串中从指定索引后第一次出现的索引

F--public int indexOf(String str)//获取指定字符串在字符串中第一次出现的索引

G--public String substring(int beginIndex)
//获取字串，从指定索引到结尾
H--public String substring(int beginIndex,int endIndex)
//获取字串，从beginIndex到endIndex（牢记，获取的字串包括左边，不包括右边）
*/
public class String3 {
public static void main(String[] args) {

String s = "heallo,java";
System.out.println(s.length());// 返回字符串的长度
System.out.println("s字符串中，下标为2处的字符为：" + s.charAt(1));// 获取：下标为2处的字符
System.out.println(s.indexOf("jav"));// 返回指定字符在字符串中第一次出现的索引
System.out.println(s.indexOf("a", 3));// 获取ch这个字符在该字符串中的指定索引后第一次出现的索引

System.out.println(s.substring(2));// 结果为：allo,java--获取字串，从指定索引到结尾
System.out.println(s.substring(0, 3));// 结果为：hea---（牢记，获取的字串包括左边，不包括右边
}

}

String的遍历
通过A--public int length()方法和B--public char charAt(int index)方法可以遍历String

package com.itheima;

public class string4 {
public static void main(String[] args) {
String s="androd,java";
//字符串的遍历：两个方法的结合
/*
* 通过A--public int length()方法
* B--public char charAt(int index)方法可以遍历String
*/
for (int i = 0; i < s.length(); i++) {
System.out.println(s.charAt(i));

}

}

}

String的方法（转换功能）

byte[] getByteds()把字符串转成字节数组
char[] toCharArray()把字符串转成字符数组
static String copyValueOf(char[] chs)把字符数组转成字符串
static String valueOf(char[] chs)把字符数组转成字符串
static String valueOf(int i)基本类型，把基本类型转成字符串
String toLowerCase()把字符串转成小写
String toUpperCase()把字符串转成大写
String concat(String str)字符串拼接

package importMethod;

public class StringDemo
{
public static void main(String[] args)
{
/*
* String的方法（转换功能）
*
* byte[] getByteds()把字符串转成字节数组 char[] toCharArray()把字符串转成字符数组
*
* static String copyValueOf(char[] chs)把字符数组转成字符串 static String
* valueOf(char[] chs)把字符数组转成字符串 static String valueOf(int
* i)基本类型，把基本类型转成字符串
*
* String toLowerCase()把字符串转成小写 String toUpperCase()把字符串转成大写 String
* concat(String str)字符串拼接
*/

String s = "java-android";

byte[] bys = s.getBytes();// 把字符串转成字节数组
System.out.println("此数组bys的长度是：" + bys.length);

char[] ch = s.toCharArray();// 把字符串转成字符数组
System.out.println("此数组ch的长度是：" + ch.length);

char[] ch1 = new char[]
{ 'a', 'n', 'd', 'r', 'o', 'i', 'd' };
System.out.println(String.valueOf(ch1));// 把字符数组转成字符串
System.out.println(String.copyValueOf(ch1));// 把字符数组转成字符串

int a = 100;
System.out.println(String.valueOf(a));// 基本类型，把基本类型转成字符串

String string = "java AND android";
System.out.println(string.toUpperCase());// 把字符串转成大写---JAVA AND ANDROID
System.out.println(string.toLowerCase());// 把字符串转成小写---java and android

String s1 = "hello", s2 = "java";

System.out.println(s1.concat(s2));// 字符串拼接-----hellojava

}

}

copyValueOf(char[] chs)和 valueOf（）的区别？

--copyValueOf(char[] chs)只把字符数组转成string
-- valueOf（）可以把任意类型转成String

String的方法（替换功能）
A--public String replace(char oldChar,char newChar)
把字符串中所有oldChar的字符替换为newChar
B--public String replace(String oldChar,String newChar)

String trim()该方法是，去除字符串两端的空格

package importMethod;

/*
* A--public String replace(char oldChar,char newChar)
把字符串中所有oldChar的字符替换为newChar
B--public String replace(String oldChar,String newChar)
c--public String replace(CharSequence target,CharSequence replacement)

target - 要被替换的 char 值序列
replacement - char 值的替换序列

c---String trim()该方法是，去除字符串两端的空格

*/
public class string_tihuan
{
public static void main(String[] args)
{
String olds="   java_an   droid   ";
String news="hello";
System.out.println(olds.replace(olds, news));//结果----hello
System.out.println(olds.replace(news, olds));//结果---   java_an   droid
System.out.println(news.replace("l", "mm"));//结果----hemmmmo
System.out.println(olds.trim());//结果为----java_an   droid只能去除两端的空格
}

}

(1)字符串缓冲区类。
(2)String,StringBuffer/StringBuilder的区别?
A:String的字符串长度固定。而StringBuffer/StringBuilder的字符串长度是可以改变的。
B:StringBuffer是线程安全的，效率低。
StringBuilder是线程不安全的，效率高。
(3)构造方法：
A:StringBuffer sb = new StringBuffer();//没有参数的构造方法，其初始容量为16
B:StringBuffer sb = new StringBuffer(50);//带参数的，初始容量为指定的值
C:StringBuffer sb = new StringBuffer("hello");//初始容量为String.length()+16
(4)成员方法：
public int capacity()//获得理论值
public int length()//获得字符串中的实际长度
A:添加功能
append

StringBuffer操作后，如果返回的是StringBuffer类型，实质返回的是本身对象
StringBuffer sb=new StringBuffer();
StringBuffer s1=sb.append("hello");
StringBuffer s2=sb.apped("world");
s1==s2//true   返回的是true，说明s1和s2同一个对象
所以，可以改为，sb.append("hello").append("world");链式操作

public StringBuffer insert(int offset,char c)
在指定位置上插入字符，以前位置上的字符先后移动

B:删除功能
public StringBuffer delete(int start,int end)
删除从start到end的字符
public StringBuffer deleteCharAt(int index)
删除指定位置的字符
C:替换功能
public StringBuffer replace(int start,int end,String str)
把从[start,end)包左不包右的字符全部替换为str

D:截取功能
public String substring(int start)
public CharSequence subSequence(int start,int end)包左不包右

E:反转功能
public StringBuffer reverse()//"你爱我"----->“我爱你”

package importMethod;

/*
*       public int capacity()//获得理论值
public int length()//获得字符串中的实际长度
A:添加功能
append

StringBuffer操作后，如果返回的是StringBuffer类型，实质返回的是本身对象
StringBuffer sb=new StringBuffer();
StringBuffer s1=sb.append("hello");
StringBuffer s2=sb.apped("world");
s1==s2//true   返回的是true，说明s1和s2同一个对象
所以，可以改为，sb.append("hello").append("world");链式操作

public StringBuffer insert(int offset,char c)
在指定位置上插入字符，以前位置上的字符先后移动

B:删除功能
public StringBuffer delete(int start,int end)
删除从start到end的字符（包左不包右）
public StringBuffer deleteCharAt(int index)
删除指定位置的字符
C:替换功能
public StringBuffer replace(int start,int end,String str)
把从[start,end)包左不包右的字符全部替换为str

D:截取功能
public String substring(int start)
public CharSequence subSequence(int start,int end)包左不包右

E:反转功能
public StringBuffer reverse()//"你爱我"----->“我爱你”
*/

public class stringBufferDemo
{
public static void main(String[] args)
{
StringBuffer sb = new StringBuffer("android_i am coming!");

System.out.println("字符串的实际长度为：" + sb.length() + " |加上16就是总容量： " + sb.capacity());
// 结果为：字符串的实际长度为：20 |加上16就是总容量： 36

StringBuffer sb1 = new StringBuffer();// 添加功能
sb1.append("android").append(" ").append("hello");
System.out.println(sb1);// 结果为：android hello

// 在指定位置上插入字符，以前位置上的字符先后移动
System.out.println(sb1.insert(2, 'M'));// 结果为：anMdroid hello

// 删除指定位置的字符
System.out.println(sb1.deleteCharAt(0));// 结果为：nMdroid hello
// 在指定位置上插入字符，以前位置上的字符先后移动
System.out.println(sb1.delete(0, 2));// 结果为：droid hello--注意：（包左不包右）

// 替换功能
System.out.println(sb1.replace(0, 2, "MH"));// 结果为：MHoid
// hello--注意：（包左不包右）

// 截取功能
System.out.println(sb1.substring(4));// 结果为：d hello
System.out.println("没有截取之前sb1为：" + sb1 + "截取之后为：" + sb1.substring(0, 4));// 结果为：MHoi

// 反转功能
System.out.println("没有翻转之前sb1为：" + sb1 + "翻转之后为：" + sb1.reverse());
// 结果为：没有翻转之前sb1为：MHoid hello翻转之后为：olleh dioHM
}

}

String和StringBuffer的相互转化:

String------->StringBuffer
String s="hello";
方式一： StringBuffer的构造方法
StringBuffer sb=new StringBuffer(s);
方式二： StringBuffer的append（）方法
StringBuffer sb=new StringBuffer();
sd.append(s);//public StringBuffer append(String str)

StringBuffer------->string
StringBuffer sb=new StringBuffer(“hehe”);
方式一：String的构造方法
String s=new String（sb）；
方式二：StringBuffer的toString（）方法
String s=sb.toString();////public String toString()