第五章：API（1）

最新推荐文章于 2024-11-07 16:17:22 发布

金清泽

最新推荐文章于 2024-11-07 16:17:22 发布

阅读量102

点赞数

分类专栏： Java 文章标签： java api string

本文链接：https://blog.csdn.net/m0_53752829/article/details/116833218

版权

Java 专栏收录该内容

18 篇文章 1 订阅

订阅专栏

学习目标：

掌握API相关知识

学习内容：

1、基本数据类型封装类 2、 Object类 3、 Arrays类 4、 String类

学习时间：

2021年5月5日 2021年5月9日

学习产出：

1、技术笔记 1 遍 2、CSDN 技术博客 1 篇

Java API概述

API(Application Programming Interface)应用程序编程接口

是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明

包装类（如：Integer，Double等）这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作方法。

基本数据类型封装类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VswgLMX7-1621042303926)(E:\Users\asus\AppData\Roaming\Typora\typora-user-images\1621038944929.png)]

对于包装类来说，这些类的用途主要包含两种：

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

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

Integer  n  = new Integer(10);
         // 包装的一些关于int类相关信息
          System.out.println(n.MAX_VALUE);//最大int型整数 2^31-1
          System.out.println(n.MIN_VALUE);//最小int型整数 -2^31
          System.out.println(Integer.SIZE);//Integer.SIZE:位数：32
          System.out.println(Integer.BYTES);//Integer.BYTES:字节数：4个字节

         Integer m =  new Integer("12");
         System.out.println(m+10);

        System.out.println(m.compareTo(n));//比较大小
        System.out.println(n.equals(m));//比较是否相等
        System.out.println(Integer.max(10,5));

        System.out.println(Integer.toBinaryString(3));//返回字符串表示的无符号二进制数值
        System.out.println(Integer.toHexString(17));//返回字符串表示的无符号十六进制数值
        System.out.println(Integer.toOctalString(9));//返回字符串表示的无符号八进制数值

         int x = 10;
         Integer  n  = new Integer(x);
         int m  =  n.intValue();//取出对象中包含的int值

         String s = "10";
         int y = Integer.parseInt(s); //将String类型转为int

         String s1  = n.toString(); //将整数 转为 String

         Integer in =   Integer.valueOf(x);
         Integer in1 =   Integer.valueOf("10");

装箱和拆箱A

装箱

● 自动将基本数据类型转换为包装器类型

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

拆箱

● 自动将包装器类型转换为基本数据类型

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

int x = 10;
         /*
         基本类型转引用类型
         Integer  n  =  new Integer(x);
         Integer  n1  =  Integer.valueOf(x);
         */

         Integer n = x;  //自动装箱  默认调用valueOf()方法 创建一个Integer对象

             //n.intValue()
         int y = n;//自动拆箱  将引用类型转为基本类型  默认调用intValue()方法 取出包含的int值

/*
               自动装箱的问题

                  == 在比较基本类型时,比较的就是值是否相等
                  == 在比较引用类型时,比较对象在内存中的地址是否相等

                   自动装箱调用valueOf()
                   public static Integer valueOf(int i) {
                         判断值如果在 -128 到 127之间 会从缓存数组中取出一个对象返回,
                         多个值相同,返回的是同一个对象
                        if (i >= IntegerCache.low && i <= IntegerCache.high)
                            return IntegerCache.cache[i + (-IntegerCache.low)];
                        return new Integer(i);//不在-128 到 127之间会创建新的对象返回
                    }
            */
            Integer x = 127;
            Integer y = 127;
            System.out.println(x==y);//10 true  128 false


            Integer m = new Integer(128);
            Integer n = new Integer(128); //两个不同的对象比较
            System.out.println(m==n);//10 false  128 false

           System.out.println(127==127);

Object类

Object类是所有Java类的祖先（根基类）。每个类都使用 Object 作为超类（父类）。所有对象（包括数组）都实现这个类的方法。

如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类

//public class Person extends Object
public class Person

