第十五天 常用API-object&string&stringbuilder&stringbuffer【悟空教程】

第十五天 常用API-object&string&stringbuilder&stringbuffer【悟空教程】

第15天 常用API

第1章 常用API

1.1 常用API

• API(Application Programming Interface)
  • 应用程序编程接口
  • 编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为API。本章涉及的Java API指的就是JDK中提供的各种功能的Java类。
• Java API-Java API就是sun公司提供给我们使用的类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。
• 源代码-在JDK中有src.zip文件，这个文件夹是所有Java类的源文件。可以在其中查看相对应的类的源码。
• 我们可以通过查帮助文档来了解Java提供的API如何使用

1.2 使用步骤

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

1.3 Object类

Object类是Java语言中的根类，即所有类的父类。其所有方法子类都可以使用。其中的toString、equals是非常常用的方法。

public class Person extends Object{

private String name;

private int age;

public Person() {

super();

// TODO Auto-generated constructor stub

}

public Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

//Person类重写了Object类的equals方法 不比较地址值 比较对象属性内容

@Override

public boolean equals(Object obj) {

//向下转型 将obj转换为Person类型

Person other = (Person)obj;

//this与other的比较 属性的比较

//如果this和other的年龄不相等 直接返回false

if(this.age !=other.age){

return false;

}

//如果继续往下走代表年龄相等 那么比较姓名

//因为String类重写了equals 比较的不是地址值比较的是两个字符串的内容是否相等

//索引调用equals比较两个对象的姓名

if(!this.name.equals(other.name)){

return false;

}

return true;

}

// @Override

// public int hashCode() {

//

// return 0x35d;

// }

// Person类重写了Object类的toString方法 不打印地址值 打印对象属性内容

@Override

public String toString() {

String info = "name:"+name+" age:"+age;

return info;

}

}

1.3.1 toString方法

当调用System.out.println()方法时，实际上是调用被打印者的toString方法，返回字符串，再将字符串打印的过程。

但是Object类的toString方法返回的为对象地址值，即对象的类型+@+哈希值(地址值)。所以我们需要重写User类的该方法，让该方法返回的是一个User对象的具体信息，而不是其地址值。

import java.util.Scanner;

/*

* Object类 是所有类的根类

*

* 前提是在Object类中：

* public String toString() 对象的类型+@+哈希值(地址值)

*

* 调用toString方法打印的是地址值，但是通常我们不希望打印地址值，我们希望能够看到对象的属性值

*

*

*

*/

public class Demo01_Object {

public static void main(String[] args) {

Object obj = new Object();

System.out.println(obj.toString());

System.out.println(obj);

Person p = new Person("柳岩",18);

System.out.println(p.toString());

System.out.println(p);

//

// Scanner sc = new Scanner(System.in);

// System.out.println(sc);

}

}

1.3.2 equals方法

由于引用类型不能像基本类型一样使用==运算符来进行运算判断，所以判断两个对象是否”相同”使用的是equals方法。

Object类的equals方法比较的为对象地址值，所以我们需要重新定义两个对象的比较规则，比如字符串就是重写了equals方法才比较的为内容，否则比较的也为地址值。再比如本例中，我们可以将姓名相同的User判断为相同的User。这时根据规则重写equals方法即可。（如果有别的需求则按照别的需求来重写equals方法!）

注意：在复写Object中的equals方法时，一定要注意public boolean equals(Object obj)的参数是Object类型，在调用对象特有数据时，一定要进行类型转换，在转换之前必须进行类型判断。

/*

* 类似*号这种运算符是不能操作引用数据类型的

*

* ==比较的是对象的地址值

* 前提：Object的equals方法

* public boolean equals(Object obj) 和==一样都是比较两个引用数据类型的地址值，

* 只有两个对象的引用是同一个时返回true

* 调用equals方法比较的是地址值，但是通常我们不希望比较地址值，我们希望能够比较对象的属性值

*

*/

