java复习第十一天常用类和API的用法

最新推荐文章于 2024-05-04 19:16:54 发布

郭首志

最新推荐文章于 2024-05-04 19:16:54 发布

阅读量179

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/a331685690/article/details/79943256

版权

java 专栏收录该内容

70 篇文章 1 订阅

订阅专栏

java开发工具Eclipse使用手册

注意：打开eclipse的第一件事情去更改工作空间的编码，改成UTF-8，因为现在普遍默认使用的编码都是UTF-8

1.eclipse可以去www.eclipse.org去下载
2.下载完成之后不需要安装，直接解压即可使用；强烈的建议你将eclipse.exe发送到桌面快捷方式；然后双击运行
3.选择你代码存放的工作空间，以后写的代码都放在这个文件夹中了，你们学习阶段可以放在一个文件夹中
4.更改工作空间的配置：
Window-》Preferences-》General-》Workspace-》选择UTF-8编码，最后点击OK
Window-》Preferences-》General-》APPearance-》Colors and Fonts-》Basic-》Text font-》双击打开编辑，选择你想要的字体和大小
Window-》Preferences-》General-》keys-》搜索run java Application-》改成你想要的快捷键
5.新建工程
右击Project Explorer-》选择new-》Project-》Java Project
src：存放源代码的，在src底下创建包的
6.运行代码
在包含main方法的类中右击鼠标，选择run as-》Java Application
7.快捷键
Ctrl+1：万能键
Ctrl+O：快速查找方法
Ctrl+T：查看选中类的继承体系
Ctrl+/：加上或者取消单行注释
Ctrl+M：最大化和最小化代码窗口
Ctrl+D：删除当前选中的行
Ctrl+N：新建创建打开
Ctrl+W：关闭当前代码窗口
Ctrl按着不要放+鼠标左击或直接按F3：查看源代码
Ctrl+Shift+O：导入需要的包，删除无用的包
Ctrl+Shift+F：自动格式化代码，一般会和你的输入法快捷键冲突
Ctrl+Shift+/：多行注释
Ctrl+Shift+\：取消多行注释
Ctrl+Shift+T：全局查找指定的类
Ctrl+Shift+W：关闭所有的代码窗口
Ctrl+Shift+X：所选字母转大写
Ctrl+Shift+Y：所选字母转小写
Ctrl+Alt+↑↓：复制当前行的内容，你一定要把你的显卡快捷键禁用了，不然你的屏会颠倒
Alt+↑↓：移动当前行
Alt+/：代码提示补全
Alt+Shift+M：将选中的代码封装成方法
Alt+Shift+S：自动生成快捷菜单
Shift+Enter：在下面新建一行
8.波浪线含义
黄色波浪线是警告的意思，不影响运行，一般无视
红色波浪线是错误的意思，不处理就无法运行程序
9.工程的导出和导入
导出：选中指定的工程，赋值，粘贴
导入：右击Project Explorer-》import-》General-》existing projects...-》选中要导入的工程-》

一定要勾选copy projects into workspace

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
Object构造方法：
Object() 因为所有的子类默认都会访问父类的无参构造方法
Object类常用方法：

1.protected void finalize() 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法

public class Test7 {
	public static void main(String[] args) throws Exception {
		Person p = new Person();
		 System.out.println(p.name);
		 p = null;//将堆内存中的对象置为没有引用指向
		System.out.println("--------------------------------------");	        
	}
}
class Person  {
	public String name = "张三";
	public int age = 18;
	public Object obj = new Object();
}

2.public int hashCode() 返回该对象的哈希码值，哈希值默认是由对象的地址值计算得来的，可以代表对象的地址值

