java常用类

最新推荐文章于 2024-08-15 14:47:41 发布

sw_eet

最新推荐文章于 2024-08-15 14:47:41 发布

阅读量184

点赞数

文章标签： java 类

本文链接：https://blog.csdn.net/sw_eet/article/details/103812997

版权

常用类

Object类

概述
- java.lang.Object类，是java语言的根类，即所有类的父类，他所描述的所有方法，子类都可以使用。在对象实例化的时候，最终找到的父类Object
- 如果一个类没有特别指明父类，那么默认认为继承Object类

toString方法

一个类是否重写了toString方法，直接打印这个对象即可，没有重写会打印堆地址值，重写后会打印属性

package object;

import java.util.Random;
import java.util.Scanner;

/*
java.lang.Object
Object类是所有类的根类，所有类都直接或间接继承他
 */
public class ToString {
    public static void main(String[] args) {
        //Person类默认继承了Object类，所以可以直接使用ToString方法
        // 返回该对象的字符串表示

        Person p = new Person("zhangsan", 18);
        String s = p.toString();
        System.out.println(s);

        //打印对象在堆中的地址值，object.Person@1b6d3586
        //直接打印对象的名字，就是调用toString方法
        //直接打印p，就相当于打印p.toString
        System.out.println(p);

        //看一个类是否重写了toString方法，直接打印这个对象即可，没有重写会打印地址值，重写后会打印属性

        Random random = new Random();
        System.out.println(random);//java.util.Random@4554617c,没有被重写

        Scanner scanner = new Scanner(System.in);
        System.out.println(scanner);//java.util.Scanner[delimiters=\p{javaWhitespace}+][position=0][match valid=false][need input=false][source closed=false][skipped=false][group separator=\,][decimal separator=\.][positive prefix=][negative prefix=\Q-\E][positive suffix=][negative suffix=][NaN string=\Q�\E][infinity string=\Q∞\E]
        //已经被重写了

    }
}

/*
package object;

public class Person {
    private String name;
    private  int age;

    public Person() {
    }

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

    /*
    直接打印对象的堆地址值无意义，我们重写他完成一些其他功能
    打印对象的属性   name    age
     */
    /*
    @Override
    public String toString() {
        //return "ads";

        return "{name=" +name+"   "+"age="+age+"}";
    }
    */

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

 */

equals方法

调用成员方法equals并指定参数为另一个对象，可以判断领个对象是否相同。只要不是同一个对象，结果必为false（布尔值）

1
package object;

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

    /*
    public boolean equals(Object obj) {
        return (this == obj);
    }
    this,那个对象调用的this，则this就代表那个对象
    obj代表传递的参数p2
    this == obj           ------------>      p1==p2

    参数obj可以传递任意的对象
    ==比较运算符
    比较基本类型时，比较的是值
    比较引用类型时，比较的是地址值
     */

        Person p1 = new Person("zhangsan", 18);
        Person p2 = new Person("lisi", 18);
        //打印p1与p2的地址
        System.out.println("p1"+p1);
        System.out.println("p2"+p2);
        boolean a = p1.equals(p2);
        System.out.println(a);

        System.out.println("===========================");
        //把p2的地址值赋值给p1
        p1=p2;
        System.out.println("p1"+p1);
        System.out.println("p2"+p2);
        boolean b = p1.equals(p2);
        System.out.println(b);

    }
}

2
package object;

import java.util.Objects;

public class Person {
    private String name;
    private  int age;

    public Person() {
    }

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

   /*
    Object类的equals方法比较的是对象的地址值，我们重写他，让他比较对象属性的值（name   age）
    问题
        其中隐含着一个多态（父类对象new子类对象）
        多态的弊端无法，无法使用子类的特有属性，因为父类中可能不包含这些属性
        解决，可以使用向下转型（强转）把Object类转换为，Person类

   */


   /* @Override
    public boolean equals(Object obj) {
        //判断传递的参数是否为自己本身，如果是直接返回true，提高程序效率
        if(obj==this){
            return true;
        }
        //判断传递的参数是否为null，如果是直接返回false，提高程序效率
        if(obj==null){
            return false;
        }
        //不是同一类型不能强转，因此我们需要先判断是否为同一类型
        if(obj instanceof Person){
            *//* Person p3=(Person) obj;
        boolean a=this.name==p3.name&&this.age==p3.age;
        return a;*//*

            //使用向下转型把Object转换为Person
            Person p3=(Person)obj;
            //比较两个对象，一个是this.p2   一个是obj(p3)
            return this.name==p3.name&&this.age==p3.age;
        }
        //不是Person类型直接返回false
        return false;

        //可以使用官方的重写方法，Alt+Insert--->equal and hashcode------>
        //下面为方法
    }*/

    @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);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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