public class Demo02_Object {

public static void main(String[] args) {

Person p = new Person("班长",18); //0x1111

Person p2 = new Person("柳岩",20); //0x2222

Person p3 = new Person("柳岩",20);//0x3333

//使用==比较引用数据类型 ，比较的是对象的地址值

System.out.println(p==p2);//false

System.out.println(p2==p3);//false

System.out.println("--------------------------");

System.out.println(p.equals(p2));

System.out.println(p2.equals(p3));

System.out.println(p.equals(p));

}

}

1.3.3 其他方法

public final Class<?> getClass() //返回对象数据类型

public int hashCode() //返回对象哈希值(地址值)(常作为识别不同对象的依据)

protected void finalize() throws Throwable //垃圾回收器调用，执行清除资源

/*

* Object类的其他方法

*

* public final Class<?> getClass() //返回对象数据类型

* public int hashCode() //返回对象哈希值(地址值)(常作为识别不同对象的依据)

*/

public class Demo03_Object {

public static void main(String[] args) {

Person p = new Person();

//返回对象数据类型

Class x = p.getClass();

System.out.println(x);

System.out.println(p.toString());

System.out.println(p.hashCode());

}

}

1.4 String类

1.4.1 字符串概念

字符串是日常开发过程中最常用的。代表一个字符序列，其底层为字符数组。

我们之前认为的一些高深莫测的问题其实都是通过字符串的拼写来完成的，比如在浏览器发送一个HTTP请求,实际就是发送一个符合规定格式的字符串。

我们需要更为熟练地应用String类的方法。

1.4.2 字符串的特殊性

字符串是特殊的引用类型，表现在字符串是常量，每一个字符串的值都是无法被改变的(请一定区分开是对象内容改变还是变量指向的地址值改变)，存在于内存当中的特殊区域——常量池。

当使用字面值常量来表示字符串时，字符串一旦生成，在常量池中是不可变的，那么不管有多少个引用，只要他们指向的字符串值相同，即就是这些引用指向同一片内存区域。

• 直接赋值创建字符串对象

String s = “hello”;

//演示字符串可以共享

String str1 = "javahelp";

String str2 = "javahelp";

System.out.println(str1==str2);

输出的结果为true，就说明str1的引用和str2的引用指向的同一片内存区域。

注意：但是，如果使用new关键字创建对象，不使用字面值常量，则其仍为堆内存中普通的对象，各自有各自的地址。

• 通过构造方法创建字符串对象

String s = new String(“hello”);

演示1：

/*

* 字符串的特殊性

* 字符串是特殊的引用类型，表现为字符串是常量，一旦创建不可改变

*/

public class Demo01_String {

public static void main(String[] args) {

String s = "i love java"; //0x1111

// s = "i like java"; //0x2222

System.out.println(s);

String s2 = "i love java"; //0x1111

System.out.println(s == s2);//比较地址值

System.out.println(s.equals(s2));//比较内容

System.out.println("-------------------");

String s3 = new String("i love java");

System.out.println(s==s3);//false

System.out.println(s.equals(s3)); //true

System.out.println("-----------------------------------");

String ss1 = "abc";

String ss4 = "abc";

String ss2 = new String("abc");

String ss3 = new String("abc");

System.out.println(ss1==ss4);//true

System.out.println(ss1==ss2);//fasle

System.out.println(ss2==ss3);//false

System.out.println(ss1.equals(ss4));//true

}

}

演示2：

public class Demo02String {

public static void main(String[] args) {

String s1 = new String("hello");

String s2 = "hello";

System.out.println("s1:"+s1);

System.out.println("s2:"+s2);

System.out.println("s1==s2:"+(s1==s2)); //false

String s3 = "hello";

System.out.println("s1==s3:"+(s1==s3)); //false

System.out.println("s2==s3:"+(s2==s3)); //true

}

}

1.4.3 构造方法

