黑马程序员--Java基础学习笔记【Object类、String类】

 

 ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------    

 

• Object类

在Java类继承结构中，java.lang.Object类位于顶端。

所有类都直接或间接继承Object类。

（接口不能继承Object类，接口中隐含定义了Object类的所有公共方法，但是全抽象）

Object类型的引用变量可以指向任何类型对象。

Object类成员方法

public String toString() {

return getClass().getName() + "@" + Integer.toHexString(hashCode());// 类名@散列码

}

重写toString方法

public String toString() {

return getClass().getName() + " [name= "+ name + " , salary= " + salary + "]"; // 类名[域值]

}

publicfinalnative Class<?> getClass();

 

publicbooleanequals(Object obj){

   return(this== obj);

}

• “==”和equals 区别

前者是比较运算符，后者是方法

 

前者比较基本类型，符号两端数据是否相等

比较引用类型，符号两端引用类型的地址是否相等，即是否指向相同的对象

equals 方法

不重写的情况下，默认同“==”，比较的是对象的地址

可以重写方法建立对象自己的比较方法，比较成员变量的值

protectedvoid finalize() throws Throwable { }

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

• final,finally, finalize 的区别

final是一个修饰符，修饰类不能被继承，修饰变量必须在声明时给定初值，且不可修改，修饰方法不能被重载。

finally用在异常处理时提供finally块来执行任何清除操作，如果抛出异常，先执行相匹配的catch子句，再进入finally块执行。

finalize是方法名，Java允许使用该方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。

• Scanner类SinceJDK5获取用于键盘输入

构造方法 public Scanner(InputStream source)

成员方法hasNextXXX(), nextXXX()

 

• String类

• String是不可变对象

    java.lang.String使用了final修饰，不能被继承

    字符串底层封装了字符数组及针对字符数组的操作算法

    字符串一旦创建，对象永远无法改变，但字符串引用可以重新赋值

• String类的构造方法

    public String()

    public String(byte[] bytes)

public String(byte[] bytes, int offset, intlength)

public String(char[] value)

public String(char[] value, int offset, intcount)

public String(String original)

字符串是常量，创建之后不能更改，证明String对象的不变性

    String string = "www.itcast.cn";

    System.out.println(string);// www.itcast.cn

    method(string);

    System.out.println(string); // www.itcast.cn

    voidmethod(Strings) {

       s = s + "0807Java";

    }

• Sting 常量池

    Java为了提高性能，静态字符串（字面量/常量/常量连接的结果）在常量池中创建，并尽量使用同一个对象，重用静态字符串；对于重复出现的字符串直接量，JVM会首先在常量池中查找，如果存在即返回该对象。

String str1= "itcast";

      

       // 不会创建新的String对象，而是使用常量池中已有的"itcast"

       Stringstr2= "itcast";

      

       System.out.println(str1 == str2); // true

      

       // 使用new 关键字会创建新的String对象

       // 创建了2个对象，new String()和 "itcast"

       Stringstr3= newString("itcast");

      

       System.out.println(str1 == str3); // false

       // String类重写了equals方法

       System.out.println(str1.equals(str3)); // true

 

String类的判断方法

    boolean equals(Object obj)

    boolean equalsIgnoreCase(String str)

    boolean contains(String str)

    boolean startsWith(String str) // 检测字符串是否以指定字符串开头

    boolean endsWith(String str)

    boolean isEmpty()

String类的获取功能

    int length()

    char charAt(int index) // 获取指定索引上的字符

    int indexOf(int ch) // 获取指定字符第一次出现位置的索引，没有返回-1

    int indexOf(String str)

    int indexOf(int ch, int fromIndex)

    int indexOf(String str, int fromIndex)

    int lastIndexOf(String str, int from) // 返回最后一个出现的位置

    String substring(int beginIndex)

    String substring(int beginIndex, int endIndex)

String 类的转换功能

    byte[] getBytes()

    char[] toCharArray()

    static String valueOf(char[] chs) // 字符数组à字符串

    static String valueOf(Object obj) // 其他类型à字符串

    String toLowerCase() // 将字符串中的大写字母转成小写

    String toUpperCase()

    String concat(String str) // 将指定字符串str连接到调用字符串的结尾，返回一个新的字符串对象

其他功能

    String replace(char old, char new)

    String replace(String old, String new)

    String trim() // 去掉字符串首尾两端的空格

    int compareTo(String str) // 按字典顺序比较

    int compareToIgnoreCase(String str)

    String[] split(String regex) // 按照正则表达式的匹配拆分字符串

 

// 自定义方法实现两个字符串的比较，完全相等返回 true

    publicstaticboolean isEqual(String str1, String str2) {

       // 将两个字符串分别转换成字符数组

       char[] array1 = str1.toCharArray();

       char[] array2 = str2.toCharArray();

       // 比较两个字符数组的长度，如果相等，继续比较数组元素

       if (array1.length == array2.length) {

           // 遍历字符数组

           for (inti = 0; i < array1.length; i++) {

              // 比较当前索引元素是否相等，不相等返回 false，停止继续比较

              if (array1[i] != array2[i]) {

                  returnfalse;

              }

           }

           // 字符数组遍历完毕，每个元素值都相等，返回 true

           returntrue;

       }

       // 当字符数组长度不同时，直接返回 false

       returnfalse;

    }

 

