JAVA每日作业day7.1-7.3小总结

ok了家人们前几天学了一些知识，接下来一起看看吧

一**.API**

Java 的 API （ API: Application( 应用 ) Programming( 程序 )
Interface(接口 ) ）
Java API 就是 JDK 中提供给我们使用的类，这些类将底层
的代码实现封装了起来，我们不需要关心这些类是如何
实现的，只需要学习这些类如何使用即可。
我们在每次查看类中的方法时，都打开源代码进行查
看，这种方式过于麻烦。其实，我们可以通过查帮助文
档的方式，来了解 Java 提供的 API 如何使用。

• 打开API帮助文档。
• 点击显示，找到索引，看到输入框。
• 在输入框里输入，然后回车。
• 看包。java.lang下的类不需要导包，其他需要。
• 看类的解释和说明。
• 看构造方法。
• 看成员方法

二**.Object****类**

2.1 Object****类概述

java.lang.Object 类是 Java 语言中的根类，每个类都使用
Object 作为超类。所有对象（包括数组）都实现这个类
的方法。
如果一个类没有特别指定父类，那么默认则继承自
Object 类。例如：

public class DemoTest/*extends Object*/
 { // ... }

**2.2 toString()**方法

方法声明： public String toString() ：返回该对象的字符
串表示。

public class Person {
 private String name;
 private int age;

 public Person() {}

 public Person(String name, int age) {
     this.name = name;
     this. Age = age;
 }

// 省略 getXXX() 和 setXXX() }

public class DemoTest {
 public static void main(String[] args) {
 Person p=new Person("张三",23);

 // String str = p.toString();
 // System.out.println(str);
 System.out.println(p.toString());

 //源码中println()方法默认调用了 toString()System.out.println(p); 
    }
 }

由于 toString 方法返回的结果是内存地址，而在开发中，
内存地址并没有实际的应用价值，经常需要按照对象的
属性得到相应的字符串表现形式，因此也需要重写它。

public class Person {
 private String name;
 private int age;

 public Person() { }

 public Person(String name, int age) {this.name = name; this. Age = age;}

// 省略 getXXX() 和 setXXX()

 @Override
 public String toString() { return name+"..."+age; } }

public class DemoTest {
 public static void main(String[] args) {
 Person p=new Person("张三",23);
 System.out.println(p.toString());
 System.out.println(p);
 }

 }

在 IntelliJ IDEA 中，可以点击 Code 菜单中的
Generate... ，也可以使用快捷键 alt+insert ，点击
toString() 选项。选择需要包含的成员变量并确定。

public class Person {
 private String name;
 private int age;

 public Person() { }

 public Person(String name, int age) { this.name = name; this. Age = age; }

// 省略 getXXX() 和 setXXX()

 @Override
 public String toString() {
 return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
 }
 }

**2.3 equals()**方法

方法声明： public boolean equals(Object obj) ：指示其
他某个对象是否与此对象 " 相等 " 。
equals 方法默认比较两个对象的内存地址是否相同，相
同则返回 true 。
Object 类 equals() 方法源码：

public boolean equals(Object obj) {
 return (this == obj);
 }

• this是当前对象，哪个对象调用的equals方法就表示哪个对象
• obj 表述传递的参数，参数类型 Object ，可以传递任意类型对象。
  • this==obj 比较两个对象的内存地址是否相同

public class Person {
 private String name;
 private int age;

 public Person() { }

 public Person(String name, int age) { this.name = name;this.age = age; }

// 省略 getXXX() 和 setXXX()

 @Override
 public String toString() {
 return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; 
    }
 }

* ==: 既可以比较基本数据类型 , 也可以比较引用数据类型
* 比较基本数据类型 : 比较值是否相等
* 比较引用数据类型 : 比较地址值是否相等
*
* public boolean equals(Object obj) ：指示其
他某个对象是否与此对象 " 相等 " 。
*/
public class DemoTest {
public static void main ( String [] args ) {
// 比较基本数据类型
int a = 10 ;
int b = 20 ; System . out . println ( a == b ); //false
// 比较引用数据类型
Person p01 = new Person ( " 张三 " , 23 );
Person p02 = new Person ( " 张三 " , 23 );
System . out . println ( p01 == p02 ); //false
//Object 类的 equals() 方法
System . out . println ( p01 . equals ( p02 )); //false
}
}
实际应用中，比较内存地址是否相同并没有意义，我们
可以定义对象自己的比较方式，比较对象中成员变量的
值是否相同。需要对方法进行重写。
需求：重写 equals() 方法，比较两个对象中姓名和年龄是
否相同，如果姓名和年龄都相同返回 true ，否则返回
false 。
public class Person {
private String name ;
private int age ;
public Person () {
}
public Person ( String name , int age ) {
this . name = name ;
this . age = age ;
}
// 省略 getXXX() 和 setXXX()
@Override
public boolean equals ( Object obj ) {
// 判断两个对象地址弱相同，即为同一个对象
if ( this == obj ){
return true ;
}
//obj 对象为空，无需比较，返回 false
if ( obj == null ){
return false ;
}
// 如果 Obj 是 Person 类型 则强制转换
if ( obj instanceof Person ){
Person person = ( Person ) obj ;
return
this . name . equals ( person . name ) &&
this . age == person . age ;
}
return false ;
}
@Override
public String toString () {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}' ;
}
public class DemoTest {
public static void main ( String [] args ) {
Person p01 = new Person ( " 张三 " , 23 );
Person p02 = new Person ( " 张三 " , 23 );
System . out . println ( p01 . equals ( p02 )); //true
}
}
在 IntelliJ IDEA 中，可以使用 Code 菜单中的 Generate...
选项，也可以使用快捷 alt+insert ，并选择 equals() and
hashCode() 进行自动代码生成。

三**.String****类**

3.1 String****类概述

String 类代表字符串， Java 程序中的所有字符串文字
（例如 "abc" ）都被实现为此类的实例。
Java 程序中所有的双引号字符串，都是 String 类的对
象。
String 类在 java.lang 包下，所以使用的时候不需要
导包！

3.2 String****类的构造方法

public String() 创建一个空字符串对象
public String(String original) 通过给定的内容创建一
个 String 对象
public String(char[] value) 根据 char 数组中的内容 , 来
创建对应的字符串对象
public String(byte[] bytes) 根据 byte 数组中的内容 , 来
创建对应的字符串对象
public String(byte[] bytes, int offset, int length) 指
定 byte 数组的范围 , 根据指定范围中的内容 , 来创建对应
的字符串对象
直接写字符串字面值也是 String 类对象 例如 : String
str = "abc";
public class DemoTest {
public static void main ( String [] args ) {
//public String() ：创建一个空白字符串对象，不含有任何内容
String str01 = new String ();
System . out . println ( "str01=" + str01 );
//public String(String original) 通过给定的内容创建一个 String 对象
String str02 = new String ( "abc" );
System . out . println ( "str02=" + str02 );
//public String(char[] value) 根据char数组中的内容 , 来创建对应的字符串对象
char [] cs = { 'a' , 'b' , 'c' , 'd' };
String str03 = new String ( cs );
System . out . println ( "str03=" + str03 );
//public String(byte[] bytes) 根据byte数组中的内容 , 来创建对应的字符串对象
byte [] bs = { 97 , 98 , 99 , 100 , 101 };
String str04 = new String ( bs );
System . out . println ( "str04=" + str04 );
//public String(byte[] bytes, int offset, int length)
// 指定 byte 数组的范围 , 根据指定范围中的内容, 来创建对应的字符串对象
String str05 = new String ( bs , 1 , 3 );
System . out . println ( "str05=" + str05 );
// 直接写字符串字面值也是 String 类对象
String str06 = "hello" ;
System . out . println ( "Str06=" + str06 );
}
}

3.3****两种方式创建字符串的区别

通过 new 创建的字符串对象，每一次 new 都会申请
一个内存空间，虽然字符串内容相同，但是地址值不
同
public class DemoTest {
public static void main ( String [] args ) {
String str01 = new String ( "hello" );
String str02 = new String ( "hello" );
System . out . println ( str01 == str02 ); //false 地址值不同
}
}
以 " " 方式给出的字符串，只要字符序列相同 ( 顺序和大
小写 ) ，无论在程序代码中出现几次，都只会建立一个
String 对象
public class DemoTest {
public static void main ( String [] args ) {
String str01 = "hello" ;
String str02 = "hello" ;
System . out . println ( str01 == str02 ); //true
}
}

3.4****字符串常用方法

public int length (): 返回此字符串的长度。
public boolean equals(String s): 比较两个字符串内容
是否相同、区分大小写
public boolean equalsIgnoreCase (String
anotherString) ：将此字符串与指定对象进行比较，
忽略大小写。
public String concat (String str): 将指定的字符串连接
到该字符串的末尾。
public char charAt (int index): 返回指定索引处的
char 值。
public int indexOf (String str): 返回指定子字符串第一
次出现在该字符串内的索引。
public String substring (int beginIndex): 返回一个子
字符串，从 beginIndex 开始截取字符串到字符串结
尾。
public String substring (int beginIndex, int
endIndex): 返回一个子字符串 , 从 beginIndex 到
endIndex 截取字符串。含 beginIndex, 不含
endIndex 。
public class DemoTest {
public static void main ( String [] args ) {
String str = "woaijava" ;
//public int length (): 返回此字符串的 长度。
int len = str . length ();
System . out . println ( len ); //8
//public boolean equals(String s): 比较两个字符串内容是否相同、区分大小写
boolean lean01 = str . equals ( "woaiJava" ); //false
System . out . println ( lean01 );
//public boolean equalsIgnoreCase(String anotherString)
// 将此字符串与指定对象进行比较，忽略大小写。
boolean lean02 = str . equalsIgnoreCase ( "woaiJava" );
System . out . println ( lean02 ); //true
//public String concat (String str):
将指定的字符串连接到该字符串的末尾。
String newStr = str . concat ( "haha" );
System . out . println ( newStr ); //woaijavahaha
//public char charAt (int index): 返回指定索引处的 char 值。
char c = str . charAt ( 3 );
System . out . println ( c ); //i
// 遍历字符串 w o a i j a
v a
for ( int i = 0 ; i < str . length (); i ++ ){
System . out . print ( str . charAt ( i ) + "\t" );
}
System . out . println ();
//public int indexOf (String str):
// 返回指定子字符串第一次出现在该字符串内的
索引。
beginIndex 开始截
取字符串到字符串结尾。
String sub01 = str . substring ( 4 );
System . out . println ( sub01 ); //java
//public String substring (int beginIndex, int endIndex):
// 返回一个子字符串 , 从 beginIndex 到 endIndex截取字符串。
// 含 beginIndex, 不含 endIndex 。
String sub02 = str . substring ( 2 , 6 );
System . out . println ( sub02 ); //aija
}
}

3.5****其他方法

public class DemoTest {
public static void main ( String [] args ) {
//boolean isEmpty() 判断字符串是否为空(长度为 0 返回 true ，不为 0 返回 false)
String str01 = null ; // 空 表示什么都没有
String str02 = "" ; // 空字符串对象
String str03 = " " ; // 有一个空格字符的字符 串对象
System . out . println ( "---------------------" );
//System.out.println(str01.isEmpty());//Nul
lPointerException
System . out . println ( str02 . isEmpty ()); //true System . out . println ( str03 . isEmpty ()); //false
System . out . println ( "---------------------" );
//boolean contains(CharSequence s) 判
断字符串中是否包含 给定的字符串
String str04 = "helloworld" ;
System . out . println ( str04 . contains ( "Hello" ))
; //false
System . out . println ( str04 . contains ( "world" ))
; //true
System . out . println ( "---------------------" );
//boolean startsWith(String prefix) 判断字符串是否以 给定的字符串开头
//boolean endsWith(String suffix) 判断字符串是否以 给定的字符串 结尾。
String str05 = "helloworld.java" ;
System . out . println ( str05 . startsWith ( "world" )); //false
System . out . println ( str05 . startsWith ( "he" )); //true
System . out . println ( str05 . endsWith ( ".java" )) ; //true
System . out . println ( str05 . endsWith ( ".html" )) ; //false
System . out . println ( "---------------------" );
//String toLowerCase() 把字母都转成其对应的小写形式
//String toUpperCase() 把字母都转成其对应的大写形式
String str06 = "AbCdEf" ;
System . out . println ( str06 . toLowerCase ()); //abcdef
System . out . println ( str06 . toUpperCase ()); //ABCDEF
System . out . println ( "---------------------" );
//String replace(char oldChar, char newChar)用新内容替代旧内容，返回新的字符串
String str07 = " 小学生放假了 , 小学生打游戏 了" ; String str08 = str07 . replace ( " 小学生" , "***" );
System . out . println ( str08 ); //*** 放假了,*** 打游戏了
System . out . println ( "---------------------" );
//char[] toCharArray() 将此字符串转换为一个新的字符数组
String str09 = "abcd" ;
char [] cs = str09 . toCharArray ();
System . out . println ( Arrays . toString ( cs )); //[ a, b, c, d]
System . out . println ( "---------------------" );
//byte[] getBytes() 把字符串转换为字节数组
String str10 = "hello" ;
byte [] bs = str10 . getBytes ();
System . out . println ( Arrays . toString ( bs )); //[
104, 101, 108, 108, 111]
System . out . println ( "---------------------" );
// String trim() 移除首尾空格
String str11 = " zhangsan " ;
String str12 = str11 . trim ();
System . out . println ( str12 )；
System . out . println ( "---------------------" );
//String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
// 传入一个普通的字符串 , 没有特殊含义
String str13 = "a,b,c,d,e" ;
String [] sp01 = str13 . split ( "," );
System . out . println ( Arrays . toString ( sp01 )); //[a, b, c, d, e]
// 高级用法 : 传入有特殊含义的字符串 , 其实就是正则表达式
// 正则表达式 : . 匹配任何单字符
String str14 = "a.b.c.d.e" ;
String [] sp02 = str14 . split ( "\\." );
System . out . println ( Arrays . toString ( sp02 ));
}

}

四**.StringBuilder****类**

4.1 String****类字符串拼接问题

public static void main ( String [] args ) {
String str = "hello" ;
str += "world" ;
System . out . println ( str );
}
}
在 API 中对 String 类有这样的描述：字符串是常量，它们
的值在创建后不能被更改。
根据这句话分析我们的代码，其实总共产生了三个字符
串 : Hello 、 World 和 HelloWorld 。
String 类的字符串拼接 , 每一次拼接完都会得到一个新的
字符串对象 , 所以比较耗时 , 也浪费空间。