3
package object;

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

    /*
    public boolean equals(Object obj) {
        return (this == obj);
    }
    this,那个对象调用的this，则this就代表那个对象
    obj代表传递的参数p2
    this == obj           ------------>      p1==p2

    参数obj可以传递任意的对象
    ==比较运算符
    比较基本类型时，比较的是值
    比较引用类型时，比较的是地址值
     */

        Person p1 = new Person("zhangsan", 18);
        Person p2 = new Person("zhangsan", 18);

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

       /* //打印p1与p2的地址
        System.out.println("p1"+p1);
        System.out.println("p2"+p2);
        boolean a = p1.equals(p2);
        System.out.println(a);

        System.out.println("===========================");
        //把p2的地址值赋值给p1
        p1=p2;
        System.out.println("p1"+p1);
        System.out.println("p2"+p2);
        boolean b = p1.equals(p2);
        System.out.println(b);*/

    }
}

Objects类

在java的JDK7中添加了，Objects工具类，它提供一些方法来操作对象，它由一些静态的方法组成，这些方法是null-save（空指针安全的）或者null-tolerant（能够容忍空指针），用于继续算对象的hashcode，返回对象的字符串表示形式，比较两个对象

比较两个对象时，Object的equals方法容易抛出空指针异常，Objects中的equals方法优化了这个问题

package object;

import java.util.Objects;

public class DemoObjects {
    public static void main(String[] args) {
        String s1="abc";
        String s2="aBc";
        boolean p1 = s1.equals(s2);
        System.out.println(p1);
        System.out.println("=========================");
        s1=null;
        //boolean p2 = s1.equals(s2);//  NullPointerException(出现空指针异常)，null不能调用方法
        /*
        使用Objects里面的equal方法，比较，
         public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
    }
        */
      boolean p2=Objects.equals(s1,s2);
        System.out.println(p2);


    }
}

日期时间类

Date类

java.util.Date类，表示特定的瞬间，精确到毫秒

date拥有多个构造函数，只是部分已经过时，但是其中为过时的构造函数可以把毫秒转化为日期对象

public Date();，分配Data对象并初始化对象，以表示分配他的时间，精确到毫秒
public Date(long data);，分配Data对象并初始化对象，以表示分配自标准基准时间（历元，epoch），即1970.1.1-00：00：00（GMT）以来的毫秒数
由于我们是东八区因此我们是，1970.1.1-08：00：00开始计时
毫秒值的作用，可以对时间日期进行计算，然后转化为日期，1天=146060秒=86400秒=86400000毫秒

总的来说，使用无参构造，可以设置当前系统时间的毫秒时刻。使用long类型构造参数，可以自动以毫秒时刻

1
package date;
/*
毫秒值的作用，可以对时间日期进行计算
可以把日期转换为毫秒，进行计算，计算完毕，再把毫秒转换为日期

注意，中国是东八区，需要加八个小时

把日期转化为毫秒，就是把现在的日期与历元进行比较（1577672377905L）
把毫秒转化为日期，
1天=24*60*60秒=86400秒=86400000毫秒

*/
public class DemoDate {

    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());//获取当前系统的毫秒值System.currentTimeMillis()
    }
}

2
    
package date;

import java.util.Date;

public class DemoDate02 {

    public static void main(String[] args) {
        demo01();
        System.out.println("===================================");
        demo02();
        System.out.println("===================================");
        demo03();
    }
    /*
    long getTime          把日期转换为毫秒相当于System.currentTimeMillis()
    返回在历元至现在Date对象的的毫秒值
     */
    private static void demo03() {
        Date date02 = new Date();
        long time02 = date02.getTime();
        System.out.println(time02);
    }

    /*
        Date类的带参数构造方法
        传递毫秒值，把毫秒制转换为日期
        Date(long date)
    */
    private static void demo02() {
        Date date01 = new Date(1577672377905L);
        System.out.println(date01);
    }
    //Date类的空参数构造方法
    //Date()用于获取当前系统的日期和时间
    private static void demo01() {
        Date date = new Date();
        System.out.println(date);//Mon Dec 30 10:28:13 CST 2019
    }
}

DateFormat类

java.text.DateFormat，是时间日期格式化类子类的抽象类，我们可以通过这个类帮我们完成日期和文本之间的转换，也就是可以在Date对象和String对象之间转化

格式化，按照指定格式，从Date对象转化为String对象
解析，按照指定格式，从String对象转化为Date对象

构造方法

由于DateFormat类是抽象类，不能直接使用，所以需要常用子类java.text.SimpleDateFormat，这个类需要一个格式来指定格式化、解析的标准

public SimpleDateFormat(String pattern)，pattern代表时间日期格式

date1

date2

package date;

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

/*
    DemoForMat是时间、日期的抽象化子类
    作用
        格式化 日期----->文本    解析，文本----->日期
    成员方法
        String format(Date date)   按照指定模式，把Date日期格式化为符合的模式的字符串
        Date parse(String source)   按照指定模式，把字符串D格式化为符合的模式的ate日期
        DateForMat是一个抽象类，无法直接创建对象使用，可以使用DateForMat类的子类SimpleDateFormat
        java.text.SimpleDateFormat
            public class SimpleDateFormat extends DateFormat
       SimpleDateFormat(String pattern)
            使用给定模式 SimpleDateFormat并使用默认的 FORMAT语言环境的默认日期格式符号。
       参数
            String pattern，指定的格式，区分大小写
            y       年
            M       月
            d       日
            H       时
            m       分
            s       秒
            写出对应模式，就会显示为对应模式
            yyyy-MM-dd HH：mm：ss
         注意
              模式中的字母不能改，连接模式的符号可以改
     */