public class Test7 {
	public static void main(String[] args) throws Exception {
		Person p = new Person();
		// public int hashCode() 返回该对象的哈希码值，哈希值是默认由对象的地址值计算得来的，可以代表对象的地址值
		Person p2 = new Person();// Person默认的哈希值就是由地址值计算得来的
		// ==比较的是两个对象的地址值
		System.out.println(p == p2);// false
		System.out.println(p.hashCode());// 366712642
		System.out.println(p2.hashCode());// 1829164700
		String s = new String("哈哈");
		String s2 = new String("哈哈");
		// ==比较的是两个对象的地址值
		System.out.println(s == s2);// false
		// String类重写了Object的hashCode方法，String的哈希值是由内容计算得来的
		System.out.println(s.hashCode());// 694528
		System.out.println(s2.hashCode());// 694528
	}
}

class Person {
	public String name = "张三";
	public int age = 18;
	public Object obj = new Object();

}

3.public Class getClass() 返回此 Object 的运行时类

public class Test7 {
	public static void main(String[] args) throws Exception {
		Person p = new Person();
		Person p2 = new Person();
		/* public Class getClass() 返回此 Object 的运行时类
		 * java语言中可以将任何一个事物都封装成类，那么一个java类(类名，成员变量，成员方法，包名，实现的接口，继承的类)也可以被封装成类，
		 * 这个类就是Class
		 */
		/*
		 * clazz表示的就是Person的字节码文件对象，也就是方法区中的Person.class对象
		 * 每个字节码文件对象在内存中都是唯一的，因为每个字节码文件只会被类加载器加载一次
		 */
		Class clazz = p.getClass();
		Class clazz2 = p2.getClass();
		System.out.println(clazz == clazz2);// true
		// public String getName()以 String 的形式返回此 Class 对象所表示的实体全包名名称
		System.out.println(clazz.getName());// cn.edu360.Person
		// public String getSimpleName()返回源代码中给出的底层类的简称
		System.out.println(clazz2.getSimpleName());// Person
	}
}

class Person  {
	public String name = "张三";
	public int age = 18;
	public Object obj = new Object();
}

4.public String toString() 返回该对象的字符串表示

public class Test7 {
	public static void main(String[] args) throws Exception {
		Person p = new Person();	
		Person p2 = new Person();
		// public String toString() 返回该对象的字符串表示
		// println会默认调用一个对象的toString方法
		System.out.println(p);// Person [name=张三, age=18]
		// Object类的toString方法默认实现：getClass().getName() + "@" +
		System.out.println(p.toString());// Person [name=张三, age=18]
		String s3 = new String("哈哈");
		// 因为String的toString方法被重写了
		System.out.println(s3.toString());// 哈哈
	}
}
class Person  {
	public String name = "张三";
	public int age = 18;
	public Object obj = new Object();
	// 我们不满意父类的toString方法实现，所以我们自己需要重写
	/*
	 * @Override//如果是重写的方法加上@Override不会报错 public String toString() { return
	 * "name="+name+",age="+age; }
	 */
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

}

5.public boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”

方法2
public class Test7 {
	public static void main(String[] args) throws Exception {
		Person p = new Person();
		Person p2 = new Person();//Person默认的哈希值就是由地址值计算得来的
		String s = new String("哈哈");
		String s2 = new String("哈哈");
		//public boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”
		//在java中一般用“==”比较地址值，用equals方法比较对象的内容
		//==比较的是地址值
		System.out.println(s==s2);//false
		//String类的equals方法默认比较的是内容
		System.out.println(s.equals(s2));//true
		System.out.println(p==p2);//false
		//Object类的equals方法默认比较的是地址值
		p.age = 19;
		System.out.println(p.equals(p2));//false
			
	}
}

class Person {
	public String name = "张三";
	public int age = 18;
	public Object obj = new Object();
	//我们不满意父类的equals方法实现，所以我们自己需要重写
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}

重写方法的方式不一样

方法1

