JAVA09
1、java.lang包下的类在使用的时候是不需要导包的
2、sc.next（）—遇到空格和tab键输入会有问题； 和 sc.nextLine（）—遇到\r\n就会停止
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int num = sc.nextInt(); // \r\n
System.out.println("请输入一个字符串");
String s = sc.nextLine();// 遇到上个步骤留下来的\r\n就直接结束了
sc.close();
建议都使用nextLine来作为输入
3、如果打印一个对象的引用, 结果不是全类名 + 16进制地址值的话, 说明该对象就重写了toString方法
4、==号，基本数据类型比较的是值是否相等，引用数据类型比较的是地址值是否相等
5、equals方法只能比较引用数据类型是否相等，因为是一个方法，就必须用对象来调用
@Override
public boolean equals(Object obj) {
if (this == obj) // 如果当前对象和传入对象的地址值相同, 直接返回true
return true;
if (obj == null) // 如果传入的对象为null, 那就说明当前对象有值, 传入对象没值, 没有可比性了, 返回false
return false;
if (getClass() != obj.getClass()) // 如果当前对象的字节码和传入对象的字节码不一致, 说明类型不一样, 没有可比性, 返回false(省略this.getClass())
return false;
Person other = (Person) obj; // 向下转型，不转拿不到属性值
if (age != other.age) // 年龄不同, 直接返回false(省略this.age)
return false;
if (name == null) {
if (other.name != null) // 当前对象的name如果为null, 传入对象的name不是null, 直接返回false
return false;
} else if (!name.equals(other.name)) // 如果姓名不一样, 返回false;
return false;
------------------------------------
String name = "zhangsan";
String name1 = "zhangsan";
System.out.println(name==name1);//true
int [] a = {
1,2,3};
int [] b = {
1,2,3};
System.out.println(a==b);//false
6、挺好的程序，看看
package com.heima.test;
import java.util.Scanner;
public class Test1Student {
/*
* 需求: 键盘录入两个学生信息, 比较两个学生的属性值是否相同, 如果相同则打印学生信息, 如果不相同给出提示
*
* 学生信息: 姓名, 年龄
*/
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
Student stu1 = getStu();
Student stu2 = getStu();
if(stu1.equals(stu2)){
System.out.println(stu1);
}else{
System.out.println("您输入的两个学生信息不相同");
}
}
public static Student getStu(){
System.out.println("请输入学生姓名:");
String name = sc.next();
System.out.println("请输入学生年龄:");
int age = sc.nextInt();
Student s = new Student(name,age); //调用了Studeet类
return s; //返回Student类对象引用
}
}
class Student {
private String name;
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(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;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) 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;
}
}
7、字符串是不可被改变的，本身就是一个对象，并没有像其他类的set方法来对其进行改变；字符串底层是一个字符数组
8、String构造方法:
在java1.8之后，就把String的char类型转换为了byte类型！！！
private final char value[];//jdk1.8
private final byte value[];//jdk1.9
- String(String original): 把字符串数据封装成字符串对象
- String(char[] value) : 把字符数组的数据封装成字符串对象
- String(char[] value, int index, int count): 把字符数组中的一部分数据封装成字符串对象
9、字符串常量池（在方法区中），jdk1.8版本之后, 字符串常量池从方法区移动到了堆内存
字符串常量池的概念:
* 当我们在使用双引号创建字符串对象的时候, 首先会检查该字符串在常量池中是否存在
*
* 如果不存在, 则创建
* 如果存在, 不再重复创建, 而是直接引用原有的字符串地址
*/
public static void main(String[] args) {
String s1 = "123";
String s2 = new String("123"); //s2会指向堆内存中的123，不是常量池中的，此步骤创建了两个对象，字符串常量池和堆内存中都有一个
String s3 = "123";
System.out.println(s1 == s2);//false
System.out.println(s1 == s3);//true
}
}
public class TestString {
public static void main(String[] args) {
String s1 = "abc";
String s2 = "a" + "b" + "c"; // Java有常量优化机制, 在编译生成字节码的时候, 就会将该代码变成 String s2 = "abc";
System.out.println(s1 == s2); // true ！！！！！！！！！
}
public static void method3() {
String s1 = "abc"; //当字符串之间使用+号进行串联的时候，底层都会自动创建一个字符串缓冲区StringBuilder，底层调用append方法完成字符串的拼接
String s2 = "ab";
String s3 = s2 + "c";
System.out.println(s1 == s3); // false
}
public static void method2() {
String s1 = "123";
String s2 = new String("123");
System.out.println(s1 == s2); // false s1记录的是常量池地址, s2记录的是堆内存地址
// s2中的字符串数据, 是常量池中的副本
}
public static void method1() {
String s1 = "123";
String s2 = "123";
System.out.println(s1 == s2); // true 因为s1和s2都是指向常量池中的地址
}
}
10、不错的程序
/*
* 需求: 模拟登录,给三次机会,并提示还有几次
* 1. 创建键盘录入对象, 准备接受数据
* 2. 调用两次next方法, 接受字符串类型的用户名和密码
* 3. 假设用户名和密码都是"admin", 让键盘录入的用户名和密码进行比较
*/
public static void main(String[] args) {
// 1. 创建键盘录入对象, 准备接受数据
Scanner sc = new Scanner(System.in);
for(int i = 1; i <= 3; i++){
// 2. 调用两次next方法, 接受字符串类型的用户名和密码
System.out.println("请输入用户名:");
String userName = sc.next();
System.out.println("请输入密码:");
String passWord = sc.next();
// 3. 假设用户名和密码都是"admin", 让键盘录入的用户名和密码进行比较
if("admin".equals(userName) && "admin".equals(passWord)){
//！！！！
System.out.println("登陆成功");
// 4. 如果登陆成功, 结束循环
break;
}else{
// 5. 如果循环到达了最后一次, 给出特殊的提示
if(i == 3){
System.out.println("明儿再来");
}else{
System.out.println("登陆失败, 您还有" + (3-i) + "次机会");
}
}
}
}
}
11、获取字符串中的每一个字符
第一种遍历方式:
* int length():获取字符串的长度，其实也就是字符个数
* char charAt(int index):获取指定索引处的字符
* // StringIndexOutOfBoundsException --> 字符串索引越界异常
for(int i = 0; i < s.length(); i++){
System.out.println(s.charAt(i));//根绝i值来获取相应索引处的字符值
}
第二种遍历方式:
* char[] toChatArray() : 将字符串拆分成字符数组
char[] cArr = s.toCharArray();
for (int i = 0; i < cArr.length; i++) {
//获得字符数组
System.out.println(cArr[i]);
}
12、StringBuilder会提高效率
String是一个不可改变的字符序列
StringBuilder是一个可以改变的字符序列（初始容量是16个字符）
字符串的拼接: 每一次用+号串联的时候, 底层都会重新创建一个StringBuilder, 然后再通过append方法完成拼接, 最后通过toString方法转换成字符串
---这个步骤, 是每一次相加都会进行的步骤--- 所以说非常消耗内存
StringBuilder的拼接: 单独在堆内存中创建一块空间, 所有的数据拼接, 都在这一块空间内进行. 如果想转成字符串, 可以在拼接结束后, 手动调用toString方法进行转换.
public class Demo4_StringBuilder {
/*
* StringBuilder : 是一个可变的字符序列
*
* StringBuilder append(String str) : 返回该对象自己本身
*/
public static void main(String[] args) {
// 1. 创建一个空的字符串缓冲区(区域, 容器)
StringBuilder sb = new StringBuilder();
// 2. 调用append方法添加数据
StringBuilder sb1 = sb.append("aaa");
StringBuilder sb2 = sb.append("bbb");
System.out.println(sb1 == sb2); // true,不会重新开辟空间，返回的是自己！！！
// 链式编程: 如果一个方法的返回值是一个对象, 对象就可以继续向下调用方法
sb.append("红色").append("蓝色").append("绿色");
System.out.println(sb.reverse()); //直接反转
}
}
13、StringBuilder和String的相互转换
Scanner sc = new Scanner(System.in);
System.out.println("请输入:");
String s = sc.nextLine();
StringBuilder sb = new StringBuilder(s); //将字符串转为StringBuilder
System.out.println(sb.reverse()); //通过StringBuilder来进行字符串的反转，因为String里没有这个方法
sb.toString; //就可以转换为String了
public class Demo5_StringBuilder {
/*
* String和StringBuilder的相互转换
*
* 思路: 为什么两者需要相互转换呢?
*
* 有些时候, 我们需要用到的方法, String里面没有, 但StringBuilder里面有, 就可以进行转换.
*
* 1. String - StringBuilder
*
* 根据StringBuilder的构造方法即可
*
* StringBuilder(String s)
*
* 2. StringBuilder - String
*
* 调用StringBuilder的toString方法
*
* 需求: 键盘录入一个字符串, 判断该字符串是否是对称字符串
*
* 123321 123321
* 111 111
* 123123
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个对称字符串:");
String src = sc.next();
// 将字符串转换为StringBuilder目的就是为了调用反转的方法
StringBuilder sb = new StringBuilder(src);
// 将反转后的数据跟源字符串进行比对
String dest = sb.reverse().toString();
if(src.equals(dest)){
System.out.println("是对称字符串");
}else{
System.out.println("不是对称字符串");
}
}
}
14、StringBuilder是jdk1.5版本的，StringBuffer是jdk1.0版本的。StringBuilder是线程不安全的，StringBuffer是线程安全的。
15、总结
1. Object
* toString : 用于展示数据更加方便
1. 打印对象引用的时候, println默认会调用该对象的toString方法
2. 推荐重写类的toString方法, 让该方法打印对象的属性值
Person p = new Person("张三",23);
System.out.println(p);
alt + shift + s + s
* equals : 用于对象之间比较属性的
1. 如果没有重写Object类的equals方法, 默认比较的也是地址值
2. 推荐重写Object类的equals方法, 让对象的比较, 根据内容进行比较
alt + shift + s + h
2. String
特点:
1. String是一个不可改变的字符序列
2. 所有双引号都是String这个类的对象
思路:
char[]数组和String之间是可以相互转换的
字符数组 - 字符串 char[] cArr = {
'a','b','c'};
String s = new String(cArr);
字符串 - 字符数组 String s = "abc";
char[] cArr = s.toCharArray();
构造方法:
1. String(String s); // 将传入的字符串, 封装为字符串对象, 但是这种方式会创建两个字符串对象
2. String(char[] value); // 将传入的字符数组, 转换为字符串
3. String(char[] value, int index, int count);
// 将字符数组的一部分转换为字符串
成员方法:
1. int length() : 返回字符串中字符出现的个数
2. char[] toCharArray() : 将一个字符串拆分成字符数组
3. char charAt(int index) : 根据索引获取字符
4. boolean equals() : 比较两个字符串的内容是否相同, 区分大小写
5. boolean equalsIgnoreCase() : 比较两个字符串的内容是否相同, 忽略大小写
3. StringBuilder
1. StirngBuilder是可以改变的字符序列
2. StringBuilder是字符串的缓冲区, 可以对于字符串的操作, 提高效率
构造方法:
StringBuilder() : 创建一个空的字符串缓冲区, 里面不带任何任务
StringBuilder(String s) : 创建一个字符串缓冲区, 里面带有传入的字符串数据
成员方法:
StringBuilder(自己) append(任意类型);
append方法支持链式编程.
StringBuilder reverse() : 对整个缓冲区的内容, 进行反转.
int length() : 获取缓冲区中的字符的个数
String toString() : 将字符串缓冲区, 转换为String字符串
重点:
String - StringBuilder的相互转换
String - StringBuilder 可以通过StringBuilder的构造方法
StringBuilder sb = new StringBuilder("abc");
StringBuilder - String
可以通过toString方法，sb.toString();