Java笔记

1.Math

概述：Math包含执行基本数字运算的方法
若没有构造方法，该如何使用类中的成员呢？
看类的成员是否都是静态的，如果是，通过类名就可以直接调用

Math类的常用方法

方法名说明
public static int abs（int a）返回参数的绝对值
public static double ceil（double a）返回大于或等于参数的最小double值，等于一个整数
public static double floor（double a）返回小于或等于参数的最大double值，等于一个整数
public static int round(float a)按照四舍五入返回最接近参数的int
public static int max(int a,int b)返回两个int值中的较大值
public static int min(int a,int b)返回两个int值中的较小值
public static double pow(double a,double b)返回a的b次幂的值
public static double random（）返回值为double的正值[0.0，1.0）

2.System

常用方法

方法名说明
public static void exit(int status)终止当前运行的Java虚拟机，非零表示异常终止
public static long current TimeMillis（）返回当前时间（以毫秒为单位）

3.Object

Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类。
构造方法：public Object()

为什么说子类的构造方法默认访问的是父类的无参构造方法？
因为他们的顶级父类只有无参构造方法。

方法名说明
public String toString（）返回对象的字符串表示形式。建议所有子类重写该方法，自动生成
public boolean equals（Object obj）比较对象是否相等。默认比较地址，重写可以比较内容，自动生成

toString

/*
学生类中重写的内容
*/
 //重写Object中的方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

/*
    Object是类层次结构的根，每个类都可以将它作为超类。所有的类都直接或者间接的继承自该类

    看方法的源码，选中方法，Ctrl + B

    建议子类重写此方法toString()
 */
public class ObjectDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("张三");
        s.setAge(20);
        System.out.println(s);  //myObject_01.Student@b4c966a
        System.out.println(s.toString());
        /*
          public void println(Object x) {  // x = s
              String s = String.valueOf(x);
              synchronized (this) {
                print(s);
                newLine();
             }
          }

           public static String valueOf(Object obj) {
                return (obj == null) ? "null" : obj.toString();
         }

            public String toString() {
                return getClass().getName() + "@" + Integer.toHexString(hashCode());
         */

    }
}

equals

/*
学生类中重写的内容
*/

    @Override
    public boolean equals(Object o) {
        /*
            this----s1
            o----s2，向上转型将s2传递给o
         */
        //比较地址是否相同，若相同，直接返回
        if (this == o) return true;
        //判断参数是否为null  ||  判断两个对象是否来自同一个类
        if (o == null || getClass() != o.getClass()) return false;

        //向下转型
        Student student = (Student) o; // student = s2

        if (age != student.age) return false;
        //比较姓名内容是否相同
        return name != null ? name.equals(student.name) : student.name == null;
    }

/*
    测试类
    public boolean equals(Object obj):指示一些其他对象是否等于此
 */
public class ObjectDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("张三");
        s1.setAge(20);

        Student s2 = new Student();
        s2.setName("张三");
        s2.setAge(20);

        //需求：比较两个对象的内容是否相同
        //System.out.println(s1==s2);      //false,因为s1和s2代表的是地址值

        //比的依旧是地址，所以不同，所以需要重写equals方法
        //System.out.println(s1.equals(s2));  //false
        /*public boolean equals(Object obj) {
            //this---s1
            //obj---s2
            return (this == obj);
        }*/

        //重写方法之后
        System.out.println(s1.equals(s2));  //true

    }
}

4.Arrays

1.冒泡排序
排序：将一组数据按照固定的规则进行排列
冒泡排序：一种排序方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有的数据按要求完成排序。

如果有n个数据进行排序，总共需要比较n-1次
每一次比较完毕，下一次的比较就会少一个数据参与

public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = { 21, 52, 62, 19, 23, 68} ;
        System.out.println("排序前:" + arrayToString(arr));

        //排序
        for (int n = 0;n < arr.length - 1;n++){
            for (int i = 0;i < arr.length - 1 -n;i++){
                if(arr[i] > arr[i+1]){
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }
        System.out.println("排序后：" + arrayToString(arr));

    }

    //把数组中的元素按照指定的规则组成一个字符串
    public static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}

