黑马程序员——java-几个常用的类（Object，Scanner，String，StringBuffer/StringBuilder）

———–android培训、java培训、java学习型技术博客、期待与您交流！————

1 Object类

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

---

Object类中常用的方法

public String toString()---//返回该对象的字符串表示
public final Class  getClass()---返回的是字节码对象//反射时候用到
public boolean equals(Object obj)--指示其他某个对象是否与此对象“相等”。 
protected void finalize()-----当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法   
public int hashCode()----返回地址值

---

重要的方法:

---public String toString()

返回对象的字符串表达形式--getClass().getName() + '@' + Integer.toHexString(hashCode())

一般输出对象（s）的引用的时候，默认输出的都是该引用调用的toString()方法 （s.toString() )  

         一般都重写此方法。重写的时候，不用自己添加，快捷键Alt+Shift+s，然后点击toString()即可。

package importMethod;

class Persion// 定义一个Persion类
{
    public String name;
    public int age;

    public Persion(String name, int age)// 带参数的构造方法
    {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString()//重写Object类的该方法
    {
        return "Persion [name=" + name + ", age=" + age + "]";
    }


}

public class ObjectDemo
{
    public static void main(String[] args)
    {
        Persion persion = new Persion("袁郎", 25);// 创建Persion对象
        //System.out.println(persion);// 打印Persion对象（看结果）
        // 输出的结果是：importMethod.Persion@56bf1a4a（说明给Persion类没有重写toString()方法）


        System.out.println(persion);// 打印Persion对象（看结果）
      //输出结果为：Persion [name=袁郎, age=25]（因为Persion类重写了toString()方法）
    }

}

---public boolean equals(Object obj)

   ==的作用
    --比较基本类型，比较的是基本类型的值是否相同
    --比较引用类型，比较的是引用类型的地址值是否相同   
默认情况下Object的equals方法比较的是对象的地址值是否相同
所以如果要比较对象的值是否相同，需要重写equals方法，也不用手动添加，有快捷键    

---对象 instanceof 类名（判断，该对象是否是该类的一个对象）

2 Scanner类的用法

   用法：用于接受用户键入的数据
  构造方法：--public Scanner(InputStream source)

   Scanner in =new Scanner(System.in)；

   解释这个构造方法中的参数问题：
   System类中有一个成员变量in，是静态修饰的：如下
   public static final InputStream in；
   所以：System.in调用后返回的是一个InputStream 字节输入流的对象（详情看IO流那一节）

    Scanner类中的重要方法：

    --public byte nextByte()//接受字节
    --public int nextInt()//接受int类型
    --public long nextLong()//接受long类型
    --public float nextFloat()//接受float类型
    --public double nextDouble()//接受double类型
    --public short nextShort()//接受short类型
    --public String nextLine()//接受String类型

package importMethod;

import java.util.Scanner;

public class ScannerDemo
{
    private void mian()
    {
        Scanner in =new Scanner(System.in);//定义一个扫面器对象
        System.out.println("请输入一个整数");

        int a=in.nextInt();//接受数据
        System.out.println("输入的数是："+a);//输出数据
    }

}

小问题----连续的先接受一个int在接受一个String时候在输入一个int值后，int值默认后边还有\n,此时 会\n当做String赋值
int i=sc.nextInt();String s=sc.nextLine();
解决方法；
     ---A在int值接受结束后再，重新定义一个Scanner 对象用于接受String

package importMethod;

import java.util.Scanner;

public class Scannerproblem
{
    public static void main(String[] args)
    {
        Scanner s=new Scanner(System.in);

        int a=s.nextInt();
        Scanner i=new Scanner(System.in);//接受一个int类型的数据后，重新定义扫描器
        String string=i.nextLine();//在接受一个String类型的数据

        System.out.println(a);
        System.out.println(string);
    }

}

