JAVA从头开始--API

最新推荐文章于 2025-03-25 10:18:01 发布

crraxx

最新推荐文章于 2025-03-25 10:18:01 发布

阅读量246

点赞数 2

分类专栏： java 文章标签： java 字符串

本文链接：https://blog.youkuaiyun.com/crraxx/article/details/110958176

版权

java 专栏收录该内容

35 篇文章

订阅专栏

API

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

API是Java语言中提供的众多的类和接口也是官方对提供的类，接口的功能进行说明的文档。

基本数据类型的包装类

基本数据类型（8种）：结构简单，有时不能满足我们的需求，如1.直接获得int类的最大值。2.int型转化为16进制。3.把int类型转化为字符串类型。4.将字符串类的数字转化为int。。。。为了解决这些不足，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类。

构造方法

Integer num1 = new Integer(10);//将int值包装在Integer类的对象中
Integer num2 = new Integer("10");//把字符串转化为int类型

比较的方法

1.compareTo

2.max(a,b)，min(a,b))

3.equals

转化的方法

1.将基本类型转化为引用类型

2.将引用类型转化为基本类型

3.基本类型转化为String

（以上方法以java.lang.Integer为例）

实例1：

package com.ff.javaapi.day1.numbase;
/*
API
1.java语言中提供的众多的类和接口
2.官方对提供的类，接口的功能进行的文档说明
 */
/*
在java中基本数据类型结构简单，不能满足某些需求，如：
1.直接获得int类的最大最小值
2.将int型转化为16进制
3.把int型转化为字符串型
4.把字符串型转换为int型。。。。。
 */
public class IntDemo1 {
    public static void main(String[] args) {
        int num = 2 ;
        System.out.println(num);

        Integer num1 = new Integer(num);//将int值包装在Integer类的对象中，Integer类中就可以提供很多的方法对int型的值进行操作。
        Integer num2 = new Integer("10");//把字符串转为int型
        System.out.println(Integer.MAX_VALUE);//int型的最大值
        System.out.println(Integer.MIN_VALUE);//int型的最小值
        System.out.println(Integer.BYTES);//int型所占的字节数
        System.out.println(Integer.SIZE);//int型所占的位数

        System.out.println(Integer.toBinaryString(10));//转化为2进制
        System.out.println(Integer.toHexString(12));//转化为16进制
        System.out.println(Integer.toOctalString(18));//转化为8进制
    }
}

运行结果：
在这里插入图片描述
实例2：

package com.ff.javaapi.day1.numbase;

public class IntDemo2 {
    public static void main(String[] args) {
        //构造方法
        Integer num1 = new Integer(10);//将int值包装在Integer类的对象中
        Integer num2 = new Integer("10");//把字符串转化为int类型

        /*比较的方法
        1.compareTo
        2.max(a,b)，min(a,b));
        3.equals
         */
        System.out.println(num1.compareTo(num2));//底层实现为(x < y) ? -1 : ((x == y) ? 0 : 1);

        System.out.println(Integer.max(15,12));
        System.out.println(Integer.min(15,15));
        System.out.println(Integer.min(12,15));

        System.out.println(num1.equals(num2));//equals方法比较两数的具体值
        System.out.println(num1==num2);//==基本数据类型是比较值是否相等，引用数据类型时比较对象在内存中的地址是否相等
        /*
        转化的方法
        1.将基本类型转化为引用类型
        2.将引用类型转化为基本类型
        3.基本类型转化为String
         */
        Integer num3 = new Integer(12);
        int num4 = num3.intValue();//取出对象中具体的值
        System.out.println(num4);
        System.out.println(num3);

        long num5 = num3.longValue();
        System.out.println(num5);

        int num6 = Integer.parseInt("13");
        //把基本数据类型转化为引用数据类型
        Integer num7 = Integer.valueOf(12);
        Integer num8 = Integer.valueOf(12);
        System.out.println(num7==num8);
        //把数值转化为字符串类型
        System.out.println(num8.toString());
        System.out.println(Integer.toString(5));
    }
}

运行结果：

自动装箱与拆箱

自动装箱:将基本类型转换为引用类。
自动拆箱:将引用类型转换为基本类型。

package com.ff.javaapi.day1.numbase;

public class IntDemo3 {
    public static void main(String[] args) {
        /*
        自动装箱：将基本类型转换为引用类型
        自动拆箱：将引用类型转换为基本类型
         */

        //自动装箱：隐式调用valueOf()方法
        int n = 2;
        Integer n1 = n;
        //自动拆箱:隐式调用intValue()方法
        int n2 = n1;
    }
}