• 构造方法
  • public String(String original)
  • public String(char[] value)
  • public String(char[] value,int offset,int count)
  • 直接赋值也可以是一个对象

注意：字符串是一种比较特殊的引用数据类型，直接输出字符串对象输出的是该对象中的数据。

public class Demo01String {

public static void main(String[] args) {

//方式1

//String(String original):把字符串数据封装成字符串对象

String s1 = new String("hello");

System.out.println("s1:"+s1);

System.out.println("---------");

//方式2

//String(char[] value):把字符数组的数据封装成字符串对象

char[] chs = {'h','e','l','l','o'};

String s2 = new String(chs);

System.out.println("s2:"+s2);

System.out.println("---------");

//方式3

//String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象

//String s3 = new String(chs,0,chs.length);

String s3 = new String(chs,1,3);

System.out.println("s3:"+s3);

System.out.println("---------");

//方式4

String s4 = "hello";

System.out.println("s4:"+s4);

}

}

1.4.4 常见方法

• 判断功能方法
  • boolean equals(Object obj):比较字符串的内容是否相同
  • boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
  • boolean startsWith(String str):判断字符串对象是否以指定的str开头
  • boolean endsWith(String str):判断字符串对象是否以指定的str结尾

public class Demo01String {

public static void main(String[] args) {

//创建字符串对象

String s1 = "hello";

String s2 = "hello";

String s3 = "Hello";

//boolean equals(Object obj):比较字符串的内容是否相同

System.out.println(s1.equals(s2));

System.out.println(s1.equals(s3));

System.out.println("-----------");

//boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写

System.out.println(s1.equalsIgnoreCase(s2));

System.out.println(s1.equalsIgnoreCase(s3));

}

}

• 模拟用户登录案例,给三次机会,并提示还有几次

public class Demo02StringTest {

public static void main(String[] args) {

//定义两个字符串对象，用于存储已经存在的用户名和密码

String username = "admin";

String password = "admin";

//给三次机会，用for循环实现

for(int i=0; i<3; i++) {

//键盘录入用户名和密码

Scanner sc = new Scanner(System.in);

System.out.println("请输入用户名：");

String name = sc.nextLine();

System.out.println("请输入密码：");

String pwd = sc.nextLine();

//拿键盘录入的用户名和密码和已经存在的用户名和密码进行比较

if(username.equals(name) && password.equals(pwd)) {

System.out.println("登录成功");

break;

}else {

if((2-i) ==0) {

System.out.println("用户名和密码被锁定,请与管理员联系!");

}else {

System.out.println("登录失败,你还有"+(2-i)+"次机会!");

}

}

}

}

}

• 获取功能方法
  • int length():获取字符串的长度，其实也就是字符个数
  • char charAt(int index):获取指定索引处的字符
  • int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回-1
  • String substring(int start):从start开始截取字符串到字符串结尾
  • String substring(int start,int end):从start开始，到end结束截取字符串;包括start，不包括end

public class Demo01String {

public static void main(String[] args) {

//创建字符串对象

String s = "helloworld";

//int length():获取字符串的长度，其实也就是字符个数

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

System.out.println("--------");

//char charAt(int index):获取指定索引处的字符

System.out.println(s.charAt(0));

System.out.println(s.charAt(1));

System.out.println("--------");

//int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回-1

System.out.println(s.indexOf("l"));

System.out.println(s.indexOf("owo"));

System.out.println(s.indexOf("ak"));

System.out.println("--------");

//String substring(int start):从start开始截取字符串到字符串结尾

System.out.println(s.substring(0));

System.out.println(s.substring(5));

System.out.println("--------");

//String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end

System.out.println(s.substring(0, s.length()));

System.out.println(s.substring(3,8));

}

}

• 字符串的遍历

