Java的迭代器Integer，char类型的包装类类型Charcater，日历类Calendar，Random类，Math类

2021/7/31 17:06:23

编程Tag： string Java int out system char random public println

本文主要是介绍Java的迭代器Integer，char类型的包装类类型Charcater，日历类Calendar，Random类，Math类，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Integer:int类型的包装类类型(引用类型),包含了int类型的原始数据值

int----->String
需要基本类型和String类型之间转换:需要中间桥梁(基本类型对应的包装类类型)
   整数类型引用类型(默认值都是null)
   byte Byte
   short Short
   int Integer
   long Long
   浮点类型
   float Float
   double Double
   字符类型
   char Character
   布尔类型
   boolean    Boolean

需求:
   进制的转换----就可以使用Integer静态功能十进制---->二进制 "以字符串形式体现"
十进制---->八进制
十六进制
   通过Integer得到int类型的取值范围
   public static String toBinaryString(int i):将整数---->二进制的字符串
   public static String toOctalString(int i):将整数---->八进制的字符串
   public static String toHexString(int i):将整数---->十六进制数据
   public static final int MAX_VALUE:int的最大值
   public static final int MIN_VALUE:int的最小值

Integer的构造方法:

   Integer(int value):可以将int类型保证为Integer类型
Integer(String s) throws NumberForamtException: 抛出一个数字格式化异常
   注意事项:
   当前字符串如果不是能够解析的整数的,就会出现数字格式化异常,s必须为数字字符串

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

        //创建Integer类对象
        int i = 100 ;
        Integer integer = new Integer(i) ;
        System.out.println(integer);
        System.out.println("---------------------");
        //创建一个字符串
       // String s = "hello" ;
        String s  = "50" ;
        Integer integer2 = new Integer(s) ;
        System.out.println(integer2);
    }
}

integer的拆装箱

JDK5以后新特性:
   自动拆装箱,可变参数,静态导入,增强for循环,<泛型>,枚举类

   自动拆装箱:
   基本类型---> 对应的包装类类型 (装箱)
   int---->Integer
   对应的包装类型---->基本类型 (拆箱)

Integer----> int

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

        //创建Integer类对象
        int i = 100 ;
        Integer ii = new Integer(i) ;
        ii += 200 ;
        System.out.println("ii:"+ii);

Charcater:char类型的包装类类型,

构造方法
public Character(char value)

主要功能
   public static boolean isUpperCase(char ch):判断当前字符是否大写字母字符
   public static boolean isLowerCAse(char ch):是否为小写字母字符
   public static boolean isDigit(char ch):是否为数字字符

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

        //创建字符类对象
        Character character = new Character('a') ;
//        Character character = new Character((char)(97)) ;
        System.out.println(character);

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

        System.out.println("isUpperCase():"+Character.isUpperCase('A'));
        System.out.println("isUpperCase():"+Character.isUpperCase('a'));
        System.out.println("isUpperCase():"+Character.isUpperCase('0'));

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

        System.out.println("isLowerCase():"+Character.isLowerCase('A'));
        System.out.println("isLowerCase():"+Character.isLowerCase('a'));
        System.out.println("isLowerCase():"+Character.isLowerCase('0'));

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

        System.out.println("isDigit():"+Character.isDigit('A'));
        System.out.println("isDigit():"+Character.isDigit('a'));
        System.out.println("isDigit():"+Character.isDigit('0'));

       // char ch = 'a' ;
       // System.out.println(Character.toUpperCase(ch));
    }
}

需求:
键盘录入一个字符串,有大写字母字符,数字字母字符,小写字母字符,不考虑其他字符,分别统计
大写字母字符,小写字母字符数字字符的个数!

输入:
   "Hello123World"

   输出:
   大写字母有2个
   小写字母字符:8个
   数字字符:3个

分析:
   0)定义三个统计变量
   bigCount
   smallCount
   numberCount
1)键盘录入一个字符串
2) 方式1 获取到每一个字符, 字符对应ASCII码表的值 (太麻烦)
   方式2:将字符串转换成字符数组
