Java基础语法（十五）

最新推荐文章于 2023-05-31 13:25:57 发布

汪喆_Jack

最新推荐文章于 2023-05-31 13:25:57 发布

阅读量365

点赞数 2

分类专栏： JAVA相关文章标签： Java String StringBuffer StringBuild equals()

本文链接：https://blog.csdn.net/qq_34829447/article/details/82080464

版权

JAVA相关专栏收录该内容

57 篇文章 15 订阅

订阅专栏

一.Java的API及Object类

1.API概念

API(Application Programming Interface)
Java API
- 是Java提供给我们使用的类，这些类将底层的实现封装了起来
- 我们不需要关心这些类是如何实现的，只需要学习这些类如何使用
在JDK安装目录下src.zip文件中，是java的源文件

2.Object类概述

Object类概述
- 类层次结构的根类
- 所有类都直接或者间接的继承自该类
- Object中描述的所有方法子类都可以使用
- 所有类在创建对象的时候，最终找的父类就是Object
构造方法
- public Object()
注意：接口不继承Object，因为自身没有构造方法，没有机会调用Object的构造方法

3.equals方法比较内存地址

Object类中的equals方法：boolean equals(Object obj)
- 用于比较两个对象是否相同，Object类中就是使用两个对象的内存地址在比较
- Object类中的equals方法内部使用的就是==比较运算符

实例代码

public class Person extends Object{
  private String name;
  private int age;
  public Person(){}
  public Person(String name, int age) {
      this.name = name;
      this.age = age;
  }
  /*
         * 将父类的equals方法写过来,重写父类的方法
         * 但是,不改变父类方法的源代码, 方法equals 比较两个对象的内存地址
         *              
         */
  public boolean equals(Object obj){                    
      return this == obj;
  }     
  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;
  }              
}
//测试代码
public class TestEquals {
  public static void main(String[] args) {
      //Person类继承Object类,继承下来了父类的方法equals
      Person p1 = new Person("李四",20);
      Person p2 = new Person("张三",20);
      //Person对象p1,调用父类的方法equals,进行对象的比较
      boolean b = p1.equals(p1);
      System.out.println(b);
  }
}

4.重写equals方法

开发中要比较两个对象是否相同，经常会根据对象中的属性值进行比较
在开发经常需要子类重写equals方法根据对象的属性值进行比较
==号和equals方法的区别
- ==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值
- equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承Object类中的方法,如果没有重写Object类中的equals方法,equals方法和==号比较引用数据类型无区别,重写后的equals方法比较的是对象中的属性

实例代码

public class Person extends Object{
  private String name;
  private int age;
  public Person(){}
  public Person(String name, int age) {
      this.name = name;
      this.age = age;
  }
  /*
         * 重写父类的方法toString()
         * 没有必要让调用者看到内存地址
         * 要求: 方法中,返回类中所有成员变量的值
         */
  public String toString(){
      return name + age;
  }
  /*
         * 将父类的equals方法写过来,重写父类的方法
         * 但是,不改变父类方法的源代码, 方法equals 比较两个对象的内存地址
         * 
         * 两个对象,比较地址,没有意义
         * 比较两个对象的成员变量,age
         * 两个对象变量age相同,返回true,不同返回false
         * 
         * 重写父类的equals,自己定义自己对象的比较方式
         */
  public boolean equals(Object obj){
      if( this == obj){
          return true;
      }
      //对参数obj,非null判断
      if( obj == null){
          return false;
      }
      if( obj instanceof Person){
          // 参数obj接受到是Person对象,才能转型
          // 对obj参数进行类型的向下转型,obj转成Person类型
          Person p = (Person)obj;
          return this.age ==  p.age;
      }
      return false;
  }             
  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;
  }              
}
//测试代码
public class TestEquals {
  public static void main(String[] args) {
      //Person类继承Object类,继承下来了父类的方法equals
      Person p1 = new Person("李四",20);
      Person p2 = new Person("张三",20);
      //Person对象p1,调用父类的方法equals,进行对象的比较
      boolean b = p1.equals(p1);
      System.out.println(b);
  }
}

