首页 > 编程语言 >Java基础语法(14)| Object类、String类

Java基础语法(14)| Object类、String类

时间:2024-04-10 18:29:37浏览次数:43  
标签:Java 14 int Object System String 字符串 println out

1.Object类

Object类概述

 java.lang.Object类是Java语言中的根类,即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时 候,最终找的父类就是Object。如果一个类没有特别指定父类,那么默认则继承自Object类。例如:

public class MyClass  {  	
}
public class MyClass extends Object{}

 其中的两个方法

方法名说明
public String toString()返回该对象的字符串表示。
public boolean equals(Object obj)指示其他某个对象是否与此对象“相等”。

 toString方法

public String toString():返回该对象的字符串表示。

toString方法返回该对象的字符串表示,其实该字符串内容就是对象的类型+@+内存地址值。

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

  • 覆盖重写

如果不希望使用toString方法的默认行为,则可以对它进行覆盖重写。

(在IDEA中我们可以使用快捷键 atl + inset 快速生成toString方法)

例如自定义的Person类

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

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

    // 省略构造器与Getter Setter
}

equals方法

public boolean equals(Object obj):指示其他某个对象是否与此对象“相等”。

调用成员方法equals并指定参数为另一个对象,则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。

 默认比较方式

如果没有覆盖重写equals方法,那么Object类中默认进行==运算符的对象地址比较,只要不是同一个对象,结果必然为false。

 重写equals方法

如果希望进行对象的内容比较,即所有指定的部分成员变量相同就判定两个对象相同,则可以覆盖重写equals方法。

(在IntelliJ IDEA中,可以使用Code菜单中的Generate…选项,也可以使用快捷键alt+insert,并选择equals() and hashCode()进行自动代码生成 )

public class Student extends Object {
    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;
    }    
    //直接自动生成即可 alt + insert 生成
    @Override
    public boolean equals(Object obj) {
        // 转换为当前类型
        Student s = (Student)obj;
        if(this.name.equals(s.name) && this.age == s.age) {
            return true;
        }else {
            return false;
        }
    }
}
public class StudentDemo {
    public static void main(String[] args) {
        Student s1 = new Student("yanqi",20);
        Student s2 = new Student();

        // ==:比较引用类型比较的是地址值是否相同
        System.out.println(s1 == s2 );//false

        // ==: 比较基本数据类型比较的是值是否相同
        int a = 3;
        int b = 4;
        System.out.println(a == b );//false
        System.out.println("====================");

        //equals: 比较两个对象比较的是地址值是否相同
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equals(s1));//true
        System.out.println("================");

        //我们重写equals,让比较两个对象的值
        Student s4 = new Student("yanqi",20);
        System.out.println(s1.equals(s4));
        
        System.out.println("基本数据类型不能使用equals,因为只有类才可以继承object");
    }
}

2. String类

 String类概述

String 类代表字符串。Java程序中所有的字符串文字(例如 "abc" )都可以被看作是实现此类的实例。

String类 中包括用于检查各个字符串的方法,比如用于比较字符串,搜索字符串,提取子字符串以及创建具有翻译为大写小写的所有字符的字符串的副本。

 String类的特点

字符串不变:字符串的值在创建后不能被更改

String s1 = "abc"; 
s1 += "d"; 
System.out.println(s1); // "abcd" 
// 内存中有"abc","abcd"两个对象,s1从指向"abc",改变指向,指向了"abcd"。

因为String对象是不可变的,所以它们可以被共享

String s1 = "abc";
String s2 = "abc";
// 内存中只有一个"abc"对象被创建,同时被s1和s2共享。

String的本质

  • JDK8之前是char[] 数组

  • JDK8之后是byte[] 数组

 String 类使用步骤

查看类

java.lang.String:此类不需要导入

 查看构造方法

方法名说明
public String()初始化新创建的String对象,以使其表示空字符序列
public String(char[] value)通过当前参数中的字符数组来构造新的String。
String(char[] value, int offset, int count)通过当前参数中的字符数组的一部分来构造新的String。
public String(byte[] bytes)通过使用平台的默认字符集解码当前参数中的字节数组来构造新的
String(byte[] bytes, int offset, int length)通过使用平台的默认字符集解码当前参数中的字节数组的一部分来构造新的String

代码示例:

// 无参构造
String str = new String();
// 通过字符数组构造
char chars[] = {'a', 'b', 'c'};     
String str2 = new String(chars);

