×

【JavaSE(六)】Java常见对象(上)

96
苍云横渡
2018.05.16 20:01 字数 2600

原文地址: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 学习笔记
Web note ad 1