2.Arrays类的概述和常用方法
Arrays类包含用于操作数组的各种方法

方法名说明
public static String toString（int[ ] a）返回指定数组的内容的字符串表示形式
public static void sort(int[ ] a)按照数字顺序排列指定的数组
import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {21,51,36,23,99};
        System.out.println("排序前：" + Arrays.toString(arr));
        //排序前：[21, 51, 36, 23, 99]

        Arrays.sort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));
        //排序后：[21, 23, 36, 51, 99]

    }
}

工具类的设计思想：
构造方法用private修饰 //防止外界创建对象
成员用public static 修饰 //使用类名访问该成员方法

5.基本类型包装类

1.概述：
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
常用的操作之一：用于基本数据类型与字符串之间的转换

基本数据类型包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean
public class IntegerDemo {
    public static void main(String[] args) {
        //需求：判断一个数据是否在int范围内
        //public static final int MIN_VALUE
        //public static final int MAX_VALUE
        System.out.println(Integer.MIN_VALUE);  //-2147483648
        System.out.println(Integer.MAX_VALUE);  //2147483647

    }
}

2.Integer类的概述和使用

Integer:包装一个对象中的原始类型int的值

方法名说明
public Integer根据 int 值创建 Integer 对象（过时
public Integer（String s）根据 String 值创建 Integer 对象（过时）
public static Integer valueOf（int i）返回表示指定的 int 值的 Integer 实例
public static Integer valueOf（String s）返回一个保存指定值的 Integer 对象String
public class IntegerDemo {
    public static void main(String[] args) {
        /*Integer i1 = new Integer(100);   //表示已过时
        System.out.println(i1);

        Integer i2 = new Integer("100");   //表示已过时
        //Integer i2 = new Integer("zxc");   //NumberFormatException
        System.out.println(i2);*/

        //第一种方法已过时，推荐使用这一种
        Integer i1 = Integer.valueOf(100);
        System.out.println(i1);

        Integer i2 = Integer.valueOf("100");
        //Integer i2 = Integer.valueOf("zxc");   //NumberFormatException
        System.out.println(i2);
        
    }
}

3.int 和String的相互转换

基本类型包装类的最常见操作就是：用于基本类型和字符串之间的相互转换

1.int 转换为 String
public static String valueOf(int i)：返回int参数的字符串表示形式。该方法是String类中的方法
2.String 转换为 int
public static int parseInt (String s)：将字符串解析为int类型。该方法是Integer类中的方法

/*
    int和String的相互转换
 */
public class IntegerDemo {
    public static void main(String[] args) {
        //int ---> String
        int number = 100;
        //法一   本质是拼接字符串
        String s1 = "" + number;
        System.out.println(s1);

        //法二   public static String valueOf(int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("-----------");

        //String ---> int
        String s = "100";
        //法一：  String ---> Integer ---> int
        Integer i = Integer.valueOf(s);
        //public int intValue()
        int x = i.intValue();
        System.out.println(x);

        //法二  public static int parseInt (String s)   静态方法，直接调用
        int y = Integer.parseInt(s);
        System.out.println(y);

    }
}

案例：字符串中数据排序
需求：字符串：“91 27 46 38 50”，请写程序实现最终输出结果是： “27 38 46 50 91”
在这里插入图片描述

import java.util.Arrays;

public class IntegerTest {
    public static void main(String[] args) {
        //定义一个字符串
        String s = "91 27 46 38 50";

        //把字符串中的数字数据存储到一个int类型的数组中
        String[] strArray = s.split(" ");

        //定义一个int数组，把String[] 数组中的每一个元素存储到int数组中
        int[] arr = new int[strArray.length];
        for (int i = 0;i < arr.length;i++){
            arr[i] = Integer.parseInt(strArray[i]);
        }

        //对int数组进行排序
        Arrays.sort(arr);

        //把排序后的int数组中的元素进行拼接得到一个字符串，拼接采用StringBuilder实现
        StringBuilder sb = new StringBuilder();
        for (int i = 0;i < arr.length;i++){
            if(i == arr.length-1){
                sb.append(arr[i]);
            }else {
                sb.append(arr[i]).append(" ");
            }
        }
        //将String转为StringBuilder类型
        String result = sb.toString();

        //输出结果
        System.out.println("result:" + result);
        
    }
}