public class DemoForMat {
        public static void main(String[] args) {
            //格式化
            demo01();
            System.out.println("=========================================");
            //解析
            demo02();
        }

    private static void demo02() {
            /*
            Date parse(String source)   按照指定模式，把字符串D格式化为符合的模式的ate日期
            步骤
                1.创建SimpleDateFormat对象，构造方法中指定模式
                2.使用SimpleDateFormat对象中的方法parse，把文本转化为日期
            注意
                public Object parseObject(String source) throws ParseException
                parse申明了一个异常叫做ParseException，解析异常，字符串和我们的构造方法的模式不一样，就抛出异常
             */
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH：mm：ss");
        Date date = new Date();
        String a=simpleDateFormat.format(date);
        try {
            System.out.println(simpleDateFormat.parse(a));
        } catch (ParseException e) {
            e.printStackTrace();
        }

    }


        private static void demo01() {
            /*
             使用DateForMat中的format方法，把文本格式化
             1.创建SimpleDateFormat对象，构造方法中指定模式
             2.使用SimpleDateFormat对象中的方法format，按照构造方法中的指定模式，把Date日期格式转化为符合模式的文本
            */
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH：mm：ss");
            System.out.println(simpleDateFormat.format(System.currentTimeMillis()));
            System.out.println("=========================================");
            Date date = new Date();
            System.out.println(date);
            String s=simpleDat
                eFormat.format(date);
            System.out.println(s);
        }
    }

练习

使用时间相关api，计算一个人出生了多少天

package date;
    /*
    使用时间相关api，计算一个人出生了多少天
    分析
    	1.用Scanner的next取日期字符串
    	2.使用parse把字符串转换为Date格式
    	3.获取历元到当前毫秒值
    	4.历元到你出生的毫秒值
    	5.两值相减，转化为天数
    	
     */

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

public class Demo03 {
    public static void main(String[] args) throws ParseException {
        System.out.println("输入你的出生日期格式，年.月.日");
        Scanner scanner = new Scanner(System.in);
        String day=scanner.next();

        Date date = new Date();
        long time1 = date.getTime();

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd");
        Date parse = simpleDateFormat.parse(day);
        System.out.println(parse);
        long time2 = parse.getTime();
        long time=time1-time2;
        System.out.println(time);
        System.out.println("你出生了"+time/(24*60*60*1000)+"天");
    }
}

Calendar（日历类）

java.text.Calendar，是日历类。在Date类后出现，替换了很多Date的方法。该类将所有能用到的类，封装为静态成员变量，方便获取，日历类方便获取各个时间属性。

抽象类
常用方法
- public int get(int field);，返回给定日历字段的值
- public void set (int field int value);，金给定的日历字段设置为给定的值
- public abstract void add (int field int amount);，根局日历规则，为给定日历添加或减去给定时间量
- public Date getTime();，返回一个Calendar时间值（从历元到现在的的毫秒偏移量）的Date对象

字段值	含义
YEAR	年
MONTH	月
DAY_OF_MONTH	月中的天（几号）

package calendar;

    /*
        java.text.Calendar
        是抽象类，里面提供了很多操作日历字段的方法（YEAR ， MONTH ， DAY_OF_MONTH ， HOUR ）
        Calendar无法直接创建方法使用，里面有一个静态方法，getInstance()，该方法返回了Calendar类的子类对象
        static Calendar getInstance(TimeZone zone, Locale aLocale) 获取具有指定时区和区域设置的日历。
    */

import java.util.Calendar;

public class Demo01 {
    public static void main(String[] args) {
        Calendar instance = Calendar.getInstance();//多态
        System.out.println(instance);
    }
}



package calendar;

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

/*
        public int get(int field);，返回给定日历字段的值
        public void set (int field int value);，金给定的日历字段设置为给定的值
       public abstract void add (int field int amount);，根局日历规则，为给定日历添加或减去给定时间量
        public Date getTime();，返回一个Calendar时间值（从历元到现在的的毫秒偏移量）的Date对象
       参数
             int field      日历类的字段，可以使用calendar的静态成员获取，

    */
public class Demo02 {
        public static void main(String[] args) {
            demo01();
            System.out.println("========================");
            demo02();
            System.out.println("========================");
            demo03();
            System.out.println("========================");
            demo04();
        }

        /*
        public Date getTime();，返回一个Calendar时间值（从历元到现在的的毫秒偏移量）的Date对象
        把日历对象转换为日期对象
        */
    private static void demo04() {
        Calendar instance = Calendar.getInstance();
        Date time = instance.getTime();
        System.out.println(time);
    }

