【JAVA】API - 1

已于 2022-06-26 23:24:07 修改
阅读量133 收藏
点赞数
文章标签： java 开发语言
于 2022-06-19 21:43:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56492261/article/details/125361771
版权

今天学习新的模块，学习API的相关知识。

  • Java API概述
  • 基本数据类型包装类
  • Object
  • Arrays类
  • String类

Java API概述

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

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

大家可以到JAVA官网下载或在线阅读API。

基本数据类型包装类

基本数据类型有：byte，short，int，long，float，double，char，boolean。

我们使用的基本数据类型很简单，但不利于我们面向对象的编程，为了解决这个问题，在设计时为每个数据类型设计了一个对应的代表。

java为这些基本数据类型提供了包装类，在类中包含着基本数据类型成员变量。

例如int类型的包装类是Integer：

public class Demo1 {
    public static void main(String[] args) {

        Integer a=new Integer(10);
        int b=20;
        Integer c=new Integer(30);

        a.compareTo(b);
        a.compareTo(c);

        System.out.println(c.byteValue());
        System.out.println(c.doubleValue());
        System.out.println(c.equals(20));
        System.out.println(c.floatValue());
        System.out.println(Integer.toHexString(20));
        System.out.println(Integer.toBinaryString(99));
        System.out.println(Integer.hashCode(60));
        System.out.println(Integer.toOctalString(30));

    }
}

装箱和拆箱

装箱：将基本数据类型转换为包装类。使用Integer和valueOf（int）等方法。                                  拆箱：将包装类拆分为基本数据类型。使用是Integer的intValue等方法。

装箱和拆箱还可以分为自动装箱和自动拆箱。

 //装箱
        Integer i=Integer.valueOf(128);

        //拆箱
        int ii=i.intValue();
        
        //自动装箱
        Integer a=128;  //Integer a=Integer.valueof(128);
        Integer aa=128;
        System.out.println(a==aa);
        System.out.println(a.equals(aa));
        System.out.println(Integer.parseInt("40"));//将字符串类型转换为int类型，但如果字符串里有字母会报错
        System.out.println(Integer.valueOf("25"));
        System.out.println(Integer.valueOf(25));
        System.out.println();

        //自动拆箱
        Integer c=20;
        int cc=c;
        System.out.println(cc);
        System.out.println(c.intValue());
        System.out.println();

Object类

Object是所有类的父类，是类的根基，在我们编写的没个类中，

都默认继承了Object类。

public class Demo1 {

}

public class Demo1 extends Object{

}

//这两是相同的

 下面学习Object类中的相关方法。

toString方法

当我们要对对象进行输出时，java会默认调用类中的toString方法，以字符串形式输出。

equals方法

但我们要对对象定义的是否相等进行判定时，可以使用equals方法。

要注意的是，== 引用类型比较,比较对象地址是否相等，而equals()比较的是对象中的内容是否相等。

下面是上述两种方法的代码体现。

public class ObjectDemo2 extends Object {


    public static void main(String[] args) {

        Car c = new Car("奥迪", 73000);
        Car c1 = new Car("奥迪", 73000);
        
         public boolean equals(Object obj) {
           return (this == obj);
         }
      
        System.out.println(c.equals(c1));
        System.out.println(c==c1);//false

        Integer i = new Integer(10);
        Integer ii = new Integer(10);
        System.out.println(i.equals(ii));//true

 

    }

}



public class Car extends Object{

     private String name;
     private int  price;

    public Car(String name, int price) {
        this.name = name;
        this.price = price;
    }


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

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Car){
            Car otherCar = (Car)obj;
            return this.name.equals(otherCar.name) && this.price==otherCar.price;
        }
        return false;
    }
}

Arrays类

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

equals 方法

equals方法用来比较两个非同一数组是否相等，而数组本身的equals判断另一个数组是否它本身。如果两个相等，则返回true，否则返回false，参数的类型可以是原生数据类型和引用类型的任意一种类型。

sort －排序

sort排序是将指定的类型，除 boolean 以外的任意原生数据类型，数组所有元素或指定范围内的元素按数字升序进行排序。

toString() 方法