5.重写toString方法

为什么要重写toString方法
- toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值
- 由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它
- Object类中的toString的核心代码
```
getClass().getName() + "@" + Integer.toHexString(hashCode()) 
```
- 由于默认情况下的数据对我们来说没有意义，一般建议重写该方法

实例代码

/*
         * 重写父类的方法toString()
         * 没有必要让调用者看到内存地址
         * 要求: 方法中,返回类中所有成员变量的值
         */

public String toString(){
  return name + age;
} 

//Eclipse中自动生成的toString
@Override
public String toString() {
  return "Person [name=" + name + ", age=" + age + "]";
}

//测试代码
public class TestToString {
  public static void main(String[] args) {
      //调用Person类的方法toString()
      //输出语句中,写的是一个对象,默认调用对象的toString方法
      Person p = new Person("张三",20);
      String s = p.toString();
      System.out.println(p);
      System.out.println(s);
      /*
                 * System.out.println(p);
                 * System.out.println(p.toString());
                 */
      /*Random r = new Random();
            System.out.println(r.toString());
            Scanner sc = new Scanner(System.in);
            System.out.println(sc.toString());*/
  }
}

二.String类

1.String类的概念和不变性

API中的String类的描述，发现String 类代表字符串
Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
字符串是常量,在创建之后不能更改【原因:定义代码中是private final char value[]】
其实就是说一旦这个字符串确定了，那么就会在内存区域中就生成了这个字符串。字符串本身不能改变，但str变量中记录的地址值是可以改变的。
源码分析,String类底层采用的是字符数组
```
private final char value[]
```
private修饰说明value只能在String类内部使用,而且又没有提供get方法,所以外部无法获取value数组,就无法改变数组中元素的值。final修饰说明value是常量,一旦创建,就不能被改变,value一旦被初始化成某个数组,将永远指向这个数组,不可能再指向其它的数组了。

实例代码

/*
     *   String类特点:
     *     一切都是对象,字符串事物 "" 也是对象
     *     类是描述事物,String类,描述字符串对象的类
     *     所有的 "" 都是String类的对象
     *     
     *     字符串是一个常量,一旦创建,不能改变
     */
public class StringDemo {
  public static void main(String[] args) {
      //引用变量str执行内存变化
      //定义好的字符串对象,不变
      String str = "itcast";
      System.out.println(str);
      str = "itheima";
      System.out.println(str);
  }
}

这里写图片描述

2.String类创建方式和比较

String s3 = "abc";在内存中只有一个对象。这个对象在字符串常量池中
String s4 = new String("abc");在内存中有两个对象。一个new的对象在堆中，一个字符串本身对象，在字符串常量池中

实例代码

public class StringDemo2 {
  public static void main(String[] args) {
      //字符串定义方式2个, 直接=  使用String类的构造方法
      String str1 = new String("abc");
      String str2 = "abc";
      System.out.println(str1);
      System.out.println(str2);
      System.out.println(str1==str2);//引用数据类型,比较对象的地址 false
      System.out.println(str1.equals(str2));//true(因为String类重写了equals方法)
  }
}

这里写图片描述

3.String类构造方法

这里写图片描述

String传递字节数组的实例代码【默认编码表GBK，汉字编码为负，两个字节表示一个汉字】

public class StringDemo3 {
    public static void main(String[] args) {
        function();
    }
    /*
                 *  定义方法,String类的构造方法
                 *  String(byte[] bytes)  传递字节数组
                 *  字节数组转成字符串
                 *  通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
                 *  平台 : 机器操作系统
                 *  默认字符集: 操作系统中的默认编码表, 默认编码表GBK
                 *  将字节数组中的每个字节,查询了编码表,得到的结果
                 *  字节是负数,汉字的字节编码就是负数, 默认编码表 ,一个汉字采用2个字节表示
                 *  
                 *  String(byte[] bytes, int offset, int length) 传递字节数组
                 *  字节数组的一部分转成字符串
                 *  offset 数组的起始的索引
                 *  length 个数,转几个   , 不是结束的索引
                 */