toString

        Person p = new Person();

        /*
          使用System.out.println(p);输出对象,此时会默认调用对象中的toString()
          当类中没有toString()时,默认调用父类toString()
           public String toString() {
                return getClass().getName() + "@" + Integer.toHexString(hashCode());
            }

            一般情况下可以重写Object类中toString()
        */
        System.out.println(p);

重写toString

@Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

equals方法

/*
     Object类中equals
         public boolean equals(Object obj) {
            return (this == obj);
         }
    */
     public static void main(String[] args) {
         Person p1 = new Person();
         p1.setName("张三");
         p1.setAge(20);

         Person p2 = new Person();
         p2.setName("张三");
         p2.setAge(20);
         System.out.println(p1.equals(p2));

         String s = new String("abc");
         String s1 = new String("abc");
         System.out.println(s==s1);//false
                         //String类重写了equals()  比较的是对象中包含的内容是否相等
         System.out.println(s.equals(s1));//true

         Integer x = 128; //new Integer(128);
         Integer y = 128; //new Integer(128);
         System.out.println(x==y);//false
         System.out.println(x.equals(y));//true
         //几乎API中所有类都重写Object类中equals(),比较的是对象中包含的内容是否相等
     }

Arrays类

java.util.Arrays类

用于操作数组工具类，里面定义了常见操作数组的静态方法。

equals 方法

int [] a = {1,2,3,4,5};
        int [] b = {1,2,3,4,5};
        System.out.println(a==b);//flase
        System.out.println(Arrays.equals(a, b));//true
        /*
            * public static boolean equals(int[] a, int[] a2) {
            if (a==a2)
                return true;
            if (a==null || a2==null)
                return false;

            int length = a.length;
            if (a2.length != length)
                return false;

            for (int i=0; i<length; i++)
                if (a[i] != a2[i])
                    return false;

            return true;
      }*/

sort-排序

      int [] a = {5,4,3,2,1};
      //Arrays.sort(a);//0---length-1  对整个数组进行排序
      //public static void sort(type[] a, int fromIndex(包括), int toIndex(不包括))
      Arrays.sort(a,0,3);//0  --- 3-1    对指定的区间进行排序
      System.out.println(Arrays.toString(a));

自定义对象排序

自定义类实现Comparable接口

重写compareTo方法

//用来做比较, 提供的一个自定义排序规则的方法
    //compareTo()方法会在sort()的底层中调用
    @Override
    public int compareTo(Student o) {
        //return  this.num-o.num ;// 小于0   等于0  大于0
        return this.name.compareTo(o.name);
    }

         Student [] students = new Student[5];

         Student s1 = new Student(101, "张三1");
         Student s2 = new Student(102, "张三2");
         Student s3 = new Student(103, "张三3");
         Student s4 = new Student(104, "张三4");
         Student s5 = new Student(105, "张三5");

         students[0] = s2;
         students[1] = s5;
         students[2] = s1;
         students[3] = s4;
         students[4] = s3;

         //对引用类型数组进行排序时,类实现
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));


        String [] sarr = {"a","c","d","b"};
        Arrays.sort(sarr);
        System.out.println(Arrays.toString(sarr));