public class Demo02StringTest {

public static void main(String[] args) {

//创建一个字符串对象

String s = "abcde";

//原始做法

System.out.println(s.charAt(0));

System.out.println(s.charAt(1));

System.out.println(s.charAt(2));

System.out.println(s.charAt(3));

System.out.println(s.charAt(4));

System.out.println("---------");

//用for循环改进

for(int x=0; x<5; x++) {

System.out.println(s.charAt(x));

}

System.out.println("---------");

//用length()方法获取字符串的长度

for(int x=0; x<s.length(); x++) {

System.out.println(s.charAt(x));

}

}

}

• 统计字符串中大写、小写几数字字符个数

public class Demo03StringTest {

public static void main(String[] args) {

//键盘录入一个字符串数据

Scanner sc = new Scanner(System.in);

System.out.println("请输入一个字符串数据：");

String s = sc.nextLine();

//定义三个统计变量，初始化值都是0

int bigCount = 0;

int smallCount = 0;

int numberCount = 0;

//遍历字符串，得到每一个字符

for(int x=0; x<s.length(); x++) {

char ch = s.charAt(x);

//拿字符进行判断

if(ch>='A' && ch<='Z') {

bigCount++;

}else if(ch>='a' && ch<='z') {

smallCount++;

}else if(ch>='0' && ch<='9') {

numberCount++;

}else {

System.out.println("该字符"+ch+"非法");

}

}

//输出结果

System.out.println("大写字符："+bigCount+"个");

System.out.println("小写字符："+smallCount+"个");

System.out.println("数字字符："+numberCount+"个");

}

}

• 转换功能方法
  • char[] toCharArray():把字符串转换为字符数组
  • String toLowerCase():把字符串转换为小写字符串
  • String toUpperCase():把字符串转换为大写字符串

public class Demo01String {

public static void main(String[] args) {

//创建字符串对象

String s = "abcde";

//char[] toCharArray():把字符串转换为字符数组

char[] chs = s.toCharArray();

for(int x=0; x<chs.length; x++) {

System.out.println(chs[x]);

}

System.out.println("-----------");

//String toLowerCase():把字符串转换为小写字符串

System.out.println("HelloWorld".toLowerCase());

//String toUpperCase():把字符串转换为大写字符串

System.out.println("HelloWorld".toUpperCase());

}

}

• 键盘录入一个字符串，把该字符串的首字母转成大写，其余为小写。

public class Demo02StringTest {

public static void main(String[] args) {

//键盘录入一个字符串

Scanner sc = new Scanner(System.in);

System.out.println("请输入一个字符串：");

String s = sc.nextLine();

//截取首字母

String s1 = s.substring(0, 1);

//截取除了首字母以外的字符串

String s2 = s.substring(1);

//2转大写+3转小写

String s3 = s1.toUpperCase()+s2.toLowerCase();

//输出即可

System.out.println("s3:"+s3);

}

}

• 去除空格和分割功能方法
  • String trim()去除字符串两端空格
  • String[] split(String str)按照指定符号分割字符串

public class Demo01String {

public static void main(String[] args) {

//创建字符串对象

String s1 = "helloworld";

String s2 = " helloworld ";

String s3 = " hello world ";

System.out.println("---"+s1+"---");

System.out.println("---"+s1.trim()+"---");

System.out.println("---"+s2+"---");

System.out.println("---"+s2.trim()+"---");

System.out.println("---"+s3+"---");

System.out.println("---"+s3.trim()+"---");

System.out.println("-------------------");

//String[] split(String str)

//创建字符串对象

String s4 = "aa,bb,cc";

String[] strArray = s4.split(",");

for(int x=0; x<strArray.length; x++) {

System.out.println(strArray[x]);

}

}

}

• 把数组中的数据按照指定个格式拼接成一个字符串 举例：int[] arr = {1,2,3}; 输出结果：[1, 2, 3]