  ---B 把所有的数据都用字符串接受，然后要什么类型就转成什么类型（用到String类）

package importMethod;

import java.util.Scanner;

public class Scannerproblem
{
    public static void main(String[] args)
    {
        Scanner i =new Scanner(System.in);

        String s=i.nextLine();
        //在接受一个String类型的数据，把所有数据都用String接受
        //在输出的时候，需要什么类型，就转成什么类型


        System.out.println(s.valueOf(s));

    }

}

3 String类

构造方法：
A--String()
B--String(byte[] bytes) 把字节数组转成字符串
C--String(byte[] bytes, int index, int length)把字节数组的一部分转成字符串
D--String(char[] value) 把字符数组转成字符串
E--String(char[] value, int indexint count) 把字符数组的一部分转成字符串
F--String(String original) 把字符串转成字符串

package com.itheima;

/*
 * 构造方法：
 A--String()
 B--String(byte[] bytes) 把字节数组转成字符串
 C--String(byte[] bytes, int index, int length)把字节数组的一部分转成字符串
 D--String(char[] value) 把字符数组转成字符串
 E--String(char[] value, int indexint count) 把字符数组的一部分转成字符串
 F--String(String original) 把字符串转成字符串

 */
public class string_Demo {
    public static void main(String[] args) {
        // A--String()
        String s = new String();
        System.out.println("s 对象的长度为：" + s.length());

        // String(char[] value) 把字符数组转成字符串
        char[] ch = new char[] { 'e', 'd', 'c', 'b', 'a' };
        String bs = new String(ch);// 把字符数组转成字符串
        String bs1 = new String(ch, 0, 2);// 把字符数组的一部分转成字符串
        System.out.println(bs);

        // String(String original) 把字符串转成字符串
        System.out.println(new String(new String("赵云！")));// 把字符串转成字符串

    }

}

  字符串的特点：一但被赋值，它的值就不能被改变（但是字符对象的引用所指向的地址是可以改变的）
        字符串的本质就是一个字符数组（数组的特点，长度是固定的）
例子：
    String s="hello";
               s+="world";
    System.out.println(s);//输出的值是：helloworld

---

面试题1
 String s=new String("hello")和String s1="hello"的区别？
 s==s1(false)比较的是地址 s.equals(s1)(true)比较的是内容
画内存图可以解释
![这里写图片描述](https://img-blog.csdn.net/20150428103348930)

---

面试题2
String s1="hello"
String s2="world"
String s3="helloworld"
s3.equals(s1+s2)//true

s3==s1+s2//false  字符变量相加，先开空间在相加存储 
s3=="hello"+"world"//true  字符常量相加，先相加，再在常量池中找如果有，就返回常量池的地址，否则在开空间，返回地址

---

String的方法（判断方法）
  A--public boolean equals(Object anObject)
  比较字符串的内容是否相同，区分大小写
  B--public boolean equalsIgnoreCase(String anotherString)
  按字典顺序比较两个字符串，不考虑大小写

  C--public boolean contains(CharSequence s)
  判断字符串中是否包含指定的字符
  D--public boolean endsWith(String suffix)
  判断是否是以指定的字符结尾
  E--public boolean startsWith(String prefix,int toffset)
       判断是否是以指定的字符开头  

---

  F--public boolean isEmpty()
      判断字符串是否为空
      String s=""
      s.idEmpty()//结果为true
      String s="null"
      s.idEmpty()//这样写要报错，空对象，就是没有对象，没有对象就不能调用方法

---

package com.itheima;

/*String 的判断方法：
 *  A--public boolean equals(Object anObject)
     比较字符串的内容是否相同，区分大小写
     B--public boolean equalsIgnoreCase(String anotherString)
       按字典顺序比较两个字符串，不考虑大小写
     C--public boolean contains(CharSequence s)
      判断字符串中是否包含指定的字符
      D--public boolean endsWith(String suffix)
      判断是否是以指定的字符结尾
      E--public boolean startsWith(String prefix,int toffset)
           判断是否是以指定的字符开头               
      F--public boolean isEmpty()
        判断字符串是否为空
 */
public class string2 {
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = "hello";

        System.out.println(s1.equals(s2));// 结果为false，次方法比较大小写
        System.out.println(s1.equalsIgnoreCase(s2));// 结果为true。次方法不区分大小写
        System.out.println(s1.contains("ello"));//结果为true ,包含指定的字符
        System.out.println(s1.startsWith("He"));//结果为true,以指定的字符开头  
        System.out.println(s1.endsWith("lo"));//结果为true,以指定的字符结尾
        System.out.println(s1.isEmpty());//结果为false,字符串为空

    }

}

String的方法（获取功能）
   A--public int length()//返回字符串的长度
   B--public char charAt(int index)//返回指定索引处的字符
   C--public int indexOf(int ch)//返回指定字符在字符串中第一次出现的索引
   D--public int indexOf(int ch,int fromIndex)
            //获取ch这个字符在该字符串中的指定索引后第一次出现的索引  
   E--public int indexOf(String str,int fromIndex)
   //获取str字符串在该字符串中从指定索引后第一次出现的索引  