// 通过字节数组构造
byte bytes[] = { 97, 98, 99 };     
String str3 = new String(bytes);

String类常用的方法

判断功能的方法

String类的判断功能:
boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
boolean contains(String str):判断大字符串中是否包含小字符串
boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
boolean isEmpty():判断字符串是否为空。
注意:
字符串内容为空和字符串对象为空。
String s = "";内容为空
String s = null; 字符串对象为空

代码示例:

public class StringDemo {
	public static void main(String[] args) {
		// 创建字符串对象
		String s1 = "helloworld";
		String s2 = "helloworld";
		String s3 = "HelloWorld";

		// boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
		System.out.println("equals:" + s1.equals(s2));
		System.out.println("equals:" + s1.equals(s3));
		System.out.println("-----------------------");

		// boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
		System.out.println("equals:" + s1.equalsIgnoreCase(s2));
		System.out.println("equals:" + s1.equalsIgnoreCase(s3));
		System.out.println("-----------------------");

		// boolean contains(String str):判断大字符串中是否包含小字符串
		System.out.println("contains:" + s1.contains("hello"));
		System.out.println("contains:" + s1.contains("hw"));//false 一定是连在一起的
		System.out.println("-----------------------");

		// boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
		System.out.println("startsWith:" + s1.startsWith("h"));
		System.out.println("startsWith:" + s1.startsWith("hello"));
		System.out.println("startsWith:" + s1.startsWith("world"));
		System.out.println("-----------------------");
		// 练习:boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾这个自己玩
		// boolean isEmpty():判断字符串是否为空。
		System.out.println("isEmpty:" + s1.isEmpty());
		String s4 = "";
		String s5 = null;
		System.out.println("isEmpty:" + s4.isEmpty());
		// NullPointerException
		// s5对象都不存在,所以不能调用方法,空指针异常
		System.out.println("isEmpty:" + s5.isEmpty());
	}
}

获取功能的方法

  • public int length() :返回此字符串的长度

  • public String concat(String str): 将指定的字符串连接到该字符串的末尾。

  • public char charAt(int index): 返回指定索引处的char值。

  • public int indexOf(int ch):返回指定子字符串第一次出现在该字符串内的索引。

  • public String substring(int beginIndex):返回一个子字符串,从beginIndex开始截取字符串到字符串结尾。

  • public String substring(int beginIndex,int endIndex):返回一个子字符串,从beginIndex到endIndex截取字符串。含beginIndex,不含endIndex。

代码示例:

/*
 * String类的获取功能
 * int length():获取字符串的长度。
 * char charAt(int index):获取指定索引位置的字符
 * int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
 * 		为什么这里是int类型,而不是char类型?
 * 		原因是:'a'和97其实都可以代表'a'
 * 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 StringDemo {
	public static void main(String[] args) {
		// 定义一个字符串对象
		String s = "helloworld";

		// int length():获取字符串的长度。
		System.out.println("s.length:" + s.length());
		System.out.println("----------------------");

		// char charAt(int index):获取指定索引位置的字符
		System.out.println("charAt:" + s.charAt(7));
		System.out.println("----------------------");

		// int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
		System.out.println("indexOf:" + s.indexOf('l'));
		System.out.println("----------------------");

		// int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
		System.out.println("indexOf:" + s.indexOf("owo"));
		System.out.println("----------------------");

		// int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
		System.out.println("indexOf:" + s.indexOf('l', 4));//从第4个索引开始找l第一次出现的位置
		System.out.println("indexOf:" + s.indexOf('k', 4)); // -1
		System.out.println("indexOf:" + s.indexOf('l', 40)); // -1如果没有就返回-1
		System.out.println("----------------------");

		// 自己练习:int indexOf(String str,int
		// fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。

		// String substring(int start):从指定位置开始截取字符串,默认到末尾。包含start这个索引
		System.out.println("substring:" + s.substring(5));
		System.out.println("substring:" + s.substring(0));
		System.out.println("----------------------");

		// String substring(int start,int
		// end):从指定位置开始到指定位置结束截取字符串。包括start索引但是不包end索引,包左不包
		System.out.println("substring:" + s.substring(3, 8));
		System.out.println("substring:" + s.substring(0, s.length()));
	}
}

 字符串遍历

/*
 * 需求:遍历获取字符串中的每一个字符  
 * 分析:
 * 		A:如何能够拿到每一个字符呢?
 * 			char charAt(int index)
 * 		B:我怎么知道字符到底有多少个呢?
 * 			int length()
 */