    public static void function(){
        byte[] bytes = {97,98,99,100};
        //调用String类的构造方法,传递字节数组
        String s = new String(bytes);
        System.out.println(s);//abcd
        byte[] bytes1 ={65,66,67,68,69};
        //调用String构造方法,传递数组,传递2个int值
        String s1 = new String(bytes1,1,3);
        System.out.println(s1);//BCD
    }
}

String传递字符数组的实例代码

/*
      *  String类构造方法
      *  String类的构造方法,重载形式
      * 
      */
public class StringDemo3 {
  public static void main(String[] args) {
      function_1();
  }
  /*
         * String(char[] value) 传递字符数组
         * 将字符数组,转成字符串, 字符数组的参数,不查询编码表
         * 
         * String(char[] value, int offset, int count) 传递字符数组
         * 将字符数组的一部分转成字符串
         * offset  数组开始索引
         * count   个数
         */
  public static void function_1(){
      char[] ch = {'a','b','c','d','e','f'};
      //调用String构造方法,传递字符数组
      String s = new String(ch);
      System.out.println(s);//abcdef
      String s1 = new String(ch,1,4);
      System.out.println(s1);//bcde
  }
}

4.String类的其他方法

int length(): 返回字符串的长度
String substring(int beginIndex,int endIndex): 获取字符串的一部分
String substring(int beginIndex): 获取字符串的一部分
boolean startsWith(String prefix): 判断一个字符串是不是另一个字符串的前缀,开头
boolean endsWith(String prefix): 判断一个字符串是不是另一个字符串的后缀,结尾
boolean contains (String s): 判断一个字符串中,是否包含另一个字符串
int indexOf(char ch): 查找一个字符,在字符串中第一次出现的索引,被查找的字符不存在,返回-1
int indexOf(String str)：获取给定的字符串，在该字符串中第一次出现的位置
int indexOf(char ch,int fromIndex) ：从指定位置开始，获取给定的字符，在该字符
byte[] getBytes(): 将字符串转成字节数组,此功能和String构造方法相反,byte数组相关的功能,查询编码表
char[] toCharArray(): 将字符串转成字符数组,功能和构造方法相反
boolean equals(Object obj): 方法传递字符串,判断字符串中的字符是否完全相同,如果完全相同返回true
boolean equalsIgnoreCase(String s): 传递字符串,判断字符串中的字符是否相同,忽略大小写
char charAt(int i)：返回i索引位置的字符
boolean isEmpty()：判断该字符串的内容是否为空字符串
String replace(char old,char new)：在该字符串中，将给定的旧字符，用新字符替换
String replace(String old,String new)：在该字符串中，将给定的旧字符串，用新字符串替换
String trim()：去除字符串两端空格，中间的不会去除，返回一个新字符串
String toLowerCase()：把该字符串转换成小写字符串
String toUpperCase()：把该字符串转换成大写字符串

实例代码

public class StringDemo4 {
  public static void main(String[] args) {
      function_9();
  }
  /*
         *  boolean equals(Object obj)
         *  方法传递字符串,判断字符串中的字符是否完全相同,如果完全相同返回true
         *  
         *  boolean equalsIgnoreCase(String s)
         *  传递字符串,判断字符串中的字符是否相同,忽略大小写
         */
  public static void function_9(){
      String str1 = "Abc";
      String str2 = "abc";
      //分别调用equals和equalsIgnoreCase
      boolean b1 = str1.equals(str2);
      boolean b2 = str1.equalsIgnoreCase(str2);
      System.out.println(b1);//false
      System.out.println(b2);//true
  }

  /*
         * char[] toCharArray() 将字符串转成字符数组
         * 功能和构造方法相反
         */
  public static void function_8(){
      String str = "itcast";
      //调用String类的方法toCharArray()
      char[] ch = str.toCharArray();
      for(int i = 0 ; i < ch.length ; i++){
          System.out.println(ch[i]);
      }
  }

