常用API（二）

最新推荐文章于 2024-11-13 17:07:29 发布

被迫成为全栈工程师的小H

最新推荐文章于 2024-11-13 17:07:29 发布

阅读量249

点赞数

分类专栏： java高级文章标签： java 编程语言

本文链接：https://blog.csdn.net/PIONEERRR/article/details/112987736

版权

java高级专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1.static关键字

在这里插入图片描述

概述：对于姓名，年龄，学号来说，每个对象都要有自己独立的数据，但是对于所在教室来说，这是多个对象共享同一份数据。

一旦用了static关键字，那么这样的内容就不再属于对象自己，而是属于类的，例如上面的教室。所以，凡是本类的对象，都共享同一份(这样可以节省内存)。

1.1用static关键字来修饰成员
创建一个学生类，给与姓名；年龄；学号

public class student {
    private  String name;//姓名
    private  int age;   //年龄
    static  String room="101";
    private int id;
//这些成员变量分别用Art+insert来快速创建方法
    }
     private static  int idcounter=0;  //这是一个创建对象个数的计数器。
     public student()   //每创建一个对象就++，这样就可以按照先后创建的顺序来编写
     {
         ++idcounter;
     }
   
    public student(String name, int age)
    {
        this.age=age;
        this.name=name;
        this.id=++idcounter;
    }

    public static String getRoom() {
        return room;
    }

    public static void setRoom(String room) {
        student.room = room;
    }


    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
  public int getId() {
        return id;    
    }

    public void setId(int id) {
        this.id = id;
    }

在上面的基础下我们创建两个学生对象。

public class demostatic {
   
    public static void main(String[] args) {
  student one=new student("小明",19);
  student two=new student("小红",20);
        System.out.println("姓名："+one.getName()+"年龄"+one.getAge()+"教室"+one.room+"学号"+one.getId());   //姓名：小明年龄19教室101学号1

        System.out.println("姓名："+two.getName()+"年龄"+two.getAge()+"教室"+two.room+"学号"+two.getId());   //姓名：小红年龄20教室101学号2

    }

}

1.2

/ 1.一旦使用static修饰成员方法，那么这就成为了静态方法，静态方法不属于对象，是属于类的。
如果没有static关键字，则必须先创建对象，然后通过对象来使用它。

/ 2.无论使用成员变量还是成员方法，如果有了static，都推荐使用类名称来调用

/ 3.实例可以访问静态，静态方法和变量不能直接访问实例方法和变量。
原因：在内存中先有的静态，后有的实例方法

/ 4.this代表着当前对象,谁调用了这个方法，谁就是当前对象。

public class demostatic1 {

    int num;
    static int num1;

       
    //成员方法
    public void method() {
        System.out.println("这是一个成员方法。");
        //成员方法可以访问成员变量
        System.out.println(num);
        //成员方法可以访问静态变量
        System.out.println(num1);
    }

    public static void main(String[] args) {
        //静态方法可以访问静态变量
        System.out.println(num1);

        //静态方法不能直接访问非静态
        //System.out.println(num);  错误写法

        //静态方法不能使用this关键字
    }
}

1.3 static关键字的内存图
在这里插入图片描述
注意;根据类名称访问静态成员变量的时候，全程和对象没有关系，哪怕你用该类的对象来调用静态成员变量，都会被翻译成用类来调用方法。

public class demostatic {

    public static void main(String[] args) {
  student one=new student("小明",19);
        System.out.println(one.getName());
        System.out.println(one.getAge());
        System.out.println(student.room);

  student two=new student("小红",20);

        System.out.println(two.getName());
        System.out.println(two.getAge());
        System.out.println(two.room);

    }

}
//结果

小明
19
101
小红
20
101

1.4
静态代码块

 特点： 当第一次用到本类时。静态代码块执行唯一的一次，静态内容总是由于构造方法先执行。
 用途：用来一次性的对静态成员变量进行赋值

    /*静态代码块
    public class 类名称
      static
    {
       静态代码块的内容
    }
    */