public class Test7 {
	public static void main(String[] args) throws Exception {
		Person p = new Person();
		Person p2 = new Person();//Person默认的哈希值就是由地址值计算得来的
		String s = new String("哈哈");
		String s2 = new String("哈哈");
		//public boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”
		//在java中一般用“==”比较地址值，用equals方法比较对象的内容
		//==比较的是地址值
		System.out.println(s==s2);//false
		//String类的equals方法默认比较的是内容
		System.out.println(s.equals(s2));//true
		System.out.println(p==p2);//false
		//Object类的equals方法默认比较的是地址值
		p.age = 19;
		System.out.println(p.equals(p2));//false
			
	}
}
//如果此对象的类不能实现接口 Cloneable，则会抛出 CloneNotSupportedException
class Person implements Cloneable{
	public String name = "张三";
	public int age = 18;
	public Object obj = new Object();
	//我们不满意父类的equals方法实现，所以我们自己需要重写
	@Override
	public boolean equals(Object obj) {
		//我们要比较两个对象的成员变量内容是否相等
		if(null==obj){//如果obj为空，直接返回false
			return false;
		}else if(!(obj instanceof Person)){//如果obj不是Person类型，直接返回false
			return false;
		}else if(getClass()!=obj.getClass()){//如果this字节码文件和obj的字节码文件不一致，直接返回false
			return false;
		}
		//接下来比较obj的成员是否和this的成员一致
		Person p = (Person) obj;
		//先比较姓名，如果姓名相等再比较年龄；如果姓名不相等直接返回false
		return this.name.equals(p.name)?this.age==p.age:false;
	}
}

6.protected Object clone() 创建并返回此对象的一个副本

public class Test8 {
	public static void main(String[] args) throws Exception {
		Person p = new Person();
		//*了解*protected  Object clone() 创建并返回此对象的一个副本(浅克隆)
		//我想克隆p，就相当于在堆内存中又创建了一个Person对象
		Object obj = p.clone();
		System.out.println(obj);//Person [name=张三, age=19]
		Person p4 = (Person) obj;
		System.out.println(p==p4);//false
		//当对象的成员变量是一个引用变量时，浅克隆对象和原始对象使用的还是同一个变量的值
		System.out.println(p.obj==p4.obj);//true
		
	}
}
//如果此对象的类不能实现接口 Cloneable，则会抛出 CloneNotSupportedException
class Person implements Cloneable{
	public String name = "张三";
	public int age = 18;
	public Object obj = new Object();
	//想要具有克隆的能力，首先需要实现Cloneable接口，然后重写clone方法
	@Override
	protected Object clone() throws CloneNotSupportedException {
		//直接使用父类的克隆方法即可
		return super.clone();
	}	
}

7.被native修饰的方法，底层代码不是java语言的实现的，是由C或者C++实现的

8.Scanner类的使用

（1）

import java.util.Scanner;

/*
 * 我们使用Scanner的时候，一般是先使用hasNextXxx方法判断要接收的类型和输入的类型是否匹配，如果匹配再使用nextXxx方法接收
 * 比如我们想接收一个int类型的值：
 * 	可以先使用hasNextInt方法判断值是否匹配，如果匹配再使用nextInt接收
 */
public class ScannerDemo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个整数：");
		// InputMismatchException：输入的不匹配异常
		if (sc.hasNextInt()) {
			int i = sc.nextInt();
			System.out.println(i);
		} else {
			System.out.println("你输入的不是一个整数");
		}
	}
}

（2）

import java.util.Scanner;
/*
 * 比如我们输入的是123，但是按了回车键，那么在内存中的内容就是"123\r\n"，但是我们使用nextInt只接收了123，\r\n没有被接收，
 * \r\n就被后面的nextLine接收了，就会造成程序立马结束的假象
	怎么解决呢？
		可以将所有的数据统一用nextLine接收，然后再使用数据类型转型成对应的类型
 */
public class ScannerDemo2 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个整数：");
		if(sc.hasNextInt()){
			//可以将所有的数据统一用nextLine接收
			String s = sc.nextLine();
			//然后再使用数据类型转型成对应的类型
			int i = Integer.parseInt(s);//将字符串数字转换成整数
			System.out.println(i);
		}else{
			System.out.println("你输入的不是一个整数");
		}
		System.out.println("请输入一个字符串：");
		String s = sc.nextLine();
		System.out.println(s);
	}
}

