常用类(一)Integer,Object,String向前冲

---

JavaSE第五章常用类(API)

• Java API概述

• API(Application Programming Interface)应用程序编程接口
  是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明.

1.基本数据类型包装类

(1)包装类和其中的方法

• 基本数据类型包装类概念:

  • 八个和基本数据类型对应的类统称为包装类.
    因为在面向对象的编程中,基本数据类型不是面向对象的,通常会使用不便,所以对每个基本类型设计了一个包装类

  • 包装类:这些类封装了一些基本数据类型的数值和与基本数据类型相关的方法.

基本数据类型	包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

• 作为和基本数据类型对应的类类型存在。

• 包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。

包装类常用属性方法

(2)包装类常用属性方法如java.lang.Integer类

        int num = 10;
        Integer num1 = new Integer(num);
        System.out.println(num);
        Integer num2 = new Integer(12);
        System.out.println(Integer.BYTES);//字节数
        System.out.println(Integer.MAX_VALUE);//最大值
        System.out.println(Integer.MIN_VALUE);//最小值
        System.out.println(Integer.SIZE);//位数
        System.out.println(num2.TYPE);//类型
        System.out.println(Integer.toBinaryString(num2));//2进制
        System.out.println(Integer.toHexString(num2));//16进制
        System.out.println(Integer.toOctalString(num2));//8进制

        Integer num1 = new Integer(10);
        Integer num2 = new Integer(12);
        System.out.println(num1.compareTo(num2));//比较大小,前大为1相等为0后大为-1
        System.out.println(num1.equals(num2));//比较是否相等,相等为true,不等为false  比较的值
        System.out.println(num1 == num2);//比较时,多用于引用对象,比较地址
        System.out.println(Integer.max(num1,num2));//输出值大的
        System.out.println(Integer.min(num1,num2));//输出值小的
        int num3 = Integer.valueOf(num1);//把num3转换为引用类型int
        int num4 = Integer.valueOf("num1");//把num3转换为引用类型String
        int num5 = num1.intValue();//取出对象的具体值
        int num6 = Integer.valueOf(num3);//把引用类型转化为基本类型int

• 装箱:自动将基本数据类型转换为包装器类型

  • 装箱的时候自动调用的是Integer的valueOf(int)方法

• 拆箱:自动将包装器类型转换为基本数据类型

  • 拆箱的时候自动调用的是Integer的intValue方法

         Integer num1 = new Integer(10);
         Integer num2 = new Integer(10);
         System.out.println(num1.equals(num2));//true
         System.out.println(num1 == num2);//false  俩个对象
         Integer a = 126;//装箱
         Integer b = 126;
         System.out.println(a == b);//true  里面有一个缓存对象
         Integer c= Integer.valueOf(128);
         Integer d= Integer.valueOf(128);
         System.out.println(c == d);//false
         int num3 = 5;
         /*
         自动装箱
          */
         Integer num4 = num3;
         //Integer num4 = Integer.valueOf(num3);
         /*
         自动拆箱
          */
         int num5 = num4;
         //int num5 = num4.intValue();

2.Object类

(1)重写toString

• 当类中没有没有定义toString时,会默认调用父类的(object)的toString调用父类时,输出地址
  public String toString() {
  return getClass().getName() + “@” + Integer.toHexString(hashCode());//用16进制输出地址
  }
  public native int hashCode();
• native修饰本地方法,java不实现,调用操作系统来实验
  • 子类如果写了,则调用子类的toString

    String name ;
    int age ;
    public ObjectDemo2(String name , int age){
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "姓名:"+ name +"\n"+ "年龄:"+age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ObjectDemo2 demo4 = (ObjectDemo2) o;
        return age == demo4.age &&
                Objects.equals(name, demo4.name);
    }

    ObjectDemo2 x = new ObjectDemo2("王帅",99);
    System.out.println(x);  

(2)equals和==的区别

• Object中equals方法比较时比较的是地址,等同于"=="
  public boolean equals(Object obj) {
  return (this == obj);
  }
• 所以调用equals时需要在子类重写
  Demo4 y = new Demo4(“王帅”,99);
  System.out.println(x.equals(y));
  System.out.println(x == y);
• 子类改了后可以用来比较
  在其他int long等类中都重写了equals

      ObjectDemo2 y = new ObjectDemo2("王帅",99);
        System.out.println(x.equals(y));
        System.out.println(x == y);

3.String类

(1)成员方法

• 字符串是多个字符组成的字符序列,是常量,值是不能改变的
  • 一旦改变,是在内存中重新创建了一个新对象,相当于覆盖旧对象
  • 字符串是以char[]的形式在底层存在的
  • private final char value[];//注:字符串中 final是常量

 //String创建对象的方式有俩种
        String s = "abc";//第一次创建时,会在字符串常量池中检测有没有字符串,若没有则在常量池中创建一个对象
        String s1 = "abc";//第二次创建时,如果常量池已经存在,则直接指向池中对象
        System.out.println(s.equals(s1));//true
        System.out.println(s == s1);//true
        //通过构造方法创建对象
        String a = new String("abc");
        String b = new String("abc");
        System.out.println(a.equals(b));//true
        System.out.println(a == b);//false  因为创建了俩个对象

        s += "bcd";//相当于在创建了一个对象
        System.out.println(s);

