Java基础篇之常用类（1）
目录
常用API：
Scanner：
object类：
to String()方法：
equals（）方法：
String类：
String类创建对象的特点：
String练习之模拟用户登录：
String练习之字符串遍历：
String练习之数组元素拼接：
String练习之字符串反转：
StringBuilder概述及其与String的区别：
StringBuilder构造方法：
StringBuilder常用方法：
链式反应：
反转功能：
StringBuilder与String的相互转换：
StringBuilder练习之数组元素拼接成指定格式字符串：
StringBuilder练习之字符串反转：
常用API：
API：应用程序编程接口
A:打开帮助文档
B:点击显示，找到索引，看到输入框
C:你要学习什么内容，你就在框框里面输入什么内容
举例：Random
D:看包
java.lang包下的类在使用的时候是不需要导包的
E:看类的描述
Random类是用于生成随机数的类
F:看构造方法
Random():无参构造方法
Random r = new Random();
G:看成员方法
public int nextInt(int n):产生的是一个[0,n)范围内的随机数
调用方法：
看返回值类型：人家返回什么类型，你就用什么类型接收
看方法名：名字不要写错了
看形式参数：人家要几个参数，你就给几个，人家要什么数据类型的，你就给什么数据类型的
int number = r.nextInt(100);
Scanner：
需求：通过Scanner获取字符串数据
Scanner：用于获取键盘录入数据。（基本数据类型，字符串数据）
public String nextLine():获取录入字符串数据
package SC;
/*
@author: MR.chan
@file: Scanner01.py
@time: 2020/03/29
@desc:
*/
import java.util.Scanner;
public class Scanner01 {
public static void main(String[] args) {
//录入数据
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入一个字符串");
String line = sc.nextLine();
System.out.println("line:"+line);
}
}object类：
Object:是类层次结构的根类，所有的类都直接的或者间接的继承自该类。
构造方法：object（）
to String()方法：
直接输出对象名，输出底层调用的是对象的to string（）方法
查看API，我们发现建议所有子类都重写to String（）
如何重写该方法？可自动生成
public class ObjectDemo {
public static void main(String[] args) {
Student s = new Student();
s.setName("林青霞");
s.setAge(30);
System.out.println(s);//若未重写to String（）则输出地址值
System.out.println(s.toString());
//底层方法
/*
public void println(Object x) { //Object x = s;
String s = String.valueOf(x);
synchronized (this) {
print(s);
newLine();
}
}
public static String valueOf(Object obj) { //Object obj = x;
return (obj == null) ? "null" : obj.toString();
}
*/
}
}public class Student {
private String name;
private int age;
public Student(){}
public Student(String name,int 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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}输出结果：
Student{name='林青霞', age=30}
Student{name='林青霞', age=30}
equals（）方法：
==：
可以比较基本数据类型，比较基本数据类型的时候比较的是基本数据类型的值是否相同
也可以比较引用数据类型，比较引用数据类型的时候比较的是引用数据类型的地址是否相等
通过查看API，我们找到了比较对象是否相等的方法：
public boolean equals(Object obj)
Object类中 的equals（）方法默认的是比较对象的地址是否相等
要比较对象是否相等，就要重写方法
package SC;
/*
@author: MR.chan
@file: Student.py
@time: 2020/03/29
@desc:
*/
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student(){}
public Student(String name,int age){
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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
}package SC;
/*
@author: MR.chan
@file: ObjectDemo.py
@time: 2020/03/29
@desc:
*/
public class ObjectDemo {
public static void main(String[] args) {
Student s = new Student();
s.setName("林青霞");
s.setAge(30);
Student s2 = new Student("林青霞",30);
System.out.println(s == s2);//false
System.out.println(s.equals(s2));//true
}
}输出结果：
false
true
String类：
String：
代表字符串类。
由多个字符组成的一串数据
字符串的本质就是一个字符数组
构造方法：
String(String original):把字符串数据封装成字符串对象
String(char[] value):把字符数组的数据封装成字符串对象
String(char[] value, int index, int count):把字符数组的一部分数据封装成字符串对象
public class String_01 {
public static void main(String[] args) {
String s1 = new String("hello");
System.out.println(s1);
System.out.println("-------");
char[] a2 = {'l','o','v','e'};
String s2 = new String(a2);
System.out.println(s2);
System.out.println("-------");
String s3 = new String(a2,0,a2.length-1);
System.out.println(s3);
System.out.println("-----");
}
}
输出结果：
hello
-------
love
-------
lov
-----
String类创建对象的特点：
A:通过构造方法创建对象
B:通过直接赋值的方式创建对象
这两种方式的创建是有区别的
通过构造方法创建的字符串对象是在堆内存。
通过直接赋值的方式创建的字符串对象是在方法区的常量池
public class String_01 {
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = "hello";
String s4 = "hello";
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s3 == s4);
}
}输出结果：
false
false
true
图解如下：
String练习之模拟用户登录：
需求：模拟登录,给三次机会,并提示还有几次
分析：
A:定义两个字符串对象，用于存储已经存在的用户名和密码
B:键盘录入用户名和密码
C:拿键盘录入的用户名和密码去跟已经存在的用户名和密码进行比较
如果内容相同，就提示登录成功
如果内容不同，就提示登录失败，并提示还有几次机会
public boolean equals(Object anObject):比较字符串的内容，严格区分大小写(用户名和密码)
public boolean equalsIgnoreCase(String anotherString):比较字符串的内容，不考虑大小写(验证码)
import java.util.Scanner;
public class test01 {
public static void main(String[] args) {
String admin = "admin";
String password = "admin";
Scanner sc = new Scanner(System.in);
for(int x = 2;x>=0;x--){
System.out.println("请输入用户名：");
String adn = sc.nextLine();
System.out.println("请输入密码：");
String psw = sc.nextLine();
if(x==0){
System.out.println("您的账户已被锁定");
}else {
if(adn.equals(admin)&&psw.equals(password)){
System.out.println("登陆成功");
break;
}else {
System.out.println("用户名密码错误，你还有"+x+"机会");
}
}
}
}
}String练习之字符串遍历：
需求：遍历字符串（获取字符串的每一个字符）
假如让我们来提供方法，我们应该提供一个根据索引返回指定位置的字符的办法
返回值：char
形式参数：int index
public char charAt(int index):返回指定索引处的值
public class Stringtest02 {
public static void main(String[] args) {
String s = "java";
for (int x =0;x输出结果：
j
a
v
a
String练习之数组元素拼接：
需求：把数组中的数据按照指定格式拼接成一个字符串
举例：int【】arr = {1,2,3}；
输出结果：【1,2,3】
分析：
A：定义一个int类型的数组
B：写方法实现把数组中中的元素按照指定的格式
C：调用方法
D：输出结果
public class Stringtest03 {
public static void main(String[] args) {
int []arr = {1,2,3};
System.out.println(arrToString(arr));
}
public static String arrToString(int []arr){
String s = "";
s+="[";
for (int x =0;x输出结果：
[1, 2, 3]
String练习之字符串反转：
需求：字符串反转
举例：键盘录入“abc”
输出结果：“cba”
分析：
A：键盘录入字符串数据
B：写方法实现字符串数据的反转
把字符串倒着遍历，再把每一个得到的字符拼接成一个字符串
C：调用方法
D：输出结果
import java.util.Scanner;
public class Stringtest04 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String s = sc.nextLine();
System.out.println(reverse(s));
}
public static String reverse(String s){
String s1 = "";
for (int x = s.length()-1;x>=0;x--){
s1+=s.charAt(x);
}
return s1;
}
}输出结果：
请输入一个字符串：
abc
cba
StringBuilder概述及其与String的区别：
StringBuilder:是一个可变的字符串。字符串缓冲区类。
String和StringBuilder的区别：
String的内容是固定的
StringBuilder的内容是可变的
+=拼接字符串耗费内存原因:
每次拼接都会产生新的字符串对象,而利用StringBuilder来拼接字符串自始至终用的都是同一个StringBuilder容器
StringBuilder构造方法：
public StringBuilder()
public StringBuilder(String str)
public class StringBuilderDemo {
public static void main(String[] args) {
StringBuilder SB = new StringBuilder();
System.out.println("SB:"+SB);
System.out.println(SB.length());
System.out.println("-----------");
StringBuilder sb2 = new StringBuilder("helloworld");
System.out.println("sb2:"+sb2);
System.out.println(sb2.length());
System.out.println("-----------");
}
}输出结果：
SB:
0
-----------
sb2:helloworld
10
-----------
StringBuilder常用方法：
添加功能：
public StringBuilder append（任意类型）
反转功能：
public StringBuilder reverse()
public class StringBuilderDemo {
public static void main(String[] args) {
StringBuilder SB = new StringBuilder();
StringBuilder sb2 = SB.append("HELLO");
System.out.println("sb2:"+sb2);
System.out.println(sb2.length());
System.out.println("-----------");
System.out.println("SB:"+SB);
System.out.println(SB.length());
System.out.println("-----------");
SB.append("WORLD");
SB.append(100);
SB.append(true);
System.out.println("SB:"+SB);
}
}输出结果：
sb2:HELLO
5
-----------
SB:HELLO
5
-----------
SB:HELLOWORLD100true
链式反应：
如下程序中SB.append（）.append（）
反转功能：
.reverse();
public class StringBuilderDemo {
public static void main(String[] args) {
StringBuilder SB = new StringBuilder();
SB.append("hello").append("world").append(100).append(true);
System.out.println(SB);
SB.reverse();
System.out.println(SB);
}
}输出结果：
helloworld100true
eurt001dlrowolleh
StringBuilder与String的相互转换：
StringBuilder--转String
public class StringBuilderDemo {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
sb.append("hello");
String s = sb.toString();
System.out.println(s);
}
}String--转StringBuilder
public class StringBuilderDemo {
public static void main(String[] args) {
String s = "hello";
StringBuilder s2 =new StringBuilder(s);
System.out.println(s2);
}
}StringBuilder练习之数组元素拼接成指定格式字符串：
需求：把数组中的数据按照指定格式拼接成一个字符串
举例：int【】arr = {1,2,3}；
输出结果：【1,2,3】
public class test05 {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
System.out.println(arr1(arr));
}
public static StringBuilder arr1(int[] arr) {
StringBuilder s = new StringBuilder();
s.append("[");
for (int x = 0; x < arr.length; x++) {
if (x == arr.length - 1) {
s.append(arr[x]);
} else {
s.append(arr[x]).append(", ");
}
}
s.append("]");
// String s2 = s.toString();
return s;
}
}StringBuilder练习之字符串反转：
import java.util.Scanner;
public class test06 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String s = sc.nextLine();
System.out.println("result:"+myreverse(s));
}
public static StringBuilder myreverse(String s ){
// StringBuilder sb = new StringBuilder(s);
// sb.reverse();
String ss = sb.toString();
// return sb;
return new StringBuilder(s).reverse();
}
}