9.StringBuilder 的使用

（1）

/*
 * StringBuilder概述：一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。
 * 该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。
 * 如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
 */
public class StringBuilderDemo {
	public static void main(String[] args) {
		// public StringBuilder()构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符
		StringBuilder sb = new StringBuilder();
		System.out.println(sb.length());//理论值：16	实际值：0
		
		// public StringBuilder(int capacity)构造一个不带任何字符的字符串生成器，其初始容量由 capacity 参数指定
		StringBuffer sb2 = new StringBuffer(32);
		System.out.println(sb2.length());//理论值：32	实际值：0
		
		// public StringBuilder(String str)构造一个字符串生成器，并初始化为指定的字符串内容
		StringBuilder sb3 = new StringBuilder("hello");
		System.out.println(sb3.length());//理论值：16 实际值：5
	}
}

（2）

public class StringBuilderDemo2 {
	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();
		
		// 添加功能
		// public StringBuilder append(String str)将指定的字符串追加到此字符序列
		sb.append("哈哈").append("呵呵").append("嘻嘻");//链式编程
		
		//可以通过toString方法取出值
		System.out.println(sb);//哈哈呵呵嘻嘻
		
		// public StringBuilder insert(int offset,String str)将字符串插入此字符序列中
		sb.insert(2, "吼吼");
		System.out.println(sb);//哈哈吼吼呵呵嘻嘻
		
		// 删除功能
		// public StringBuilder deleteCharAt(int index)删除指定索引对应的字符
		sb.deleteCharAt(0).deleteCharAt(0);
		System.out.println(sb);//吼吼呵呵嘻嘻
		
		// public StringBuilder delete(int start,int end)删除指定的子字符串，从start开始到end-1结束
		sb.delete(0, 2);
		System.out.println(sb);//呵呵嘻嘻
		
		// 替换功能
		// public StringBuilder replace(int start,int end,String str)将此字符串从start开始到end-1结束的子字符串替换为str子字符串
		sb.replace(2, 4, "哈哈哈哈哈哈");
		System.out.println(sb);//呵呵哈哈哈哈哈哈
		
		// 反转功能
		// public StringBuilder reverse()将此字符串反转
		sb.reverse();
		System.out.println(sb);//哈哈哈哈哈哈呵呵
		
		// 截取功能
		// public String substring(int start)从start开始截取到末尾
		String s = sb.substring(2);
		System.out.println(s);//哈哈哈哈呵呵
		System.out.println(sb);//哈哈哈哈哈哈呵呵
		
		// public String substring(int start,int end)从start开始到end-1结束截取子字符串
		s = sb.substring(6, 8);
		System.out.println(s);//呵呵
		System.out.println(sb);//哈哈哈哈哈哈呵呵

	}
}

10 。String 类的用法

（1）

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.Arrays;

/*
 * 	String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。 
	字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享
	
	字符串的底层实现就是一个字符数组，所以说字符串就是字符序列
	
	编码：就是把看的懂变成看不懂
	解码：就是把看不懂的变成看的懂的
 */