   F--public int indexOf(String str)//获取指定字符串在字符串中第一次出现的索引

   G--public String substring(int beginIndex)
     //获取字串，从指定索引到结尾
   H--public String substring(int beginIndex,int endIndex)
       //获取字串，从beginIndex到endIndex（牢记，获取的字串包括左边，不包括右边）

package com.itheima;

/*
 *    A--public int length()//返回字符串的长度
 B--public char charAt(int index)//返回指定索引处的字符
 C--public int indexOf(int ch)//返回指定字符在字符串中第一次出现的索引
 D--public int indexOf(int ch,int fromIndex)
 //获取ch这个字符在该字符串中的指定索引后第一次出现的索引  
 E--public int indexOf(String str,int fromIndex)
 //获取str字符串在该字符串中从指定索引后第一次出现的索引  

 F--public int indexOf(String str)//获取指定字符串在字符串中第一次出现的索引

 G--public String substring(int beginIndex)
 //获取字串，从指定索引到结尾
 H--public String substring(int beginIndex,int endIndex)
 //获取字串，从beginIndex到endIndex（牢记，获取的字串包括左边，不包括右边）
 */
public class String3 {
    public static void main(String[] args) {

        String s = "heallo,java";
        System.out.println(s.length());// 返回字符串的长度
        System.out.println("s字符串中，下标为2处的字符为：" + s.charAt(1));// 获取：下标为2处的字符
        System.out.println(s.indexOf("jav"));// 返回指定字符在字符串中第一次出现的索引
        System.out.println(s.indexOf("a", 3));// 获取ch这个字符在该字符串中的指定索引后第一次出现的索引

        System.out.println(s.substring(2));// 结果为：allo,java--获取字串，从指定索引到结尾
        System.out.println(s.substring(0, 3));// 结果为：hea---（牢记，获取的字串包括左边，不包括右边
    }

}

String的遍历
    通过A--public int length()方法和B--public char charAt(int index)方法可以遍历String

package com.itheima;

public class string4 {
    public static void main(String[] args) {
        String s="androd,java";
        //字符串的遍历：两个方法的结合
        /*
         * 通过A--public int length()方法
         * B--public char charAt(int index)方法可以遍历String
         */
        for (int i = 0; i < s.length(); i++) {
            System.out.println(s.charAt(i));

        }

    }

}

---

String的方法（转换功能）

