java常用类介绍

最新推荐文章于 2024-08-23 00:00:00 发布

一克粽子

最新推荐文章于 2024-08-23 00:00:00 发布

阅读量585

点赞数 17

文章标签： java 开发语言

本文链接：https://blog.csdn.net/excavatio/article/details/140642890

版权

学习地址

实用类介绍

能定义并使用枚举类型
掌握包装类及装箱，拆箱概念
会使用math类进行数学运算
会使用random类获取随机数

实用类介绍1

枚举

枚举是由一组固定的常量组成的类型

通过enum关键字进行声明

枚举的好处

类型安全
易于输入
代码清晰

访问修饰符 enum 名字{

声明常量

}

例：public enum Genders{

Male,Female

}

使用

public class Student{

public Genders sex;

}

Student stu=new Student();

stu.sex=Genders.Male;

stu.sex=“你好”;//就会报错

实现

package day01;

public class Students {
    public Genders sex;//学员性别

    public static void main(String[] args) {
        Students stu=new Students();
        //类型安全，易于输入，赋值
        //确保赋值的正确性
        //代码清晰
        stu.sex=Genders.男;
    }
}
package day01;

public enum Genders {
    男,女
}

枚举的使用

需求：输入今天星期几，对用户一周要做的事情做提示

一般思路
package day01;
//用户一周做什么事情
public class WeekDo {
    public void doWhat(int day){
        //对用户输入的星期几做判断
        if(day>7||day<1){
            System.out.println("输入不合理，输入必须在1-7之间");
            return;
        }
        switch (day){
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("工作日，请努力工作，加油");
                break;
            case 6:
                System.out.println("工作了一周辛苦了，休息一下吧");
                break;
            case 7:
                System.out.println("放松一下，为下周工作做准备吧");
                break;
        }
    }

    public static void main(String[] args) {
        WeekDo week=new WeekDo();
        week.doWhat(7);
        
    }
}

枚举修改

package day01;
//用户一周做什么事情
public class WeekDo {
    public void doWhat(Week day){
        //对用户输入的星期几做判断
        switch (day){
            case MON:
            case TUE:
            case WED:
            case THU:
            case FRI:
                System.out.println("工作日，请努力工作，加油");
                break;
            case SAT:
                System.out.println("工作了一周辛苦了，休息一下吧");
                break;
            case SUN:
                System.out.println("放松一下，为下周工作做准备吧");
                break;
        }
    }

    public static void main(String[] args) {
        WeekDo week=new WeekDo();
        week.doWhat(Week.FRI);

    }
}
package day01;

public enum Week {
    MON,TUE,WED,THU,FRI,SAT,SUN
}

需求

为同学们java学习阶段定义枚举：L1,L2,L3，分别表示第一，二，三阶段

编程输出每个阶段的学习目标

L1:Java开发工程师

L2:大数据开发工程师

L3:大数据挖掘工程师

package day01;
public enum JieDuan {
    L1,L2,L3
}

package day01;
public class Meijueceshi {
    public void xuexi(JieDuan n){
        switch (n){
            case L1:
                System.out.println("Java开发工程师");
                break;
            case L2:
                System.out.println("大数据开发工程师");
                break;
            case L3:
                System.out.println("大数据挖掘工程师");
                break;
        }
    }
    public static void main(String[] args) {
        Meijueceshi jieduan=new Meijueceshi();
        jieduan.xuexi(JieDuan.L1);
        //JieDuan jd=JieDuan.L1;
        //jieduan.xuexi(jd);
    }
}

包装类及其构造方法

掌握包装类及其作用
掌握包装类的两种构造方法

包装类：把基本数据类型转换为对象

基本类型都在java.lang包里面有一个相应的包装类

包装类作用：

提供一系列实用的方法
集合不允许存放基本数据类型，存放数字时，就可以使用包装类型

package day01;
public class Test2 {
    public static void main(String[] args) {
        //包装类的构造方法
        //1.以每个包装类对应的基本类型作为参数
        //基本类型-----包装类
        int i=9;
        Integer i1=new Integer(i);
        double d=9.8;
        Double D1=new Double(d);
        char c='c';
        Character c1=new Character(c);
        float f=9.8f;
        Float f1=new Float(f);
        boolean b=true;
        Boolean b1=new Boolean(b);

        //2.以字符串做参数，除了Character
        //当number类型的包装类构造方法的字符串，必须能转换成number的字串
        //字符串不能为null
        Integer i2=new Integer("123");
        System.out.println(i2+1);//124，不是1231
        Double D2=new Double("87.9");
        System.out.println(D2+1);//88.9，不是87.91
        Float f2=new Float("9.8");
        System.out.println(f2+1);//10.8,不是9.81
        Boolean b2=new Boolean("true");
        System.out.println(b2);//true
        Boolean b3=new Boolean("false");
        System.out.println(b3);//false
        //无论是否是大小写的true都是true
        Integer i3=new Integer("love");
        System.out.println(i3);//异常
        Integer i4=new Integer("null");
        System.out.println(i4);//异常
        Integer i5=new Integer(null);
        System.out.println(i5);//异常
        //Character c2=new Character("a");
        //报错character没有这种构造方法
    }
}