public class StringDemo {
	public static void main(String[] args) throws UnsupportedEncodingException {
		//获取平台默认字符集
		String name = Charset.defaultCharset().name();
		System.out.println(name);//UTF-8
		
		//public byte[] getBytes()使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
		byte[] bytes = "金三银四".getBytes();//使用UTF-8进行编码
		
		//Arrays.toString(数组名);遍历数组
		System.out.println(Arrays.toString(bytes));
		
		// public String(byte[] bytes)通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String
		String s = new String(bytes);//使用UTF-8进行解码
		System.out.println(s);//金三银四
		
		/*
		 *  public String(byte[] bytes,int offset,int length)
		 *  	bytes - 要解码为字符的 byte
				offset - 要解码的第一个 byte 的索引
				length - 要解码的 byte 数 
		 */
		System.out.println(bytes.length);//12
		s = new String(bytes,6,6);
		System.out.println(s);//银四
		
		// public String(char[] value)分配一个新的 String，使其表示字符数组参数中当前包含的字符序列
		char[] value = {'金','三','银','四'};
		s = new String(value);
		System.out.println(s);//金三银四
		
		/*
		 *  public String(char[] value,int offset,int count)
		 *  	value - 作为字符源的数组。
				offset - 初始偏移量。
				count - 长度。 
		 */
		System.out.println(value.length);//4
		s = new String(value,1,2);
		System.out.println(s);//三银
		
		// public String(String original)初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
		s = new String("哈哈");//首先在方法区中的常量池中开辟一个空间存放"哈哈"，然后再在堆内存中开辟一个空间将"哈哈"的值复制一份到堆内存中
		System.out.println(s);//哈哈
		
		String s2 ="哈哈";
		String s3 ="哈哈";
		//s2和s3指向的都是方法区中常量池中的"哈哈"
		System.out.println(s2==s3);//true
		System.out.println(s==s2);//false
	}
}

（2）

public class StringDemo2 {
	public static void main(String[] args) {
		//字符串是常量；它们的值在创建之后不能更改
		// 问s的结果是多少?
		String s = "hello";
		String temp = s;
		s += "world";//变量相加，内部使用的是StringBuilder容器来存放字符串，最终的值是在堆中
		//s = "hello"+"world";//常量相加，最终的值还是在方法区中的常量池中
		System.out.println(s);//helloworld
		System.out.println(s==temp);//false
		String s4 = "helloworld";
		System.out.println(s==s4);//false
		
		String s2 = "呵呵";
		String s3 = "呵呵";
		System.out.println(s2==s3);//true
	}
}

（3）

public class StringDemo3 {
	public static void main(String[] args) {
		//String s = new String("hello")和String s2 = "hello";的区别?
		
		//在内存中至少创建了两个“hello”对象，首先在常量池中创建一个"hello"，然后再在堆中开辟一个空间将常量池中的"hello"复制到堆中
		String s = new String("hello");
		
		//直接在常量池中找到"hello"然后将地址值赋值给s2
		String s2 = "hello";
		
		System.out.println(s==s2);//false
		System.out.println(s.equals(s2));//true
	}
}

（4）

//判断方法
public class StringDemo4 {
	public static void main(String[] args) {
		String s = "abcDEFg";
		// boolean equals(Object obj)将此字符串与指定的对象比较
		System.out.println(s.equals("ABCDEFG"));//false
		
		// boolean equalsIgnoreCase(String str)将此 String 与另一个 String 比较，不考虑大小写
		System.out.println(s.equalsIgnoreCase("abcdefg"));//true
		
		// boolean contains(String str)当且仅当此字符串包含指定的字符串时，返回 true
		System.out.println(s.contains("bc"));//true
		
		// boolean startsWith(String str)测试此字符串是否以指定的前缀开始
		System.out.println(s.startsWith("abc"));//true
		
		// boolean endsWith(String str)测试此字符串是否以指定的后缀结束
		System.out.println(s.endsWith("Fg"));//true
		
		// boolean isEmpty()当且仅当 length() 为 0 时返回 true
		System.out.println(s.isEmpty());//false
	}
}

（5）

/*
 * 获取方法
 * 
 * 数组获取长度：数组名.length
 * 字符串获取长度：字符串名.length()
 */
