API — 常用类

小谭同学ha

已于 2023-03-15 15:29:09 修改

阅读量142

点赞数

文章标签： java 开发语言

于 2022-12-28 23:01:01 首次发布

本文链接：https://blog.csdn.net/qq_69032468/article/details/128367430

版权

5.3 binarySearch -使用二分搜索算法搜索指定数组

7.3 SimpleDateFormat 日期格式化类

1.API概述

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

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

2.基本数据类型包装类

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类

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

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

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

2.1 自动装箱、自动拆箱

自动装箱：基本类型 转为 包装类型

自动调用的是Integer的valueOf(int)方法

int a=10;
Integer m=a;

public static void main(String[] args) {

        /*
        自动装箱
         */
        /*Integer a=127;
        Integer b=127;*/
        /*
          Integer a = 127;  默认会调用 Integer Integer.valueOf(int i){ }
           在Integer类中为了节省空间,对-128--+127之间的255个对象进行缓存(数组)
            在-128 +127之间的时候,直接从数组获取,如果值相同的时候,取到的对象是相同的.
            如果不在-128 +127之间, 每次都会创建一个新的对象
         */
        Integer a=128;
        Integer b=128;
        System.out.println(a==b);//true  /false
        Integer c=new Integer(127);
        Integer d=new Integer(127);
        System.out.println(c==d);//false
    }

自动拆箱：包装类型 转为 基本类型

自动调用的是Integer的intValue方法

Integer n=new Integer(50);
int t=n;

3.Object类

是所有类的基类，所有对象都实现此类的方法。

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

3.1 equals()方法

基本类型   比较值是否相等
引用类型   比较引用变量所指向的内存空间的地址

public class EqualsDemo {
    public static void main(String[] args) {
        
        int a=12;
        int b=12;
        System.out.println(a==b);//true   基本类型比较，比较值是否相等
        String s1=new String("abc");
        String s2=new String("abc");
        System.out.println(s1==s2);//false  比较内存中的对象地址
        System.out.println(s1.equals(s2));//true  比较的是两个字符串内容
        Person p1=new Person("jim",20);
        Person p2=new Person("jim",20);
        System.out.println(p1==p2);//false  比较的是对象内存地址
        System.out.println(p1.equals(p2));//false  重写equals()之后，true
        /*
        p1.equals(p2) 调用的是父类(Object)的equals(),比较对象内存地址

        public boolean equals(Object obj) {
            return (this == obj);
        }
        如想在其它类中比较对象中内容是否相等，就重写Object类的equals()
        */

    }
}

3.2 toString()方法

● Object类中定义有public String toString()方法，其返回值是 String 类型，描述当前对象的有关信息。