// 自定义方法实现两个字符串的比较，完全相等返回 true

    publicstaticboolean isEqual2(String str1, String str2) {

       if (str1.length() == str2.length()) {

           for (inti = 0; i < str1.length(); i++) {

              if (str1.charAt(i) != str2.charAt(i)) {

                  returnfalse;

              }

           }

           returntrue;

       }

       returnfalse;

    }

 

// 将字符串中的英文字符进行大小写互转

    publicstatic StringtoAnotherCase(String string) {

       // 将字符串转换成字符数组

       char[] array = string.toCharArray();

       // 遍历字符数组，根据判断ASCII值判断其大小写状态并进行转换

       for (inti = 0; i < array.length; i++) {

           // 大写字母 --> 小写字母

           if (array[i] >= 65 && array[i] <= 90) {

              array[i] += 32;

           }elseif(array[i] >= 97 && array[i] <= 122) { // 小写字母 --> 大写字母

              array[i] -= 32;

           }// 其他字符不处理

       }

       // 将字符数组转换成字符串

//     StringanotherCase = String.valueOf(array);

      

       StringanotherCase= newString(array);

       // 返回转换后的字符串

       returnanotherCase;

    }

 

// 判断一个字符串是不是回文

    publicstaticboolean isPalindrome(String string) {

       // 限制判断字符的长度不小于 3 个字符，且必须是奇数

       if (string.length() >= 3&& string.length()% 2 == 1) {

           // 将字符串转换成字符数组

           char[] array = string.toCharArray();

           // 从字符数组索引的头尾两端取元素判断是否相等，不相等直接返回 false

           for (intmin = 0, max = array.length - 1; min < max; min++, max--) {

              if (array[min] != array[max]) {

                  returnfalse;

              }

           }

           // 判断完毕没有不相等的元素则返回 true

           returntrue;

       }

       // 字符长度小于3，直接返回 false

       returnfalse;

    }

 

// 统计字符串中大小写字母数字其他字符出现的次数

    publicstaticvoid count(String string) {

       // 计数器

       intupper = 0, lower = 0, digit = 0, other = 0;

       // 遍历数组

       for (inti = 0; i < string.length(); i++) {

           // 取出数组中每个位置上的字符元素

           charch = string.charAt(i);

           if (ch >= 'a' && ch <= 'z') { // 判断小写

              lower++;

           }elseif(ch >= 'A' && ch <= 'Z') { // 判断大写

              upper++;

           }elseif(ch >= '0' && ch <= '9') { // 判断数字

              digit++;

           }else{ // 其他字符

              other++;

           }

       }

//     other= string.length() - lower - upper;

       System.out.println("lower= "+ lower);

       System.out.println("upper= "+ upper);

       System.out.println("digit= "+ digit);

       System.out.println("other= "+ other);

    }

 

// 统计一个字符串在另一个字符串中出现的次数

    publicstaticvoid countTimes(String string, String sub) {

       // 计数器，index保存当前查找结果的索引

       intcount = 0, index = 0;

       // 循环查找，结束条件是在目标串中查找不到子串

       while ((index = string.indexOf(sub)) != -1) {

           count++;

           // 截取字符串，保留此次索引+字串长度以后的部分

           string = string.substring(index + sub.length());

       }

       System.out.println("共出现" + count + "次");

    }

 

// 将字符串反转，结果返回反转之后的字符串

    publicstatic String reverse(String string) {

       // 字符串 --> 字符数组

       char[] cs = string.toCharArray();

       // 交换首尾两端的数组元素，实现位置反转

       for (intmin = 0, max = cs.length - 1; min < max; min++, max--) {

           chartemp = cs[min];

           cs[min] = cs[max];

           cs[max] = temp;

       }

       // 字符数组 --> 字符串

       string = new String(cs);

 

       returnstring;

    }

 

• StringBuffer和StringBuilder

封装可变的字符串，对象创建后可以通过调用方法改变其封装的字符序列。

StringBuffer线程安全的可变字符序列，StringBuilder线程不安全的可变字符序列

构造方法

    StringBuffer() // 空的字符串缓冲区，默认初始容量16个字符

    StringBuffer(int capacity) // 指定容量

    StringBuffer(String str) // 字符串 -->字符串缓冲区

成员方法

    public StringBuffer append(String str) // 追加字符串

    public StringBuffer insert(int offset,String str) // 插入字符串

    public StringBuffer deleteCharAt(int index)// 删除字符

    public StringBuffer delete(int start, intend) // 删除字符串

    public StringBuffer replace(int start, intend, String str) // 替换字符串

    public StringBuffer reverse() // 字符串反转

    public String substring(int start) // 获取子串

    public String substring(int start, int end)

 

 

       StringBufferbuffer= newStringBuffer("www.itcast.cn");

       System.out.println(buffer); // www.itcast.cn

       System.out.println("证明缓冲区可变");

       method(buffer);

       System.out.println(buffer); // www.itcast.cn0807Java

   

        // 定义方法向缓冲区中追加字符串

void method(StringBuffer buffer) {

           buffer.append("0807Java");

        }

 

// 定义方法实现缓冲区反转

    publicstaticvoidreverseBuffer(StringBuffer buffer) {

       // 缓冲区变成字符串,变成字符数组

       char[] ch = buffer.toString().toCharArray();

       // 数组反转

       for (inti = 0, j = ch.length - 1; i < j; i++, j--) {

           chartemp = ch[i];

           ch[i] = ch[j];

           ch[j] = temp;

       }

       // 数组变成缓冲区,清空原有缓冲区

       buffer.delete(0,buffer.length());

        buffer.append(ch);

    }