public class person {
    
person()
{
    System.out.println("构造方法执行！");
}
static
{
    System.out.println("静态代码块执行！");
}
    public static void main(String[] args) {
        person one=new person();
    }
    }
//结果
//静态代码块执行！
//构造方法执行！

2.数组工具类
java.util.Arrays是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组的常见操作。

public static String to String (数组)，按参数数组变成字符串（按照默认的格式：[元素1,元素2,元素3。。]）

 public static void main(String[] args) {
        //创建一个int 数组
        int[] intarray={10,20,30};
        //将int[]数组按照默认格式变成字符串
        String intstr= Arrays.toString(intarray);
        System.out.println(intstr);

        //结果：[10, 20, 30]
        }

public static void sort(数组)，按默认升序（从小到大）对数组的元素进行排序,b把数组按字符串输出。

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

        //创建一个int数组
        int []array={2,5,6,1,4,9,3};
        //将数组的元素按照升序排序。
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));

备注：
1.如果是数值，则int[ ]按照默认格式变成字符串
2.如果是字符串，sort默认按照字母升序
3.如果是自定义类型，那么这个自定义的类需要有Comparable和comparator的接口支持。

2.1 Arrays的练习

请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印

import java.util.Arrays;

public class arrayspractice {
    //请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印
    public static void main(String[] args) {
        String str="jahdakJHDKAd725768";
        
        //将字符串数组变为字符数组
        char [] chars=str.toCharArray();
        
        //升序打印sort
        Arrays.sort(chars);

        //倒序遍历：
        for (int i = chars.length-1; i >=0; i--) {
            System.out.println(chars[i]);
        }
//结果为：k j h d d a a K J H D A 8 7 7 6 5 2 
    }
}

由这个练习题可以得到的结论：
如果大小写字母还有数字混在一起，升序输出则是数字>大写字母>小写字母

3.数学工具类Math

java.util.Math是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。

public static double abs(double num);   取绝对值

public static double ceil(double num);  向上取整（负数按正方向取整）

public static double floor(double num); 向下取整

public static long round(double num);   四舍五入

Math.PI就是π

按住ctrl左击Math可查看π的值

题目：计算在-10.8到5.9之间,绝对值大于6或者小于2.1的整数有多少个。

int count=0;
 double min=-10.8;
 double max=5.9;
 for(int i=(int)min;i<(int)max;i++)
 {
     int abs=Math.abs(i);
     if(abs<2.1||abs>6)
     {
         System.out.println(i);
         count++;
     }

 }
        System.out.println("符合条件的总共有："+count);
    }
}

4.Object类(所有类的父类)
java.lang.object类不用导包

4.1 object类里面的toString方法
定义一个标准的类，要添加tostring方法 art+insert

看一个类是否重写了toString方法直接打印类对应对象的名字即可
如果没有重写tostring方法，打印的就是对象的地址值

//定义一个person类
public class person {
    private  int age;
private  String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public person() {
    }

    public person(int age, String name) {
        this.age = age;
        this.name = name;
    }
//重写toString方法
    @Override
    public String toString() {
        return "person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
//
import Demoobject.person;

public class DemoMain {
    public static void main(String[] args) {
        person p=new person();
        //重写object的toString方法
        System.out.println(p);  //person{age=0, name='null'}
    }
}

4.2 equals方法

4.2.1Object equals方法直接用

public class demo1 {


public static void main(String[] args) {
    person p1= new person(18,"p1");
    person p2 =new person(19,"p2");

    boolean a=p1.equals(p2);
    System.out.println(a);  //false
}

}

4.2.21Objects equals方法

这个方法可以容忍空指针异常如果已经为空指针是用不了的，第一个Object equals 方法里面已经是空指针了
下面那个Objects.equals是用不了的，会错误,如果直接用Object equals的方法就可以避免空指针异常

import java.util.Objects;

public class demo {
    public static void main(String[] args) {
        String a=null;
        String b="ABC";
       boolean one=a.equals(b);
      System.out.println(one); //NullPointerException

        /*Objects的equals方法
   这个方法可以容忍空指针异常   如果已经为空指针是用不了的，上面已经为已经比较为空指针了，
   下面那个Objects.equals是用不了的，会错误,如果直接用下面的方法就可以避免空指针异常
        */
       boolean two= Objects.equals(a,b);
        System.out.println(two);    //false
    }
}

5 Date类

5.1表示特点
这个是在java.lang.Date包下的

类 Date表示特定的瞬间，精确到毫秒
把日期转换成毫秒
当前日期：2077-01-01
时间原点(0毫秒)：1970年1月1日 00:00:00(英国格林威治) 1970年1月1日 08:00:00(中国)

public class demo1 {
     */
    //获取从原点开始到现在经历了多少毫秒
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());//获取系统从原点到现在经历了多少毫秒
        //从原点到现在经历了多少天
        System.out.println(System.currentTimeMillis()/86400000);
    }
}