对比“==”与“equals()”方法

基本数据类型转换为引用数据类型有两种方式。例如：

Integer num0 = new Integer(10);//1.使用new + 构造方法 ()
Integer num2 = Integer.valueOf(10);//2. 使用装箱(valueOf(10))

实例：

package com.ff.javaapi.day1.numbase;

public class IntDemo4 {
    public static void main(String[] args) {
        Integer num0 = new Integer(10);
        Integer num1 = new Integer(10);
        System.out.println(num0.equals(num1));//比较的是数据本身的大小
        System.out.println(num0 == num1);//若为引用类型，则比较的是对应的地址；若为基本数据类型，则比较的是数据本身的大小
        /*
           使用装箱(valueOf(10))，在创建对象时,值如果在-128--+127之间如果多个值相同,指向的是内存中同一个地址
           使用new + 构造方法 ()，不管值是否在此区间中,都会创建新的对象
        */
        Integer num2 = Integer.valueOf(10);
        Integer num3 = Integer.valueOf(10);
        System.out.println(num2.equals(num3));//比较的是数据本身的大小
        System.out.println(num2 == num3);//在创建对象时如果值在-128————+127之间，则返回true

        Integer num4 = Integer.valueOf(128);
        Integer num5 = Integer.valueOf(128);
        System.out.println(num4.equals(num5));//比较的是数据本身的大小
        System.out.println(num4 == num5);//在创建对象时如果值不在-128————+127之间，则返回false

    }
}

运行结果：

在这里插入图片描述

Object

Object是所有类的父类。

实例：

1.定义一个名为Person的类

package com.ff.javaapi.day1.object;

import java.util.Objects;

public class Person {
    int age;
    String  name;

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

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

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

}

2.toString方法

package com.ff.javaapi.day1.object;

    /*父类中的toString()方法底层实现为
    public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
    */
    /*
    将对象输出是会调用toString()
    子类中没有toString ,因此会默认调用父类中的toString()，但父类中的toString()会将对象地址转换为16进制，我们看不懂。
    父类中的toString方法不能满足子类的需求，因此在子类中需要重写toString()方法
     */
public class ObjectDemo1 {
    public static void main(String[] args) {
        Person person = new Person(20, "Tom");
        System.out.println(person);

    }
}

运行结果：

在这里插入图片描述

3.equals()方法

package com.ff.javaapi.day1.object;
    /*
    父类（object）中的equals方法相当于“==”，基本没有什么用，他的底层实现为：
    public boolean equals(Object obj) {
            return (this == obj);
        }
        当我们需要比较对应的值是否相等时不可以满足子类的需求，则需要在子类中重写equals()
     */
public class ObjectDemo2 {

    public static void main(String[] args) {
        Person person1 = new Person(20,"kdfj");
        Person person2 = new Person(20,"kdfj");
        System.out.println(person1.equals(person2));//在未重写父类equals()时相当于“==”，比较的是对象的地址。为了比较值是否相等则可以在子类中根据要求重写equals()方法
        System.out.println(person1==person2);//引用类型，比较的是地址
    }
}

运行结果：

String类/StringBuffer类/StringBuilder类

String

字符串是多个字符组成的字符序列, 是常量值，不可改变。

一旦改变是在内存中重新创建一个新的对象。

字符串创建

字符串对象的创建方式有两种:

String   s = "abc";//直接声明且赋值
String s2 = new String("abc");//通过new+构造方法创建

实例：

package com.ff.javaapi.day1.string;
    /*
    字符串的创建有两种方式
    1.直接声明且赋值如： String s = "abc";
    创建对象时会检测字符常量池中是否存在。如不存在，则直接创建；如存在则直接指向常量池中的对象即可。
    2.通过new+构造方法创建
    只要是new出来的对象，则在内存中一定是独一无二的空间。
     */
public class StringDemo1 {
    public static void main(String[] args) {
        String s = "abc";
        String s1 = "abc";
        System.out.println(s.equals(s1));//比较两个的值是否相等
        System.out.println(s==s1);//引用数据类型，比较两个的地址是否相等

        String s2 = new String("abc");
        String s3 = new String("abc");
        System.out.println(s2.equals(s3));//比较两个的值是否相等
        System.out.println(s2==s3);//引用数据类型，比较两个的地址是否相等

    }
}