3)遍历字符数组
   获取到每一个字符
   如果当前字符 'A', 'Z' 大写字母字符 bigCount ++
   'a' ,'z' 小写字母字符 smallCount++
   '0','9' 数字字符 numberCount++

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

        //定义三个统计变量
        int bigCount = 0  ;
        int smallCount = 0 ;
        int numberCount =  0;
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请您输入一个数据:");
        String line = sc.nextLine() ;

        //转换成字符数组
        char[] chs = line.toCharArray();
        for (int i = 0; i <chs.length ; i++) {
            char ch = chs[i] ;

         /*   //判断
            if(ch>='A' && ch<='Z'){
                //大写字母
                bigCount ++ ;
            }else if(ch>='a' && ch<='z'){
                //小写字母
                smallCount ++ ;
            }else if(ch >='0' && ch<='9'){
                numberCount ++ ;
            }*/

         //直接判断
            if(Character.isDigit(ch)){
                numberCount ++ ;
            }else if(Character.isUpperCase(ch)){
                bigCount ++ ;
            }else if(Character.isLowerCase(ch)){
                smallCount ++;
            }
        }
        System.out.println("大写字母字符有"+bigCount+"个");
        System.out.println("小写字母字符有"+smallCount+"个");
        System.out.println("数字字符有"+numberCount+"个");
    }
}

日历类:java.util.Calendar

Calendar:提供一些诸如获取年,月,月中的日期等等字段值
抽象类,不能实例化
如果一个类没有抽象方法,这个类可不可以定义为抽象类? 可以,为了不能实例化,通过子类间接实例化

不能实例化:
静态功能,返回值是它自己本身
public static Calendar getInstance()

成员方法:
     public int get(int field):根据给定日历字段----获取日历字段的值(系统的日历)
   public abstract void add(int field,int amount):给指定的日历字段,添加或者减去时间偏移量
   参数1:日历字段
   参数2:偏移量

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

        //创建日历类对象
        //获取系统的年月日
       // Calendar c = new Calendar() ;
        //public static Calendar getInstance()
        Calendar calendar = Calendar.getInstance();
       // System.out.println(calendar);

        //获取年
        //public static final int YEAR
        int year = calendar.get(Calendar.YEAR) ;

        //获取月:
        //public static final int MONTH:0-11之间
        int month = calendar.get(Calendar.MONTH) ;

        //获取月中的日期
        //public static final int DATE
        //public static final int DAY OF MONTH : 每个月的第一天1
        int date = calendar.get(Calendar.DATE) ;

        System.out.println("当前日历为:"+year+"年"+(month+1)+"月"+date+"日");

        System.out.println("------------------------------------------------");
        //获取3年前的今天
        //给year设置偏移量
        // public abstract void add(int field,int amount)
       // calendar.add(Calendar.YEAR,-3);
        //获取
      //  year = calendar.get(Calendar.YEAR) ;
      //  System.out.println("当前日历为:"+year+"年"+(month+1)+"月"+date+"日");

        //5年后的十天前
        //需求:键盘录入一个年份,算出任意年份的2月份有多少天 (不考虑润月)
    }
}

java.util.Date-----String 格式化过程

DateForamt:抽象类----提供具体的日期/格式化的子类:SimpleDateFormat
format(Date对象)--->String

SimpleDateFormat:构造函数
public SimpleDateFormat():使用默认模式
   public SimpleDateFormat(String pattern):使用指定的模式进行解析或者格式 (推荐)
   参数:
   一种模式
表示年 "yyyy"
表示月 "MM"
表示月中的日期 "dd"
一天中小时数 "HH"
分钟数 "mm"
秒数 "ss"

String:日期文本----->Date
  解析过程
public Date parse(String source)throws ParseException
   如果解析的字符串的格式和 public SimpleDateFormat(String pattern)的参数模式不匹配的话,就会出现解析异常!

封装成功工具类DateUtils: 构造方法私有,功能都是静态
   第一个将String---Date
   将Date--->String

public class DateDemo2 {
    public static void main(String[] args) throws ParseException {
        //Date----->String:格式化
        //1)创建Date对象:表示当前系统时间对象
        Date date  = new Date() ;
        System.out.println(date);
        //2)创建SimpleDateForamt对象:(中间桥梁)
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
        //3)调用format:格式化
        String strDate = sdf.format(date);
        System.out.println(strDate);

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

        //String---->Date(重点)
        //1)有一个日期文本格式
        //2)创建SimpleDateFormat对象指定一个模式
        //3)调用解析parse方法
        //注意:SimpleDateFormat解析模式必须和String日期文本格式匹配一致
        String source = "2008-5-12" ; //日期文本

        //SimpleDateFormat sdf2  = new SimpleDateFormat("yyyy年MM月dd日") ;
        SimpleDateFormat sdf2  = new SimpleDateFormat("yyyy-MM-dd") ;
        //public Date parse(String source)throws ParseException
        Date dateResult = sdf2.parse(source);
        System.out.println(dateResult);
    }
}