4.自动装箱和拆箱
装箱：把基本数据类型转换为对应的包装类类型
拆箱：把包装类类型转换为对应的基本数据类型

/*
    装箱：把基本数据类型转换为对应的包装类类型
    拆箱：把包装类类型转换为对应的基本数据类型
 */
public class IntegerDemo {

    public static void main(String[] args) {
        //装箱：把基本数据类型转换为对应的包装类类型
        Integer i = Integer.valueOf(100);
        Integer ii = 100;  // 自动装箱。 Integer.valueOf(100);，底层依旧做了这个动作，jdk5之后就简化了

        //拆箱：把包装类类型转换为对应的基本数据类型
        //ii = ii.intValue() + 200; // ii.intValue() + 200 整个为基本类型，赋值给Integer类型的ii，自动装箱; ii.intValue()为拆箱
        ii += 200; //自动拆箱、装箱  i + 200 自动拆箱; i = i + 200; 是自动装箱

        System.out.println(ii);

        Integer iii = null;
        if(iii != null) {
            iii += 300;   //NullPointerException
        }

    }
}

注：在使用包装类类型的时候，如果做操作，最好先判断是否为null。只要是对象，在使用前就必须进行不为null 的判断

6.日期类

Date代表了一个特定的时间，精确到毫秒。

方法名说明
public Date​()分配一个 Date对象并对其进行初始化，以便它代表被分配的时间，精确到毫秒。
public Date​(long date)分配一个 Date对象，并将其初始化为表示从标准基准时间起指定毫秒数。
import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        //public Date()
        Date d1 = new Date();
        System.out.println(d1);

        //public Date(long date)
        long date = 1000*60*60;
        Date d2 = new Date(date);
        System.out.println(d2);  //Thu Jan 01 09:00:00 CST 1970
    }
}

Date类的常用方法

方法名说明
public long getTime（）获取的是日期从1970年1月1日00:00:00到现在的毫秒值
public void setTime(long time)设置时间，给的是毫秒值
import java.util.Date;

public class Demo {
    public static void main(String[] args) {
        //创建日期对象
        Date d = new Date();
        //public long getTime():距离1970年的时间，毫秒
        System.out.println(d.getTime());//    1642668616116
        System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");  //52.0886801152968年

        System.out.println("-----------");
        //public void setTime(long time) :设置时间，给的是毫秒值
        System.out.println(d); //当前时间

        long time = 1000*60*60;
        d.setTime(time);
        System.out.println(d); //Thu Jan 01 09:00:00 CST 1970

        long time1 = System.currentTimeMillis();
        d.setTime(time1);
        System.out.println(d);  //当前时间

    }
}

SimpleDateFormat类概述
SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。
日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从 ‘A’ 到 ‘Z’ 以及从 ‘a’ 到 ‘z’ 引号的字母被解释为表示日期或时间字符串的组件的模式字母。

常用的模式字母及对应关系：
y 年
M 月
d 日
H 时
m 分
s 秒

构造方法

方法名说明
public SimpleDateFormat​()构造一个 SimpleDateFormat使用默认模式和日期格式
public SimpleDateFormat​(String pattern)构建一个 SimpleDateFormat ，使用给定的模式和默认的日期格式。

SimpleDateFormat 格式化和解析日期
1.格式化（从Date到String）
public final String format​():将日期格式化成日期/时间字符串

2.解析（从String到Date）
public Date parse(String source):从给定字符串的开始解析文本以生成日期

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

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        /*格式化（从Date到String）
        public final String format():将日期格式化成日期/时间字符串*/
        Date d = new Date();

        /*SimpleDateFormat sdf = new SimpleDateFormat();
        String s = sdf.format(d);
        System.out.println(s);  //2022/1/20 下午8:09*/

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s = sdf.format(d);
        System.out.println(s);   //2022年01月20日 20:12:53

        System.out.println("--------------------------");

        //String ---> Date
        String ss = "2022-01-20 20:13:02";  //给定的两个模式须统一
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf2.parse(ss);  //报错，选中parse按下Alt+enter，选中第一个即可
        System.out.println(dd); //Thu Jan 20 20:13:02 CST 2022

    }
}