运行结果：

“+”连接

实例2：

package com.ff.javaapi.day1.string;
    /*
    字符串类型的为常量，一旦创建值不可以改变。
    如要改变则会在内存中重新创建一个新的对象。
    字符串底层是char数组存储，单个字符串存储。
    final修饰的值不能变。
     */
public class StringDemo2 {
    public static void main(String[] args) {
        String s= "abc";
        s+="bcd";
        s+="gef";
        System.out.println(s);
    }
}

运行结果：

package com.ff.javaapi.day1.string;
//判断功能
public class StringDemo3 {
 public static void main(String[] args) {
   		String str1 = new String("abc");
        String str2 = new String("abc");
        System.out.println(str1.equals(str2));//比较两数值是否完全相等
        System.out.println(str1.equalsIgnoreCase(str2));//不区分大小写，比较内容是否相等
        System.out.println(str1.contains("a"));//判断str1中是否包含有“a”
        System.out.println(str1.isEmpty());//判断str1是否为空
        System.out.println(str1.startsWith("a"));//判断str1 是否以“a”开始
        System.out.println(str1.endsWith("s"));//判断str1 是否以“s”结束
        System.out.println("a".compareTo("d"));//比较“a”和“b”的ASCII相差多少，常用于比较大小，在排序中使用较多
    }
}

运行结果：

获取功能

实例4：

package com.ff.javaapi.day1.string;
//获取功能
public class StringDemo4 {
    public static void main(String[] args) {
        String str = new String("abcdefdab");
                               //012345678
        System.out.println(str.length());//获取str的长度
        System.out.println(str.charAt(2));//获取str索引位置为2的字符   
        System.out.println(str.indexOf("d"));//从索引位置0开始，获取“d"第一次出现的索引位置，若不存在则返回-1
        System.out.println(str.indexOf("d",4));//从索引位置5开始，获取“d"第一次出现的索引位置
        System.out.println(str.lastIndexOf("a"));//从后向前开始索引，查找“a”出现的位置
        System.out.println(str.lastIndexOf("c",6));//从第6个索引位置开始，从后向前查找”c“的位置
        System.out.println(str.substring(3));//截取从第3个索引位置开始的元素
        System.out.println(str.substring(2,6));//截取从第2个索引位置开始到第6个索引位置的元素(包含2所在的索引位，不包含6所在的索引位)
    }
}

运行结果：

替换功能

实例5：

package com.ff.javaapi.day1.string;
//正则运算符
public class StringDemo5 {
    public static void main(String[] args) {
        String s = new String("abcdefabg");
        System.out.println(s.replace("a", "A"));//把s字符串中的“a”全部替换成“A”
        System.out.println(s.replace("ab", "AB"));//把s字符串中的“ab”全部替换成“AB”
        System.out.println(s.replaceAll("a", "AB"));//把s字符串中的“a”全部替换成“AB”
        System.out.println(s.replaceFirst("a", "AB"));//把s字符串中的“a”全部替换成“AB”
        String s1 = " abc ";
        System.out.println(s1.trim());//将字符串s1前后的空格去掉且输出
        System.out.println(s1.length());//统计字符串s1的长度
        String s2 = " a b c_ 1";
        System.out.println(s2.replace(" ", ""));//去掉字符串s2中的所有空格并输出
        System.out.println(s2.length());//统计字符串s2的长度
        System.out.println(s2.replaceAll("\\w", "s"));//将s2中的字母,数字字符和"_"字符用s替换
        System.out.println(s2.replaceAll("\\W", "s"));//将s2中的所有非单词字符用s替换
    }
}

运行结果：

转换功能

构造方法1.public String (byte[] bytes)

2.public String (char[] value)

转换功能方法

1.byte[] getBytes();

2.char[] to CharArray()

实例：