包装类的两种常用的构造方法

参数为基本数据类型
参数为字符串

包装类的常用方法1

包装类的常用方法

XXXValue():包装类转换成基本类型
toString()：基本类型到字符串

package day01;

public class Test2 {
    public static void main(String[] args) {
        //XXXValue()，把包装类转换成基本数据类型
        Integer i=new Integer(100);
        int inum=i.intValue();
        Boolean b=new Boolean(true);
        boolean b1=b.booleanValue();

        //toString(),以字符串的形式返回包装对象表示的基本类型数据
        int num=100;
        String snum=Integer.toString(num);
        
        boolean b3=true;
        String s=Boolean.toString(b3);
        //常用的方法：基本类型到字符串
        boolean b4=true;
        String s2=true+"";
    }
}

包装类的常用方法2

常用方法

parseXXX():把字符串转成相应的基本数据类型（Character除外）
valueOf()：基本类型转换成包装类
- 基本类型作参数：所有包装类都有
- 字符串作参数：除了Character其他的都有

//3.parseXXX()字符串转成基本数据类型,character没有这个方法
String age="19";
int agenum=Integer.parseInt(age);
String score="90.1";
double score1=Double.parseDouble(score);
String sc="女";
//char csc=Character.parseChar(sc);
//编译报错，不存在这个方法

//4、valueOf()基本类型转换成包装类
//基本类型作参数,都有
int j=90;
Integer j1=Integer.valueOf(j);
char  sex='男';
Character sex1=Character.valueOf(sex);
//字符串作参数，character没有这个方法

String m="123";
Integer m1=Integer.valueOf(m);
//注意：包装类为number类型，参数字符串必须是数字兼容的字符串
String m2="love";
//Integer m13=Integer.valueOf(m);
//报错，不兼容
//注意：出了参数内容为true，其他都是false
String flag="true";
String flags="True";
String flags1="false";
String flags12="china";
Boolean bflag=Boolean.valueOf(flag);//true
Boolean bflags=Boolean.valueOf(flags);//true
Boolean bflags1=Boolean.valueOf(flags1);//false
Boolean bflags12=Boolean.valueOf(flags12);//false
String  sex11="男";
//Character sex12=Character.valueOf(sex11);
//报错，character不存在字符串的valueOf方法

装箱和拆箱

掌握什么是装箱和拆箱

基本类型和包装类的自动转换

装箱：基本类型转换成包装类的对象

Integer intObject=5;

拆箱：包装类独享转换成基本类型值

int intValue=intObject;

package day01;
import java.util.ArrayList;
import java.util.List;
public class Test2 {
    public static void main(String[] args) {
        //1.XXXValue()，把包装类转换成基本数据类型，自动转换，拆箱
        Integer i=new Integer(100);
        //int inum=i.intValue();
        int inum=i;//拆箱

        //4、valueOf()基本类型转换成包装类，自动转换，装箱
        //基本类型作参数,都有
        int j=90;
        //Integer j1=Integer.valueOf(j);
        Integer j1=j;//装箱
        
        //集合只能存储包装类型
        List list=new ArrayList();
        int num=100;
        Integer numinter=new Integer(num);
        list.add(numinter);
        list.add(num);//自动进行装箱
    }
}

JDK1.5之后允许基本数据类型和包装类混用计算

包装类不是用来取代基本数据类型的

在基本数据类型需要用对象表示时使用

Math类

java.lang.Math类提供了常用的数学运算方法和两个静态常量E（自然对数的底数）和PI（圆周率）

Math.abs(-3.5)//3.5，求绝对值

Math.max(10,20)//20，求最值

package day01;

