java API

提示:

注意在使用基本数据类型 （四项八类 字符、整型、浮点、布尔）的时候可以直接传入参数。其他的需要new对象进行传入（匿名或者声明）

equals方法：

我们经常遇到过两个对象的比较，判断2个对象是否相等的情况，在python中，因为不是强类型语言，在比较基本数据类型的时候，我们一般用== 在比较对象的时候，根据对象的属性判断对象是否相等。

在java中也是，在比较对象的时候根据对象的属性值来判断，在java中，所有java类的超类是object（Class Object is the root of the class hierarchy. Every class has Object as a superclass. All objects, including arrays, implement the methods of this class.），object本身为我们提供了一些方法，为子类可以对object的方法进行重写。

equals方法：

object中equal方法，只是比较2个对象的内存地址是否相等（内部用==比较），如下：

package com.test;

public class Equal_Demo {
    public static void main(String[] args){
        equal p1=new equal("tom");
        equal p2=new equal("tom");
        if(p1.equals(p2)){
            System.out.printf("相等");
        }else {
            System.out.printf("不相等");
        }
    }
}
class  equal{
    private String name;
    public  equal(String name){
        this.name=name;
    }
    public void show(){
        System.out.printf("ok");
    }
}

 输出：

object类实现：

内部实际上使用==来比较2个对象内存地址是否相等。这个并不是我们想要的，因为有时候我们对2个对象的属性值相等即可。比如上面的我们认为对象的name属性相等的话，就认为这2个对象相等。

我们重写equals方法。

package com.test;

public class Equal_Demo {
    public static void main(String[] args){
        equal p1=new equal("tom");
        equal p2=new equal("tom");
        if(p1.equals(p2)){
            System.out.printf("相等");
        }else {
            System.out.printf("不相等");
        }
    }
}
class  equal{
    private String name;
    public  equal(String name){
        this.name=name;
    }
    public void show(){
        System.out.printf("ok");
    }
    public boolean equals(Object obj){
        if(obj==this){//this 是当前被调用对象。如果对象的内存地址相等的话，必然相等。
            return true;
        }
        if(obj instanceof equal){
        equal p=(equal) obj;//因为obj是Object 对象所以并不包含子类的字段，所以需要向下转型。
        if(this.name==p.name){//判断字段的相等性.
            return true;
        }else {
            return false;
        }
        }else {
            return false;
        }
    }
}

注意：

在方法中当前调用对象为this引用。

字段是当前类的属性，如上例子，object为父类所以无法调用子类的字段，如果想调用的话，需要类型转换。

 二：在Object中，也toString方法。Returns a string representation of the object. 默认返回对象的内存地址。

package test01;

public class Tostring {
    public  static  void  main(String ...args){
        Check_Prin p1=new Check_Prin("tom","22");
        System.out.printf(p1.toString());
    }
}

class Check_Prin{
    private String age;
    private String name;
    public   Check_Prin(String name,String age){
        this.name=name;
        this.age=age;
    }
    public void  show(){
        System.out.printf("PK");
    }
} 

输出结果：

输出是对象的内存地址。所以我们需要重写Object的tostring方法。一般当我们System的输出打印对象的时候，会调用对象的tostring方法。如果对象的类没有重写这个方法，会调用父类的toString方法。

类似python 中的内置方法__str__方法。在输出字符串的时候，我们更像要得到的是对象的属性信息。如下：

package test01;

public class Tostring {
    public  static  void  main(String ...args){
        Check_Prin p1=new Check_Prin("tom","22");
        System.out.printf(p1.toString());
    }
}

class Check_Prin{
    private String age;
    private String name;
    public   Check_Prin(String name,String age){
        this.name=name;
        this.age=age;
    }
    public void  show(){
        System.out.printf("PK");
    }
    public  String toString(){
        return this.name+" "+this.age;
    }
}

 效果：

 三：String类。

String类是public final class String extends Object implements Serializable, Comparable<String>, CharSequence  是不可被继承类。字符串类一旦被创建之后，不可以被更改。（Strings are constant; their values cannot be changed after they are created. String buffers support mutable strings.）

赋值不需要new。

String str = "abc";

 初始化字符串：