public class Demo01StringTest {

public static void main(String[] args) {

//定义一个int类型的数组

int[] arr = {1,2,3};

//调用方法

String s = arrayToString(arr);

//输出结果

System.out.println("s:"+s);

}

/*

* 写方法实现把数组中的元素按照指定的格式拼接成一个字符串

* 两个明确：

* 返回值类型：String

* 参数列表：int[] arr

*/

public static String arrayToString(int[] arr) {

String s = "";

s += "[";

for(int x=0; x<arr.length; x++) {

if(x==arr.length-1) {

s += arr[x];

s += "]";

}else {

s += arr[x];

s += ", ";

}

}

return s;

}

}

• 字符串反转 举例：键盘录入”abc” 输出结果：”cba”

public class Demo02StringTest {

public static void main(String[] args) {

//键盘录入一个字符串

Scanner sc = new Scanner(System.in);

System.out.println("请输入一个字符串：");

String s = sc.nextLine();

//调用方法

String result1 = reverse1(s);

String result2 = reverse2(s);

//输出结果

System.out.println("result1:"+result2);

System.out.println("result2:"+result2);

}

//把字符串倒着遍历，得到的每一个字符拼接成字符串。

public static String reverse1(String s) {

String ss = "";

for(int x=s.length()-1; x>=0; x--) {

ss += s.charAt(x);

}

return ss;

}

//把字符串转换为字符数组，然后对字符数组进行反转，最后在把字符数组转换为字符串

public static String reverse2(String s) {

//把字符串转换为字符数组

char[] chs = s.toCharArray();

//对字符数组进行反转

for(int start=0,end=chs.length-1; start<=end; start++,end--) {

char temp = chs[start];

chs[start] = chs[end];

chs[end] = temp;

}

//最后在把字符数组转换为字符串

String str = new String(chs);

return str;

}

}

完成以下练习：

1：int[] arr = {34,12,89,68};将一个int[]中元素转成字符串 格式 [34,12,89,68]

2：查找指定文章中共出现多少个字母a。如果以a开头，则删除开头的a，最后将其全部转换为e。

第2章 StringBuilder类

2.1 StringBuilder概述

我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuilder就可以解决这个问题。

2.2 StringBuilder和String的区别?

• String的内容是固定的。
• StringBuilder的内容是可变的。

2.3 构造方法

• public StringBuilder()
• 和构造方法相关的方法
  • public int capacity():返回当前容量,理论值
  • public int length():返回长度（字符数）,实际值

public class Demo01StringBuilder {

public static void main(String[] args) {

//创建对象

StringBuilder builder = new StringBuilder();

System.out.println("builder:"+builder);

System.out.println("builder.capacity():"+builder.capacity());

System.out.println("builder.length():"+builder.length());

}

}

2.4 方法

• 添加功能
  • public StringBuilder append(任意类型):添加数据，并返回自身对象
• 反转功能
  • public StringBuilder reverse()

public class Demo02StringBuilder {

public static void main(String[] args) {

//创建对象

StringBuilder builder = new StringBuilder();

//public StringBuilder append(任意类型)

//StringBuilder builder2 = builder.append("hello");

/*

System.out.println("builder:"+builder);

System.out.println("builder2:"+builder2);

System.out.println(builder == builder2); //true

*/

/*

builder.append("hello");

builder.append("world");

builder.append(true);

builder.append(100);

*/

//链式编程

builder.append("hello").append("world").append(true).append(100);

System.out.println("builder:"+builder);

//public StringBuilder reverse()

builder.reverse();

System.out.println("builder:"+builder);

}

}

• 与String的相互转换
  • StringBuilder -- String

public String toString():通过toString()就可以实现把StringBuilder转成String

• String -- StringBuilder

StringBuilder(String str):通过构造方法就可以实现把String转成StringBuilder

public class Demo03StringBuilderTest {

public static void main(String[] args) {

//StringBuilder -- String

/*

StringBuilder builder = new StringBuilder();

builder.append("hello").append("world");

String s = builder.toString();

System.out.println(s);

*/

//String -- StringBuilder

String s = "helloworld";

StringBuilder builder = new StringBuilder(s);

System.out.println(builder);

}

}

