java object类常用方法 &String类及常用方法

A52091

已于 2022-04-22 13:35:50 修改

阅读量996

点赞数 1

分类专栏： java 文章标签： java

于 2022-04-21 18:23:06 首次发布

本文链接：https://blog.csdn.net/A52091/article/details/124319950

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Java Object 类

Java Object 类是所有类的父类，也就是说 Java 的所有类都继承了 Object，子类可以使用 Object 的所有方法。
Object 类位于 java.lang 包中，编译时会自动导入，我们创建一个类时，如果没有明确继承一个父类，那么它就会自动继承 Object，成为 Object 的子类。

类的常用重要方法

public String toString()
返回对象的字符串表示形式
举例：

public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        //调用person对象的方法toString()
        String s = person.toString();
        //com.yls.demo1.Person@1b6d3586  这是对象在内存中的“地址”
        System.out.println(s);
        //com.yls.demo1.Person@1b6d3586
        System.out.println(person);  
        //得出结论 输出语句中必须(默认）调用toString()方法 
        //无权更改，sun公司规定死的
        //输出语句System.out.println(对象)调用对象的toString()
        //System.out.println(对象)==System.out.println(对象.toString())
    }
}

在实际开发中，一般重写父类的toString()方法，不用默认的对象地址表现形式，而是建立我们自己的字符串表现形式

重写父类toString()方法

public class Person {
    /**
     * 重写父类的方法toString
     * 返回字符串
     * @return
     * 重写方法的目标：方法中，返回类中成员变量的值
     */
    private  String name;
    private  int age;
    public Person(){}
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString(){
        return name +":" + age;
    }
}


public class Test {
    public static void main(String[] args) {
        Person person = new Person("李四",25);
        //调用person对象的方法toString()
        String s = person.toString();
        //李四:25
        System.out.println(s);
        //李四:25
        System.out.println(person);  
    }
}

boolean equals(Object obj)
比较两个对象是否相等，java认为任何对象都有可比性
object 类方法equals源码：

public boolean equals(Object obj) {
        return (this == obj);
    }
    //this指调用者，obj指传入的Object对象参数

默认比较对象的内存地址
但是一般对象的地址没有可比性，所以我们需要重写我们的equals方法，建立我们对象自己的比较形式
举例如下：


    @Override
    public boolean equals(Object obj){
        //健壮性判断1，如果obj的值为null，比较的另一个对象不存在
        if (obj == null) {
            return false;
        }
        //健壮性判断2，判断this和obj是不是一个对象，如果是就直接返回true
        if(this == obj){
            return true;
        }
        //这里涉及一个多态的问题，
        //obj应该向下转型为Person才可以调用age
        //同时需注意安全性判断
        if (obj instanceof Person) {
            Person p = (Person) obj;
            return this.age == p.age;
        }
        //不是Person 没有可比性
        return false;
    }


 Person person = new Person("李四",25);
 Person person1 = new Person("王二", 25);
 boolean b = person.equals(person1);
 System.out.println(b);   //true

String 字符串类

java.lang.Object
java.lang.String
All Implemented Interfaces:
Serializable ， CharSequence ， Comparable < String >
继承Object类，实现三个接口，字符串对象是常量，一旦创建不能修改
程序中只要写" ",都是String类的对象

字符串的实现原理
字符串数据类型在Java中是不存在的，其实现原理是char[]数组表示的
“abc” 实际上是char[] ch = {’a’, ‘b’, ‘c’}来表示
JDK9版本之后，为了节约内存，char数组变为byte数组
JDK8及以前都是char数组

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];   //成员变量char数组
	......

数组前修饰符final，表示最终数组，一旦建立其地址就被锁死（常量）为了线程安全。