        byte[] getByteds()把字符串转成字节数组
        char[] toCharArray()把字符串转成字符数组
        static String copyValueOf(char[] chs)把字符数组转成字符串
        static String valueOf(char[] chs)把字符数组转成字符串
        static String valueOf(int i)基本类型，把基本类型转成字符串
        String toLowerCase()把字符串转成小写
        String toUpperCase()把字符串转成大写
        String concat(String str)字符串拼接

package importMethod;

public class StringDemo
{
    public static void main(String[] args)
    {
        /*
         * String的方法（转换功能）
         * 
         * byte[] getByteds()把字符串转成字节数组 char[] toCharArray()把字符串转成字符数组
         * 
         * static String copyValueOf(char[] chs)把字符数组转成字符串 static String
         * valueOf(char[] chs)把字符数组转成字符串 static String valueOf(int
         * i)基本类型，把基本类型转成字符串
         * 
         * String toLowerCase()把字符串转成小写 String toUpperCase()把字符串转成大写 String
         * concat(String str)字符串拼接
         */

        String s = "java-android";

        byte[] bys = s.getBytes();// 把字符串转成字节数组
        System.out.println("此数组bys的长度是：" + bys.length);

        char[] ch = s.toCharArray();// 把字符串转成字符数组
        System.out.println("此数组ch的长度是：" + ch.length);

        char[] ch1 = new char[]
        { 'a', 'n', 'd', 'r', 'o', 'i', 'd' };
        System.out.println(String.valueOf(ch1));// 把字符数组转成字符串
        System.out.println(String.copyValueOf(ch1));// 把字符数组转成字符串

        int a = 100;
        System.out.println(String.valueOf(a));// 基本类型，把基本类型转成字符串

        String string = "java AND android";
        System.out.println(string.toUpperCase());// 把字符串转成大写---JAVA AND ANDROID
        System.out.println(string.toLowerCase());// 把字符串转成小写---java and android

        String s1 = "hello", s2 = "java";

        System.out.println(s1.concat(s2));// 字符串拼接-----hellojava

    }

}

---

   copyValueOf(char[] chs)和 valueOf（）的区别？                

--copyValueOf(char[] chs)只把字符数组转成string
-- valueOf（）可以把任意类型转成String

---

String的方法（替换功能）
    A--public String replace(char oldChar,char newChar)
    把字符串中所有oldChar的字符替换为newChar
            B--public String replace(String oldChar,String newChar)     

String trim()该方法是，去除字符串两端的空格

package importMethod;

/*
 * A--public String replace(char oldChar,char newChar)
        把字符串中所有oldChar的字符替换为newChar
   B--public String replace(String oldChar,String newChar)    
   c--public String replace(CharSequence target,CharSequence replacement) 

        target - 要被替换的 char 值序列
        replacement - char 值的替换序列 



   c---String trim()该方法是，去除字符串两端的空格

 */
public class string_tihuan
{
    public static void main(String[] args)
    {
        String olds="   java_an   droid   ";
        String news="hello";
        System.out.println(olds.replace(olds, news));//结果----hello
        System.out.println(olds.replace(news, olds));//结果---   java_an   droid 
        System.out.println(news.replace("l", "mm"));//结果----hemmmmo
        System.out.println(olds.trim());//结果为----java_an   droid只能去除两端的空格
    }

}

4
StringBuffer/StringBuilder

(1)字符串缓冲区类。
(2)String,StringBuffer/StringBuilder的区别?
    A:String的字符串长度固定。而StringBuffer/StringBuilder的字符串长度是可以改变的。
    B:StringBuffer是线程安全的，效率低。
      StringBuilder是线程不安全的，效率高。
(3)构造方法：
    A:StringBuffer sb = new StringBuffer();//没有参数的构造方法，其初始容量为16
    B:StringBuffer sb = new StringBuffer(50);//带参数的，初始容量为指定的值
    C:StringBuffer sb = new StringBuffer("hello");//初始容量为String.length()+16
(4)成员方法：
   public int capacity()//获得理论值
   public int length()//获得字符串中的实际长度
    A:添加功能
    append

    StringBuffer操作后，如果返回的是StringBuffer类型，实质返回的是本身对象
    StringBuffer sb=new StringBuffer();
    StringBuffer s1=sb.append("hello");
    StringBuffer s2=sb.apped("world");
    s1==s2//true   返回的是true，说明s1和s2同一个对象
    所以，可以改为，sb.append("hello").append("world");链式操作

