【JavaSE（六）】Java常见对象（上）

作者: 苍云横渡 | 来源:发表于2018-05-16 20:01 被阅读69次

原文地址：https://www.cloudcrossing.xyz/post/38/

1 Object类

1.1 Object类概述

Object类位于java.lang包中，java.lang包包含着Java最基础和核心的类，在编译时会自动导入。

Object类是类层次结构的根类，所有的类都在直接或间接的继承自Object类。

Object类的构造方法只有一个无参构造public Object()，这也就是为什么子类构造方法默认访问父类的构造是无参构造。

1.2 了解的方法

public int hashCode()：返回该对象的哈希码值。注意：哈希值是根据哈希算法计算出来的一个值，这个值和地址值有关，但是不是实际地址值
public final Class getClass() ：返回此 Object 的运行时类。还可以调用Class类的方法：public String getName()：以 String 的形式返回此 Class 对象所表示的实体。格式obj.getClass().getName());
protected void finalize()：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。用于垃圾回收，但是什么时候回收不确定
protected Object clone()：创建并返回此对象的一个副本。其可以实现对象的克隆，包括成员变量的数据复制，但是它和两个引用指向同一个对象是有区别的。其还分为：
- 复制对象 or 复制引用
- 深拷贝 or 浅拷贝

public class StudentDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        //创建学生对象
        Student s = new Student();
        s.setName("林青霞");
        s.setAge(27);
        
        //克隆学生对象
        //Object.clone()方法返回一个Object对象
        //我们必须进行强制类型转换才能得到我们需要的类型
        Object obj = s.clone();
        Student s2 = (Student)obj;
        System.out.println("---------");
        
        System.out.println(s.getName()+"---"+s.getAge());
        System.out.println(s2.getName()+"---"+s2.getAge());
    }
}

1.3 toString()方法

public String toString()：返回该对象的字符串表示。通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法，可以使用ecilpse快捷键自动生成，其默认的是返回成员变量的信息。

Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：getClass().getName() + '@' +Integer.toHexString(hashCode()).

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

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    ...

    @Override
    public String toString() { //ecilpse快捷键默认重写的toString()
        return "Student [name=" + name + ", age=" + age + "]";
    }   
}

public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.hashCode());
        System.out.println(s.getClass().getName());
        System.out.println("--------------------");
        System.out.println(s.toString());
        System.out.println("--------------------");
        // 直接输出对象的名称，其实默认调用了该对象的toString()方法
        System.out.println(s);
    }
}

1.4 equals()方法

public boolean equals(Object obj)：判断某个对象是否与此对象“相等”，返回布尔值。默认情况下，比较的是地址值是否相同（即对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true）。

一般来说子类也会重写该方法，用来比较对象的成员变量值是否相同，可以使用ecilpse快捷键自动生成。

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

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    ...

    @Override
    public boolean equals(Object obj) {  ////ecilpse快捷键默认重写的equals()
        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;
    }
    
//  @Override
//  public boolean equals(Object obj) {
//      //这里要改进，根据这里比较的成员变量来决定返回true还是false
//      //name是String类型的，而String是引用类型的，所以，在这里不能直接用==比较，应该用equals()比较
//      //String的equals()方法是重写自Object类的，比较的是字符串的内容是否相同
//      //this -- s1
//      //obj -- s2
//      //我们要使用的是学生类的特有成员变量,所以要向下转型
//      Student s = (Student)obj; //s -- obj -- s2;
//      if(this.name.equals(s.name) && this.age == s.age) {
//          return true;
//      }else {
//          return false;
//      }
//  }
    
//  @Override
//  public boolean equals(Object obj) {
//      //为了提高效率
//      if(this == obj){
//          return true;
//      }
//      //为了提供程序的健壮性
//      //我先判断一下，obj是不是学生的一个对象，如果是，再做向下转型，如果不是，直接返回false。
//      //这个时候，我们要判断的是对象是否是某个类的对象?
//      //记住一个格式：对象名 instanceof 类名
//      //表示：判断该对象名是否是该类名一个对象
//      if(!(obj instanceof Student)){
//          return false;
//      }
//      //如果是就继续
//      Student s = (Student)obj;
//      return this.name.equals(s.name) && this.age == s.age;
//  }
}

回顾一下：

==
- 基本类型：比较的是值是否相同
- 引用类型：比较的是地址值是否相同
equals()
- 引用类型：默认比较的是地址值是否相同，但一般重写成比较成员变量值是否相同