2.5 练习

• 数组元素格式拼接

举例：int[] arr = {1,2,3};结果：[1, 2, 3]

public class Demo04StringBuilderTest {

public static void main(String[] args) {

//定义一个数组

int[] arr = {1,2,3};

//调用方法

String s = arrayToString(arr);

//输出结果

System.out.println("s:"+s);

}

/*

* 写方法实现拼接

* 两个明确：

* 返回值类型：String

* 参数列表：int[] arr

*/

public static String arrayToString(int[] arr) {

StringBuilder builder = new StringBuilder();

builder.append("[");

for(int x=0; x<arr.length; x++) {

if(x==arr.length-1) {

builder.append(arr[x]).append("]");;

}else {

builder.append(arr[x]).append(", ");

}

}

String result = builder.toString();

return result;

}

}

• 字符串反转

public class Demo05StringBuilderTest {

public static void main(String[] args) {

//1:键盘录入一个字符串

Scanner sc = new Scanner(System.in);

System.out.println("请输入一个字符串：");

String s = sc.nextLine();

//3:调用方法

String result = myReverse(s);

//4:输出结果

System.out.println("result:"+result);

}

/*

* 2:写方法实现反转

* 两个明确：

* 返回值类型：String

* 参数列表：String

*/

public static String myReverse(String s) {

//String -- StringBuilder -- reverse() -- String

StringBuilder builder = new StringBuilder(s);

builder.reverse();

String result = builder.toString();

return result;

}

}

• 判断对称字符串

例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串

public class Demo06StringBuilderTest {

public static void main(String[] args) {

//1:键盘录入一个字符串

Scanner sc = new Scanner(System.in);

System.out.println("请输入一个字符串：");

String s = sc.nextLine();

//3:调用方法

boolean b = isSymmetry(s);

//4:输出结果

System.out.println("b:"+b);

}

/*

* 2:写方法实现判断一个字符串是否是对称字符串

* 两个明确：

* 返回值类型：boolean

* 参数列表：String s

*/

public static boolean isSymmetry(String s) {

//把字符串反转，和反转前的字符串进行比较，如果内容相同，就说明是对称字符串

StringBuilder builder = new StringBuilder(s);

builder.reverse();

String result = builder.toString();

return result.equals(s);

}

}

第3章 StringBuffer类

3.1 概念

字符串是不可变的，所以每拼写一次字符串均会产生新的对象，而字符串缓冲区是一个可变的字符串临时存储区域。在该区域内存储、拼写需要的字符串，当需要真正的字符串时，再将存储区内的字符串取出，这样全部过程只有一个字符串缓冲区对象，更为高效。

同步安全问题会在多线程的学习后了解。

StringBuffer是线程同步的(安全的)，StringBuilder是不同步的(不安全的)，二者方法完全一致。

线程同步操作需要消耗更多的系统资源，所以更慢，而在日常开发过程中，同一个字符串的操作通常不会涉及多线程问题，所以在不考虑安全问题的情况下，尽量使用速度更快的StringBuilder。

3.2 常见方法

public StringBuilder append(Xxx xxx) //向字符串缓冲区中添加字符串

public String toString() //将缓冲区内内容返回

//其他删除、修改、插入等方法可自行查询API

import Person;//导入Person类

/*

* StringBuffer 字符串缓冲区 线程安全 效率低

* StringBuilder 字符串缓冲区 线程不安全 效率高

*

* public StringBuilder append(Xxx xxx) //向字符串缓冲区中添加字符串

* public String toString() //将缓冲区内内容返回

*/

public class Demo01 {

public static void main(String[] args) {

String s ="";

for (int i = 0; i < 10; i++) {

s+="i love java"+i;

}

System.out.println(s);

StringBuilder sb = new StringBuilder();

for (int i = 0; i < 10; i++) {

sb.append("i lova java"+i);

}

sb.append(true);

sb.append('d');

sb.append(250);

sb.append(new Person());

System.out.println(sb.toString());

}

}