5.2 Date常用的两个构造方法和成员方法

import java.util.Date;

public class Datemethod {


     /*
        Date类的空参数构造方法
        Date() 获取当前系统的日期和时间  就是打印对象
        */
    public static  void demo1()
    {
        Date date=new Date();
        System.out.println(date); //Mon Feb 01 19:12:57 CST 2021
    }
    public static  void demo2()
    {
//有参数构造方法 传递毫秒值 将毫秒值转换为Date日期
        Date date=new Date(0L);
        System.out.println(date); //Thu Jan 01 08:00:00 CST 1970

    }
    //成员方法 传递从原点到现在的毫秒数
    public static  void demo3()
    {
        //long getTime 把日期转换为毫秒值 (相当于)System.currentTimeMillis()
        Date date=new Date();
        long time=date.getTime();
        System.out.println(time);

    }
    public static void main(String[] args) {
        demo3();

    }

}

5.3 DateFofmat类

5.3.1java.text.DateFormat 是时间和日期格式化子类的抽象类

DateFormat是一个抽象类，无法直接创建对象来使用，可以使用DateFormat类的子类
java.text.SimpleDateFormat extends DateFormat

作用：

格式化：成员方法： String Format(Date date) 把Date日期格式化为符合模式的字符串格式化：日期——>文本
解析： Date parse(String source) 把符合日期格式的的字符串解析为Date日期解析：文本——>日期

5.3.2 构造方法：
SimpleDateFormat(String pattern) 参数是指定的格式
用给定的模式和默认的语言环境的日期符号构造 SimpleDateFormat 在构造对象的时候就标定格式

5.3.3格式：
.如 yyyy-MMM-ddd HH:mm:ss 字母对应的英文的缩写而-符号可以改变的
如yyyy年MMM月ddd天 hh时mm分ss秒

y M d H m s

如何用SimpleDateFormat定义格式 new SimpleDateFormat(“格式”).format(Date date时间);

黑体举例

//打印系统当前时间
            Date  time=new Date(System.currentTimeMillis());
         //定义格式 通过SimpleDateFormat 对象，然后放入系统时间     new SimpleDateFormat("格式").format(Date date);
         //按照格式打印时间
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(time));

代码举例

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

    public class Dateformatintro {
//这是格式化
        public static void demo1()
        {
            Date  date =new Date();
            SimpleDateFormat si=new SimpleDateFormat();
            //调用 String Format(Date date)
            String s= si.format(date);
            //输出符合模式的字符串
            System.out.println(s);
        }
        //这是解析

   //注意：parse 调用了一个抛出了异常的方法（构造方法） 调用了一个抛出异常的方法,就必须处理这个异常,要么throws 继续抛出这个异常,要么try catch自己处理
        public static  void demo2() throws ParseException {
             Date date =new Date();
             SimpleDateFormat  si= new SimpleDateFormat("yyyy年MM月dd日 HM时mm分ss秒");
            Date date1=si.parse("2021年10月01日 07时05分24秒");

            System.out.println(date1);
        }
        public static void main(String[] args) throws ParseException {
           demo1();
           //调用异常的方法 在方法后面也要加 art+enter throws异常
           demo2();
    }
}