2 Scanner类

2.1 Scanner类概述

Scanner类在JDK5以后出现的用于键盘录入数据的类。

其构造方法为public Scanner(InputStream source)。而System类下有一个静态的字段：public static final InputStream in;——标准的输入流，对应着键盘录入。

常用格式：Scanner sc = new Scanner(System.in);（InputStream is = System.in;）。

import java.util.Scanner

public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int s = sc.nextInt();
        System.out.println("x:" + x);
    }
}

基本方法格式：

hasNextXxx()：判断输入数据是否为Xxx类型，返回的是布尔值
nextXxx()：返回Xxx类型的元素

import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        if (sc.hasNextInt()) {
            int x = sc.nextInt();
            System.out.println("x:" + x);
        } else {
            //InputMismatchException：输入的和你想要的不匹配
            System.out.println("你输入的数据有误");
        }
    }
}

2.2 要掌握的两个方法

public int nextInt()：获取一个int类型的值
public String nextLine()：获取一个String类型的值

import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 先获取一个字符串，在获取一个int值
        // String s1 = sc.nextLine();
        // int b = sc.nextInt();
        // System.out.println("s1:" + s1 + ",b:" + b);
        // System.out.println("-------------------");

        // 先获取一个int值，在获取一个字符串
        int a = sc.nextInt();
        String s2 = sc.nextLine();
        System.out.println("a:" + a + ",s2:" + s2);
        System.out.println("-------------------");
    }
}

当我们先获取一个int值，在获取一个字符串时会发现输入整数之后回车，程序就结束了。原因是java将回车的（\n）也作为一个字符串赋值给s2了。如何解决呢？

重新定义一个Scanner对象
把所有的数据都用字符串获取，然后在进行相应的转换

int a = sc.nextInt();
Scanner sc2 = new Scanner(System.in);
String s = sc2.nextLine();
System.out.println("a:" + a + ",s:" + s);

最后补充一下：

next() 与 nextLine() 区别：

next()：
- 1、一定要读取到有效字符后才可以结束输入
- 2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉
- 3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
- 4、next() 不能得到带有空格的字符串
nextLine()：
- 1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符
- 2、可以获得空白

3 String类

3.1 String类概述

字符串是多个字符组成的一串数据（其可以和字符数组进行相互转换）。字符串在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。

构造方法：

public String()：空构造
public String(byte[] bytes)：把字节数组转成字符串
public String(byte[] bytes,int index,int length)：把字节数组的一部分转成数组
public String(char[] value)：把字符数组转成数组
public String(char[] value,int index,int count)：把字符数组的一部分转成字符串
public String(String original)：把字符串常量值转成字符串

public class StringDemo {
    public static void main(String[] args) {
        // public String():空构造
        String s1 = new String();
        System.out.println("s1:" + s1);
        System.out.println("s1.length():" + s1.length());
        System.out.println("--------------------------");

        // public String(byte[] bytes):把字节数组转成字符串
        byte[] bys = { 97, 98, 99, 100, 101 };
        String s2 = new String(bys);
        System.out.println("s2:" + s2); //输出：s2:abcde
        System.out.println("s2.length():" + s2.length());
        System.out.println("--------------------------");

        // public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
        // 我想得到字符串"bcd"
        String s3 = new String(bys, 1, 3);
        System.out.println("s3:" + s3);
        System.out.println("s3.length():" + s3.length());
        System.out.println("--------------------------");

        // public String(char[] value):把字符数组转成字符串
        char[] chs = { 'a', 'b', 'c', 'd', 'e', '爱', '林', '亲' };
        String s4 = new String(chs);
        System.out.println("s4:" + s4);
        System.out.println("s4.length():" + s4.length());
        System.out.println("--------------------------");

        // public String(char[] value,int index,int count):把字符数组的一部分转成字符串
        String s5 = new String(chs, 2, 4);
        System.out.println("s5:" + s5);//输出：s5:cde爱
        System.out.println("s5.length():" + s5.length());
        System.out.println("--------------------------");
        
        //public String(String original):把字符串常量值转成字符串
        String s6 = new String("abcde");
        System.out.println("s6:" + s6);
        System.out.println("s6.length():" + s6.length());
        System.out.println("--------------------------");
        
        //字符串字面值"abc"也可以看成是一个字符串对象。
        String s7 = "abcde";
        System.out.println("s7:"+s7);
        System.out.println("s7.length():"+s7.length());
    }
}