案例：日期工具类
需求：定义一个日期工具类（DateUtils），包含两个方法：把日期转换为指定格式的字符串；把字符串解析为指定格式的日期，然后定义一个测试类（DateDemo），测试日期工具类的方法。
在这里插入图片描述

/*
    工具类
    构造方法私有
    成员方法静态
 */
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateUtils {
    //私有构造方法，外界无法访问
    private DateUtils(){}
    /*
        日期转为指定格式的字符串
        返回值类型：String
        参数：Date date, String format
     */
    public static String dateToString(Date date, String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String s = sdf.format(date);
        return s;
    }
    /*
        把字符串解析为指定格式的日期
        返回值类型：Date
        参数：String s, String format
     */
    public static Date stringToDate(String s, String format) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date d = sdf.parse(s);
        return d;

    }
    
}

/*
    测试类
 */

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

public class DateDemo {
    public static void main(String[] args) throws ParseException {
        //创建日期对象
        Date d = new Date();
        String s1 = DateUtils.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);   //2022年01月21日 11:25:02

        String s2 = DateUtils.dateToString(d, "yyyy年MM月dd日");
        System.out.println(s2);   //2022年01月21日

        System.out.println("-------------------");

        String s = "2022-01-21 11:11:11";
        Date dd = DateUtils.stringToDate(s, "yyyy-MM-dd HH:mm:ss");
        System.out.println(dd);  //Fri Jan 21 11:11:11 CST 2022
    }
}

Calendar类概述
Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法。
Calendar提供了一个类方法getlnstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化：Calendar rightNow = Calendar.getlnstance（）；

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //获取对象
        Calendar c = Calendar.getInstance();  //多态形式
        System.out.println(c);

        //public int get(int field)
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1; //因为月份从0开始，所以+1
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");  //2022年1月21日

    }
}

Calendar的常用方法

方法名说明
public int get(int field)返回给定日历字段的值
public abstract void add​(int field, int amount)根据日历的规则，将指定的时间量添加或减去给定的日历字段
public void set​(int year, int month, int date)设置当前日历的年月日
import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //获取对象
        Calendar c = Calendar.getInstance();  //多态形式
        System.out.println(c);

        //public int get(int field)
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1; //因为月份从0开始，所以+1
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");  //2022年1月21日

        //public abstract void add(int field, int amount)	根据日历的规则，将指定的时间量添加或减去给定的日历字
        c.add(Calendar.YEAR, - 3);  //对年份进行加减

        //10年后的5天前
        c.add(Calendar.YEAR , 10);
        c.add(Calendar.DATE, - 5);

        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1; //因为月份从0开始，所以+1
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");  //2032年1月16日
        //public void set(int year, int month, int date)	设置当前日历的年月日
        c.set(2010,1,19);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1; //因为月份从0开始，所以+1
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日"); //2010年2月19日,因为月份从0开始的

    }
}

案例：二月天
需求：获取任意一年的二月有多少天。

思路：
1.键盘录入任意的年份
2.设置日历对象的年、月、日
*年：来自于键盘录入
*月：设置为3月，月份从0开始，所以设置的值为2
*日：设置为1日
3.3月1日往前推一天，就是2月的最后一天
4.获取这一天输出即可

import java.util.Calendar;
import java.util.Scanner;

public class CalendarTest {
    public static void main(String[] args) {
        //键盘录入年份
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份：");
        int year = sc.nextInt();

        //设置年月日
        Calendar c = Calendar.getInstance();
        c.set(year,2,1);  // 3月1日

        //3.1往前推一天
        c.add(Calendar.DATE,-1);

        //获取这一天
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年的2月有" + date + "天");

    }
}
版权声明：本文为weixin_46045873原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。