    public StringBuffer insert(int offset,char c)
        在指定位置上插入字符，以前位置上的字符先后移动

    B:删除功能
        public StringBuffer delete(int start,int end)
                     删除从start到end的字符
        public StringBuffer deleteCharAt(int index)
        删除指定位置的字符
    C:替换功能
        public StringBuffer replace(int start,int end,String str)
                    把从[start,end)包左不包右的字符全部替换为str    

    D:截取功能
        public String substring(int start)
        public CharSequence subSequence(int start,int end)包左不包右

    E:反转功能
        public StringBuffer reverse()//"你爱我"----->“我爱你”

package importMethod;

/*
 *       public int capacity()//获得理论值
 public int length()//获得字符串中的实际长度
 A:添加功能
 append

 StringBuffer操作后，如果返回的是StringBuffer类型，实质返回的是本身对象
 StringBuffer sb=new StringBuffer();
 StringBuffer s1=sb.append("hello");
 StringBuffer s2=sb.apped("world");
 s1==s2//true   返回的是true，说明s1和s2同一个对象
 所以，可以改为，sb.append("hello").append("world");链式操作

 public StringBuffer insert(int offset,char c)
 在指定位置上插入字符，以前位置上的字符先后移动

 B:删除功能
 public StringBuffer delete(int start,int end)
 删除从start到end的字符（包左不包右）
 public StringBuffer deleteCharAt(int index)
 删除指定位置的字符
 C:替换功能
 public StringBuffer replace(int start,int end,String str)
 把从[start,end)包左不包右的字符全部替换为str    

 D:截取功能
 public String substring(int start)
 public CharSequence subSequence(int start,int end)包左不包右

 E:反转功能
 public StringBuffer reverse()//"你爱我"----->“我爱你”
 */

public class stringBufferDemo
{
    public static void main(String[] args)
    {
        StringBuffer sb = new StringBuffer("android_i am coming!");

        System.out.println("字符串的实际长度为：" + sb.length() + " |加上16就是总容量： " + sb.capacity());
        // 结果为：字符串的实际长度为：20 |加上16就是总容量： 36

        StringBuffer sb1 = new StringBuffer();// 添加功能
        sb1.append("android").append(" ").append("hello");
        System.out.println(sb1);// 结果为：android hello

        // 在指定位置上插入字符，以前位置上的字符先后移动
        System.out.println(sb1.insert(2, 'M'));// 结果为：anMdroid hello

        // 删除指定位置的字符
        System.out.println(sb1.deleteCharAt(0));// 结果为：nMdroid hello
        // 在指定位置上插入字符，以前位置上的字符先后移动
        System.out.println(sb1.delete(0, 2));// 结果为：droid hello--注意：（包左不包右）

        // 替换功能
        System.out.println(sb1.replace(0, 2, "MH"));// 结果为：MHoid
                                                    // hello--注意：（包左不包右）

        // 截取功能
        System.out.println(sb1.substring(4));// 结果为：d hello
        System.out.println("没有截取之前sb1为：" + sb1 + "截取之后为：" + sb1.substring(0, 4));// 结果为：MHoi

        // 反转功能
        System.out.println("没有翻转之前sb1为：" + sb1 + "翻转之后为：" + sb1.reverse());
        // 结果为：没有翻转之前sb1为：MHoid hello翻转之后为：olleh dioHM
    }

}

   String和StringBuffer的相互转化:

String------->StringBuffer
         String s="hello";
            方式一： StringBuffer的构造方法
             StringBuffer sb=new StringBuffer(s);
            方式二： StringBuffer的append（）方法
            StringBuffer sb=new StringBuffer();
                sd.append(s);//public StringBuffer append(String str)

StringBuffer------->string
              StringBuffer sb=new StringBuffer(“hehe”);
                方式一：String的构造方法
                String s=new String（sb）；
               方式二：StringBuffer的toString（）方法
               String s=sb.toString();public String toString()

———–android培训、java培训、java学习型技术博客、期待与您交流！————