    /*
     public abstract void add (int field int amount);，根局日历规则，为给定日历添加或减去给定时间量
    */
    private static void demo03() {
        Calendar instance = Calendar.getInstance();
        int i = instance.get(Calendar.YEAR);
        System.out.println(i);
        instance.add(Calendar.YEAR,2);
        int i1 = instance.get(Calendar.YEAR);
        System.out.println(i1);
        int i3 = instance.get(Calendar.MONTH);
        System.out.println(i3);
        instance.add(Calendar.MONTH,-2);
        int i2 = instance.get(Calendar.MONTH);
        System.out.println(i2);
    }

    /*
     public void set (int field int value);，金给定的日历字段设置为给定的值
    */
    private static void demo02() {
        Calendar instance = Calendar.getInstance();
        instance.set(Calendar.YEAR,2222);
        int i = instance.get(Calendar.YEAR);
        System.out.println(i);

        //同时设置年月日
        instance.set(3333,2,21);//set方法重载
    }

    /*
    public int get(int field);，返回给定日历字段的值
    */
        private static void demo01() {
            //使用getIntance方法获取calendar对象
            Calendar instance = Calendar.getInstance();
            int i = instance.get(Calendar.YEAR);
            System.out.println(i+"年");
            int i1 = instance.get(Calendar.MONTH);
            System.out.println(i1+1+"月");//西方的月份是0----7
            int i2 = instance.get(Calendar.DAY_OF_MONTH);
            System.out.println(i2+"号");
            int i4 = instance.get(Calendar.DAY_OF_WEEK_IN_MONTH);
            System.out.println("这个月的第"+i4+"个周");
            int i3 = instance.get(Calendar.DAY_OF_WEEK);//星期
            System.out.println("这个周的第"+i3+"天");
        }
    }

System类

java.lang.System，里面包含了大量静态方法。可以获取与系统相关的操作、系统的信息。

常用方法

static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)` 将指定源数组中的数组从指定位置复制到目标数组的指定位置。
static long currentTimeMillis()` 返回当前时间（以毫秒为单位）。

package system;

import java.sql.SQLOutput;
import java.util.Scanner;

/*
- static void arraycopy(Object src,  int srcPos, Object dest, int destPos,  int length)`  将指定源数组中的数组从指定位置复制到目标数组的指定位置。

- static long  currentTimeMillis()`  返回当前时间（以毫秒为单位）。
*/
public class Demo01 {
    public static void main(String[] args) {

        demo01();
        System.out.println("=================");
        demo02();//数组复制
    }

    /*
     static void arraycopy(Object src,  int srcPos, Object dest, int destPos,  int length)`
     src - 源数组。
    srcPos - 源数组中的起始位置。
    dest - 目标数组。
    destPos - 目的地数据中的起始位置。
    length - 要复制的数组元素的数量。
    */
    private static void demo02() {
        int[] a={1,2,3,4,5,6,7,8,9};
        int[] b={1,11,111,1111,11111,111111};
        System.arraycopy(b,2,a,3,2);
        for (int i : a) {
            System.out.println(i);
        }
    }

    /*
   static long  currentTimeMillis()`  返回当前时间（以毫秒为单位）。
    计算运算耗费时间
    */
    private static void demo01() {
        //打印1----99999所用时间
        long a=System.currentTimeMillis();
        for (int i = 0; i <= 9999; i++) {
            System.out.println(i);
        }
        long a1=System.currentTimeMillis();
        System.out.println(a1-a);
    }
}

StringBuilder

String类
- 由于String类的对象内容不可改变。所以每当字符串拼接时总是在内存中建立新的对象。
- 字符串的底层是一个被final修饰的数组，是一个常量

例，String s=“a”+“b”+“c”；，内存中会出现5个字符串，“a”、“b”、“c”、“ab”、“abc”

StringBuilder
- 字符串缓冲区，提高效率（可以看成一个字符串可以变化的数组）
- 底层是一个数组，但没有被final修饰，可变长
- StringBuilder的初始容量是16bit，超出了自动增加16
- StringBuilder在组合是一个数组，占用空间少

1
    package stringbuild;

    /*
    java.lang.StringBuilder            字符串缓冲区，可以提高字符串效率
    构造方法
            StringBuilder()             构造一个没有字符的字符串构建器，初始容量为16个字符。
            StringBuilder(String str)   构造一个初始化为指定字符串内容的字符串构建器。
    */

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

        StringBuilder stringBuilder = new StringBuilder();
        System.out.println("gsyugyu"+stringBuilder);

        StringBuilder huiheduihdui = new StringBuilder("huiheduihdui");
        System.out.println("ghuihuiwyiuwh"+huiheduihdui);
    }
}

2
    package stringbuild;

    /*
        StringBuilder常用方法
               append添加任意类型的字符串形式，返回当前对象本身
    */
public class Demo02 {
        public static void main(String[] args) {

            //创建StringBuild对象
            StringBuilder stringBuilder = new StringBuilder();
            //使用append方法添加数据
            //append返回的是this，this==stringBuilder
            StringBuilder hsuhui = stringBuilder.append("hsuhui");

            System.out.println(stringBuilder==hsuhui);//引用类型比较地址

            stringBuilder.append(1111);
            stringBuilder.append("juifhuifjiuj");
            stringBuilder.append(false);
            stringBuilder.append(10.25);
            System.out.println(stringBuilder);

            //链式编程，方法的返回值是一个对象可以继续调用
            stringBuilder.append(1111).append("juifhuifjiuj").append(false).append(10.25);
            System.out.println(stringBuilder);
        }
}