字符串的特点：

字符串一旦被赋值，就不能被改变（注意：这里指的是字符串的值不能被改变，而不是引用不能改变）
字面值作为字符串对象和通过构造方法创建对象是不同的
- 前者会创建两个对象，后者创建一个对象

public class StringDemo2 {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = "hello";

        System.out.println(s1 == s2);// false
        System.out.println(s1.equals(s2));// true
    }
}

==：比较引用类型比较的是地址值是否相同
equals()：比较引用类型，默认也是比较地址值是否相同。而String类重写了equals()方法，比较的是内容是否相同

public class StringDemo3 {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1 == s2);// false
        System.out.println(s1.equals(s2));// true

        String s3 = new String("hello");
        String s4 = "hello";
        System.out.println(s3 == s4);// false
        System.out.println(s3.equals(s4));// true

        String s5 = "hello";
        String s6 = "hello";
        System.out.println(s5 == s6);// true
        System.out.println(s5.equals(s6));// true
    }
}

public class StringDemo4 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        System.out.println(s3 == s1 + s2);// false
        System.out.println(s3.equals((s1 + s2)));// true

        System.out.println(s3 == "hello" + "world");// true 
        System.out.println(s3.equals("hello" + "world"));// true

        // 通过反编译看源码，我们知道上面两个语句已经做好了处理。
        // System.out.println(s3 == "helloworld");
        // System.out.println(s3.equals("helloworld"));
    }
}

结论：

字符串如果是变量相加，则先开空间，再拼接
字符串如果是常量相加，则先拼接，然后在字符串常量池找，如果有就直接返回，否则创建

3.2 字符串的判断功能

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));  //true
        System.out.println("equals:" + s1.equals(s3));  //false
        System.out.println("-----------------------");

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

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

        // boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
        System.out.println("startsWith:" + s1.startsWith("h"));  //true
        System.out.println("startsWith:" + s1.startsWith("hello"));  //true
        System.out.println("startsWith:" + s1.startsWith("world"));  //false
        System.out.println("-----------------------");

        // boolean isEmpty():判断字符串是否为空。
        System.out.println("isEmpty:" + s1.isEmpty());  //false

        String s4 = "";
        String s5 = null;
        System.out.println("isEmpty:" + s4.isEmpty());  //true
        // NullPointerException
        // s5对象都不存在，所以不能调用方法，空指针异常
        //System.out.println("isEmpty:" + s5.isEmpty());
    }
}

3.3 字符串的获取功能以及遍历

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)：获取从指定位置开始到指定位置结束截取的字符串，包括start索引但是不包括end索引

注意：索引从0开始！

public class StringDemo {
    public static void main(String[] args) {
        // 定义一个字符串对象
        String s = "helloworld";

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

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

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

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

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

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

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

字符串的遍历：利用length()以及charAt(int index)。

public class StringTest {
    public static void main(String[] args) {
        // 定义字符串
        String s = "helloworld";
        for (int x = 0; x < s.length(); x++) {
            System.out.println(s.charAt(x));
        }
    }
}

举个例子：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)

public class StringTest2 {
    public static void main(String[] args) {
        //定义一个字符串
        String s = "Hello123World";
        
        //定义三个统计变量
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        
        //遍历字符串，得到每一个字符。
        for(int x=0; x<s.length(); x++){
            char ch = s.charAt(x);
            
            //判断该字符到底是属于那种类型的
            if(ch>='a' && ch<='z'){
                smallCount++;
            }else if(ch>='A' && ch<='Z'){
                bigCount++;
            }else if(ch>='0' && ch<='9'){
                numberCount++;
            }
        }
        
        //输出结果。
        System.out.println("大写字母"+bigCount+"个");
        System.out.println("小写字母"+smallCount+"个");
        System.out.println("数字"+numberCount+"个");
    }
}

3.4 字符串的转换功能

byte[] getBytes()：把字符串转换为字节数组
char[] toCharArray()：把字符串传唤为字符数组
static String valueOf(char[] chs)：把字符数组转换为字符串
static String valueOf(int i)：把int类型的数据转换成字符串
String toLowerCase()：把字符串转成小写
String toUpperCase()：把字符串转成大写
String concat(String str)：将指定字符串拼接到当前字符串后边

注意：String类的valueOf方法可以把任意类型的数据转成字符串。在这里不详细展开记录了。

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);
    }
}