public class StringTest {
	public static void main(String[] args) {
		// 定义字符串
		String s = "helloworld";
		// 原始版本
		// 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(s.charAt(5));
		// System.out.println(s.charAt(6));
		// System.out.println(s.charAt(7));
		// System.out.println(s.charAt(8));
		// System.out.println(s.charAt(9));

		// 只需要我们从0取到9
		// for (int x = 0; x < 10; x++) {
		// System.out.println(s.charAt(x));
		// }
		// 如果长度特别长,我不可能去数,所以我们要用长度功能
		for (int x = 0; x < s.length(); x++) {
			// char ch = s.charAt(x);
			// System.out.println(ch);
			// 仅仅是输出,我就直接输出了
			System.out.println(s.charAt(x));
		}
	}
}

转换功能的方法

  • public char[] toCharArray():将此字符串转换为新的字符数组。

  • public byte[] getBytes():使用平台的默认字符集将该String编码转换为新的字节数组。

  • public String replace(char oldChar, char newChar):将oldChar匹配的字符串使用newChar字符串替换。

  • public String replaceFirst(String regex,String replacement)用给定的 replacement 替换此字符串匹配给定的regex的第一个子字符串。

  • public String toUpperCase() : 将字符中转换为大写

  • public String toLowerCase(): 将字符中转换为小写

代码示例: 

/*
 * String的转换功能:
 * byte[] getBytes():把字符串转换为字节数组。
 * char[] toCharArray():把字符串转换为字符数组。
 * static String valueOf(char[] chs):把字符数组转成字符串。
 * static String valueOf(int i):把int类型的数据转成字符串。
 * 		注意:String类的valueOf方法可以把任意类型的数据转成字符串。
 * String toLowerCase():把字符串转成小写。
 * String toUpperCase():把字符串转成大写。
 * String concat(String str):把字符串拼接。
 */
public class StringDemo {
	public static void main(String[] args) {
		// 定义一个字符串对象
		String s = "JavaSE";

		// byte[] getBytes():把字符串转换为字节数组。
		byte[] bys = s.getBytes();
		for (int x = 0; x < bys.length; x++) {
			System.out.println(bys[x]);
		}
		System.out.println("----------------");
		// char[] toCharArray():把字符串转换为字符数组。
		char[] chs = s.toCharArray();
		for (int x = 0; x < chs.length; x++) {
			System.out.println(chs[x]);
		}
		System.out.println("----------------");
        
		// static String valueOf(char[] chs):把字符数组转成字符串。
		String ss = String.valueOf(chs);
		System.out.println(ss);
		System.out.println("----------------");
		// static String valueOf(int i):把int类型的数据转成字符串。
		int i = 100;
		String sss = String.valueOf(i);
		System.out.println(sss);
		System.out.println("----------------");
		// String toLowerCase():把字符串转成小写。
		System.out.println("toLowerCase:" + s.toLowerCase());
		System.out.println("s:" + s);
		// System.out.println("----------------");
		// String toUpperCase():把字符串转成大写。
		System.out.println("toUpperCase:" + s.toUpperCase());
		System.out.println("----------------");
		// String concat(String str):把字符串拼接。
		String s1 = "hello";
		String s2 = "world";
		String s3 = s1 + s2;
		String s4 = s1.concat(s2);
		System.out.println("s3:"+s3);
		System.out.println("s4:"+s4);
	}
}

 分割-替换-去空格-正则的功能方法

  • public String[] split(String regex):将此字符串按照给定的regex(规则)拆分为字符串数组。

  • public String trim():去除该字符串的两端空格

代码示例:

public class String_Demo03 {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "aa|bb|cc";
        String[] strArray = s.split("\\|"); // ["aa","bb","cc"]   
        for(int x = 0; x < strArray.length; x++) {
            System.out.println(strArray[x]); // aa bb cc
        }        
        // 替换功能
		String s1 = "helloworld";
		String s2 = s1.replace('l', 'k');//字符
		String s3 = s1.replace("owo", "ak47");//字符串
		System.out.println("s1:" + s1);
		System.out.println("s2:" + s2);//hekkoworkd
		System.out.println("s3:" + s3);//hellak47rld
		System.out.println("---------------");       
        System.out.println("替换功能:"+s1);
        System.out.println(s1.replaceAll("\\s","e"));//把空格替换成e