  /*
         *  byte[] getBytes() 将字符串转成字节数组
         *  此功能和String构造方法相反
         *  byte数组相关的功能,查询编码表
         */
  public static void function_7(){
      String str = "abc";
      //调用String类方法getBytes字符串转成字节数组
      byte[] bytes = str.getBytes();
      for(int i = 0 ; i < bytes.length ; i++){
          System.out.println(bytes[i]);//97 98 99
      }
  }

  /*
         *  int indexOf(char ch)
         *  查找一个字符,在字符串中第一次出现的索引
         *  被查找的字符不存在,返回-1
         */
  public static void function_6(){
      String str = "itcast.cn";
      //调用String类的方法indexOf
      int index = str.indexOf('x');
      System.out.println(index);//-1
  }

  /*
         *  boolean contains (String s)
         *  判断一个字符串中,是否包含另一个字符串
         */
  public static void function_5(){
      String str = "itcast.cn";
      //调用String类的方法contains
      boolean b =str.contains("ac");
      System.out.println(b);//false
  }

  /*
         * boolean endsWith(String prefix)
         * 判断一个字符串是不是另一个字符串的后缀,结尾
         * Demo.java
         *     .java
         */
  public static void function_4(){
      String str = "Demo.java";
      //调用String类方法endsWith
      boolean b = str.endsWith(".java");
      System.out.println(b);//true
  }

  /*
         * boolean startsWith(String prefix)  
         * 判断一个字符串是不是另一个字符串的前缀,开头
         * howareyou
         * hOw
         */
  public static void function_3(){
      String str = "howareyou";
      //调用String类的方法startsWith
      boolean b = str.startsWith("hOw");
      System.out.println(b);//false
  }

  /*
         *  String substring(int beginIndex,int endIndex) 获取字符串的一部分
         *  返回新的字符串
         *  包含头,不包含尾巴
         *  
         *  String substring(int beginIndex)获取字符串的一部分
         *  包含头,后面的字符全要
         */
  public static void function_2(){
      String str = "howareyou";
      //调用String类方法substring获取字符串一部分
      str= str.substring(1, 5);
      System.out.println(str);//owar
      String str2 = "HelloWorld";
      str2 = str2.substring(1);
      System.out.println(str2);//elloWorld
  }

  /*
         *  int length() 返回字符串的长度
         *  包含多少个字符
         */
  public static void function(){
      String str = "cfxdf#$REFewfrt54GT";
      //调用String类方法length,获取字符串长度
      int length = str.length();
      System.out.println(length);//19
  }
}

三.字符串缓冲区

1.StringBuffer特点：可变字符序列

StringBuffer概述
- 通过JDK提供的API，查看StringBuffer类的说明
- 线程安全的可变字符序列
- 底层采用字符数组实现,初始容量为16
- 内部也是采用数组实现，但是没有final
StringBuffer和String的区别
- String是一个不可变的字符序列
- StringBuffer是一个可变的字符序列

2.StringBuffer类的方法

StringBuffer append(), 将任意类型的数据,添加缓冲区
- append 返回值,写return this
- 调用者是谁,返回值就是谁
- 故方法调用链，可以一直.下去
- 注意是任意类型变成char之后追加，boolean也可以
StringBuffer delete(int start,int end)：删除缓冲区中字符
- 开始索引包含,结尾索引不包含
public StringBuffer deleteCharAt(int index)：在原有字符串缓冲区内容基础上，删除指定位置上的字符
StringBuffer insert(int index, 任意类型): 将任意类型数据,插入到缓冲区的指定索引上
StringBuffer replace(int start,int end, String str): 将指定的索引范围内的所有字符,替换成新的字符串
StringBuffer reverse(): 将缓冲区中的字符反转
String toString(): 继承Object,重写toString()，返回String类型
public String substring(int start) ：从指定位置开始，到末尾结束，截取该字符串缓冲区，返回新字符串
public String substring(int start,int end) ：从指定位置开始，到指定位置结束，截取该字符串缓冲区，返回新字符串