5.4homework 计算从自己出生开始经历了多少天

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

public class homework {
    //计算出一个人出生了多少天
    //打印出生时间
    // 得到现在时间
    // 都转化为毫秒值相减
    //把毫秒转化为天数

    public static void main(String[] args) throws ParseException {

//        1.使用Scanner类中的方法next 获取出生日期
        Scanner in=new Scanner(System.in);

        System.out.println("请输入您的出生日期，格式为 yyyy-MM-dd");
        String  birthdaydateString=in.next();

//        2.使用DateFormat方法parse,把字符串的出生日期解析为Date格式
        SimpleDateFormat si=new SimpleDateFormat("yyyy-MM-dd");
//        3.把Date的出生日期转化为毫秒值
        Date date1=new Date();
        Date birthdaydate =si.parse(birthdaydateString);
        long birthdaytime=birthdaydate.getTime();
//        4.获取当前的日期，转化为毫秒值
        long todaytime= date1.getTime();
        //    5.使用当前日期-出生日期
        long max=todaytime-birthdaytime;

//        6.把毫秒值转化为天数
       long day=max/86400000;
        System.out.println(day); //7211
    }
}

6.Calendar类

6.1抽象类里面提供了很多操作日历字段的方法。如YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法

注意：Calendar类无法直接创建对象来使用,里面有个静态方法getInstance()，该方法返回了Calendar的子类对象

import java.util.Calendar;

public class demoCalendar {
    public static void main(String[] args) {
    //返回子类对象
        Calendar c=Calendar.getInstance();//父类对象接收一个子类 多态
        System.out.println(c);
    }
}

6.2
Calendar常用的成员方法

public int get (int field) 返回给定日历字段的值
参数：传递给定日历字段 (YEAR,MONTH。。)
public void set(int field, int value);
field；传递制定的日历字段(Year.MONTH)
value；给指定字段设置的值
把指定的字段增加或者减少指定的值
public abstract void add(int field,int amount) { }根据日历的规则，给制定日历字段添加或者减去指定的时间量
参数 field：传递制定的日历字段(Year.MONTH)
int amount ：增加/减少指定的值
正数：增加负数：减少
public Date getTime() 返回一个表示此Calendar时间值的Date对象
把日历对象转化为日期对象
就TM是显示现在日期

import java.util.Calendar;
import java.util.Date;

public class demoCalendar {

    public static void main(String[] args) {
        demo01();
        demo2();
        demo3();
        demo4();
    }
/*  public int get (int field) 返回给定日历字段的值
    参数：传递给定日历字段 (YEAR,MONTH。。)
* */
       private static void demo01()
        {
            Calendar c= Calendar.getInstance();
            int year= c.get(Calendar.YEAR); //2021
            System.out.println(year);
            int month=c.get(Calendar.MONTH);
            System.out.println(month);  //1
        }

    /*
      public void set(int field, int value);
      field； 传递制定的日历字段(Year.MONTH)
      value； 给指定字段设置的值
     */
    private  static  void demo2()
    {
        Calendar a=Calendar.getInstance();
        //这个就是改时间 改年
        a.set(Calendar.YEAR,2077);
        int year=a.get(Calendar.YEAR);//2021  --> 2077
        System.out.println(year);
        // 同时设置年月日
        a.set(2099,12,1);
        int all=a.get(Calendar.DAY_OF_MONTH);
        System.out.println(all);  //1
    }
/* 把指定的字段增加或者减少指定的值
   public abstract void add(int field,int amount)  {  }根据日历的规则，给制定日历字段添加或者减去指定的时间量
  参数 field； 传递制定的日历字段(Year.MONTH)
     int amount ； 增加/减少指定的值
     正数： 增加    负数： 减少
 */
    private  static  void demo3()
    {
         Calendar l=Calendar.getInstance();
         //增加年
         l.add(Calendar.YEAR,10);
         //增加月
        l.add(Calendar.MONTH,5);
        int year= l.get(Calendar.YEAR); //2031
        System.out.println(year);
        int month=l.get(Calendar.MONTH);
        System.out.println(month);  //6  西方月份0-11

    }
    /*public Date getTime() 返回一个表示此Calendar时间值的Date对象
    把日历对象转化为日期对象
    就TM是显示现在日期
    * */
    public static void demo4()
    {
        Calendar e=Calendar.getInstance();
      Date date= e.getTime();
        System.out.println(date); //Tue Feb 02 12:33:40 CST 2021
    }
}