		// 去除字符串两空格
		String s4 = " hello world  ";
		String s5 = s4.trim();
		System.out.println("s4:" + s4 + "---");
		System.out.println("s5:" + s5 + "---");
        
        //正则表达式-校验用户写的内容是否满足当前规定  手机号:123 4000 8888
        String s5 ="13140008888";
        boolean matches = s5.matches("^1[356789]\\d{9}$");
        System.out.println(matches);
        
    }
}

 

标签:Java,14,int,Object,System,String,字符串,println,out
From: https://blog.csdn.net/m0_46331650/article/details/137559591

相关文章

  • P3891 [GDOI2014] 采集资源 题解
    题面。看到大家都是两个动态规划的写法,来给大家讲一下只用一次动态规划的写法。思路设\(f_{i,j}\)表示工作效率为\(i\),获取\(j\)点资源所需的最短时间,不以苦工设状态是因为苦工会因为后面购买而改变,不太现实。\(tme\)表示答案,即到达\(t\)点资源所需的最短时间。从\(0......
  • JavaScript 中的深度学习
    JS-PyTorch是一个JavaScript库,从头开始构建,以紧密跟随PyTorch的语法。它以一种文档完备、单元测试和可解释的方式实现,因此可以帮助其他JavaScript学习者进入机器学习!欢迎尝试Web演示!(本文视频讲解:java567.com)1.简介src/tensor.ts包含一个完全功能的张量(Tensor)对象,可以......
  • Java登陆第四十二天——Axios拦截器
    如果想在axios发送HTTP请求之前。或者是接收响应之前做一些额外的工作,可以通过拦截器完成。Axios拦截器分为请求拦截器,响应拦截器。分别在请求或响应时生效。一图了解Axios拦截器提供了两种文本函数:名字太长,直接看语法语法格式如下://请求拦截器,f1对应请求发送成功函数,f2......
  • CF1466H 做题记录
    link非常adhoc的题,但是值得一练的好题!一眼下去,我们会发现这个条件真的太过于抽象,根本无法想象。注意到题目给了我们一个关键信息:一个排列组\(\{b_1,b_2,...,b_n\}\)对应唯一的好的分配方案。考虑建立图论模型:每个人的编号向最喜欢的物品编号连边,形成一棵内向基环树森林。......
  • java中实现Runnable接口
    在Java中,要实现Runnable接口,你需要创建一个类,并让这个类实现Runnable接口中的run方法。Runnable接口是一个只有一个抽象方法的函数式接口,该方法是run。以下是一个简单的例子,展示了如何实现Runnable接口:java//实现Runnable接口的类publicclassMyRunnableimplementsRunnabl......
  • java异常处理
    publicclassTestException{publicstaticvoidmain(String[]args){int[]arr={11,22,33};try{System.out.println(arr[5]);}catch(Exceptionex){}try{//saveAge(100);saveAge......
  • JavaScript实现文件大小转换、单位转换、toFixed、indexOf、substr、substring、B、KB
    constbytesToSize=(size)=>{if(size<0.1*1024){//小于0.1KB,则转化成Bsize=size.toFixed(2)+'B'}elseif(size<0.1*1024*1024){//小于0.1MB,则转化成KBsize=(size/1024).toFixed(2)+'KB'}else......
  • objectarx中,修改标注数据之后无效的解决方法
    最近在写objectarx的标注,发现同样的代码,有些标注可以修改成功,但是有些修改之后无效。但是修改颜色之类的可以起效果。能修改成功的标注都是自定义的标注,用默认的标注修改之后就无效,并且返回值也都是eok。修改之后立马去查看标注的顶点数据,发现是修改之后的。但是在等到把对象关闭......
  • Java代码(01)
    1.回文数判断(核心:如何把一个数倒过来)2.用减法实现商和余数3.求质数:4.可以进行强转5.数组作为返回值,函数名前面的int要加[]6.将一个数组中from到to的数组值复制到另一个数组中7.判断101到200之间有多少个素数并输出个数8.生成验证码9.打分1......
  • JavaScript 模块的循环加载
    "循环加载"(circulardependency)指的是,a脚本的执行依赖b脚本,而b脚本的执行又依赖a脚本。//a.jsvarb=require('b');//b.jsvara=require('a');通常,"循环加载"表示存在强耦合,如果处理不好,还可能导致递归加载,使得程序无法执行,因此应该避免出现。 但是实际上,这是很......