import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) {
        System.out.println(Math.abs(-1.5));
        System.out.println(Math.max(10,25));
        System.out.println(Math.min(-1,10));
        //生成0.0到1.0之间的随机数（包括0）
        //System.out.println(Math.random());
        //幸运抽奖，生成0-9之间的随机数
        int random=(int) (Math.random()*10);
        System.out.println("系统生成的随机数是"+random);
        Scanner input=new Scanner(System.in);
        System.out.println("请输入你的私我会员卡号：");
        int no=input.nextInt();
        //会员卡号的百位==随机数就中奖
        int baiwei =no/100%10;
        if(baiwei==random){
            System.out.println("恭喜你中奖了");
        }
        else {
            System.out.println("谢谢参与");
        }
    }

}

random类

random类位于java.util.random中

需要创建一个对象

Random rand=new Random();

调用方法

package day01;
import java.util.Random;
public class Test2 {
    public static void main(String[] args) {
        //创建random的对象(随机数生成器）
        //随机数生成器种子不同，每次生成的随机数是不同的
        //随机数种子相同，每次生成的随机数都是相同的
        Random random1 =new Random(500);
        Random random2 =new Random(500);
        //生成随机整数int范围内
        System.out.println(random1.nextInt(20));
        //生成随机整数0-10范围内
        System.out.println(random2.nextInt(10));
    }
}

常用写法：

Random random1 =new Random()；

Random random1 =new Random(时间的毫秒数);

实用类介绍2

掌握如何操作字符串
- 会使用string类
- 会使用stringBuffer类
掌握如何操作日期和时间
- 会使用date类花蕊calendar类操作日期时间
- 会使用simpledateformat类格式化日期时间

string类的length（）方法

使用string对象存储字符串

string类提供的方法：

计算字符串长度
比较字符串内容
连接字符串
提取字符串

string类提供了length（）方法，获取字符串长度

返回字符串中的字符数

package day01;

import java.util.Scanner;

//用户注册，密码不小于6位
public class Register {
    public static void main(String[] args) {
        Scanner input =new Scanner(System.in);
        System.out.println("请输入用户名");
        String name=input.next();
        System.out.println("请输入密码");
        String pwd=input.next();
        if(pwd.length()<6){
            System.out.println("密码不能少于6位");
        }
        else {
            System.out.println("注册成功");
        }
    }
}

只能判断一次，进行一次输入。修改成输入大于6位成功退出

package day01;

import java.util.Scanner;

//用户注册，密码不小于6位
public class Register {
    public static void main(String[] args) {
        Scanner input =new Scanner(System.in);
        System.out.println("请输入用户名");
        String name=input.next();
        System.out.println("请输入密码");
        String pwd=input.next();
        do{
            System.out.println("密码不能少于6位");
            System.out.println("请输入密码");
            pwd=input.next();
        }while(pwd.length()<6);
        System.out.println("注册成功！");
    }
}

string的equals（）方法

string的equals（）方法，比较存储在两个字符串对象的内容是否一致

package day01;

import java.util.Scanner;

//用户注册，密码不小于6位
public class Register {
    public static void main(String[] args) {
        Scanner input =new Scanner(System.in);
        System.out.println("请输入用户名");
        String name=input.next();
        System.out.println("请输入密码");
        String pwd=input.next();
        //假设数据库已经存储了用户成功注册的用户名TOM,密码1234567
        if(name.equals("TOM")&&pwd.equals("1234567")){
            System.out.println("登陆成功");
        }
        else {
            System.out.println("用户名和密码不匹配，登录失败");
        }
        //==基本数据类型的值是否相等
        int i=8;
        int j=8;
        System.out.println(i==j);//t
        //字符串比较方法：equals（）比较两个字符串内容是否相等
        //字符串的==，比较两个字符串的内存地址是否相等
        String s1="hello";
        String s2="hello";
        //以上2行代码创建了1个对象
        String s3=new String("hello");
        String s4=new String("hello");
        String s5=s3;
        System.out.println(s1.equals(s2));//t
        System.out.println(s1==s2);//t
        System.out.println(s3==s2);//f
        System.out.println(s3==s4);//f
        System.out.println(s3==s5);//t

    }
}

string的其他比较方法

使用equalsIgnoreCase（）方法：不区分大小写

使用toLowerCase()方法：全部小写

使用toUpperCAse（）方法：全部大写

使用concat()方法：连接字符串

使用+连接字符串

使用trim()方法：删去开头结尾空格，中间不删

需求：登录时不考虑大小写问题，实现登录

package day01;

import java.util.Scanner;