binarySearch-二分搜索

        
        /*
        二分查询,查找指定值在数组中位置
        前提:数组要有序
        ● 声明： 
        public static int binarySearch(type[] a, type key)
        public static int binarySearch(long[] a,int fromIndex,int toIndex,long key)
        a - 要搜索的数组。 
        key - 要搜索的值。 
        fromIndex - 要排序的第一个元素的索引（包括）。 
        toIndex - 要排序的最后一个元素的索引（不包括）。 
        type - byte、double、float、object、long、int、short、char
        */
        int [] a = {2,1,3,7,6,5,8};

        Arrays.sort(a);
        //   1,2,3,5,6,7,8
        //如果key在数组中，则返回搜索值的索引；否则返回-1或者”-“(插入点)
        System.out.println(Arrays.binarySearch(a, 4));
        System.out.println(Arrays.binarySearch(a, 0,5,6));

        System.out.println(mybinarySearch(a,9));
    }

    public static  int mybinarySearch(int [] a,int key){
        int low = 0;
        int high = a.length - 1;
        while (low <= high) {
            int mid = (low + high) >>> 1;//找中间位置
            int midVal = a[mid];//中间位置值
            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -1;  // key not found.
    }

copyOf - 数组复制

//数组复制
        int[] a = {1,2,3,4,5};
        //返回一个指定长度的新数组,并将原数组中的内容复制到新数组中
        int [] b = Arrays.copyOf(a, 10);
        System.out.println(Arrays.toString(b));

String类

String类概述

字符串是由多个字符组成的一串数据(字符序列)的字符串常量,java中所有字符串都是String类的实例

两种创建形式

/*
      String 表示字符串
      所有字符串都是String类的实例(对象)
      字符串值不能改变(一旦给定字符串的值,值就不能改变) 因为底层用到一个final修饰的char 数组
          private final char value[];  底层是单个字符存储  char a=97 b=98 c=99
     */
public static void main(String[] args) {
           /*
             String对象的两种创建方式
             1.
             String s = "abc";

             2.
             String s1  = new String("abc");
            */

        String s1 = "abc";//首先会在字符串常量池中查找,如果没有,就在常量池中创建
        String s2 = "abc";//如果常量池已经存在,就不需要创建,直接返回地址即可
        System.out.println(s1==s2);//true
        System.out.println(s1.equals(s2));//true

        String s3 = new String("abc");
        String s4 = new String("abc"); //都会在堆中创建一个对象
        System.out.println(s3==s4);//false
        System.out.println(s3.equals(s4));//true
    }

判断

/*
            String 构造方法
           */
        String s = new String("abC");//创建一个""  this.value = "".value;
        String s1 = new String("abc");// this.value = original.value;


        /*
          判断
          boolean equals(Object obj)
          boolean equalsIgnoreCase(String str)
          boolean contains(String str)
          boolean isEmpty() boolean
          startsWith(String prefix)
          boolean endsWith(String suffix)
         */
        System.out.println(s.equals(s1));//判断两个对象中的内容是否相等
        System.out.println(s.equalsIgnoreCase(s1));//判断两个对象中的内容是否相等 忽略大小写
        String s2 = "abcdefg";
        System.out.println(s2.contains("ab"));//判断是否包含指定字符串
        System.out.println(s2.isEmpty()); //判断是否为空("")  为空返回true
        System.out.println(s2.startsWith("ab"));//判断是否以指定的字符串开头
        System.out.println(s2.endsWith("ab"));//判断是否以指定的字符串结尾
        System.out.println("a".compareTo("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 s = "abcdedfg";
                    // 01234567
           System.out.println(s.length());
           char c = s.charAt(3);//返回指定索引的字符
           System.out.println(c);

           int index = s.indexOf("d");//获取指定字符串首次出现的位置 从前向后找
           System.out.println(index);

          int index1 = s.indexOf("d",4);//从指定的位置开始,获取指定字符串首次出现的位置
          System.out.println(index1);

          int index2 = s.lastIndexOf("d");
          System.out.println(index2);

        String s3 = "abcdedfg";
                  // 01234567

        String s4 =   s3.substring(2); //从s3 截取指定区间的字符串  从指定位置开始 到  结束
        System.out.println(s3);//abcdedfg
        System.out.println(s4);//cdedfg

        String s5 =   s3.substring(2,6);//k指定区间截取  开始位置 -- 结束位置(不包含结束)
        System.out.println(s5);

转换

          /*
            String toLowerCase()
            String toUpperCase()
            String concat(String str)
            Stirng[] split(分割符);
           */

        String s = "abcdEFG";
        System.out.println(s.toLowerCase());//转小写
        System.out.println(s.toUpperCase());//转大写

        String s1 = s.concat("HIJK"); //两个字符串拼接 并返回新的字符串对象.
        System.out.println(s1);


        String s2 = "ab:cd:E:FGH";
        String[] array =  s2.split(":");//用指定符号 来分割字符串为数组
        System.out.println(Arrays.toString(array));