● 在进行String与其它类型数据的连接操作时（如： System.out.println(“info”+person）），将自动调用该对象类的 toString()方法

● 可以根据需要在用户自定义类型中重写toString()方法。

public class ToStringDemo {
    public static void main(String[] args) {
        /*Person p=new Person();
        p.setName("dim");


        System.out.println(p);
       */

        /*在控制台输出一个Person对象，而对象储存在内存中。
         实际输出的是一个字符串，输出时会默认调用类中toString()
         若类中无toString()，就会调用父类中的，Object类中的toString默认输出对象的内存地址
         如果想知道对象中的值，子类的实现与父类不同，在子类中重写父类的toString()，调用子类的即可
        */
        /*
        public String toString() {
                    类名                   @           hashcode()拿到对象在内存中的哈希值（10进制整数）
                                                         Integer.toHexString(哈希值) 转为16进制整数
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
       */
    }
}

4.String类

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

public class StringDemo1 {
    public static void main(String[] args) {
        /*
        字符串底层是一个个字符
         */
        String s="abc";//在内存中创建了String对象，值不能改变
        String s1=new String("abc");
        s1+="def";//创建新的字符串对象，将新数组填充到字符串对象中，吧新对象的地址赋给s1
        s1+="gh";
        System.out.println(s1);//abcdefgh

    }
}

4.1 创建方式

（1）String s = "abc"

字符串常量池
隐式创建，先在字符串常量池中检测，
如果有对应的字符串，直接将字符串常量池中的对象地址返回；
如果没有，会在字符串常量池中创建一个字符串对象

（2）String s = new String("abc");

new  创建新的对象，对象地址一定不同

public class StringDemo2 {
   
    public static void main(String[] args) {
        String s1="abc";
        String s2="abc";
        System.out.println(s1==s2);//true
        String s3=new String("abc");
        String s4=new String("abc");
        System.out.println(s3==s4);//false
    }
}

4.2 构造方法

String 的构造方法：
    new String();无参构造
    String(String s)  String类的参数
    String(byte[] b)  将byte数组转为字符串
    String(char[] c)  将char数组转为字符串

    String(StringBuffer sb)
    String(StringBuilder sb)

    getBytes();将字符串转为byte数组
    toCharArray();将字符串转为char数组

import java.util.Arrays;

public class StringDemo3 {
   
    public static void main(String[] args) {
        String s=new String();
        String s1=new String("abc");
        byte []bytes="abc".getBytes();//编码  将字符串转为byte数组 数字化传输
        System.out.println(Arrays.toString(bytes));//[97,98,99]
        String s2=new String(bytes);//解码  将byte数组转为字符串
        System.out.println(s2);//abc

        //排序
        char[] chars="bca".toCharArray();//将字符串转为数组
        Arrays.sort(chars);
        String s3=new String(chars);//将char数组转为字符串
        System.out.println(s3);//abc
        System.out.println(String.valueOf(chars));//abc
    }
}

4.3 判断功能

判断功能
boolean equals(Object obj) 重写Object类的方法，判断内容是否相等
boolean equalsIgnoreCase(String str) 不区分大小写
boolean contains(String str) 是否包含某子串
boolean isEmpty() 判断是否为空
boolean startsWith(String prefix) 是否以指定子串开始
boolean endsWith(String suffix) 是否以指定子串结束
boolean compareTo(String anotherString) 两字符串间按编码大小比较

public class StringDemo4 {
   
    public static void main(String[] args) {
        String s1="abc";
        System.out.println(s1.equals("abC"));//false
        System.out.println(s1.equalsIgnoreCase("abC"));//true
        System.out.println(s1.contains("ac"));//false  /是否包含字串 
        System.out.println(s1.isEmpty());//false
        System.out.println(s1.startsWith("ab"));//true
        System.out.println(s1.endsWith("c"));//true
        System.out.println("ab".compareTo("ac"));//-1  字符串之间的比较
    }
}

4.4 获取功能

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 class StringDemo5 {
   public static void main(String[] args) {
        String s="abcdefg";
        System.out.println(s.length());//7
        char c=s.charAt(5);
        System.out.println(c);//f
        int index=s.indexOf("c");
        System.out.println(index);//2
        int index1=s.indexOf("g",3);
        System.out.println(index1);//6
        String sub=s.substring(3);
        System.out.println(sub);//defg
        String sub1=s.substring(2,4);
        System.out.println(sub1);//cd

    }
}

4.5 转换功能

byte[] getBytes() 将字符串转为byte数组
char[] toCharArray() 将字符串转为char数组
static String valueOf(char[] chs) 将char数组转为字符串
String toLowerCase() 英文字母转小写
String toUpperCase() 英文字母转大写
String concat(String str) 连接字符串，返回新字符串
Stirng[] split(分割符); 按指定规则，将字符串拆为数组

import java.util.Arrays;

public class StringDemo6 {
    public static void main(String[] args) {
        String s="abcDEF";
        System.out.println(s.toLowerCase());//abcdef
        System.out.println(s.toUpperCase());//ABCDEF

        String s1="xxx";
        s+=10;//可以连接其他类型
        String s2=s.concat(s1);//只能连接字符串
        System.out.println(s2);//abcDEF10xxx
        String s3="ab,cd,ef,g";
        String[] a=s3.split(",");
        System.out.println(Arrays.toString(a));//[ab,cd,ef,g]

    }

}

4.6 替换功能

String replace(char old,char new)
String replace(String old,String new) 用新的字符串替换指定的所有的子串
replaceAll(String regex, String replacement) 用新的字符串替换指定的所有的子串,用正则表达式匹配
replaceFirst(String regex, String replacement) 用新的字符串替换指定的第一个出现的子串,使用正则表达式匹配
● 只能去除字符串两端空格
String trim()

public class StringDemo7 {
    public static void main(String[] args) {
        String s="a abcdefab ";
        String s1=s.replace("a","A");
        System.out.println(s1);//A AbcdefAb
        String s2=s.replace("ab","AB");
        System.out.println(s2);//a ABcdefAB 
        String ss=" ab c ";
        String ss1=ss.trim();
        System.out.println(ss1.length());//4
        System.out.println(s.replaceAll(" ","G"));//aGabcdefabG
        //正则表达式匹配
        String ss2="a1g56duk9";
        System.out.println(ss2.replaceAll("\\d","W"));//aWgWWdukW
    }
}

4.7 正则表达式（简介）

又称规则表达式,（Regular Expression，在代码中常简写为regex、regexp或RE）

4.7.1 目的

1. 判断给定的字符串是否符合正则表达式的过滤逻辑（称作“匹配”）：

2. 可以通过正则表达式，从字符串中获取我们想要的特定部分。

public class StringDemo8 {
    public static void main(String[] args) {
        String s="你好";
        //boolean r=s.matches("[0-9]");
        //boolean r=s.matches("[1,2,3,4]");
        //boolean r=s.matches("\\d");// \d == [0-9]
        //boolean r=s.matches("\\D");//非数字
        //boolean r=s.matches("[0-9]?");//表示一次或一次也没有
        //boolean r=s.matches("[0-9]*");//0次或多次
        //boolean r=s.matches("[0-9]+");//表一次或多次
        //boolean r=s.matches("[0-9]{6}");//{n} 固定的n位
        //boolean r=s.matches("[0-9]{6,}");//{n,} 至少是n位
        //boolean r=s.matches("[0-9]{6,9}");//{n,m} 最少n位，最多m位
        //boolean r=s.matches("[a-z]+"); //小写字母
        //boolean r=s.matches("[A-Z]+");//大写字母
        //boolean r=s.matches("[A-z]+");
        //boolean r=s.matches("\\w+");//[a-z,A-Z,0-9,_]
        boolean r=s.matches("[\\u4e00-\\u9fa5]+");
        System.out.println(r);
    }
}

4.8 StringBuffer类

String 对象的值不可改变，在拼接字符串时，要创建对各字符串对象，造成内存空间的浪费
String s="a";
s+="b";
s+="c";
...
若需大量拼接字符串可使用:
StringBuffer  线程安全，可变的字符串
new StringBuffer()  默认底层数组容量时16
StringBuffer("abcd"); 容量=内容长度+16

package Day1.String;

public class StringBufferDemo1 {
    public static void main(String[] args) {
        String s="abcdefg";
        s.insert(1,"GG");
        System.out.println(s);//aGGbcdefg

        s.deleteCharAt(1);//删去指定位置的字符
        System.out.println(s);//aGbcdefg

        s.delete(1,3);//删除指定区间的字符  左闭右开区间
        System.out.println(s);//acdefg

        s.replace(2,4,"XX");
        System.out.println(s);//acXXfg

        s.reverse();
        System.out.println(s);//gfXXca

    }
}

4.9 StringBuilder类

String 对象的值不可改变，在拼接字符串时，要创建对各字符串对象，造成内存空间的浪费
String s="a";
s+="b";
s+="c";
...
若需大量拼接字符串可使用:
StringBuilder  线程不安全  可变字符串

package Day1.String;

public class StringBuilderDemo1 {
    public static void main(String[] args) {
     
        StringBuilder s=new StringBuilder("a");
        s.append("abc");
        s.insert(2,"XX");
        System.out.println(s);//aaXXbc
    }
}

4.10 Random类

提供随机数

import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random r=new Random();
        System.out.println(r.nextInt());//返回的是int范围内的一个随机数
        System.out.println(r.nextInt(35)+1);//0-34  /  1-35
    }
}