java.util.Date:表示特定瞬间,精确到毫秒!
   它还允许格式化和解析日期字符串
构造方法:
   public Date():当前系统时间格式
   public Date(long date):参数为时间毫秒值---->Date对象 (1970年1月1日...)

public class DateDemo {
    public static void main(String[] args) {
        //创建日期类对象
        Date date  = new Date() ;
        System.out.println(date);
        //Wed Jul 28 17:32:06 CST 2021 日期对象
        System.out.println("------------------------");

        long time = 60*60 ;
        Date date2 = new Date(time) ;
        System.out.println(date2);
    }
}

针对java.util.Date日期对象和String:日期文本字符串进行相互转换的工具类

public class DateUtils {

    //构造方法私有化
    private DateUtils(){}

    //提供两个静态功能
    //Date---->String

（1）

    /**
     * 这个方法是针对将日期对象转换成日期文本字符串
     * @param date     需要被格式化的日期对象
     * @param pattern   需要指定的模式
     * @return  返回的日期文本字符串  结果 yyyy-MM-dd
     */
    public static String date2String(Date date,String pattern){
        //分步走
        //创建SimpleDateFormat对象
       /* SimpleDateFormat sdf = new SimpleDateFormat(pattern) ;
        String result = sdf.format(date);
        return  result ;*/

       //一步走
        return new SimpleDateFormat(pattern).format(date) ;
    }


（2）

    //String--->Date: 解析过程: parse(String source) throws ParseException

    /**
     * 这个方法针对String日期文本字符串转换成日期对象
     * @param source   需要被解析的日期文本字符串
     * @param pattern   需要解析中使用的一种模式
     * @return  返回的就是日期对象Date
     */
    public static Date string2Date(String source,String pattern) throws ParseException {

        return new SimpleDateFormat(pattern).parse(source) ;
    }
}

//测试类
public class Test {
    public static void main(String[] args) throws ParseException {

        //直接使用工具类
        //Date---->String 格式化
        Date date = new Date() ;

        String str = DateUtils.date2String(date, "yyyy-MM-dd HH:mm:ss");
        System.out.println(str);
        System.out.println("---------------------");

        //String--->Date
        String source = "2022-6-9" ;
        Date date2 = DateUtils.string2Date(source, "yyyy-MM-dd");
        System.out.println(date2);
    }
}

Random类:

构造方法
   public Random(): 产生一个随机生成器对象,通过成员方法随机数每次没不一样的(推荐)
   public Random(long seed) :参数为long类型的值(随机数流:种子),每次通过成员方法获取随机数产生的随机数相同的

获取随机数的成员方法
   public int nextInt():获取的值的范围是int类型的取值范围(-2的31次方到2的31次方-1)
   public int nextInt(int n):获取的0-n之间的数据 (不包含n)

产生随机数:
   Math类的random方法
   public static double random();
    Random类:也能够去使用
   无参构造方法 + 成员方法
   public Random():+ public int nextInt(int n)

//1-30的随机数
public class RandomDemo {
    public static void main(String[] args) {
        //创建一个随机数生成器
//        public Random(long seed)
//        Random random = new Random(1111) ;

        //每次通过随机数生成器产生的随机不同
        Random random =  new Random() ;
        //产生10个数
        for(int x = 0 ; x < 10 ; x ++){
            // public int nextInt():
//            int num = random.nextInt();

            //public int nextInt(int n)
            int num = (random.nextInt(30)+1);
            System.out.println(num);
        }
    }
}

Math类

public static int abs(int a):绝对值方法
     public static double ceil(double a):向上取整
   public static double floor(double a):向下取整
public static int max(int a,int b):获取最大值
public static int min(int a,int b):获取最小值
     public static double pow(double a,double b):a的b次幂
     public static double random():[0.0,1.0):随机数
   public static long round(double a):四舍五入
public static double sqrt(double a):开平方根

Math类中的功能都是静态的,里面构造方法私有了!
一般情况:工具类中构造方法都是会私有化(自定义的工具类),提供对外静态的公共访问方法
(Java设计模式:单例模式)