package com.ff.javaapi.day2;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringDemo1 {
    /*
    构造方法
    1.public String (byte[] bytes)
    2.public String (char[] value)
    转换功能方法
    1.byte[] getBytes();
    2.char[] to CharArray()
     */
    public static void main(String[] args) {
        String s1 = "abc";//编码：字符转字节
        byte[] b = s1.getBytes();
        System.out.println(Arrays.toString(b));

        String s2 = new String(b);//解码：字节转字符
        System.out.println(s2);
        //在中文进行解码与编码操作时需要显式的写出转化操作的方式，两个的类型都为utf-8
        //常用的转化类型有utf-8，gbk码等
        String s3 = "上海";
        byte[] b3 = new byte[0];
        try {
            b3 = s3.getBytes("gbk");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        System.out.println(Arrays.toString(b3));

        String s4 = null;
        try {
            s4 = new String(b3, "gbk");
            System.out.println(s4.toCharArray());

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

concat 和正则表达式

实例：

package com.ff.javaapi.day2;

import java.util.Arrays;

public class StringDemo2 {
    public static void main(String[] args) {
        String s = "abcdEFG";
        System.out.println(s.toUpperCase());//将其中的小写全部转化为大写
        System.out.println(s.toLowerCase());//将其中的大写全部转化为小写
        /*
        concat的连接效率高于“+”连接
        “+”在字符串的连接中效率最低
         */
        String s1 = s.concat("hijk");//将字符串s与字符串“hijk“连接起来
        String s2 = s + "hijk";//将字符串s与字符串“hijk“连接起来
        System.out.println(s1);
        System.out.println(s2);
        //使用正则表达式将字符分开
        String s3 = "abc:def:ghij:klm";
        String[] c = s3.split(":");//匹配“:”
        System.out.println(Arrays.toString(c));

        String s4 = "AB|CD|EF|G";
        String[] c1 = s4.split("\\|");//匹配“|”
        System.out.println(Arrays.toString(c1));

        String s5 = "ab1cd2ef345";
        String[] c2 = s5.split("\\d");//匹配数字
        System.out.println(Arrays.toString(c2));
    }
}

运行结果：

StringBuffer

实例：

package com.ff.javaapi.day2;

/*
StringBuffer 类只可以使用new加构造方法创建新的
大量的字符串拼接操作使用StringBuffer来进行，效率最高。因为它不会创建新的对象
内容可变，线程安全
 */
/* StringBuffer s = new StringBuffer();底层实现为：
public StringBuffer() {
        super(16);
    }
    无参的构造方法，底层创建了一个长度为16的char数组。
 */
/*
 StringBuffer s1 = new StringBuffer("abcdefg");底层实现为：
 public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }
    有参的构造方法，长度为str.length() + 16
 */
/*
StringBuffer s2= new StringBuffer("10");底层实现为：
public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }
    有参的构造方法，长度为str.length() + 16
 */
public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer s = new StringBuffer();
        StringBuffer s1 = new StringBuffer("abcdefg");
        StringBuffer s2 = new StringBuffer("10101100");
        System.out.println(s1.append("abc"));//字符串的拼接，效率最高。

        System.out.println(s2.insert(2, "char"));//在字符串的第二位插入对应字符串
        System.out.println(s2.insert(2, "c"));//在字符串的第二位插入对应字符
        System.out.println(s2.insert(2, "2"));//在字符串的第二位插入对应数字字符串

        System.out.println(s2.delete(2, 3));//删除的包含第二位不包含第三位
        System.out.println(s2.deleteCharAt(5));//删除索引位置为5的元素

        String s3 = s2.substring(2);
        System.out.println(s3);//从第2个位置开始向后截取出来
        String s4 = s3.substring(2, 5);
        System.out.println(s4);//从第2个位置开始向后截取出来到第4个位置，包含第2位不包含第5位

        System.out.println(s2.replace(2, 5, "ABC"));//用字符串“ABC”代替原字符串中的第2位到第4位
    }
}

运行结果：

StringBuilder

StringBuilder与StringBuffer中的常用方法基本一致。

package com.ff.javaapi.day2;

/*
StringBuilder 内容可变
StringBuffer 线程安全，内容可变
String 内容不可变
 */
public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder s = new StringBuilder();
        StringBuilder s1 = new StringBuilder("abcdefg");
        StringBuilder s2 = new StringBuilder("10101100");
        System.out.println(s1.append("abc"));//字符串的拼接，效率最高。

        System.out.println(s2.insert(2, "char"));//在字符串的第二位插入对应字符串
        System.out.println(s2.insert(2, "c"));//在字符串的第二位插入对应字符
        System.out.println(s2.insert(2, "2"));//在字符串的第二位插入对应数字字符串

        System.out.println(s2.delete(2, 3));//删除的包含第二位不包含第三位
        System.out.println(s2.deleteCharAt(5));//删除索引位置为5的元素

        String s3 = s2.substring(2);
        System.out.println(s3);//从第2个位置开始向后截取出来
        String s4 = s3.substring(2, 5);
        System.out.println(s4);//从第2个位置开始向后截取出来到第4个位置，包含第2位不包含第5位

        System.out.println(s2.replace(2, 5, "ABC"));//用字符串“ABC”代替原字符串中的第2位到第4位


    }

}