3
    package stringbuild;

    /*
    StringBuilder和String相互转化
        String——>StringBuilder       可以使用StringBuilder的构造方法
         StringBuilder(String str)   构造一个初始化为指定字符串内容的字符串构建器。
        StringBuilder---->String      使用 StringBuilder 的toString方法
    */
public class Demo03 {
        public static void main(String[] args) {
            String a="hello";
            StringBuilder stringBuilder = new StringBuilder(a);
            stringBuilder.append(" world");
            System.out.println(a+stringBuilder);

            String s = stringBuilder.toString();
            System.out.println(s);
        }
}

Random

package random;

import java.util.Random;

/*
    Random类，用来产生随机数字
    使用
        1.导包
        2.创建
        Random r=new Random();   小括号留空即可
        3.使用
        获取一个随机的int类型数字  r.nextInt();     范围为int所有范围，有正负
       获取一个随机的int类型数字  r.nextInt(3);     参数代表范围，左闭右开区间[0,3)
    */
public class Demo01 {
        public static void main(String[] args) {
            Random random = new Random();
            System.out.println(random.nextInt());

            System.out.println(random.nextInt(6));
        }
}

2 
    package random;

import java.util.Random;
import java.util.Scanner;

/*
    练习，猜数字游戏      二分法查找
    */
public class Text {
        public static void main(String[] args) {
            Random random = new Random();
            int a=1+random.nextInt(100);
            System.out.println("随机数是"+a);
            System.out.println("===+++++开始查找+++++===");

            Scanner scanner = new Scanner(System.in);

            int j=0;
            while (true){
                j++;
                int i = scanner.nextInt();
                if(a==i){
                    System.out.println("猜对了,你猜了"+j+"次");
                    break;
                }
                if(i>a){
                    System.out.println("猜大了");
                }else{
                    System.out.println("猜小了");
                }

            }
            scanner.close();
        }

}

Arrays工具类

package arrays;

import java.util.Arrays;

/*
    java.util.Arrays，是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见操作
    public static String toString(数组)   按照默认格式，将参数数组变成字符串
    public static void sort(数组)            数组按升序排序

    备注
        1.如果是数值，按照数字升序排列
        2.如果是字母按照字母升序排列
        3.如果是自定义类型，那么自定义类需要comparable或者comparator接口的支持
    */
public class Demo01 {
        public static void main(String[] args) {
            int[] a={1,5,3,6,4,8,9,7};
            String s= Arrays.toString(a);
            System.out.println(s);
            Arrays.sort(a);
            String s1=Arrays.toString(a);
            System.out.println(s1);

            String[] b={"b","d","c","a"};
            System.out.println(Arrays.toString(b));
            Arrays.sort(b);
            System.out.println(Arrays.toString(b));
        }
}

Math类

package math;

    /*
    java.lang.Math，数学相关的工具类，里面有大量与数学相关的静态方法，完成与数学相关的运算
    static double abs(double a)     返回值为 double绝对值。
    static double ceil(double a)    向上取整
    static double floor(double a)    向下取整
    static long round(double a)      四舍五入
    */


    /*
    计算绝对值-10.5到4.1之间，绝对值大于6.绝对值小于2的有几个数
    */
public class Demo01 {
        public static void main(String[] args) {
            double a=-10.5;
            int z=0;
            int y=0;
            for ( ; a < 4.1; a+=1) {
                double i=a;
                a=Math.ceil(a);
                a=Math.abs(a);
                if(a<0){
                    if(a>6){
                       z++;
                    }else if(a<2){
                        y++;
                    }
                }

                if(a>0){
                    if(a>6){
                        z++;
                    }else if(a<2){
                        y++;
                    }
                }
                a=i;
            }
            System.out.println("大于6的有"+z+"个"+"小于2的有"+y+"个");

        }
}

包装类

java提供两个类型系统，基本类型和引用类型。使用基本了类型在于效率，然而很多时候，会对象使用。因为对象可以做更多的功能。若果我妈们想要基本类型像对象一样使用，就可以使用基本类型对应的包装类。

基本类型	对应包装类（java.lang包）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

基本数据类型使用起来很方便，但是没有对应的方法来操作这些基本数据类型，可以使用一个类把数据类型装起来，在类中定义一些方法，这个类叫基本类。我们可以使用类中的方法来操作这些基本类型的数据。

装箱与拆箱

基本类型与对应包装类转换的过程称为装箱与拆箱。

装箱，从基本类型转换为对应的包装类对象
拆箱，从包装类对象转换为对应的基本类型

//基本类型---->包装对象
Integer i=new Integer(4);    //使用构造函数
Integer ii=Integer.valueOf(4);    //使用包装类的valuaOf方法
//包装对象---->基本类型
int n=i.intvalue();