3.3 链式调用：

在StringBuilder的方法中，有许多方法的返回值都是该类型本身，如append方法。这时，阅读API后发现，其实返回值就是其本身，这时我们可以继续调用append方法，依次类推，这种调用方法叫做链式调用。

如：

StringBuilder sb = new StringBuilder();

sb.append(“aaa”) .append(“bbb”) .append(“ccc”) .append(“ddd”) ;

String data = sb.toString(); //data的结果为aaabbbcccddd

/*

* 链式调用

*/

public class Demo02 {

public static void main(String[] args) {

StringBuilder sb = new StringBuilder();

// StringBuilder sb2 = sb.append("i love java ");

// StringBuilder sb3 = sb2.append("i like java ");

// StringBuilder sb4 = sb3.append("i enjoy java ");

//

// System.out.println(sb);

// System.out.println(sb2);

// System.out.println(sb3);

// System.out.println(sb4);

sb.append("i love java").append("i like java ").append("i enjoy java");

System.out.println(sb);

}

}

第4章 综合案例---用户登录/注册案例

4.1 案例介绍与演示

与日常登录动作相同，用户登录输入账号密码，比对数据，如果有对应数据，登录成功，否则登录失败。

实现方式类似，完成注册案例。

这里我们需要额外介绍一个新的方法：

Scanner类的 String nextLine()方法，一次读取一行。因为next方法遇到空格无法返回一行的全部内容，而nextLine可以。

4.2 案例分析

集合中存储所有用户信息，每个用户信息使用User类的一个对象表示。

登录案例共分三步：

启动项目，初始化用户数据

用户输入账号密码

比对账号密码(账号密码必须相同)

注册与登录步骤类似：

启动项目，初始化用户数据

用户输入要注册的账号密码

比对账号密码(有相同的账号不可以)

如果可以注册，则将新的用户信息添加到集合中

package StudentJavaSEday15;

import java.util.ArrayList;

import java.util.Scanner;

/** 不完美

* 1.定义user类来管理用户数据

* 2.定义一个集合存储用户信息

* 3.初始化数据到用户的集合中

* 4.提示用户 登录 or 注册

* 5.完成 登录&注册

*

* @author 奋斗蒙

*

*/

public class Login {

public static void main(String[] args) {

// 定义一个集合用于存储用户信息

ArrayList<User> userList = new ArrayList<User>();

// 为userList初始化数据

init(userList);

// 提示 登录 注册

System.out.println("请输入相应的操作：1.登录；2注册");

Scanner sc = new Scanner(System.in);

int choose = sc.nextInt();

while (true) {

switch (choose) {

case 1:

login(userList);

break;

case 2:

register(userList);

break;

default:

System.out.println("你输入有误，请重新输入：");

break;

}

}

}

/*

* 注册方法

*/

private static void register(ArrayList<User> userList) {

Scanner sc = new Scanner(System.in);

System.out.println("请输入你的注册账号：");

String registerUsername = sc.nextLine().trim();

System.out.println("请输入你的注册密码：");

String registerPassword = sc.nextLine().trim();

boolean b = false;

for (int i = 0; i < userList.size(); i++) {

User thisUser = userList.get(i);

if (thisUser.getUsername().equals(registerUsername)) {

b = false;

System.out.println("该账号已经被注册，请重新输入账号：");

}

}

if (!b) {

User registerUser = new User();

registerUser.setUsername(registerUsername);

registerUser.setPassword(registerPassword);

System.out.println("恭喜你注册成功！");

}

}

/*

* 登录方法

*/

private static void login(ArrayList<User> userList) {

Scanner sc = new Scanner(System.in);

System.out.println("请输入你的登录账号：");

String uesrName = sc.nextLine().trim();

System.out.println("请输入你的账号密码：");

String passWord = sc.nextLine().trim();

boolean a = false;

for (int i = 0; i < userList.size(); i++) {

User thisUser = userList.get(i);

if (thisUser.getUsername().equals(uesrName) && thisUser.getPassword().equals(passWord)) {

a = true;

System.out.println("登陆成功！");

}

}

if (!a) {

System.out.println("登录失败，请重新输入用户名密码！");

}

}

/*

* 初始化数据

*/

private static void init(ArrayList<User> userList) {

User user = new User();

user.setUsername("liubei");

user.setPassword("admin");

User user2 = new User();

user2.setUsername("guanyu");

user2.setPassword("admin");

User user3 = new User();

user3.setUsername("zhangfei");

user3.setPassword("admin");

userList.add(user);

userList.add(user2);

userList.add(user3);

}

}