字符串常量的特性

   public static void main(String[] args) {
        String a = "abc";
        String s = new String("abc");  //new对象新开一片堆，与a String对象中的数组地址不一样
        System.out.println(a == s);   //false
        System.out.println("---------------");

        /**
         * s1保存的是String对象
         * s2 = "hello" 和s1中的字符串在内存中的数组表现是一样的 ，JVM为了节约内存两者共用
         * s1的地址赋值给s2
         */
        String s1 = "hello";
        String s2 = "hello";
        System.out.println(s1==s2); //true
        System.out.println("---------------");

        /**
         * s3 和 s4都是变量，变量在编译的时候，javac不确定变量的计算结果是什么
         * 运行的时候jvm会为s3＋s4的结果新开内存空间
         */
        String s3 = "hhh";
        String s4 = "ooo";
        String s5 ="hhhooo";
        System.out.println(s5 ==(s3+s4)); //false
        System.out.println("---------------");
        /**
         * "hhh" "ooo" 是常量，值在编译期间就已经确定
         * 运行时期不会建立新的内存空间
         */
        System.out.println(s5==("hhh"+"ooo"));//true

    }

字符串构造方法

String(byte[] bytes)
通过使用平台的默认字符集解码指定的字节数组来构造新的 String 。
String(byte[] bytes, int offset, int length)
字节数组转换为字符串，使用平台默认字符集，参数off代表数组开始，len代表转换的个数
String(byte[] bytes, String charsetName)
charsetName是你自己可以指定的编码表比如在idea上指定GBK
GBK编码为了和英文区别都是负值的
2字节表示一个汉字
utf-8是3个字节表示一个汉字

    public static void Byte2string(){
        /**
         * String(byte[] bytes)
         * 通过使用平台的默认字符集解码指定的字节数组来构造新的 String
         * wiodows 中文版 默认字符集是GBK  ，idea启动时为jvm添加启动参数会把默认字符集改为UTF-8
         */
        byte[] b ={97,98,99};
        String s = new String(b);
        System.out.println(s); //abc

        //数组的一部分转换为字符串
        //从索引1开始，两个字符
        String s1 = new String(b,1,2);
        System.out.println(s1);//bc
    }
    public static void main(String[] args) {
        Byte2string();
    }

只有byte数组是和编码表有关，其他都无关

String(char[] value)
将数组变为字符串
String(char[] value, int offset, int length)
数组转换为字符串，参数off代表数组开始，len代表转换的个数

    public static void Char2string(){
        //构造方法，数组转为字符串
        char ch [] ={'a','b','c','q'};
        String s = new String(ch);
        System.out.println(s);//abcq
        //数组转为字符串转一部分
        String s1 = new String(ch, 1, 2);
        System.out.println(s1);//bc
    }

String类的常用方法

String类的判断方法

boolean equals(Object anObject)
将此字符串与指定对象进行比较。
boolean equalsIgnoreCase(String anotherString)
将此 String与其他 String比较，忽略案大小写
boolean startsWith(String str)
判断字符串是否以另一个字符串开头，是的化就返回true
boolean endsWith(String str)
判断字符串是否以另一个字符串结尾，是的化就返回true
boolean contains(CharSequence s)
当且仅当此字符串包含指定的char值序列时才返回true。
boolean isEmpty()
判断字符串长度是不是0，如果当且仅当是0就返回true

 /**boolean equals(Object anObject)
         * 字符串直接的比较
         * String继承自Object，重写父类方法
         */
        boolean b  = "abcd".equalsIgnoreCase("ABCD");
        boolean c  = "abcd".equals("abcD");
        boolean d = "Hello,world".startsWith("Hello");
        boolean e = "world,Hello".endsWith("Hello");
        boolean f = "Hello fine".contains("fi");
        boolean ff = "Hello fine".contains("if");

        System.out.println(b);  //true
        System.out.println(c);  //false
        System.out.println(d);  //ture
        System.out.println(e);  //true
        System.out.println(f);  //true
        System.out.println(ff); //false

sun重写的equals方法如下

 public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

String 类的获取方法，返回值不一定