package classtext01;

/*
- 装箱，从基本类型转换为对应的包装类对象
构造方法
Integer(int value)     构造一个新分配的 Integer对象，该对象表示指定的 int值。
Integer(String s)      构造一个新分配 Integer对象，表示 int由指示值 String参数。
传递的字符串必须是基本类型的字符串，不然会抛出异常  例"1000"
静态方法
static Integer valueOf(String s)     返回一个 Integer对象，保存指定的值为 String 。
static Integer valueOf( int i)     返回一个 Integer对象，保存从指定的String中 String的值，当用第二个参数给出的基数进行解析时。

 - 拆箱，从包装类对象转换为对应的基本类型
 成员方法
 int intValue()    将 Integer的值作为 int 。
*/
public class Demo01 {
    public static void main(String[] args) {

        Integer integer = new Integer(1);
        System.out.println(integer);//1    重写了toString方法
        Integer integer1 = new Integer("1");
        System.out.println(integer1);

        Integer integer2 = Integer.valueOf(1);
        System.out.println(integer2);
        Integer integer3 = Integer.valueOf("1");
        //Integer integer3 = Integer.valueOf("a");//.NumberFormatException(数字格式化异常)
        System.out.println(integer3);

        //拆箱
        int i=integer.intValue();
        System.out.println(i);
    }
}

自动拆箱装箱

package classtext01;

    /*
    自动拆箱与自动装箱，基本类型与包装类型自动进行转换
    JDK1.5之后的新特性
    */
public class Demo02 {
        public static void main(String[] args) {

            //自动装箱   把int类型的赋值给包装类
            Integer i=1;//       Integer i=new Integer(1);

            //自动拆箱  i是包装类无法直接进行运算，但是可以自动转换为基本类型进行运算
            i=i+2;//               int i=intValue(i)+2;
        }
}

基本类型与字符串之间的转换

package classtext01;

    /*
    基本类型与字符串类型之间的转化
    基本类型---->字符串
        1.基本类型的值+""（空字符串）
        2.包装类的静态方法toString（参数）
        3.String类的静态方法valueOf（方法）
    字符串---->基本类型
        使用包装类的静态方法parseXXX("数值类型的字符串")
        Integer类      static int parseInt(String s);
        Double类       static doule parseDouble(String s);


    */
public class Demo03 {
        public static void main(String[] args) {
            int i=100;
            String s=i+"";
            System.out.println(s+222);
            String s1=Integer.toString(100);
            System.out.println(s1+222);
            String s2 = String.valueOf(100);
            System.out.println(s2+222);

            int i1 = Integer.parseInt(s2);
            System.out.println(i1-1);
        }
}

File类

概述

java.io.File，文件和目录路径名的抽象表示，主要用于文件和目录的创建，查找、删除等操作。

package filetext01;

import java.io.File;

/*
    java.io.File
    文件和目录路径名的抽象表示
    java把电脑中的文件和文件夹封装为一个File类，我们可以使用File类对文件和文件夹进行操作
    我们可以使用File类的方法
        创建文件、文件夹
        删除文件、文件夹
        获取文件、文件夹
        判断文件、文件夹是否存在
        对文件夹遍历
        获取文件大小
    File类是一个与系统无关的类，任何操作系统都可以使用其中的方法

    重点记忆
        file   文件
        directory     文件夹
        path    路径
    */
public class Demo01 {
        public static void main(String[] args) {

            /*
            static String pathSeparator      与系统相关的路径分隔符字符，为方便起见，表示为字符串。
            static char pathSeparatorChar    与系统相关的路径分隔符。
            static String separator          与系统相关的默认名称 - 分隔符字符，以方便的方式表示为字符串。
            static char separatorChar        与系统相关的默认名称分隔符。

            操作路径不要写死
            windows     "F:\makedown"
            Linux       "F:/makedown"
            通用        "F:"+File.separator+"makedown"

             */

            String pathSeparator = File.pathSeparator;
            System.out.println(pathSeparator);   //路径分隔符  windows ;(分号)  Linux  :(冒号)

            String separator = File.separator;
            System.out.println(separator);//文件名称分隔符    windows\(反斜杠)  Linux  /(正斜杠)


        }
}

相对路径与绝对路径

package filetext01;

import java.io.File;

/*
        路径
            绝对路径，是一个完整的路径
                以盘符开始的路径             F:\makedown\day05.md
            相对路径，是一个简化的路径
                相对于当前项目的根目录（F:\makedown\day05.md）
                如果使用当前项目的根目录，路径可以简化书写F:\makedownday05.md简化为day05.md(可以省略项目的根目录)
            注意
                1.路径不区分大小写
                2.路径中的分隔符在windows中为，反斜杠（\）,但是\为转义字符，所以要写两次
    */