• 判断方法
  • boolean equals(Object obj)
  • boolean equalsIgnoreCase(String str)
  • boolean contains(String str)
  • boolean isEmpty()
  • boolean startsWith(String prefix)
  • boolean endsWith(String suffix)

 String a = new String();
        String b = new String("abc");
        String b1 = new String("abc");
        String c = new String("");//c为" "
        
        System.out.println(b.equals(b1));//比较是否相等
        System.out.println(b.equalsIgnoreCase("ABC"));//部分大小写比较大小
        System.out.println(b.contains("ab"));//判断是否包含子类  必须连续
        System.out.println(a.isEmpty());//判断是否为" "空
        System.out.println(b.startsWith("a"));//判断是否以a开头
        System.out.println(b.endsWith("bc"));//判断是否以c结尾

• 获取功能
  • int length()
  • char charAt(int index)
  • int indexOf(String str)
  • int indexOf(String str,int fromIndex)
  • String substring(int start)
  • String substring(int start,int end)

        String x = "abcdefgabc";
        //          0123456789
        System.out.println(x.length());
        System.out.println(x.charAt(2));//索引对应位置字符
        System.out.println(x.indexOf("c"));//对应字符写出对应位置,但是第一次直接返回
        System.out.println(x.indexOf("c",x.indexOf("c")+1));//对应字符的第二次位置
        //位置上从前往后第二个开始截取,输出后面字符串,返回一个新的字符串,原字符串不变
        System.out.println(x.substring(2));
        //相当于System.out.println(x.substring(2,x.length()));
        //位置上从前往后第二个开始到第九个(不包含第九个)截取,输出后面字符串,返回一个新的字符串,原字符串不变
        System.out.println(x.substring(2,9));

• 替换功能
  - String replace(char old,char new)
  - String replace(String old,String new)
  - replaceAll(String regex, String replacement)
  - replaceFirst(String regex, String replacement)
  - 去除字符串两空格
  String trim()

 String x = "abcd123abc";
        //          0123456789
        //创建一个新的字符串将出现的字符串选项全部代替,原字符串不变
        System.out.println(x.replace("a","A"));//全部代替
        System.out.println(x.replace("abc","ABC"));
        System.out.println(x);
        System.out.println(x.replaceAll("\\d","EFD"));//出现正泽表达式,eg:将数字全部替换
        System.out.println(x.replaceFirst("\\d","EFD"));//只替换第一次出现的数字
        //trim()只去掉前后的" "空格
        String y = " ab c ";
        System.out.println(y.length());//输出6
        String z = y.trim();
        System.out.println(z.length());//输出4,因为不取消中间的空格
        System.out.println(y.replace(" ",""));//取消空格,将" "和""替换,那不就取消了
        System.out.println(y.replace(" ","").length());//取消空格后的长度

(2)数组与字符串转换

String a = "abc";
        String x = "中国";
        byte[] b = a.getBytes();//编码 将字符转字节
        System.out.println(Arrays.toString(b));
        String f = new String(b);//解码 字节转字符  用含参的构造方法
        System.out.println(f);
        byte[] c = new byte[0];
        try {
            c = x.getBytes("utf-8");//编码
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        System.out.println(Arrays.toString(c));//一个汉字在utf里面有三个字符
        //指定字符编码
        String c1 = new String(c,0,3,"utf-8");//解码  顺便制转换了3个字符
        System.out.println(c1);

        String z =new  String( x.getBytes(),0,3);
        System.out.println(z);
        //将字符转换为字符串
        String s1 = "abc";
        char[] s2 = s1.toCharArray();//字符串转char数组
        String s3 = new String(s2);//数组转换为字符串
        String s4 = String.valueOf(s2);//数组转用字符串

(3)正泽表达式

        String a = "abcEFG";
        System.out.println(a.toLowerCase());//字符串变为小写
        System.out.println(a.toUpperCase());//字符串变为大写

        String b = a.concat("xxxx");//效率高,给字符串b添加一个xxxx字符串
        System.out.println(b);
        String c = a + "xxxxxxx";//效率低

        String x = "name:王帅|age:99|性别:nv";
        String[] y = x.split("\\|");//用到了正泽,这里\\|表示转义
        System.out.println(Arrays.toString(y));
        System.out.println(y[0]);
        String h = "abc:de:f:g";
        String[] i = h.split(":");//表示分割
        System.out.println(Arrays.toString(i));

(4)字符串的增删改查

 //无参的返回16容量的参数
        StringBuffer s = new StringBuffer();
        StringBuffer s1 = new StringBuffer(10);//容量为10
        StringBuffer s2 = new StringBuffer("abc");//相当于长度加容量的长度  3+16

        /*
        append不会创建新对象,效率特别高,大量字符串拼接建议使用StringBuffer
         */
        s1.append("abc");
        s1.append("def");
        System.out.println(s1);
        //从1位置插入字符串   insert向指定位置插入字符串
        s1.insert(1,"a");
        System.out.println(s1);
        //删除指定位置字符串
        s1.delete(0,2);
        s1.deleteCharAt(4);
        System.out.println(s1);
        //替换
        s1.replace(0,3,"def");
        System.out.println(s1);
        //逆序
        System.out.println(s1.reverse());
        //截取
        System.out.println( s1.substring(2));//截取前俩个
        System.out.println(s1.substring(0,1));//指定位置截取

(5)StringBuffer和StringBuilder

  /*
        StringBuilder  内容可变
        StringBuffer  内容可变,线程安全
        String   内容不可变,变了都是重新创建对象

         StringBuilder
         线程中一个操作,没什么事情,那如果多个线程同时进行操作呢
         StringBuffer
         会对其排序一个线程一个操作   所以效率会低一点儿

         */
        StringBuffer s = new StringBuffer();
        StringBuilder s1 = new StringBuilder();