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

API

1. 概念:

   Application Programming Interface，应用程序接口

   是一些预先定义的函数

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

   是一种通用功能集

Object

1. 顶级父类 是所有java类的祖先

2. 存在于java.lang.Object这个包中,这个包不需要我们手动导包

3. 每个类都使用Object作为超类(长辈类).所有对象(包括数组)都实现这个类的方法.

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

常用方法介绍

1. hashCode()

   • 用于返回对应对象的哈希码值 int类型----根据对象的地址值生成哈希码值

   • 不同的对象返回的哈希码值不同

   • 可以根据不同的哈希码值区分不同的对象

   •         System.out.println(s.hashCode()); //961
             System.out.println(s1.hashCode());//1101528838
     

   • 有时候也存在不同对象哈希码值相同的特殊情况,我们称之为”哈希碰撞”现象

2. toString()

   • Object 中 toString() 方法的默认是实现是:对象的地址值[对象类型@十六进制的哈希码值]

   • 子类重写了 toString之后,打印的是: 对象类型+属性+属性值

   • Student s1 = new Student(name:"海绵宝宝",age:3);
     System.out.println(s1);//Student{name='海绵宝宝', age=3}  对象类型student 属性+属性值{name='海绵宝宝', age=3}
     
     

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
     

4. 注意:

   • equals()与hashCode() 逻辑要保持一致 要重写都重写 要不重写都不重写

   • Object 默认是实现: hashCode() 的哈希码值根据地址值生成

     ? equals() 底层使用 == 比较两个对象的地址值

     ? 重写后: hashCode() 的哈希码值根据重写后传入对象的属性生成

     ? equals() 比较两个对象的 类型+属性+属性值

string

1. 特点:

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

2. 创建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  都在堆中常量池 但是内容不同 所以指向两个地址值
     

3. 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 <a.length ; i++) {
                 System.out.println(a[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

1. 特点:

   • 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);