public class Demo02 {
        public static void main(String[] args) {
            /*
            File类的构造方法
            */
            show01();
            show02("c:","a.txt");
            show03();
        }
    /*
    File(File parent, String child)   从父抽象路径名和子路径名字符串创建新的 File实例。
     参数，把路径分成了两部分
             String parent，父路径
             String child，子路径
     好处
         父路径和子路径可以单独书写，使用起来非常灵活，子路径父路径都可以变化
         父路径是File类型，可以使用File方法对路径进行一些操作，在使用路径创建对象
    */
    private static void show03() {
        File parent = new File("c:");
        File file = new File(parent,"hello");
        System.out.println(file);
    }

    /*
         File(String parent, String child)   从父路径名字符串和子路径名字符串创建新的 File实例。
         参数，把路径分成了两部分
             String parent，父路径
             String child，子路径
         好处
             父路径和子路径可以单独书写，使用起来非常灵活，子路径父路径都可以变化

    */
    private static void show02(String parent, String child) {
        File f3 = new File(parent,child);
        System.out.println(f3);
    }

    /*
    File(String pathname)   通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
    参数
        pathname路径名
        路径可以是以文件结尾，也可以是文件夹结尾
        路径可以是相对路径也可以是绝对路径
        路径可以是存在的也可以是不存在的
        创建File对象，只是把字符串封装为File对象，不考虑路径的真假情况
    */
        private static void show01() {
            File f1=new File("F:\\makedown\\a.txt");
            System.out.println(f1);//重写了toString方法

            File f2 = new File("F:\\makedown");
            System.out.println(f2);

            File f3 = new File("b.txt");//相对路径
            System.out.println(f3);
        }
    }

常用方法

package filetext01;

import java.io.File;

/*
    public String getName()     返回由此抽象路径名表示的文件或目录的名称。
    public String getAbsolutePath()     返回此抽象路径名的绝对路径名字符串。
    public String getPath()       将此抽象路径名转换为路径名字符串。
    public long length()         返回由此抽象路径名表示的文件的长度。 如果此路径名表示目录，则返回值未指定。
    */
public class Demo03 {
        public static void main(String[] args) {
            show01();
            show02();
            show03();
            show04();
        }

    /*
    public long length()         返回由此抽象路径名表示的文件的长度。 如果此路径名表示目录，则返回值未指定。
    获取得是构造方法指定文件的大小，以字节为单位
    注意
        1.文件夹没有大小概念，不能获取文件夹大小
        2.如果构造方法中的文件不存在，返回0
    */
    private static void show04() {
        File f1 = new File("E:\\图片\\000000000.png");
        long length = f1.length();
        System.out.println(length);

    }

    /*
   public String getName()     返回由此抽象路径名表示的文件或目录的名称。
   获取的就是构造方法的传递路径的结尾部分（文件或文件夹）
    */
    private static void show03() {
        File f1 = new File("F:\\java-code\\com.a\\a.txt");
        String name = f1.getName();
        System.out.println(name);

        File f2 = new File("F:\\java-code\\com.a");
        String name1 = f2.getName();
        System.out.println(name1);
    }


    /*
    public String getPath()       将此抽象路径名转换为路径名字符串。
    相对的就返回相对的，绝对的就返回绝对的
    toString方法调用的就是getPath方法
    */
    private static void show02() {
        File f1 = new File("F:\\java-code\\com.a\\a.txt");
        File f2 = new File("a.txt");
        String path = f1.getPath();
        System.out.println(path);
        String path1 = f2.getPath();
        System.out.println(path1);

    }

    /*
    public String getAbsolutePath()     返回此抽象路径名的绝对路径名字符串。
    获取构造方法中传输的路径
    无论路径是绝对的还是相对的getAbsolutePath()方法返回的都是绝对的
    */
        private static void show01() {
            //根目录是F:\java-code\com.a
            File f1 = new File("F:\\java-code\\com.a\\a.txt");
            String absolutePath1 = f1.getAbsolutePath();
            System.out.println(absolutePath1);

            File f2 = new File("a.txt");
            String absolutePath2 = f2.getAbsolutePath();
            System.out.println(absolutePath2);
        }
    }

File类判断功能方法

package filetext01;

import java.io.File;

/*
    Filer判断功能方法
        public boolean exists()          测试此抽象路径名表示的文件或目录是否存在。
        public boolean isDirectory()     测试此抽象路径名表示的文件是否为目录。
        public boolean isFile()          测试此抽象路径名表示的文件是否为普通文件。
    */
public class Demo04 {
    public static void main(String[] args) {
        show01();
        show02();
    }

    /*
     public boolean isDirectory()     测试此抽象路径名表示的文件是否为目录。
     判断构造方法中的路径是否以文件结尾
        是，true
        否，false
     public boolean isFile()          测试此抽象路径名表示的文件是否为普通文件。
     判断构造方法中的路径是否以文件结尾
        是，true
        否，false
     注意
        硬盘中只有文件夹和文件，两个方法是互斥的
        这两个方法的路径都必须存在，不然返回false
    */
    private static void show02() {

        File f2 = new File("E:\\图片\\000000000.png");
        if(f2.exists()) {
            //判断一下文件夹是否存在
            System.out.println(f2.isFile());
            System.out.println(f2.isDirectory());
        }
        File f3 = new File("E:\\图片");
        if(f3.exists()) {
            //判断一下文件夹是否存在
            System.out.println(f3.isFile());
            System.out.println(f3.isDirectory());
        }
    }