String()
String(byte[] bytes)
String(byte[] bytes, Charset charset)
String(byte[] ascii, int hibyte）

 代码：

public class String_Test {
    public static  void  main(String ...args){
        In_Str s=new In_Str();
        s.Pri();
    }
}

class In_Str{
    private String s_a= new String();
    byte[] s_b=new  byte[]{1,2,3,4};
    byte[] s_c={1,3,4,5};
    String S_d=new String(s_b);
    char[] ch_s=new  char[]{'a','b','c'};
    String ch_str=new String(ch_s);
    public void  Pri(){
        System.out.printf(this.S_d);
        String s_g=new String(new byte[]{1,2,3,4});
        System.out.printf(s_g);
        System.out.printf(ch_str);
    }
}

之前学习python的时候，我们常用的String方法比如说 分片、切割、获取索引等等。

类似分片：

substring方法：

返回值为String类型，参数为int 为字符串的切割起始，可以是单个参数也可以是2个参数，一个默认为到最后。和python切片一样。

package test02;

public class String_Test {
    public static  void  main(String ...args){
        Sub s=new Sub();
        s.sub();
    }
}


class  Sub{
    String sub="owner";
    public  void  sub(){
        System.out.printf(sub.substring(1)+"
");
        System.out.printf(sub.substring(1,2));


    }
}

 以什么字符串开头和结尾,返回值为布尔类型：

bool  startWith(String)  bool endWith(String)

package test02;

public class String_Test {
    public static  void  main(String ...args){
        In_Str s=new In_Str();
        s.Pri();
    }
}

class In_Str{
    private String s_a= new String();
    byte[] s_b=new  byte[]{1,2,3,4};
    byte[] s_c={1,3,4,5};
    String S_d=new String(s_b);
    char[] ch_s=new  char[]{'a','b','c'};
    String ch_str=new String(ch_s);
    public void  Pri(){
        if(ch_str.startsWith("a")){
            System.out.printf("ok");
        }else if (ch_str.endsWith("f")){
            System.out.printf("not end f
");
        };
    }
}

 判断字符串是否包含以及所在字符串的索引：

bool  contains(String str)  int   str.indexof(substr) 判断包含，则返回相应的索引，不包含的返回-1，返回是第一次匹配的索引。

package test02;

public class String_Test {
    public static  void  main(String ...args){
        In_Str s=new In_Str();
        s.Pri();
    }
}

class In_Str{
    char[] ch_s=new  char[]{'a','b','c','d','f'};
    String ch_str=new String(ch_s);
    public void  Pri(){
        if(ch_str.contains("ab")){
            System.out.printf("contains
");
            int ind=ch_str.indexOf("ab");
            int ind1=ch_str.indexOf("dd");
            System.out.printf(ind+"
");
            System.out.print(ind1);
        }
    }
}

 存在就返回相应的索引，否则返回-1。

 

获取字符串和字节数组：char[]  toCharArray(string)  byte[] getBytes()

package test02;

public class String_Test {
    public static  void  main(String ...args){
        In_Str s=new In_Str();
        s.Pri();
    }
}

class In_Str{
    char[] ch_s=new  char[]{'a','b','c','d','f'};
    String ch_str=new String(ch_s);
    public void  Pri(){
        char[] s_ch=ch_str.toCharArray();
        byte[] s_ch_1=ch_str.getBytes();
        for(char i:s_ch){
            System.out.print(i+"
");
        }
        System.out.print(s_ch_1);
    }
}

判断两个字符串是否相等，因为String类中已经重写对应的equals方法，所以判断2个字符串对象是否相等使用equeals()以及忽略大小写比较2个字符串是否一样。equalsIgnoreCase()

package test02;

public class String_Test {
    public static  void  main(String ...args){
        In_Str s=new In_Str();
        s.Pri();
    }
}

class In_Str{
    char[] ch_s=new  char[]{'a','b','c','d','f'};
    char[] ch_s_1=new  char[]{'A','b','c','D','f'};
    String ch_str=new String(ch_s);
    String ch_str_2=new String(ch_s);
    String ch_str_1=new String(ch_s_1);
    public void  Pri(){
        if(ch_str.equalsIgnoreCase(ch_str_1)){
            System.out.printf("相等！");
        }
        if(ch_str.equals(ch_str_2)){
            System.out.printf("相等！");
        }
    }
}

 判断字符串是否为空：bool  isEmpty()

package test02;

public class String_Test {
    public static  void  main(String ...args){
        In_Str s=new In_Str();
        s.Pri();
    }
}

class In_Str{
    String ch_str=new String();
    public void  Pri(){
        if(this.ch_str.isEmpty()){
            System.out.printf("is empty");
        }
    }
}

获取指定位置的字符：  char  charAt(int index) 去掉字符串的首尾的空格和回车 str.trim()

package test02;

public class String_Test {
    public static  void  main(String ...args){
        In_Str s=new In_Str();
        s.Pri();
    }
}

class In_Str{
    String str=new String("chi ckck 
");
    public void  Pri(){
      System.out.print(str.trim()+'
');
      System.out.print(str.charAt(2));
    }
}

字符串的大小写转换：toUpperCase(str)   toLowerCase()

package test02;

public class String_Test {
    public static  void  main(String ...args){
        In_Str s=new In_Str();
        s.Pri();
    }
}

class In_Str{
    String str=new String("cHi ckck 
");
    public void  Pri(){
    System.out.printf(str.toUpperCase());//大写转换。
    System.out.printf(str.toLowerCase());//小写转换.
    }
}

将给定新旧的字符转换成新的字符 replace(old char,new char)

package test02;

public class String_Test {
    public static  void  main(String ...args){
        In_Str s=new In_Str();
        s.Pri();
    }
}

class In_Str{
    String str=new String("cHi ckck 
");
    public void  Pri(){
        System.out.printf(str.replace('H','p'));
    }
}

将给定的旧的字符串转换成新的字符串 replace(old str,new str)

package test02;

public class String_Test {
    public static  void  main(String ...args){
        In_Str s=new In_Str();
        s.Pri();
    }
}

class In_Str{
    String str=new String("cHi ckck 
");
    public void  Pri(){
        System.out.printf(str.replace("Hi","koo"));
    }
}

字符串的切割：String[] str.split()切割字符串 返回字符串数组。

package test02;

public class String_Test {
    public static  void  main(String ...args){
        In_Str s=new In_Str();
        s.Pri();
    }
}

class In_Str{
    String str=new String("cHi ckck 
");
    public void  Pri(){
        String[] new_str=str.split("i");
        for(String i:new_str){
            System.out.print(i+'
');
        }
    }
}

练习：

题目一：获取指定字符串中，大写字母、小写字母、数字的个数。

package test02;


import java.util.ArrayList;

public class String_Test {
    public static  void  main(String ...args){
        In_Str s=new In_Str();
        s.Pri();
    }
}

class In_Str{
    String str=new String("cHi1T2ckc2k");
    char[] ch_n=str.toCharArray();
    private int upcount=0;
    private int lowcount=0;
    private int numcount=0;
    public void  Pri(){
        for (char i:ch_n){
            if('A'<i && i<'Z'){
                this.upcount+=1;
            }
            if('a'<i&& i<'z'){
                this.lowcount+=1;
            }
            if('1'<i && i<'9'){
                this.numcount+=1;
            }


        }

        System.out.print(lowcount+"
");
        System.out.print(upcount+"
");
        System.out.print(numcount+"
");

    }
}  

注意：+加号在字符串中是连接的作用，在字符中意思求和！！！！

            可以直接用字符来直接比较大小！！！

           &&和&区别：&&是 前一个表达式为false，则不执行右边的表达式。而&为无论左边表达式是否为false都执行右边。相同点是：只有所有表达式为正确才true。同理||和|

 题目二：将字符串中，第一个字母转换成大写，其他字母转换成小写，并打印改变后的字符串。

package test02;


import java.util.ArrayList;

public class String_Test {
    public static  void  main(String ...args){
        In_Str s=new In_Str();
        s.Pri();
    }
}

class In_Str{
    String str=new String("cHi1T2ckc2k");
    char[] ch_n=str.toCharArray();
    public void  Pri(){
     String   start =str.substring(0,1);
     String   end=str.substring(1);
     String new_start=start.toUpperCase();
     String new_end=end.toLowerCase();
     String new_str=new_start+new_end;
     System.out.print(new_str);

    }

 题目三：查询大字符串中，出现指定小字符串的次数。如“hellojava,nihaojava,javazhenbang”中查询出现“java”的次数。

package test02;


import java.util.ArrayList;

public class String_Test {
    public static  void  main(String ...args){
        In_Str s=new In_Str();
        s.Pri();
    }
}

class In_Str{
    String str=new String("hellojava,nihaojava,javazhenbang");
    int re_count=0;
    public void  Pri(){
        int st_index=0;
        while (st_index!= -1) {
            if (str.indexOf("java") != -1) {
                re_count += 1;
                st_index = str.indexOf("java");
                str = str.substring(st_index + 1);
            }else {
                st_index=-1;
            }
        }
        System.out.print(re_count);

    }
}

 三：StringBuffer 字符串可变缓冲区。有append、insert、replace、reverse等方法，注意操作之后也是StringBuffer 需要用toString来获取对应字符串。

StringBuilder类，比StringBuilder 处理速度更快，建议使用这个类。

package test03;

public class Str_Bu {
    public static void  main(String...args){
        S_B s_b=new S_B("winner");
        s_b.ch_str();
    }
}


class S_B{
    private String str;
    public  S_B(String str){
        this.str=str;
    }
    public void  ch_str(){
        StringBuffer st_bu=new StringBuffer(str);
        st_bu.append("ok");//尾部追加。
        st_bu.insert(2,"ko");//指定位置添加字符串。
        System.out.printf(st_bu.toString()+'
');
        st_bu.delete(1,111);
        System.out.printf(st_bu.toString());
        st_bu.replace(1,3333,"ooop");
        System.out.printf(st_bu.toString()+"
");
        st_bu.reverse();
        System.out.printf(st_bu.toString());
    }
}

 输出：

 

练习：

l  从指定位置开始，到末尾结束，截取该字符串缓冲区，返回新字符串

package test03;

public class Str_Bu {
    public static void  main(String...args){
        S_B s_b=new S_B("winner");
        s_b.ch_str();
    }
}


class S_B{
    private String str;
    public  S_B(String str){
        this.str=str;
    }
    public void  ch_str(){
        StringBuffer st_bu=new StringBuffer(str);
        String st_new=st_bu.substring(3);
        System.out.printf(st_new);
    }
}

 在原有字符串缓冲区内容基础上，删除指定位置上的字符

package test03;

public class Str_Bu {
    public static void  main(String...args){
        S_B s_b=new S_B("winner");
        s_b.ch_str();
    }
}


class S_B{
    private String str;
    public  S_B(String str){
     this.str=str;
    }
    public void  ch_str(){
        StringBuffer st_bu=new StringBuffer(str);
        st_bu.deleteCharAt(2);
        System.out.printf(st_bu.toString());
    }
}

 方法的链式调用：即一个方法的返回是一个对象，我们可 以基于这个对象继续调用对象，这种形式叫做方法的调用，比如：st_bu是StringBuffer对象。

st_bu.deleteCharAt(2).append("ok").append("oooo");

 练习：int[] arr = {34,12,89,68};将一个int[]中元素转成字符串  格式 [34,12,89,68]

package test03;

import org.omg.Messaging.SYNC_WITH_TRANSPORT;

import java.lang.reflect.Array;

public class Str_Bu {
    public static void  main(String...args){
        int[] in_ar={34,12,89,68};
        S_B s_b=new S_B(in_ar);
        s_b.ch_str();
    }
}


class S_B{
    private int[] in;
    public  S_B(int[] in){
        this.in=in;
    }
    public void  ch_str(){
        StringBuffer in_bu=new StringBuffer();
        for(int i=0;i<this.in.length;i++){
            if(i==0){
                in_bu.append("[");
                in_bu.append(Array.get(this.in,i));
            }else if (i==this.in.length-1){
                in_bu.append(Array.get(this.in,i));
                in_bu.append("]");
            }else{
                in_bu.append(Array.get(this.in,i));
            }

        };
        System.out.printf(in_bu.toString());
    }
}