int length()返回字符串长度，字符串中字符的个数
char charAt(int index) 返回指定索引上的单个字符
int indexOf(String str)返回指定的字符串，在当前字符串中第一次出现的索引
int lastindexOf(String str)返回指定的字符串，在当前字符串中最后一次出现的索引
String substring(int start,int end)截取字符串，参数表示开始和结束索引，其中截取包含开始索引，不包含结束索引

 		//int length()返回字符串长度，字符串中字符的个数
        int length = "abcde".length();
        System.out.println(length);// 5
        //char charAt(int index) 返回指定索引上的单个字符
        char chr = "hedfgg".charAt(3);
        System.out.println(chr); //f
        //int indexOf(String str)返回指定的字符串，在当前字符串中第一次出现的索引
        int index = "hello word so smart".indexOf("s");
        System.out.println(index);//11
        //以s第一次出现为准
        int index1 = "hello word so smart".indexOf("so");
        System.out.println(index1);//11
        //int lastindexOf(String str)返回指定的字符串，在当前字符串中最后一次出现的索引
        int index2 = "hello word so smart".lastIndexOf(" ");
        System.out.println(index2);//13
        //String substring(int start,int end)截取字符串，参数表示开始和结束索引，其中截取包含开始索引，不包含结束索引
        String str = "hello world";  //是锁死的字面量”hello world”
        String str1 = str.substring(2,5);  //如果不赋值的化仍然是原str ，需要赋值新的字符串
        System.out.println(str1);//llo
        System.out.println(str.substring(2,5));//llo

String类的比较大小方法

public int compareTo(String anotherString)
按字典顺序（自然顺序）比较两个字符串。比较是基于字符串中每个字符的Unicode值。

		/**
         * int compareTo(String anotherString) 按字典顺序（自然顺序）比较两个字符串
         */
        String str1 = "abcdef";
        String str2 = "abdefg";
        String str3 = "abcdef";
        String str4 = "abcdeg";
        /**
         * 返回值是int
         * 返回值为负，调用者小
         * 返回值为正，调用者大
         * 返回值为0，一样大
         */
        int i = str1.compareTo(str2);
        int j = str1.compareTo(str3);
        int k = str1.compareTo(str4);
        System.out.println(i);  //-1  底层是数组，数组中一个一个的比较 c<d为负，后边就不比了
        System.out.println(j);  //0   一个一个的比较，都相同 返回0
        System.out.println(k);  //-1  f<g为负

String类的方法，去空格，替换，切割

String trim() 去掉字符串两边的空格，中间的空格不去掉
String replace(String oldString,String newString)替换字符串
String []split(“规则字符串”) 对字符串进行切割

		// String trim() 去掉字符串两边的空格，中间的空格不去掉
        String str =" aa c bb d ";
        String s = str.trim();
        System.out.println(s); //aa c bb d

        //String []split("规则字符串") 对字符串进行切割
        String str1Split ="aa,bb,cc,dd";
        String[] strings = str1Split.split(",");
        for(int i =0; i< strings.length;i++){
            System.out.println(strings[i]);    // aa  bb cc dd
        }
        //String replace(String oldString,String newString)替换字符串
        String strReplace = "how are you ?";
        String replace = strReplace.replace("o", "ee");
        System.out.println(replace);  //heew are yeeu ?

String 类正则表达式相关

