1、Object类
java中所有的类默认都有一个共同的父类:Object
== 比较:
1、比较的是两个基本数据类型的话,比较两个数值是否相等
2、比较的是两个引用数据类型的话,比较的是两个对象的地址值是否相等
成员方法:
int hashCode() 返回对象的哈希码值。 可以看作地址值的另外一种表现形式
public final Class getClass() 返回此 Object的运行时类。 获取当前类的class文件对象, 一个类全局只有一个在方法区中
public String toString()
打印一个对象名,默认调用的是类中的toString()方法
若我们自己没有编写该方法的话,默认使用父类Object类中的toString()
而父类中默认的toString()打印是一个地址值
我们今后打印一个对象名的时候,输出是地址值意义不大,我们今后更多的是想看一个对象中成员变量值的情况
要想实现上面的输出成员变量值的话,重写toString()方法,这样调用的就是自己重写后的toString()
自动生成即可
代码案例
class Student{
String name;
int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class ObjectDemo1 {
public static void main(String[] args) {
// Student s1 = new Student();
// Student s2 = new Student();
//
// System.out.println(s1.hashCode());
// System.out.println(s2.hashCode());
//
// System.out.println(s1==s2);
//
// Class c1 = s1.getClass();
// System.out.println(c1.getName());
Student s1 = new Student("李刚", 18);
// System.out.println(s1.hashCode());
// System.out.println(s1.getClass().getName() );
// System.out.println(s1.toString()); // com.shujia.day10.Student@4554617c
//this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
System.out.println(s1.toString());
}
}
public boolean equals(Object obj)
protected void finalize() 垃圾回收用的
equals()用法代码
import java.util.Objects;
class Student2{
String name;
int age;
public Student2() {
}
public Student2(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student2{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student2 student2 = (Student2) o;
return age == student2.age && Objects.equals(name, student2.name);
}
}
public class ObjectDemo3 {
public static void main(String[] args) {
Student2 s1 = new Student2("李刚", 21);
Student2 s2 = new Student2("李刚", 21);
//默认情况下,若对象类中没有自己编写equals方法,默认使用的是父类中Object类中的equals方法
//而父类中Object类中的equals方法底层调用的是==比较,若比较的是引用数据类型,比较的是地址值
//而我们这里s1和s2接受的是不同两个对象的地址值,所以默认比较的结果是false
// System.out.println(s1.equals(s2));
//需求:当对象的姓名和年龄一样的时候,表示是同一个学生
//比较的对象类中自己重写一个equals方法,自动生成即可
System.out.println(s1.equals(s2));
}
}
protected Object clone()
java中并不是所有的类都可以被克隆,只有授权的类的对象才可以使用克隆方法
我们通过阅读帮助文档后发现,若一个对象的类没有实现Cloneable接口的话,是不可以调用clone方法的
然后,我们再去看Cloneable接口的时候,发现该接口中没有任何抽象方法,今后像这样的接口称之为标记接口
克隆在IT行业中,称之为拷贝。
拷贝分为两种:
1、浅拷贝
2、深拷贝
面试题:Object类中的clone是浅拷贝还是深拷贝。答:是浅拷贝
代码案例
class Demo1 {
int a = 10;
}
class Student3 implements Cloneable {
String name;
int age;
Demo1 demo1;
public Student3() {
}
public Student3(String name, int age, Demo1 demo1) {
this.name = name;
this.age = age;
this.demo1 = demo1;
}
@Override
public String toString() {
return "Student3{" +
"name='" + name + '\'' +
", age=" + age +
", demo1=" + demo1 +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class ObjectDemo4 {
public static void main(String[] args) throws Exception {
Demo1 d1 = new Demo1();
Student3 s1 = new Student3("刘亦菲", 36, d1);
System.out.println("s1: " + s1);
System.out.println(s1.hashCode());
// Student3 s2 = new Student3("章若楠", 21);
System.out.println("===========================================");
//首先,如果此对象的类不实现接口Cloneable ,则抛出CloneNotSupportedException 。
// Object o1 = s1.clone();
Object o1 = s1.clone();
System.out.println("o1: " + o1);
System.out.println(o1.hashCode());
}
}
二、Scanner类
Scanner: 一个简单的文本扫描器,可以使用正则表达式解析原始类型和字符串。
构造方法:
Scanner(InputStream source) 构造一个新的 Scanner ,产生从指定输入流扫描的值。
代码案例
import java.util.Scanner;
public class ScannerDemo1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//获取一个数字:
// int i = sc.nextInt();
// System.out.println(i);
//
// String s1 = sc.next();
// System.out.println(s1);
//获取数字的时候,我们是不是只能够输入数字呢?
// System.out.println("请输入一个数字:");
//hasNextXxx()判断下一个输入的内容是否是指定类型
// if(sc.hasNextInt()){
// int i = sc.nextInt();
// System.out.println(i);
// }else {
// System.out.println("您输入的内容不是一个int类型的值!");
// }
// int i = sc.nextInt();
// System.out.println(i);
String s1 = sc.next(); //无法接收换行等空白特殊字符
System.out.println(s1);
//输入字符串的另外一种方法
// String s1 = sc.nextLine(); //可以接收换行等空白特殊字符
// System.out.println(s1);
System.out.println("hello world");
}
}
3、String类
字符串:由若干个字符构成的字符序列叫做字符串
String类代表字符串。
Java程序中的所有字符串文字(例如"abc" )都被实现为此类的实例。
字符串不变; 它们的值在创建后不能被更改指的是字符串本身不能改
因为String对象是不可变的,它们可以被共享。
字符串可以被看作成一个字符数组
String类中的构造方法:
public String()
public String(byte[] bytes)
public String(byte[] bytes,int offset,int length)
public String(char[] value)
public String(char[] value,int offset,int count)
public String(String original)
代码案例
public class StringDemo2 {
public static void main(String[] args) {
//public String() 创建一个空字符串
String s1 = new String(); // 堆内存
System.out.println("s1: " + s1);
// String s2 = ""; // 常量池
// System.out.println(s1==s2);
System.out.println("=============================");
//public String(byte[] bytes) 将字节数组转成一个字符串
byte[] bytes = {97,98,99,100,101,102};
String s2 = new String(bytes);
System.out.println("s2: "+s2);
System.out.println("=============================");
//public String(byte[] bytes,int index,int length) 从字节数组的某个位置开始,向后截取变成字符串
String s3 = new String(bytes, 2, 3);
System.out.println("s3: "+s3);
System.out.println("=============================");
//public String(char[] value) //将一个字符数组转成一个字符串
char[] chars = {'我','爱','中','华'};
String s4 = new String(chars);
System.out.println("s4: "+s4);
System.out.println("=============================");
//public String(char[] value,int index,int length) 将字符数组一部分转成字符串
String s5 = new String(chars,1,2);
System.out.println("s5: "+s5);
System.out.println("=============================");
//public String(String original) 将字符串封装成一个String对象在堆内存中
String s6 = new String("你好");
System.out.println("s6: "+s6);
}
}
String类中的判断功能
String类中的判断功能:
boolean equals(Object obj)
boolean equalsIgnoreCase(String str)
boolean contains(String str)
boolean startsWith(String str)
boolean endsWith(String str)
boolean isEmpty()
代码案例
public class StringDemo4 {
public static void main(String[] args) {
//boolean equals(Object obj) 比较两个字符串的内容值
String s1 = "hello";
String s2 = "HellO";
System.out.println(s1.equals(s2));
//boolean equalsIgnoreCase(String str) 忽略大小写比较字符串内容值
System.out.println(s1.equalsIgnoreCase(s2));
//boolean contains(String str) 判断大字符串中是否包含某一个小字符串
String s3 = "今天的天气还可以李刚决定去洗个脚";
System.out.println(s3.contains("李刚决"));
//boolean startsWith(String str) 判断字符串是否以某个字符串开头
System.out.println(s3.startsWith("今天的天气数可以"));
// boolean endsWith(String str) 判断字符串是否以某个字符串结尾
System.out.println(s3.endsWith("洗个脚"));
//boolean isEmpty() 判断字符串是否为空字符串,指的是内容是否为空
String s4 = "";
System.out.println(s4.isEmpty());
String s5 = null;
// System.out.println(s5.isEmpty()); // NullPointerException
}
}
String类中的获取功能
String类中的获取功能:
int length()
char charAt(int index)
int indexOf(int ch)
int indexOf(String str)
int indexOf(int ch,int fromIndex)
int indexOf(String str,int fromIndex)
String substring(int start)
String substring(int start,int end)
代码案例
public class StringDemo5 {
public static void main(String[] args) {
String s = "李刚在数加学院中学习非常快乐!";
//int length() 获取字符串中的字符个数,字符串长度
System.out.println(s.length());
//char charAt(int index) 根据索引获取字符串中某一个字符
//字符串可以被看作成一个字符数组
// System.out.println(s.charAt(15)); // StringIndexOutOfBoundsException
//int indexOf(int ch) 根据ascii码值获取对应字符所在的索引位置,左边起第一个
String s2 = "qweasdsafqe";
System.out.println(s2.indexOf(104)); // -1
//int indexOf(int ch,int fromIndex) 从某个索引开始向后寻找某个字符,返回找到字符在整个大字符串中的索引位置
System.out.println(s2.indexOf(97,5)); // 7
//int indexOf(String str) 获取大字符串中小字符串的位置,返回小字符串第一个字符的索引
System.out.println(s2.indexOf("sdsa")); // 4
//int indexOf(String str,int fromIndex) 从某个索引开始向后寻找某个字符,返回找到字符串第一个字符在整个大字符串中的索引位置
System.out.println(s2.indexOf("saf",3)); // 6
//String substring(int start) // 从指定位置向后截取,返回新的字符串
String s3 = "李刚是真的帅!江川很不服,钱志强觉得自己是最帅的!";
String res1 = s3.substring(3);
System.out.println(res1);
//String substring(int start,int end) 截取字符串中的一部分 [start, end)
String res2 = s3.substring(7, 12);
System.out.println(res2);
}
}
String转换功能
String转换功能:
byte[] getBytes()
char[] toCharArray()
static String valueOf(char[] chs)
static String valueOf(int i)
String toLowerCase()
String toUpperCase()
String concat(String str)
代码案例
public class StringDemo6 {
public static void main(String[] args) {
String s1 = "abcdefg";
//byte[] getBytes() 将字符串转字节数组
byte[] bytes = s1.getBytes();
for(int i=0;i<bytes.length;i++){
System.out.println(bytes[i]);
}
System.out.println("----------------");
// for(byte b : bytes){
// System.out.println(b);
// }
// System.out.println("----------------");
// System.out.println(Arrays.toString(bytes));
// System.out.println("----------------");
//char[] toCharArray() 将字符串转字符数组
char[] chars = s1.toCharArray();
for(int i=0;i<chars.length;i++){
System.out.println(chars[i]);
}
System.out.println("----------------");
String s3 = new String(chars);
System.out.println(s3);
//static String valueOf(char[] chs) 将字符数组转字符串
String s2 = String.valueOf(chars);
System.out.println(s2);
//static String valueOf(int i)
System.out.println(String.valueOf(100)); // 100 -> "100"
//String toLowerCase() 转小写
String s4 = "HellOWOrlD";
String res1 = s4.toLowerCase();
System.out.println(res1);
//String toUpperCase()
String res2 = s4.toUpperCase();
System.out.println(res2);
//String concat(String str) 字符串拼接操作
String res3 = "李刚".concat("真帅!");
System.out.println(res3);
}
}
String其它功能
String其它功能:
替换功能
String replace(char old,char new)
String replace(String old,String new)
去除字符串两空格
String trim()
按字典顺序比较两个字符串
int compareTo(String str)
int compareToIgnoreCase(String str)
代码案例
public class StringDemo7 {
public static void main(String[] args) {
String s1 = "dasqwajavadwqrajjavaiojadjavafq-aedjavaqajiqa";
//String replace(char old,char new) 由新字符替换字符串中所有旧字符
String res1 = s1.replace('a', '$');
System.out.println(s1);
System.out.println(res1);
//String replace(String old,String new) 由新的字符串替换旧的字符串
String res2 = s1.replace("java", "李刚");
System.out.println(res2);
//String trim() 去除字符串两边的空格
String s2 = " hello world ";
System.out.println("s2: "+s2);
String res3 = s2.trim();
System.out.println("res3: "+res3);
//int compareTo(String str) 按字典顺序比较两个字符串是否相同 当结果是0的时候表示两个字符串内容相同
String s3 = "hello";
String s4 = "world";
String s5 = "hel";
String s6 = "hello";
System.out.println(s3.compareTo(s4)); // -15
System.out.println(s3.compareTo(s5)); // 2
System.out.println(s3.compareTo(s6)); // 0
}
}
compareTo源码解释
class String{
//s3.compareTo(s4)
//s3 - "hello"
//s4 - "hel"
public int compareTo(String anotherString) {
// this - "hello"
// anotherString - "hel"
int len1 = this.value.length; // 5
int len2 = anotherString.value.length; // 3
int lim = Math.min(len1, len2); // 3
char[] v1 = value; // ['h','e','l','l','o']
char[] v2 = anotherString.value; // ['h','e','l']
int k = 0;
while (k < lim) {
char c1 = v1[k]; // 'h' 'e' 'l'
char c2 = v2[k]; // 'h' 'e' 'l'
if (c1 != c2) {
return c1 - c2; // 104 - 119 = -15
}
k++;
}
return len1 - len2; // 5-3=2
}
}
标签:java,String,int,Object,System,day10,println,public,out
From: https://www.cnblogs.com/w-ll/p/18450765