7 . System类

两个方法：

7.1 public static long currentTimeMillis() 返回以毫秒为单位的当前时间常用来计算程序的运行时间

public class demosystem {
    public static  void test()
            /*
            public static long currentTimeMillis() 返回以毫秒为单位的当前时间
             */
        //测试从1-9999999所用的毫秒值*
        {
           //测量现在的毫秒值
            long start = System.currentTimeMillis();
            //for循环
            for (int i = 0; i < 9999999; i++) {
                System.out.println(i);
            }
            long end =System.currentTimeMillis();
            System.out.println("共用时"+(end-start)+"毫秒"); //18309ms
         }

7.2 public static void arraycopy (Object src,int srcPos,Object dest,int destPos,int Length); 将数组中指定的数据拷贝到另一个数组中。
src- 源数组
srcPos - 源数组当中的起始位置
dest- 目标数组
destPOS- 目标数组当中的起始位置
Length - 要复制的数组元素的数量

  /*
         public static void arraycopy (Object src,int srcPos,Object dest,int destPos,int  Length);
         src-     源数组
         srcPos - 源数组当中的起始位置
         dest-    目标数组
         destPOS- 目标数组当中的起始位置
         Length - 要复制的数组元素的数量

         将数组中指定的数据拷贝到另一个数组中
         */


    //数组A[1,2,3,4,5] 数组B [5,6,7,8,9]  将Src数组上的前三个元素复制到dest数组的前三个位置上
    public static void exchange(int []src,int [] dest)
    {
        System.arraycopy(src,0,dest,0,3);
        for (int i = 0; i < src.length-2; i++) {
            System.out.println(src[i]);
        }
        for (int i = 0; i < dest.length-2; i++) {
            System.out.println(dest[i]);
        }
    }