实例代码

public class StringBufferDemo {
  public static void main(String[] args) {
      function_5();
  }
  /*
             *  StringBuffer类的方法
             *   String toString() 继承Object,重写toString()
             *   将缓冲区中的所有字符,变成字符串
             */
  public static void function_5(){
      StringBuffer buffer = new StringBuffer();
      buffer.append("abcdef");
      buffer.append(12345);
      //将可变的字符串缓冲区对象,变成了不可变String对象
      String s = buffer.toString();
      System.out.println(s);//abcdef12345
  }

  /*
         *  StringBuffer类的方法
         *    reverse() 将缓冲区中的字符反转
         */
  public static void function_4(){
      StringBuffer buffer = new StringBuffer();
      buffer.append("abcdef");
      buffer.reverse();
      System.out.println(buffer);//fedcba
  }

  /*
         *  StringBuffer类方法
         *    replace(int start,int end, String str)
         *    将指定的索引范围内的所有字符,替换成新的字符串
         */
  public static void function_3(){
      StringBuffer buffer = new StringBuffer();
      buffer.append("abcdef");
      buffer.replace(1, 4, "Q");
      System.out.println(buffer);//aQef
  }

  /*
         *  StringBuffer类方法 insert
         *    insert(int index, 任意类型)
         *  将任意类型数据,插入到缓冲区的指定索引上
         */
  public static void function_2(){
      StringBuffer buffer = new StringBuffer();
      buffer.append("abcdef");   
      buffer.insert(3,9.5);
      System.out.println(buffer);//abc9.5def
  }

  /*
         * StringBuffer类方法
         *   delete(int start,int end) 删除缓冲区中字符
         *   开始索引包含,结尾索引不包含
         */
  public static void function_1(){
      StringBuffer buffer = new StringBuffer();
      buffer.append("abcdef");
      buffer.delete(1,5);
      System.out.println(buffer);//af
  }

  /*
         *  StringBuffer类方法
         *   StringBuffer append, 将任意类型的数据,添加缓冲区
         *   append 返回值,写return this
         *   调用者是谁,返回值就是谁
         */
  public static void function(){
      StringBuffer buffer = new StringBuffer();
      //调用StringBuffer方法append向缓冲区追加内容
      buffer.append(6).append(false).append('a').append(1.5);
      System.out.println(buffer);//6falsea1.5
  }
}

3.StringBuilder类

概述：可变的字符序列（线程不安全），运行速度快。提供了与StringBuffer兼容的API。
面试题：String、StringBuffer和StringBuilder的区别
- StringBuffer和StringBuilder的区别
  - StringBuffer是jdk1.0版本的,是线程安全的,效率低
  - StringBuilder是jdk1.5版本的,是线程不安全的,效率高
- String和StringBuffer,StringBuilder的区别
  - String是一个不可变的字符序列
  - StringBuffer,StringBuilder是可变的字符序列

实例代码

//利用StringBuilder拼接数组
public class StringBuilderTest {
  public static void main(String[] args) {
      int[] arr = {4,1,4,56,7,8,76};
      System.out.println(toString(arr));
  }
  /*
            * int[] arr = {34,12,89,68};将一个int[]中元素转成字符串 
            * 格式 [34,12,89,68]
            * String s = "["
            * 数组遍历
            *   s+= arr[i];
            *  s+"]"
            *  StringBuilder实现,节约内存空间, String + 在缓冲区中,append方法
            */
  public static String toString(int[] arr){
      //创建字符串缓冲区
      StringBuilder builder = new StringBuilder();
      builder.append("[");
      //数组遍历
      for(int i = 0 ; i < arr.length;i++){
          //判断是不是数组的最后一个元素
          if(i == arr.length-1){
              builder.append(arr[i]).append("]");
          }else{
              builder.append(arr[i]).append(",");
          }
      }
      return builder.toString();
  }
}