字符类 :
- [abc] 字符串的这个位置只能是abc
- [^abc] 字符串的这个位置不能是abc
- [a-zA-Z] 字符串的这个位置必须是字母,52个
- [^a-zA-Z] 字符串的这个位置必须不能是字母,52个
数字类:
- [0-9] 字符串的这个位置只能是数字
- [^0-9] 字符串的这个位置不能是数字
- [\d] 等同于 [0-9]
- [\D] 等同于 [^0-9]
预定义字符 :
- . 匹配所有的字符
- [\d] 等同于 [0-9]
- [\D] 等同于 [^0-9]
- [\w] 文字字符,包含数字,字母,下划线 [a-zA-Z0-9_]
- [\W] 文字字符,不能包含数字,字母,下划线 [^a-zA-Z0-9_]
数量词 :
- X{m} X这个字符只能出现m次 a{3}
- X{m,} X这个字符至少出现m次
- X{m,n} X这个字符至少出现m次,不超过n次
- X? X这个字符出现一次,或者一次也没有
- X* X这个字符出现零次或者多次
- X+ X这个字符出现至少一次 (出现一次或多次）

String 正则匹配校验

boolen matches(String regex)
告诉这个字符串是否匹配给定的 regular expression 。
匹配成功返回true 失败返回false
举例：

/**
     *  检查邮箱
     *  规则需求 :
     * @ 前面 : 可以是字母,数字,_  
     * @ 后面 : 数字,字母  sina qq 126 1393 yahoo gmail 
     * . 固定 : com  cn org  edu gov 字母  
     */
public static void stringMethod2(){
    String email = "shihehe@sina.com";
    // "[a-zA-Z0-9] == [\\w] \\两个\其中一个代表转义"
    //"[\\w]+" 表示[\w] 匹配一次或多次
    //(\\.[a-z]+)+ 表示(\\.[a-z]+)这个匹配组匹配一次或多次  比如.com.cn
    String reg = "[\\w]+@[a-z0-9]+(\\.[a-z]+)+"; 
    boolean b = email.matches(reg);
    System.out.println(b);

}
/**
     *  正则表达式检查手机号是否合法
     * 规则需求
     *  开头必须是1,长度固定11
     *  第二位3 4 5 6 7 8 9
     *  第三位 必须是都是数字
     */
public static void stringMethod(){
    String tel = "13800138000";
    //定义正则的规则,也是字符串
    String regex = "1[3459678][0-9]{9}";
    //正则规则,和字符串校验
    //String类的方法 matches()
    boolean b = tel.matches(regex);
    System.out.println(b);
}

String[] split(String regex)
将此字符串分割为给定的 regular expression的匹配。

   public static void stringMethod3(){
        String str = "as123d387654w5465fasfr234567sa";
        String[] strings = str.split("\\d+");
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }  //as d w fasfr sa
        System.out.println("================");
        String ip = "192.....168.....35.121";
        String[] ipArray = ip.split("\\.+");
        for (int i = 0; i < ipArray.length; i++) {
            System.out.println(ipArray[i]);  
        }// 192  168   35 121
    }

String replaceAll(String regex, String replacement)
用给定的替换，替换与给定的 regular expression匹配的此字符串的每个子字符串。
String replaceFirst(String regex, String replacement)
用给定的替换替换与给定的 regular expression匹配的此字符串的第一个子字符串。

 public static void stringMethod4(){
        String str = "as123d387654w5465fasfr234567sa";
        //字符串中的所有数组,换成#
        String repString = str.replaceAll("\\d+","#");
        System.out.println(repString);//as#d#w#fasfr#sa

        String first =  str.replaceFirst("\\d+","#");
        System.out.println(first);//as#d387654w5465fasfr234567sa
    }

String Builder类
程序开发中，常常碰到字符串连接的情况，直接的方式是通过"+"符号来实现String的直接拼接，但是这种方式每执行一次都会创建一个String对象，效率低耗时又浪费空间。使用StringBuilder类就可以避免这种问题的发生
public final class StringBuilder
extends Object
implements Serializable, CharSequence
一个可变的字符序列（字符数组）。此类提供与StringBuffer的API，但不保证同步。
创建对象的时候,StringBuilder中的数组的初始化长度为16个字符

StringBuilder自动的进行数组的扩容,新数组实现,原来数组的中元素复制到新的数组.

结论 : 无论怎么做字符串的操作,StringBuilder内部永远只有一个数组

StringBuilder类是线程不安全的类,运行速度快

StringBuffer是线程安全的类,运行速度慢,多线程的程序使用

两个类的构造方法和其他的方法一模一样.

 	   StringBuilder builder = new StringBuilder(20);
        builder.append("helo");
        System.out.println(builder); //helo
        builder.insert(3,"world");
        System.out.println(builder);//helworldo

        StringBuilder builder1 = new StringBuilder(16);
        System.out.println(builder1.append("hello").append("world").append("  ").append("over"));// helloworld  over

A52091

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
java object类常用方法 &String类及常用方法

Java Object 类Java Object 类是所有类的父类，也就是说 Java 的所有类都继承了 Object，子类可以使用 Object 的所有方法。Object 类位于 java.lang 包中，编译时会自动导入，我们创建一个类时，如果没有明确继承一个父类，那么它就会自动继承 Object，成为 Object 的子类。类的常用重要方法public String toString()返回对象的字符串表示形式举例：public class Test { public sta
复制链接

扫一扫