    /*
     public boolean exists()          测试此抽象路径名表示的文件或目录是否存在。
     判断构造方法中的路径是否存在
        存在，true
        不存在，false
    */
    private static void show01() {
        File f1 = new File("E:\\图片\\000000000.png");
        System.out.println(f1.exists());//true

        File f2 = new File("E:\\图片\\00000.png");
        System.out.println(f2.exists());//false

        File f3 = new File("com.a.iml");
        System.out.println(f3.exists());//true

    }
}

File类创建删除功能方法

package filetext01;

import java.io.File;
import java.io.IOException;

/*
    File类创建删除文件夹或文件
        public boolean createNewFile()    当且仅当具有该名称的文件尚不存在时，创建一个由该抽象路径名命名的新的空文件。
        public boolean delete()           删除由此抽象路径名表示的文件或目录。
        public boolean mkdir()            创建由此抽象路径名命名的目录。
        public boolean mkdirs()           创建由此抽象路径名命名的目录，多级文件夹
    */
public class Demo05 {
        public static void main(String[] args) throws IOException {
            show01();
            show02();
            show03();
        }

    /*
    public boolean delete()           删除由此抽象路径名表示的文件或目录。
    此方法可以删除构造路径中的文件或文件夹
    返回值  布尔
        true，文件或文件夹删除成功，返回true
        false，文件夹中有文件不会删除返回false，构造方法中的路径不存在也返回false
    注意
        delete方法是直接在硬盘删除，不经过回收站，删除请谨慎
    */
    private static void show03() {
        File f1 = new File("F:\\java-code\\com.a\\qwe");
        System.out.println(f1.delete());
    }

    /*
    public boolean mkdir()            创建由此抽象路径名命名的目录。单级空文件夹
    public boolean mkdirs()           创建由此抽象路径名命名的目录，多级空文件夹也可单级空
    返回值   布尔
        true，文件夹不存在，创建文件夹，返回true
        false，文件夹存在，不创见文件夹，返回false   构造方法中的路径不存在也返回false
    注意
        1.此方法只能创建文件夹，不能创建文件
    */
    private static void show02() {
        File f1 = new File("F:\\java-code\\com.a\\qwe");
        System.out.println(f1.mkdir());

        File f2 = new File("F:\\java-code\\com.a\\111\\222\\333");
        System.out.println(f2.mkdirs());
    }

    /*
     public boolean createNewFile()    当且仅当具有该名称的文件尚不存在时，创建一个由该抽象路径名命名的新的空文件。
     创建文件的路径在构造方法中给出
     返回值   布尔
        true，文件不存在，创建文件，返回true
        false，文件存在，不创见文件，返回false
      注意
        1.此方法只能创建文件，不能创建文件夹
        2.创建文件的路径必须存在，不然会抛出异常
        public boolean createNewFile() throws IOException
        我们使用这个方法就需要处理这个异常，要么throws要么try catch
    */
        private static void show01() throws IOException {
            File f1 = new File("F:\\java-code\\com.a\\a.txt");
            boolean newFile = f1.createNewFile();
            System.out.println(newFile);

            //相对路径
            File f2 = new File("1.txt");
            System.out.println(f2.createNewFile());
        }
    }

File类遍历目录功能

package filetext01;

import java.io.File;

/*
    public String[] list(FilenameFilter filter)     返回String数组，表示File目录中所有字文件和目录
    public File[] listFiles()                        返回File数组，表示File目录中所有字文件和目录
    注意
        listFiles()方法和list() 方法，遍历构造方法中给出目录
        如果给出的目录的路径不存在，那么就会抛出空指针异常
        如果构造方法中给出的不是一个目录，那么就会抛出空指针异常
        隐藏的文件或文件夹也会显示
    */
public class Demo06 {
        public static void main(String[] args) {
            show01();
            show02();
        }

    /*
     public File[] listFiles()                        返回File数组，表示File目录中所有字文件和目录
    */
    private static void show02() {
        File f1 = new File("F:\\java-code\\com.a");
        File[] files = f1.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    }

    /*
     public String[] list(FilenameFilter filter)     返回String数组，表示File目录中所有字文件和目录
     遍历构造目录中文件或文件夹的名称
    */
        private static void show01() {
            File f1 = new File("F:\\java-code\\com.a");
            String[] list = f1.list();
            for (String s : list) {
                System.out.println(s);
            }
        }
    }

快捷键

idea中查看方法参数;查看类、方法、属性注释

Ctrl+P：查看方法参数
Ctrl+Q：查看类、方法、属性注释

sw_eet

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java常用类

常用类Object类概述java.lang.Object类，是java语言的根类，即所有类的父类，他所描述的所有方法，子类都可以使用。在对象实例化的时候，最终找到的父类Object如果一个类没有特别指明父类，那么默认认为继承Object类toString方法一个类是否重写了toString方法，直接打印这个对象即可，没有重写会打印堆地址值，重写后会打印属性package...
复制链接

扫一扫