public class StringDemo5 {
	public static void main(String[] args) {
		String s = "今天天气真晴朗真";
		
		// int length()返回此字符串的长度
		System.out.println(s.length());//7
		
		// char charAt(int index)返回指定索引处的 char 值
		System.out.println(s.charAt(3));//气
		
		// int indexOf(char ch)返回指定字符在此字符串中第一次出现处的索引
		System.out.println(s.indexOf('气'));//3
		
		// int indexOf(char ch,int fromIndex)返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索
		System.out.println(s.indexOf('天'));//1
		//获取'真'第二次出现的索引位置
		//求出第一次出现的位置
		int index = s.indexOf('真');
		System.out.println(index);//第一次出现的位置：4
		//去掉第一次出现的位置
		index = s.indexOf('真', index+1);
		System.out.println(index);//第二次出现的位置：7
		
		// int indexOf(String str)返回指定子字符串在此字符串中第一次出现处的索引
		System.out.println(s.indexOf("气"));//3
		
		// int indexOf(String str,int fromIndex)返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
		System.out.println(s.indexOf("天"));//1
		//获取'真'第二次出现的索引位置
		//求出第一次出现的位置
		index = s.indexOf("真");
		System.out.println(index);//4
		//去掉第一次出现的位置
		index = s.indexOf("真", index+1);
		System.out.println(index);//7
		
		/*
		 *  String substring(int start)返回一个新的字符串，它是此字符串的一个子字符串。该子字符串从指定索引处的字符开始，直到此字符串末尾。
		 *  	beginIndex - 起始索引（包括）
		 */
		String s2 = s.substring(1);
		System.out.println(s);//今天天气真晴朗真
		System.out.println(s2);//天天气真晴朗真
		
		/*
		 *  String substring(int start,int end)返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符
		 *  	beginIndex - 起始索引（包括）
				endIndex - 结束索引（不包括）
				包含头，不包含尾
		 */
		int beginIndex = s.indexOf("真");
		int endIndex = s.length()-1;
		s2 = s.substring(beginIndex, endIndex);
		System.out.println(s);//今天天气真晴朗真
		System.out.println(s2);//真晴朗
	}
}

（6）

//转换方法
public class StringDemo6 {
	public static void main(String[] args) {
		String s = "今天天气好热";
		
		// byte[] getBytes()使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
		byte[] bytes = s.getBytes();
		System.out.println(bytes.length);//18
		
		// char[] toCharArray()将此字符串转换成字符数组
		char[] charArray = s.toCharArray();
		System.out.println(charArray.length);//6
		
		// static String valueOf(char[] chs)将字符数组转换成字符串
		String result = String.valueOf(charArray);
		System.out.println(result);//今天天气好热
		
		// static String valueOf(int i)将int类型的值转换成字符串
		System.out.println(String.valueOf(123));//123放在堆内存中
		System.out.println(123+"");//123放在方法区中的常量池中
		
		s = "AbcDeF";
		// String toLowerCase()将此字符串转换成小写
		System.out.println(s.toLowerCase());//abcdef
		System.out.println(s);//AbcDeF
		
		// String toUpperCase()将此字符串转换成大写
		System.out.println(s.toUpperCase());//ABCDEF
		System.out.println(s);//AbcDeF
		
		// String concat(String str)将此字符串和参数字符串拼接
		System.out.println("hello".concat("world"));//helloworld放在堆内存中
		System.out.println("hello"+"world");//helloworld放在方法区中的常量池中
	}
}

（7）

public class StringDemo7 {
	public static void main(String[] args) {
		// 替换方法
		String s = "你真菜，你菜的抠脚";
		// String replace(char old,char new)将此字符串中old的字符都用new字符替换
		String result = s.replace('菜', '*');
		System.out.println(result);//你真*，你*的抠脚
		
		// String replace(String old,String new)将此字符串中old的子字符串都用new的子字符串替换
		s = "你加我微信好不好，我给你钱";
		result = s.replace("微信", "**");
		System.out.println(result);//你加我**好不好，我给你钱
		
		// 去除字符串头尾空格方法
		// String trim()
		s = " 111 11  ";
		System.out.println(s);
		System.out.println(s.trim());
		
		// 按字典顺序比较两个字符串方法
		// int compareTo(String str)如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值
		System.out.println("abc".compareTo("aBC"));//32
		
		// int compareToIgnoreCase(String str)忽略大小写比较两个字符串的大小，如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值
		System.out.println("abc".compareToIgnoreCase("aBC"));//0
	}
}