Java教程
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 + '\'' +
'}';
}
}
-
面向对象编程基础：初学者指南09-07
-
数据结构入门：了解基础概念与简单应用09-07
-
面向对象编程入门：掌握基本概念与实践09-07
-
数据结构入门：从基础概念到基本操作09-07
-
从零开始学数据库：入门级指南与实操技巧09-07
-
综合设备故障分析与预防：实例代码与优化策略09-07
-
数据库入门：轻松掌握数据管理基础09-07
-
面向对象入门：快速掌握对象编程基础09-07
-
数据库教程：入门与实践指南09-07
-
面向对象开发教程 - 从零基础到实践应用的进阶之路09-07
-
从入门到实践：Auth机制的简单教程09-07
-
快速上手 Drizzle ORM：入门级教程09-07
-
入门指南：轻松掌握公共API的使用09-07
-
深入浅出：Server Component 在现代Web开发中的应用与实践09-07
-
GET 起 TRPC：入门级教程，轻松掌握RESTful API的简洁之道09-07