运行结果：

Arrays类

1.Arrays.equals()方法

实例1：

import java.util.Arrays;

public class ArraysDemo1 {
    public static void main(String[] args) {
        /*
        Arrays.equals 比较的是两个数组中的值是否相等
         */
        int [] a = {1,2,3,4,5};
        int [] b = {1,2,3,4,5};
        System.out.println(Arrays.equals(a,b));


        int [] a1 = {1,2,3,4,5};
        int [] b1= {1,2,3,4};
        System.out.println(Arrays.equals(a1,b1));
    }
}

运行结果：

2.Arrays.sort()方法

实例2.1

新建一个学生类

package com.ff.javaapi.day2.practice;

public class Student implements Comparable<Student> {
    private String name ;
    private int sj;
    private  int bs;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getSj() {
        return sj;
    }

    public void setSj(int sj) {
        this.sj = sj;
    }

    public int getBs() {
        return bs;
    }

    public void setBs(int bs) {
        this.bs = bs;
    }

    public Student(String name, int sj, int bs) {
        this.name = name;
        this.sj = sj;
        this.bs = bs;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sj=" + sj +
                ", bs=" + bs +
                '}';
    }

    @Override
    public int compareTo(Student o) {

       return o.bs-this.bs;//按bs从大到小排序
        // return  this.bs-o.bs;//按bs从小到大排序
        // return this.name.compareTo(o.name);//按姓名的首字母从小到大排序
    }
}

实例2.2

基本数据类型与引用数据类型的排序

package com.ff.javaapi.day3;

import com.ff.javaapi.day2.practice.Student;

import java.util.Arrays;

import static java.util.Arrays.sort;

public class ArraysDemo2 {
    	//基本数据类型的排序
    public static void main(String[] args) {
        int a[] = {9,5,6,1,2};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //引用数据类型的排序
        //需要用类实现接口
        //compareTo()方法在Sort方法中被调用，重写compareTo方法，自定义排序规则。
        Student student0 = new Student("lin",120,136);
        Student student1 = new Student("nin",150,96);
        Student student2 = new Student("min",160,116);

        Student [] stu = new Student[3];
        stu[0]=student0;
        stu[1]=student1;
        stu[2]=student2;
        Arrays.sort(stu);
        System.out.println(Arrays.toString(stu));
    }
}

运行结果：

3.Arrays.binarySearch()方法

实例3：

package com.ff.javaapi.day3;
/*
Arrays.binarySearch();方法为二分折半查找
使用二分法查找元素所在位置必须要求数组中的元素有序
 */
import java.util.Arrays;

public class ArraysDemo3 {
    public static void main(String[] args) {
        int [] a = {5,9,6,4,3,1,8};
        //先将元素转化为有序的，并打印输出
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

       //返回元素的下标，即索引结束
        int i = Arrays.binarySearch(a,3);
        System.out.println(i);
    }
}

运行结果：

4.Arrays.copyOf()方法

实例4：

package com.ff.javaapi.day3;
/*
Arrays.copyOf(a,12);方法
数组的复制
当数组的长度不够用时，将原来的内容重新复制一份给新的数组，并且指定新数组的长度。
 */
import java.util.Arrays;

public class ArraysDemo4 {
    public static void main(String[] args) {
        int [] a = {1,2,3,4,5};
        int [] b =Arrays.copyOf(a,12);
        System.out.println(Arrays.toString(b));
    }
}

运行结果：

泛型

实例5：

package com.ff.javaapi.day3;
/*
泛型：参数化类型，类型参数化
类型不确定，可以作为参数传入，只可以传入引用数据类型，如果不传入则默认为Object
 */
import com.ff.javaoop.day4.test.T;

public class TypeDemo <T,Y> {

    Y name;
    T sex;

    public  String  getAge(){
        return null;
    }

    public static void main(String[] args) {
       	//TypeDemo typeDemo = new TypeDemo();
        //jdk8以后，new加构造方法中的括号可以不传入数据类型
        //泛型可以传入一个或者多个参数
        //TypeDemo <Integer> t1 = new TypeDemo<>();
        TypeDemo <String,Integer> typeDemo = new TypeDemo<>();
    }
}