第5章 本日作业：

5.1 知识点相关题

5.1.1 定义类：Test1，定义main()方法，按以下要求编写代码：

a. 定义String变量s1，初始值：”你好”

定义String变量s2，初始值：”你好”

• 使用==符号判断s1和s2是否相等？打印结果，并说明为什么是这个结果?
• 调用s1的equals()方法和s2比较是否相等？打印结果，并说明为什么是这个结果？
• 说明上述两个结果为什么不同？

5.1.2 定义String变量s5，初始值：”努力学习，天天向上”

• 遍历这个字符串，打印每个字符；
• 然后将努力截取出来，赋值给一个新的String对象newStr。
• 然后将newstr转成一个新的字符数组，然后遍历打印。

5.1.3 定义String变量s6，存储一个带后缀的文件名，例如：”Test2.java”

• 请获取这个字符串的”文件名”和”后缀名”两部分内容，并打印。
• 判断这个字符串是否以”Test”开头，是否以”.java”结尾？打印结果

5.1.4 定义String变量s9，初始值：”Hello”

定义String变量s10，初始值：”hello”

• 调用s9的equals()方法和s10比较是否相等？打印结果，并说明为什么是这个结果？
• 如果不区分大小写的判断，需要怎样判断？

5.1.5 定义String变量s11，初始值：”fjiojavafkeajkfjavaeiajifejavapa”

• 统计一下这串字符串中有多少“java”然后将所有的“java”替换成“*”。

5.1.6 遍历字符串中每一个字符

5.1.7 统计一个字符串中大小写的个数

5.1.8 将字符串首字母变为大写，其余字母变为小写

5.1.9 判断两个Animal(包含颜色、姓名、年龄属性)对象是否相同，我们的比较规则为：只要姓名一样，就判断两个对象相同。

5.1.10 实现代码，当打印某个Animal(包含颜色、姓名、年龄属性)对象引用变量时，不打印地址值，打印格式为：”XX颜色的XX”。

5.1.11 练习字符串方法：完成1.3.3中最后的习题

5.2 代码题：

5.2.1 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

答案：

5.2.2 计算字符串中空子串出现的次数

答案：

5.2.3 请编写程序，将键盘录入的字符串倒序打印，并测试。

例： 键盘输入:abcde

打印输出:edcba

答案：

5.2.4 请编写程序，将键盘录入的字符串中敏感字符过滤掉，并测试。

例： 敏感字： 奥巴马、普京

键盘输入: 我喜欢奥巴马呀，还喜欢普京

打印输出: 我喜欢*呀，还喜欢*

答案：

5.2.5 计算小票信息上的总价.题目考察字符串的解析和引用类型转换.

小票信息已给出 :

String message= " 老菜馆\r\n==菜名============价格=======\r\n大拉皮\t\t21.90\r\n鱼香肉丝\t\t22.80\r\n巫山烤鱼\t\t58.80 \r\n===========================";

要求截取有效的以下数据：

/*

* 截取 有效数据

大拉皮 21.90

鱼香肉丝 22.80

巫山烤鱼 58.80

*/