java大数据学习第十一天--------API Object及常用方法 String特点及常用方法 StringBuilderStringBuffer---append_随笔

java大数据学习第十一天--------API Object及常用方法 String特点及常用方法 StringBuilder/StringBuffer---append API

概念:

Application Programming Interface，应用程序接口

是一些预先定义的函数

目的是提供应用程序与开发人员基于某软件可以访问的一些功能集,但又无需访问源码或理解内部工作机制的细节.

是一种通用功能集

Object

顶级父类是所有java类的祖先
存在于java.lang.Object这个包中,这个包不需要我们手动导包
每个类都使用Object作为超类(长辈类).所有对象(包括数组)都实现这个类的方法.

在不明确给出超类的情况下,Java会自动把Object类作为要定义类的超类.

常用方法介绍

hashCode()
- 用于返回对应对象的哈希码值 int类型----根据对象的地址值生成哈希码值
- 不同的对象返回的哈希码值不同
- 可以根据不同的哈希码值区分不同的对象
- ```
        System.out.println(s.hashCode()); //961
        System.out.println(s1.hashCode());//1101528838
```
- 有时候也存在不同对象哈希码值相同的特殊情况,我们称之为”哈希碰撞”现象
toString()
- Object 中 toString() 方法的默认是实现是:对象的地址值[对象类型@十六进制的哈希码值]
- 子类重写了 toString之后,打印的是: 对象类型+属性+属性值
- ```
Student s1 = new Student(name:"海绵宝宝",age:3);
System.out.println(s1);//Student{name='海绵宝宝', age=3}  对象类型student 属性+属性值{name='海绵宝宝', age=3}
```
equals()
- Object 中 equals 默认实现使用的是 == 比较
- ==比较的是左右两边的值,如果是基本类型,比较的是字面值,比如:1和1 3.4和3.4
  
  如果是引用类型,比较的是引用类型变量保存的地址值
- 子类重写了 equals() 与 hashCode() 方法后比较的是: 对象类型+属性+属性值
- ```
Student s1 = new Student(name:"海绵宝宝",age:3);
Student s2 = new Student(name:"海绵宝宝",age:3);
System.out.println(1==1);//true
System.out.println(true==true);//true
System.out.println(s1.equals(s2));//重写之前是FALSE    重写以后是true
```
注意:
- equals()与hashCode() 逻辑要保持一致要重写都重写要不重写都不重写
- Object 默认是实现: hashCode() 的哈希码值根据地址值生成
  
  equals() 底层使用 == 比较两个对象的地址值
  
  重写后: hashCode() 的哈希码值根据重写后传入对象的属性生成
  
  equals() 比较两个对象的类型+属性+属性值

string

特点:
- String 是一个封装char[]数组的对象,字符串不可变--------底层是char[]
- 是被 final 修饰的是常量
- String str = “abc”; 等效于：char[] data = {‘a’, ‘b’, ‘c’};

创建String对象的方式

方式1—保存在堆中:

        char[] value = {'a','b','c'};
        String s1 = new String(value);//触发String(char[])的含参构造来创建对象
        String s11 = new String(value);//触发String(char[])的含参构造来创建对象

方式2—保存在堆中常量池–常量池中所有元素都只有一个,可以多次取用
```
        String s2 = "abc";
        String s22 = "abc";
        String s3 = "ccc";
```

测试方法1 方法2

		System.out.println(s1==s2);//false,一个在堆里 一个在常量池里
        System.out.println(s1==s11);//false
        System.out.println(s2==s22);//true  都在堆中常量池,并且由于内容相同,所以是同一个地址值
        System.out.println(s2==s3);//false  都在堆中常量池 但是内容不同 所以指向两个地址值

String 常用方法--------------------------------------------------------------------------------“十八罗汉”

equals()-----比较两个字符串的具体内容

Object类中equals()的默认实现是通过==比较的

但是 String类已经重写过了继承自Object中的equals()

重写后,不再按照 == 比较,而是比较两个字符串的具体内容

也就是说,不论创建方式,只要串的内容一致,equals() 就返回 true
```
		System.out.println(s1.equals(s2));//true
        System.out.println(s1.equals(s11));//true
        System.out.println(s2.equals(s3));//false
```

hashCode()-----根据字符串的具体内容生成哈希码值