public class MathDemo {
    public static void main(String[] args) {
        //abs()
        System.out.println(Math.abs(-100));
        // public static double ceil(double a):向上取整
        System.out.println(Math.ceil(13.56));
       // public static double floor(double a):向下取整
        System.out.println(Math.floor(12.45));
        // public static int max(int a,int b):获取最大值
        System.out.println(Math.max(Math.max(10,30),50));//方法嵌套
        //public static double pow(double a,double b):a的b次幂
        System.out.println(Math.pow(2,3));
        //ublic static long round(double a):四舍五入
        System.out.println(Math.round(13.78));

        //  public static double sqrt(double a):开平方根
        System.out.println(Math.sqrt(4));
    }
}

Math类的功能都是静态的,就可以使用静态导入
import static 包名.类名.方法名;
（前提不能和其他方法名重名）

import  java.util.Scanner ;//导入到类的级别

import static java.lang.Math.abs ;
import static java.lang.Math.random;

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

        System.out.println(Math.abs(-100));
       // System.out.println(java.lang.Math.abs(-100)); //默认就是使用当前abs方法,并不是Math提供的
        System.out.println(abs(-100));
        System.out.println(random()*100+1);
    }

    //自定义了方法名abs
    public static int abs(int a){
       // System.out.println(a);
        return a ;
    }
}

BigDecimal可以计算的同时保留小数点后的有效位数

构造方法：
  public BigDecimal(String value):数字字符串
成员方法:
   public BigDecimal add(BigDecimal augend)加
   public BigDecimal subtract(BigDecimal subtrahend)减
public BigDecimal multiply(BigDecimal multiplicand)乘
public BigDecimal divide(BigDecimal divisor):除
格式：
   public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
   参数1:商
   参数2:小数点后保留的有效位数
   参数3:舍入模式 :四舍五入

public class BigDecimalDemo {
    public static void main(String[] args) {
        //System.out.println(1.01 / 0.36);

        //创建BigDecimal对象
        BigDecimal bg1 = new BigDecimal("1.01") ;
        BigDecimal bg2 = new BigDecimal("0.36") ;

        System.out.println("------------------------------------");
        BigDecimal bg3 = new BigDecimal("10.0") ;
        BigDecimal bg4 = new BigDecimal("5.05") ;

        System.out.println(bg1.add(bg2));
        System.out.println(bg1.subtract(bg2));
        System.out.println(bg1.multiply(bg2));
       // System.out.println(bg3.divide(bg4));//不保留(整除)
        System.out.println(bg3.divide(bg4,3,BigDecimal.ROUND_HALF_UP));//四十五入
    }
}

对象数组：能够存储对象的数组

需求:
   使用数组存储5个学生(姓名,年龄,性别),然后将数组进行遍历,获取出来每一个学生的信息!
   分析:
   1)创建一个学生类
   name,age,gender/sex
2) 数组存储5个学生
   数组的定义格式:
   数据类型[] 数组名称 = new 数据类型[长度] ; 学生对象数组
数据类型:Student类型 Student[] students = new Student[5] ;
3)创建5个学生对象:s1,s2,s3,s4,s5
4)students[0] =s1 ; 给数组中的元素进行赋值
students[1] = s2;
   5)遍历学生数组,获取学生信息
现在5个学生,以后学生的不断的增加或减少,用数组合适吗? 数组不适合针对长度可变的需求,所以Java提供---集合框架去使用!

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

        //创建学生数组
        //  数据类型[] 数组名称 = new 数据类型[长度] ;  学生对象数组
        Student[] students = new Student[5] ;
        //创建5个学生
        Student s1 = new Student("文章",35,"男") ;
        Student s2 = new Student("高圆圆",42,"女") ;
        Student s3 = new Student("刘亦菲",33,"女") ;
        Student s4 = new Student("马蓉",30,"女") ;
        Student s5 = new Student("马保国",65,"男") ;

        //给数组中的元素赋值
        students[0] = s1 ;
        students[1] = s2 ;
        students[2] = s3 ;
        students[3] = s4 ;
        students[4] = s5 ;

        //遍历学生数组
        for(int x = 0 ; x < students.length ; x ++){
            //System.out.println(students[x]);
            //就需要同getXXX()方法获取成员信息
            Student s = students[x] ;
            System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGender());
        }
    }
}

public class Student {
    private String name ;
    private int age ;
    private String gender ;

    public Student() {
    }

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

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
}

这篇关于Java的迭代器Integer，char类型的包装类类型Charcater，日历类Calendar，Random类，Math类的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！