//用户注册，密码不小于6位
public class Register {
    public static void main(String[] args) {
        Scanner input =new Scanner(System.in);
        System.out.println("请输入用户名");
        String name=input.next();
        System.out.println("请输入密码");
        String pwd=input.next();
        //假设数据库已经存储了用户成功注册的用户名TOM,密码1234567
        //必须一致就用equals
        //忽略大小写就用equalsIgnoreCase
        if(name.equalsIgnoreCase("TOM")&&pwd.equals("1234567")){
            //等同于if(name.toLowerCase().equals("TOM".toLowerCase())&&pwd.equals("1234567"))
            //等同于if(name.toUpperCase().equals("TOM".toUpperCase())&&pwd.equals("1234567"))
            System.out.println("登陆成功");
        }
        else {
            System.out.println("用户名和密码不匹配，登录失败");
        }
        //去掉字符串两端空格的方法trim(),中间空格不去
        String name1="     admin     ";
        System.out.println(name.trim());

        String s1="hello";
        String s2="world";
        System.out.println(s1+s2);//连接
        System.out.println(5+4);//加法
        System.out.println(5+"4");//连接
        System.out.println(s1.concat(s2));//连接



    }
}

string类练习

需求：使用字符串常用方法完成会员注册功能

package day01;

import java.util.Scanner;

public class Register {
    //验证会员注册信息（用户名不能低于3位，密码不低于6，两次密码相同
    public boolean verify(String name,String pwd1,String pwd2){
        boolean flag=false;
        if(name.length()<3||pwd1.length()<6){
            System.out.println("用户名长度不能小于3，密码长度不能小于6");
            flag=false;
        }
        else if(!pwd1.equals(pwd2)){
            System.out.println("两次密码不一致");
            flag=false;
        }
        else {
            System.out.println("注册成功");
            flag=true;
        }
        return flag;
    }
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("欢迎进入注册系统");
        Register register=new Register();

        String name;//用户名
        String pwd1;
        String pwd2;
        boolean flag;
        do{
            System.out.println("请输入用户名：");
            name=input.next();
            System.out.println("请输入密码：");
            pwd1=input.next();
            System.out.println("请再次输入密码：");
            pwd2=input.next();
            flag=register.verify(name,pwd1,pwd2);
        }while(!flag);

    }
    }

string类提取方法

package day01;

public class StrMethods {
    public static void main(String[] args) {
        //获取特定字符串在字符串中出现的位置
        String s="hello world";
        //indexOf第一次出现的位置,下标从0开始,找不到返回-1
        int index=s.indexOf("o");
        System.out.println(index);
        int index1=s.indexOf("yes");
        System.out.println(index1);
        //lastindexOf第一次出现的位置,下标从0开始,空格也占一个位置，找不到返回-1
        int index2=s.lastIndexOf("o");
        System.out.println(index2);
        //截取特定字符串内容,包含这个位置，到末尾的字符串
        String result=s.substring(4);
        System.out.println(result);
        //截取特定字符串内容,包含这个位置，到输入的截止的字符串位置，不包含最后
        String result2=s.substring(4,8);
        System.out.println(result2);
    }
}

string类提取方法练习

package day01;
import java.util.Scanner;
public class JobSubmit {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("欢迎进入作业提交系统");
        System.out.println("请输入你要提交的文件名");
        String fileName=input.next();
        System.out.println("请输入你的邮箱");
        String email=input.next();

        boolean jobFlag=false;//作业名是否正确
        boolean emailFlag=false;//邮箱名是否正确

        //判断作业名是否包含.java 的后缀
        int index=fileName.lastIndexOf(".");
        if(index!=-1&&fileName.substring(index).equals(".java")){
            jobFlag=true;
        }
        else {
            System.out.println("文件名无效，请重新提交");
        }

        //邮箱名
        int index2=email.lastIndexOf("@");
        int index3=email.lastIndexOf(".");
        if(index2!=-1&&index3!=-1&&index2<index3){
            emailFlag=true;
        }
        else {
            System.out.println("邮箱地址无效，请重新提交");
        }
        if(emailFlag==true&&jobFlag==true){
            System.out.println("提交成功");
        }
        else {
            System.out.println("提交失败");
        }
    }
}

需求：

输入字符串，在输入要查找的字符，判断字符在字符串中出现的次数

思路：把串一个个都分开，再逐个对比

package day01;
import java.util.Scanner;
    //查找某个特定字符串在整个字符串中出现的次数
public class Counter {
    public int counter(String info, String find) {
            int count = 0;
            String [] chars=new String[info.length()];
            //把字符串转换成数组元素
        for (int i = 0; i < chars.length; i++) {
            //把字符串i位置的字符取出来，放入数组
            chars[i]=info.substring(i,i+1);
            //拿出来数组中的元素，和后面的进行比较
            if(chars[i].equals(find)){
                count++;
            }
        }
            return count;
        }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String info=input.next();
        System.out.println("请输入要查找的字符");
        String find=input.next();