    //练习  数组a
    public static void main(String[] args) {
        test();
        int[]src={1,2,3,4,5};
        int[] dest={5,6,7,8,9};
        exchange(src,dest);

8.StringBuilder类

8.1String类和Stringbuilder的区别
String 类
每一个字符串的底层是一个被final修饰的数组并且他们是常量不可改变
private final byte[ ] value;

Stringbuilder类（始终是一个数组，在数组里面进行字符串的运算）

字符串的缓冲区，可以提高字符串的操作效率（可看成一个长度可以变化的字符串）
底层也是一个数组，但是没有被final 修饰，可以改变长度。
在这里插入图片描述
总结：StringBuilder在内存中始终是一个数组，占用了空间少，效率高，初始容量是16，超出了就翻倍扩容32.

8 .2Stringbuiler的构造方法

8.2.1构造方法
1.StringBuilder()
构造一个不带任何字符的字符串生成器，其初始容量为 16 个

 //空参数构造方法
        StringBuilder  str=new StringBuilder();
        System.out.println("空的"+str); //空的

2.StringBuilder(String str)
构造一个字符串生成器，并初始化为指定的字符串内容

//带字符的构造方法
        StringBuilder  str1=new StringBuilder("abc");
        System.out.println(str1); //abc

8.2.2
构造方法：public StringBuilder append(任意数据类型),并且append 不需要接收返回值并且可以添加任何值

public static  void testString()
{
 StringBuilder st= new StringBuilder();
 st.append(5);
 st.append("abc");
 st.append(true);
 st.append('a');
    System.out.println(st); //输出对象，得到的结果是字符串 5abctruea
}

8.3 String 和 StringBuilder的相互转换

StringBuilder 和String可以相互转换

1.String————>StringBuilder可以使用StringBuilder的构造方法
StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容

2.StringBuilder———>String 可以使用用StringBuilder中的toString方法

public class tostring {
    public static void main(String[] args) {
        //String————>StringBuilder

        String str="hello";
        System.out.println(str); //hello
        //把String字符串放到 StringBuilder构造方法里面
        StringBuilder st= new StringBuilder(str);
        //添加点东西
        st.append("world"); //helloworld
        System.out.println(st);

        //StringBuilder———>String
String s= st.toString();
        System.out.println(s); //helloworld
    }
}

9.包装类
9.1 integer

装箱：把基本类型的数据包装到包装类中
构造方法：
1.Integer(int value)
构造一个新分配的 Integer 对象，它表示指定的 int 值。

2.Integer(String s)
构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
注意：传递的字符串必须是基本类型的字符串,否则会抛出异常。”100“正确 “a”错误的

3.静态方法：
3.static Integer valueOf(int i)
返回一个表示指定的 int 值的 Integer 实例。

4.static Integer valueOf(String s)
返回保存指定的 String 的值的 Integer 对象。

5.拆箱：在包装类中取出基本类型的数据
成员方法： int intValue()
以 int 类型返回该 Integer 的值。

 public static void main(String[] args) {
        //装箱 把基本类型的数据，包装到包装类中 (基本类型的数据——>包装类)
        //1
        Integer in=new Integer(1); //方法过时
        System.out.println(in); //打印对象，输出的是1 重写了toString方法
        //2
        Integer in2=new Integer("2");
        System.out.println(in2);  //2

        //静态方法
        //3
        Integer in3=Integer.valueOf('A');
        System.out.println(in3);  //3
        
        //4
        Integer in4=Integer.valueOf(4);
        System.out.println(in4); //4
       
       
        //拆箱
        //5
        int i=in4.intValue();
        System.out.println(i);   //65
    }

9.2 Integer的自动拆箱和自动装箱

package Packageclass;
import java.util.ArrayList;
public class autopackage {
    public static void main(String[] args) {
        /*z自动装箱：自动把int类型的证书赋值包装类
        * */
        Integer in=1;
        /*包装类不能直接参与计算，可以自动把包装类转化为基本数据类型在参与计算*/
        ArrayList<Integer> list=new ArrayList<>();
        /*ArrayList无法直接存储整数，可以存储Integer包装类*/
       list.add(1);   //自动装箱
       //而Integer的数据又可以被赋值给int
        int a=list.get(0); //自动拆箱
    }
}

9.3基本类型和字符串类型之间的相互转换

基本类型与字符串类型之间的相互转换
基本类型–>字符串(String)

1.基本类型的值+" " 工作中常见的
2.包装类的静态方法toString(参数)，不是Object类的toString方法这是一种重载的toString,因为有参数
static String toString(int i)，返回一个表示指定整数的 String 对象。
3.String类的静态方法valueOf(参数)
static String valueOf(int i)
返回一个表int参数类型的字符串表示形式

字符串(String) —> 基本类型
4.使用包装类的静态方法 parse xxx(“字符串”);
Integer 类： static int parseInt(String s)
Double 类： static double parseDouble(String s)

package Packageclass;

public class autopackage {

 
        public static void main(String[] args) {

            //基本类型-->字符串(String)
            //1
            int i=100;
            String s1=i+"200";
            System.out.println(s1); //100200
            //2 将100转换成字符串
            String s2=Integer.toString(100);
            System.out.println(s2+200); //100200
            //3
            String  s3=String.valueOf(100);
            System.out.println(s3+200); //100200

            // 字符串(String) ---> 基本类型
            //4
            String s4=String.valueOf(100);
            int x=Integer.parseInt(s4);
            System.out.println(x-10); //90
    }
}