4.11 Math类

public class MathDemo {
    public static void main(String[] args) {
        System.out.println(Math.PI);3.141592653589793
        System.out.println(Math.abs(-5));//5
        System.out.println(Math.sqrt(36));//6.0
        System.out.println(Math.pow(2,4));//16.0
        System.out.println(Math.random());//0.28591826793752495   返回0-1之间随机数
        System.out.println(Math.round(5.4));//5  四舍五入
        System.out.println(Math.floor(5.9));//5.0  向下取整
        System.out.println(Math.ceil(5.1));//6.0  向上取整
        System.out.println(Math.max(5,10));//10
    }
}

5. Arrays类

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

5.1 equals()

● 比较两个非同一数组是否相等，而数组本身的equals判断另一个数组是否它本身。

public class ArraysDemo1 {
    public static void main(String[] args) {
        int[] a={1,2,3};
        int[] b={1,2,3};
        System.out.println(a==b);//false 比较的为地址
        System.out.println(Arrays.equals(a,b));//true  比较对象内容
   
    }
}

5.2 sort 排序

import java.util.Arrays;
public class ArraysDemo2 {
    public static void main(String[] args) {
        int[] a={5,4,6,2,1};
        //sort(数组名，起始索引（包含）,结束索引（不包含）)
        Arrays.sort(a,0,4);
        System.out.println(Arrays.toString(a));

    }
}