4.2 StringBuilder****类概述

StringBuilder 是一个可变的字符串类 ，我们可以把它
看成是一个容器，这里的可变指的是 StringBuilder 对象
中的内容是可变的。
StringBuilder 类和 String 类的区别
String 类：内容是不可变的
StringBuilder 类：内容是可变的

4.3 StringBuilder****类的构造方法

public StringBuilder() 创建一个空白可变字符串对
象，不含有任何内容
public StringBuilder(String str) 根据字符串的内容，
来创建可变字符串对象
public class DemoTest {
public static void main ( String [] args ) {
//public StringBuilder() ：创建一个空白可变字符串对象，不含有任何内容
StringBuilder sb01 = new StringBuilder ();
System . out . println ( "sb01=" + sb01 );
System . out . println ( " 长度=" + sb01 . length ());
//public StringBuilder(String str) ：根据字符串的内容，来创建可变字符串对象
StringBuilder sb02 = new StringBuilder ( "hello" );
System . out . println ( "sb02=" + sb02 );
System . out . println ( " 长度 =" + sb02 . length ());
}
}

4.4 StringBuilder****类常用方法

public StringBuilder append( 任意类型 ) 拼接数据，
并返回对象本身
public StringBuilder insert(int offset, 任意类型 ) 在
指定位置插入数据 , 并返回对象本身
public StringBuilder reverse() 反转字符串 , 并返回对
象本身
public class DemoTest {
public static void main ( String [] args ) {
StringBuilder sb01 = new
StringBuilder ();
//public StringBuilder append( 任意类
型 ) 拼接数据，并返回对象本身
// StringBuilder sb02 = sb01.append("hello");
System.out.println(sb02==sb01);//true
// sb01.append(123);
// System.out.println(sb01);
//public StringBuilder insert(int offset, 任意类型 )
// 在指定位置插入数据 , 并返回对象本身
// sb01.insert(5,"world");
// System.out.println(sb01)
//public StringBuilder reverse() 反转字符串, 并返回对象本身
// StringBuilder sb03 = sb01.reverse();
// System.out.println(sb01==sb03);
// System.out.println(sb01);
// 链式编程
sb01 . append ( "hello" ). append ( 123 ). insert ( 5 , "world" ). reverse ();
System . out . println ( sb01 );
}
}

4.5 StringBuilder和String****相互转换

StringBuilder 转换为 String
public String toString() ：通过 StringBuilder 类中的
toString() 就可以实现把 StringBuilder 转换为 String
String 转换为 StringBuilder
public StringBuilder(String s) ：通过 StringBuilder 的构
造方法就可以实现把 String 转换为 StringBuilder
public class DemoTest {
public static void main ( String [] args ) {
//String -->StringBuilder
String str01 = "hello" ;
StringBuilder sb = new StringBuilder ( str01 );
sb . append ( "world" );
//StringBuilder --> String
String s = sb . toString ();
System . out . println ( s );
}
}
ok了家人们睡了明天见