toString（）方法返回指定数组内容的字符串表示形式，基本数组和字符串表示形式由数组的元素列表组成，括在[  ]，相邻元素用“, ”逗号加空格分隔。
下面是以上方法的代码体现： 
import java.util.Arrays;

public class Demo4 extends Animal {
    public Demo4(int no, String name) {
        super(no, name);
    }

    public static void main(String[] args) {
        int []no={1,2,3,4,5};
        String []name={"小狗","小象","小熊","小猫","小虎"};
        int []a={1,3,5,2,4};
        //Arrays.sort(a);
        Arrays.sort(a,2,a.length);
        System.out.println(Arrays.toString(a));
        Arrays.sort(name);
        System.out.println(Arrays.toString(name));

        Animal animal1=new Animal(1,"小狗");
        Animal animal2=new Animal(2,"小象");
        Animal animal3=new Animal(3,"小熊");
        Animal animal4=new Animal(4,"小猫");
        Animal animal5=new Animal(5,"小虎");

        Animal []animal=new Animal[5];
        animal[1]=animal1;
        animal[3]=animal2;
        animal[2]=animal3;
        animal[0]=animal4;
        animal[4]=animal5;

        Arrays.sort(animal);
        System.out.println(Arrays.toString(animal));

    }
    }



public class Animal implements Comparable<Animal>{
        int no;
        String name;

    public Animal(int no, String name) {
        this.no = no;
        this.name = name;
    }

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

    @Override
       public int compareTo(Animal o) {
        return this.no-o.no;
     }
}



import java.util.Arrays;

public class Demo5 {
    public static void main(String[] args) {
        int a[]={1,2,3,4,5,6,7,8};

        System.out.println(Arrays.binarySearch(a,4));//折半查找，注意，数组需要有序数组

        int []b=Arrays.copyOf(a,10);//数组扩容
        System.out.println(Arrays.toString(b));
    }
}

String类

在java中，所有的字符串都可以视为String类的实例，而字符串是由多个字符组成的一串数据。

当一个String对象被创建且定义后就不能改变，底层是使用char数组存储。

String字符串有两种创建方式：显示创建和隐式创建。

当使用new时，即显式创建，会在堆中创建对象，而隐式创建这是将创建的字符串直接在字符串常量池中存储,如果数值相同,就直接返回字符串常量池中的对象地址。

//隐式创建
String s1 = "sidhhsid";


//显式创建
String s2 = new String("sdsdj");

构造方法

public String()

public String(String str)

public String(byte[] bytes)

public String(char[] value)

判断功能

boolean equals(Object obj)

boolean equalsIgnoreCase(String str)

boolean contains(String str)

boolean isEmpty()

boolean startsWith(String prefix)

boolean endsWith(String suffix)

获取功能

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)

  public static void main(String[] args) {
        /*
        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  = "abcdefgc";
                   //01234567
        System.out.println(s.length());//返回字符串长度
        System.out.println(s.charAt(3));//返回指定位置上的字符
        System.out.println(s.indexOf("c"));//获取指定字符首次出现的位置  从前向后
        System.out.println(s.indexOf("c",s.indexOf("c")+1));//从指定位置开始找的

        System.out.println(s.lastIndexOf("c"));//从后向前找

        System.out.println(s.substring(2));//从指定的位置开始截取一个新的子串到结尾
        System.out.println(s.substring(2,6));//从指定的位置开始截取一个到指定位置新的子串

        System.out.println( StringUtil.subFileType("hello.java"));

    }
}

转换功能

byte[] getBytes()

char[] toCharArray()

static String valueOf(char[] chs)

String toLowerCase()

String toUpperCase()

String concat(String str)

Stirng[] split(分割符)

下面是一些发放的体现代码：

         String s1 = new String("abcd");
         String s2 = new String("abcdefg");

          System.out.println(s1.equals(s2));//比较字符串内容是否相等
       
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));//比较时忽略大小写

        System.out.println(s2.contains("ab"));//是否包含指定的子串

        String s3 = "";
        System.out.println(s3.isEmpty());//判断是否为空

        System.out.println(s2.startsWith("ab"));//判断以ac开头(子串)
        System.out.println(s2.endsWith("fg"));//判断以ac结尾(子串)

爱吃草的羊驼
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值