• 自定义对象排序

自定义类实现Comparable接口

重写compareTo方法

5.3 binarySearch -使用二分搜索算法搜索指定数组

import java.util.Arrays;
public class ArraysDemo3 {
    public static void main(String[] args) {
        /*
        二分查找/折半查找
        前提：数组有界
         */
        int[] a={5,6,3,4,7,1,2};
        Arrays.sort(a);
        int index=Arrays.binarySearch(a,0,3,5);
        System.out.println(index);//index非负，表明找到
    }
}

5.4 toString() 方法

将数组以字符串形式输出

public class ArraysDemo1 {
    public static void main(String[] args) {
        int[] a={1,2,3};

        System.out.println(Arrays.toString(a));//[1, 2, 3]

    }

}

5.5 数组的复制(扩容)

public class ArraysDemo4 {
    public static void main(String[] args) {
        //数组的复制
        int[] a=new int[]{1,2,3,4,5};
        /*以前的方法
        int[] b=new int[10];
        for(int i=0;i<a.length;i++){
            b[i]=a[i];
        }*/
        int[] b= Arrays.copyOf(a,10);//数组扩容
        System.out.println(Arrays.toString(b));//[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

    }
}

6. Random类

用于产生随机数。

● 构造方法 public Random()

● 成员方法 public int nextInt()

public int nextInt(int n）

7. 日期类

7.1 Date类

● 使用Date类代表当前系统时间

Date d = new Date();

Date d = new Date(long d);

import java.util.Date;
public class DateDemo {
    public static void main(String[] args) {
        Date date=new Date();
        System.out.println(date);//Wed Dec 28 21:55:05 CST 2022
        System.out.println(date.getYear()+1900);
        System.out.println(date.getMonth()+1);
        System.out.println(date.getDate());
        System.out.println(date.getDay());//删除线，表现Java版本已不建议使用，用新的代替
        System.out.println(date.getHours());
        System.out.println(date.getMinutes());
        System.out.println(date.getSeconds());
        //返回的是自1970-1-1 00：00  至（程序运行的时间） 间的毫秒差
        System.out.println(date.getTime());//1672236088631L

    }
}

7.2 Calendar类

● Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。

Calendar c1 = Calendar.getInstance()；

import java.util.Calendar;
import java.util.GregorianCalendar;

public class CalendarDemo {
    public static void main(String[] args) {
        /*
        输入日期，得出——>当年的第几天
        Calendar 日历类  抽象类  不能创建对象
        返回的是其子类对象
        Calendar c1 = Calendar.getInstance();
         */
        Calendar calendar=new GregorianCalendar();//格里高利(公历)
        //System.out.println(calendar);
        System.out.println(calendar.get(Calendar.YEAR));
        System.out.println(calendar.get(Calendar.MONTH)+1);
        System.out.println(calendar.get(Calendar.DATE));
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));
        System.out.println(calendar.get(Calendar.WEEK_OF_MONTH));
    }
}

7.3 SimpleDateFormat 日期格式化类

● 构造方法 SimpleDateFormat(格式); // yyyy-MM-dd

● 日期转字符串 Date now=new Date(); myFmt.format(now);

● 字符串转日期 myFmt.parse(“2018-02-10”); 字符串日期格式与指定格式必须一致

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        /*
        简单的日期格式化类
        Java中表示日期：
               new Date();
               new GregorianCalendar();
        但在前端显示时，需将Java中date对象转为指定格式的字符串
        Date date=new Date();
        String s=date.getYear()+"-"+date.getMonth();太麻烦

         */
        //将日期对象转为指定格式的字符串
        /*Date date=new Date();
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");
        String s=simpleDateFormat.format(date);
        System.out.println(s);*/
        //将指定格式的字符串转为日期对象
        /*
        2004-2-19  从前端获取都是String，若需获取年较为麻烦
        故将字符串转为date对象，以面对对象的方式操作
         */
        String d="2004-2-19";
        SimpleDateFormat simpleDateFormat= new SimpleDateFormat("yyyy-MM-dd");
        Date date=simpleDateFormat.parse(d);
        System.out.println(date.getYear()+1900);
    }

}

小谭同学ha

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
API — 常用类

API(Application Programming Interface)应用程序编程接口● 是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明又称规则表达式,（Regular Expression，在代码中常简写为regex、regexp或RE）
复制链接

扫一扫