        Counter c=new Counter();
        int count=c.counter(info,find);
        System.out.println("\""+info+"\""+"中包含了"+count+"个"+"\""+find+"\"");

    }
}

字符串拆分

需求

现有一个字符串，他是一段歌词，枚举都以空格结尾，怎么拆分

思路：split（）方法

package day01;
//查找某个特定字符串在整个字符串中出现的次数
public class Counter {
    public static void main(String[] args) {
        System.out.println("+++++++++++++++++原歌词++++++");
        String song="长亭外 古道边 芳草碧连天 晚风付留底圣餐 夕阳山外山";
        System.out.println(song);
        //把字符串拆分  ，拆成字符串数组
        String [] songs=song.split(" ");
        System.out.println("+++++++++++拆分完的歌词+++++++++++");
        for(String s:songs){
            System.out.println(s);
        }
    }
}

StringBuffer类操作字符串

通过string操作字符串的时候，比如最佳，截取等，操作的是字符串的副本，字符串本身没有修改，需要定义一个新的变量进行赋值

StringBuffer：对字符串频繁修改的情况下，使用StringBuffer比string效率高

StringBuffer

声明：StringBuffer s=new StringBuffer();

StringBuffer s=new StringBuffer(“aaa”);
StringBuffer的使用
- s.toString():转换成string类型
- s.append(“***”):追加字符串
- s.insert(1,“**”)：插入字符串

package day01;
//查找某个特定字符串在整个字符串中出现的次数
public class Counter {
    public static void main(String[] args) {
        String s="hello";
        s.concat(" world!");
        //s=s.concat(" world!");
        System.out.println(s);

        //StringBuffer
        StringBuffer s1=new StringBuffer("hello");
        System.out.println(s.length());//长度
        System.out.println(s.toString());//类型转换成string
        //操作字符串本身
        s1.append(" world");
        System.out.println(s1);
        //在某个位置插入字符串
        s1.insert(5,",");
        System.out.println(s1);

    }
}

按例需求：

将一个数字字符串转换成逗号分隔的数字串，从右边开始每三个数字用逗号分隔

package day01;
import java.util.Scanner;
//查找某个特定字符串在整个字符串中出现的次数
public class Counter {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String s=input.next();
        StringBuffer number=new StringBuffer(s);
        for (int i = number.length(); i >0 ; i=i-3) {
            number.insert(i,",");
        }
        System.out.println(number);
    }
}

日期和时间操作

掌握使用date类创建日期对象
掌握使用SimpleDateFormat定制日期格式
掌握使用calendar类操作日期时间

package day01;

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

public class TimeEx {
    public static void main(String[] args) {
        Date date =new Date();
        System.out.println(date);
        //定制日期格式
        SimpleDateFormat formater=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr=formater.format(date);
        System.out.println(dateStr);
    }
}

Calendar类

抽象类，java.util.Calendar
用于设置和获取日期/时间数据的特定部分
Calendar类提供一些方法和静态字段来操作日历

package day01;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class TimeEx {
    public static void main(String[] args) {
        Date date =new Date();
        System.out.println(date);
        //定制日期格式
        SimpleDateFormat formater=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr=formater.format(date);
        System.out.println(dateStr);

        //通过Calendar类来操作时间和日期
        Calendar c=Calendar.getInstance();
        int year=c.get(Calendar.YEAR);
        int month=c.get(Calendar.MONTH)+1;
        int day=c.get(Calendar.DAY_OF_MONTH);
        System.out.println("今天是"+year+"年"+month+"月"+day+"日");
        //星期几，DAY_OF_WEEK中的sunday是1
        int week=c.get(Calendar.DAY_OF_WEEK)-1;
        System.out.println("今天是星期"+week);

    }
}

日期时间操作练习

需求：

获取当前时间，使用simpledateformat以年-月-日方式输出

计算2021年4月6日是一年中的第几个星期

package day01;

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

public class TimeEx2 {
    public static void main(String[] args) {
        Date date=new Date();
        SimpleDateFormat formater=new SimpleDateFormat("yyyy-MM-dd");
        System.out.println("当前日期为"+formater.format(date));

        Calendar c=Calendar.getInstance();
        c.set(Calendar.YEAR,2021);
        c.set(Calendar.MONTH,3);
        c.set(Calendar.DAY_OF_MONTH,6);
        int week=c.get(Calendar.WEEK_OF_YEAR);
        System.out.println("2021年4月6日是一年里的第"+week+"周");
    }
}