String 重写了hashCode(),据字符串的具体内容生成哈希码值 ,而不是根据地址值生成

 		char[] value = {'a','b','c'};
        String s1 = new String(value);
        String s2 = "abc";
	    System.out.println(s1.equals(s2));//true
        System.out.println(s1.hashCode());//96354
        System.out.println(s2.hashCode());//96354

toString()-----打印字符串的具体内容

String 重写了Object中的 toString方法,打印的是字符串的具体内容
```
 		char[] value = {'a','b','c'};
        String s1 = new String(value);
		 System.out.println(s1)//abc
```
.length() ------查看当前字符串的长度
```
System.out.println(s1.length());//3
```
.toUpperCase()-----将本字符串转为全大写
```
System.out.println(s1.toUpperCase());//ABC
```
.toLowerCase()-----将本字符串转为全小写
```
System.out.println(s1.toLowerCase());//abc
```
.startsWith()-----判断字符串是不是以指定元素开头
```
System.out.println(s1.startsWith("a")); //true
```
.endsWith()-----判断字符串是不是以指定元素结尾
```
System.out.println(s1.endsWith("a"));//false
```
.charAt()-----根据下标获取本字符串中对应位置上的元素
```
System.out.println(s1.charAt(0));//a
```

.indexOf()-----返回指定字符第一次出现的下标

 		String s3 = "abcbdbba";
        System.out.println(s3.indexOf("b"));//1

.lastIndexOf()-----返回指定字符最后一次出现的下标
```
System.out.println(s3.lastIndexOf("b"));//6
```

.concat()-----将指定字符串拼接在本字符串末尾,是临时的,不会改变原字符串内容

 System.out.println(s2.concat("cxy"));//abccxy
  System.out.println(s2);//abc
  
  想要永久拼接可以:
  		 String s4=s2.concat("aaa");
         System.out.println(s4);//abcaaa

.split()-----以指定字符作为分隔符,分割当前字符串

 		//返回值类型是String[],所以需要Arrays.toString()打印
        String s5="afbfcfdfe";
        String[] a = s5.split("f"); //以指定字符作为分隔符,分割当前字符串
        System.out.println(Arrays.toString(a));//[a,b,c,d,e]
        //我们也可以遍历数组,拿到数组中每个元素
        for (int i = 0; i

.trim()-----去除字符串首尾两端的空格

		String s6 = "      hh hhh      ";
        System.out.println(s6.trim());//hh hhh

.substring()-----截取子串-----算两个方法

		String s7 = "abcdefgh";
        System.out.println(s7.substring(3));//defgh  截取子串 从指定下标处开始截取字串[3,结束]
        System.out.println(s7.substring(3,6));//def  截取子串 从指定下标处开始截取子串[3,6)含头不含尾

String.valueOf()-----将int类型转为String类型

		System.out.println(20+10);//30,int+int->计算效果
        System.out.println("20"+10);//2010,String+int->拼接效果
        System.out.println(String.valueOf(10));//10
        System.out.println(String.valueOf(80));//80
        System.out.println(String.valueOf(80)+10);//8010 ,将int类型的80转为String类型

.getBytes()-----将指定字符串转换为byte[]

 		byte[] bs = s7.getBytes();//将指定字符串转换为byte[]
        System.out.println(Arrays.toString(bs));//[97, 98, 99, 100, 101, 102, 103, 104]

StringBuilder/StringBuffer

特点:
- StringBuilder 比 StringBuffer 快
- 封装了char[]数组
- 是可变的字符序列
- 提供了一组可以对字符内容修改的方法
- 内部字符数组默认初始容量是16：super(str.length() + 16);
- 如果大于16会尝试将扩容，新数组大小原来的变成2倍+2，容量如果还不够，直接扩充到需要的容量大小。int newCapacity = value.length * 2 + 2;
- 常用append()来代替字符串做字符串连接”+”
- ```
append()使用
    //1.创建工具类对象
     StringBuilder sb2 = new StringBuilder();
	//2.拼接10000次
	for(int i=0;i<10000;i++){
            //3.使用工具类对象的append()进行拼接
            sb2.append(s);
    }
	//4.打印拼接完毕的效果
	System.out.println(sb2);
    
```

欢迎分享，转载请注明来源：内存溢出

原文地址: https://outofmemory.cn/zaji/5677758.html

java大数据学习第十一天--------API Object及常用方法 String特点及常用方法 StringBuilderStringBuffer---append

发表评论

评论列表（0条）