//运行结果：
74
97
118
97
83
69
----------------
J
a
v
a
S
E
----------------
JavaSE
----------------
100
----------------
toLowerCase:javase
s:JavaSE
toUpperCase:JAVASE
----------------
s3:helloworld
s4:helloworld

再来一个例子。把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)。比如：helloWORLD-->Helloworld。

public class StringTest {
    public static void main(String[] args) {
        // 定义一个字符串
        String s = "helloWORLD";

        // 先获取第一个字符
        String s1 = s.substring(0, 1);
        // 获取除了第一个字符以外的字符
        String s2 = s.substring(1);
        // 把A转成大写
        String s3 = s1.toUpperCase();
        // 把B转成小写
        String s4 = s2.toLowerCase();
        // C拼接D
        String s5 = s3.concat(s4);
        System.out.println(s5);

        // 优化后的代码
        // 链式编程
        String result = s.substring(0, 1).toUpperCase()
                .concat(s.substring(1).toLowerCase());
        System.out.println(result);
    }
}

3.5 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 StringDemo {
    public static void main(String[] args) {
        // 替换功能
        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);
        System.out.println("s3:" + s3);
        System.out.println("---------------");

        // 去除字符串两空格
        String s4 = " hello world  ";
        String s5 = s4.trim();
        System.out.println("s4:" + s4 + "---");
        System.out.println("s5:" + s5 + "---");
        System.out.println("---------------");

        // 按字典顺序比较两个字符串
        String s6 = "hello";
        String s7 = "hello";
        String s8 = "abc";
        String s9 = "xyz";
        String s10 = "hel";
        System.out.println(s6.compareTo(s7));// 0
        System.out.println(s6.compareTo(s8));// 7
        System.out.println(s6.compareTo(s9));// -16
        System.out.println(s6.compareTo(s10));// 2=5-3
    }
}

//运行结果：
s1:helloworld
s2:hekkoworkd
s3:hellak47rld
---------------
s4: hello world  ---
s5:hello world---
---------------
0
7
-16
2

可以看到，当两个字符串不是包含关系的时候，compareTo()返回的结果是他们ASCII码的差。但是当两个字符串是包含关系，比如s6与s10，compareTo()返回的其实是两个字符串长度的差。

3.6 字符串的案例

统计大串中小串出现的次数。

举例：求出在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"中java出现的次数（五次）

分析：前提：是已经知道了大串和小串

A：定义一个统计变量，初始化值是0
B：先在大串中查找一次小串第一次出现的位置
- a：索引是-1，说明不存在了，就返回统计变量
- b：索引不是-1，说明存在，统计变量++
C：把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串
D：回到B

public class StringTest5 {
    public static void main(String[] args) {
        // 定义大串
        String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
        // 定义小串
        String minString = "java";

        // 写功能实现
        int count = getCount(maxString, minString);
        System.out.println("Java在大串中出现了：" + count + "次");
    }

    /*
     * 两个明确： 返回值类型：int 参数列表：两个字符串
    */
    public static int getCount(String maxString, String minString) {
        // 定义一个统计变量，初始化值是0
        int count = 0;

        /*
        // 先在大串中查找一次小串第一次出现的位置
        int index = maxString.indexOf(minString);
        // 索引不是-1，说明存在，统计变量++
        while (index != -1) {
            count++;
            // 把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串
            // int startIndex = index + minString.length();
            // maxString = maxString.substring(startIndex);
            maxString = maxString.substring(index + minString.length());
            // 继续查
            index = maxString.indexOf(minString);
        }
        */
        
        int index;
        //先查，赋值，判断
        while((index=maxString.indexOf(minString))!=-1){
            count++;
            maxString = maxString.substring(index + minString.length());
        }

        return count;
    }
}

【JavaSE（六）】Java常见对象（上）

1 Object类

1.1 Object类概述

1.2 了解的方法

1.3 toString()方法

1.4 equals()方法

2 Scanner类

2.1 Scanner类概述

2.2 要掌握的两个方法

3 String类

3.1 String类概述

3.2 字符串的判断功能

3.3 字符串的获取功能以及遍历

3.4 字符串的转换功能

3.5 String类的其他方法

3.6 字符串的案例

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java-Python-Django社区

程序员