1.Character
Character类是基本数据类型char类型的包装类类型,包含char的值
此外，该类还提供了几种方法来确定字符的类别(小写字母，数字等),并将字符从大写转换为小写,反之亦然.
构造方法:
Character(char value) 参数里面也可以为int----char :将一个字符内容构造成包装类类型
成员方法:
判断功能:
public static boolean isDigit(char ch):判断当前ch字符是否为数字
public static boolean isLowerCase(char ch):判断当前ch字符是否为小写字母字符
public static boolean isUpperCase(char ch)确定指定的字符是否为大写字符。
public class CharacterDemo {
public static void main(String[] args) {
//创建一个Character类对象
//Character character = new Character((char)97) ;
Character character = new Character('a') ;
System.out.println(character); //'a'
System.out.println("----------------------------------------") ;
//测试判断功能
System.out.println("isDigit():"+Character.isDigit('A')) ;
System.out.println("isDigit():"+Character.isDigit('0')) ;
System.out.println("isDigit():"+Character.isDigit('a')) ;
System.out.println("----------------------------------------") ;
System.out.println("isLowerCase():"+Character.isLowerCase('A')) ;
System.out.println("isLowerCase():"+Character.isLowerCase('0')) ;
System.out.println("isLowerCase():"+Character.isLowerCase('a')) ;
System.out.println("----------------------------------------") ;
System.out.println("isUpperCase():"+Character.isUpperCase('A')) ;
System.out.println("isUpperCase():"+Character.isUpperCase('0')) ;
System.out.println("isUpperCase:"+Character.isUpperCase('a')) ;
}
}2.Date
java.util.Date:表示日期格式:精确到瞬间毫秒
构造方法:
public Date():无参构造方法,获取当前系统时间的日期格式 默认使用当前系统时间
public Date(long date):将long类型-构造成Date对象:long指定时间毫秒值(与1970年1月1日)
成员方法:
public long getTime():将Date日期格式----转换成long类型返回自1970年1月1日以来的Date毫秒数
public class DateDemo {
public static void main(String[] args) {
//public Date():无参构造方法,获取当前系统时间的日期格式
Date date = new Date() ;
// long times = date.getTime();
//System.out.println(times);
System.out.println(date);
System.out.println("---------------------------------------") ;
long time = 60 * 60 ;
Date date2 = new Date(time) ;
System.out.println(date2);
}
} String 日期文本格式如何和Date格式之间转换
DateFormat是日期/时间格式化子类的抽象类，它以语言无关的方式格式化和分析日期或时间。但是它是一个抽象类,抽象类不能实例化,它提供了更具体的子类SimpleDateFormat进行操作.
java.util.Date对象------ SimpleDateFormat ------->String 日期文本格式
public SimpleDateFormat(String pattern):参数为描述日期和时间格式的一种模式
String--------------SimpleDateFormat------------------>Date
public Date parse(String source) throws ParseException:解析方法,可能出现解析异常,当前字符串开头不能解析就出问题
public class DateDemo2 {
public static void main(String[] args) throws ParseException {
//Date---->String 日期文本
//创建日期对象:表示当前系统时间
Date date = new Date() ;
//创建SimpleDateFormat对象:中间桥梁(格式化/解析 工具)
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
// public final String format(Date date)
String dateStr = sdf.format(date);
System.out.println(dateStr) ;
System.out.println("------------------------------------------") ;
//String文本------->Date日期格式
String sourc = "2012-12-20" ;
//当前的SimpleDateFormat的模式必须和字符串文本格式对应!,否则解析出问题了
//创建SimpleDateFormat对象
// SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日" ) ;
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd" ) ;
//public Date parse(String source) throws ParseException:
Date date2 = sdf2.parse(sourc);
System.out.println(date2) ;
}
}3.Calendar
java.util.Calendar:抽象类
表示的特定一组时间:诸如YEAR,MONTH,DAY_OF_MONTH 等等
静态功能:
public static Calendar getInstance()
成员变量---- 常量
public static final int YEAR :年
public static final int MONTH:月:角标是从0开始计算, 计算出来+1
public static final int DATE:月中的日期 和DAY_OF_MONTH同义词
时分秒:查看API
成员方法:
public int get(int field):获取当前的日历字段
public abstract void add(int field,int amount):设置时间偏移量,针对当前日历字段,减去或者添加指定amount(偏移量)
public class CalendarDemo {
public static void main(String[] args) {
//创建日历类对象
Calendar calendar = Calendar.getInstance();
// System.out.println(calendar); //很多信息: 需要的是年月日
//获取年
//public int get(int field):获取当前的日历字段
int year = calendar.get(Calendar.YEAR) ;
int month = calendar.get(Calendar.MONTH) ;
int date = calendar.get(Calendar.DATE) ;
System.out.println("当前系统时间日期是:"+year+"年"+(month+1)+"月"+date+"日");
System.out.println("--------------------------------------------------------") ;
//5年前的今天
//给年字段设置偏移量
/* calendar.add(Calendar.YEAR,-5) ;
year = calendar.get(calendar.YEAR) ;
System.out.println("当前系统时间日期是:"+year+"年"+(month+1)+"月"+date+"日");*/
//5年后的10天前
calendar.add(Calendar.YEAR,5) ;
year = calendar.get(calendar.YEAR) ;
//设置天
calendar.add(Calendar.DATE,-10) ;
date = calendar.get(Calendar.DATE) ;
System.out.println("当前系统时间日期是:"+year+"年"+(month+1)+"月"+date+"日");
System.out.println("-----------------------------------------------") ;
// public final void set(int year, int month, int date)设置指定的日历字段
calendar.set(2022,11,18) ;
year = calendar.get(Calendar.YEAR) ;
month = calendar.get(Calendar.MONTH) ;
date = calendar.get(Calendar.DATE) ;
System.out.println("设置的日历字段时:"+year+"年"+(month+1)+"月"+date+"日");
}
}4.System
System类不能实例化,里面提供一些标准输入流
静态字段(常量)
public static final InputSteam in ;
public static final PrintStream out ;
静态功能:
public static void gc():手动开启垃圾回收器
public static void exit(int status):参数为0,正常终止JVM
public static void arraycopy(Object src,int srcPos,Object dest,int destPos, int length):复制数组
public static long currentTimeMillis():计算当前系统时间毫秒值
public class SystemDemo {
public static void main(String[] args) {
// System.err.println("错误日志输出..");
//字节输入流
InputStream in = System.in;
Scanner sc = new Scanner(in) ;
System.out.println("请输入一个数据int:");
int a = sc.nextInt() ;
System.out.println(a) ;
System.out.println("--------------------------------") ;
//字节打印流(输出流一种):字节输出流 OutputStream 父类
PrintStream ps = System.out ;
ps.println("helloworld"); //打印内容并换行
ps.println("javaee");
}
} public static void exit(int status)//:参数为0,正常终止JVM
场景:
当前while循环和switch语句一块使用
break,结束switch语句,使用while(true),
当某个条件满足,结束, System.exit(0) ;
public static long currentTimeMillis()//:计算当前系统时间毫秒值
很少单独使用,在看程序的执行效率问题(计算时间差值) ;
io流使用字节流和字符流:分别进行文件读写复制,计算执行效率!
字节流: 读取图片文件,文本文件.音频文件/视频文件
字符流: 读文本文件效率高于字节流
public static void arraycopy(Object src,int srcPos,Object dest,int destPos, int length)
public class SystemDemo3 {
public static void main(String[] args) {
/* System.out.println("hello,程序开始了...") ;
System.exit(0) ;
System.out.println("程序结束了,Over...");*/
long start = System.currentTimeMillis() ;
for(int x = 0 ; x < 10000 ; x ++){
System.out.println("hello"+x);
}
long end = System.currentTimeMillis() ;
//计算时间差值
System.out.println("当前程序共耗时"+(end-start)+"毫秒") ;
System.out.println("---------------------------------------------") ;
//创建两个数组
int[] arr = {1,2,3,4,5,5,6,7,8} ;
int[] arr2 = {11,22,33,44,55,66} ;
//复制之前:
//将数组----String :Arrays工具类的toString(数据类型[] 数组名称)
System.out.println("复制之前: ");
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arr2));
System.out.println("-------------------------------") ;
//public static void arraycopy(Object src,int srcPos,Object dest,int destPos, int length)//复制数组
//参数1:原数组对象
//参数2:原数组中的某个位置
//参数3:目标数组对象
//参数4:目标数组对象的某个位置
//参数5:指定长度进行赋值
System.arraycopy(arr,2,arr2,2,3);
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arr2));
}
}5.Random
伪随机数生成器
构造方法
Random():创建随机数生成器,通过它调用功能获取的随机是不同的 (使用无参构造居多)
Random(long seed):创建随机数生成器,通过它调用功能,产生随机数值相同的
成员方法:
public int nextInt():获取随机数int类型范围
public int nextInt(int n):获取0-n之间随机数,不包括n
public class RandomDemo {
public static void main(String[] args) {
//创建随机数生成器
//Random random = new Random(111) ;
//空参构造
Random random = new Random() ;
//for循环:产生10个随机
for(int x = 0 ; x < 10 ; x ++){
//int num = random.nextInt();//取值范围:int类型范围
// System.out.println(num);
int num = random.nextInt(30) ;
System.out.println(num) ;
}
}
}
6.Math
java.lang.Math: 数学的运算工具类
功能都是静态
public static double abs(double/int a):求绝对值
public static double ceil(double a):向上取整
public static double floor(double a):向下取整
public static double max(double a,double b):获取最大值
public static double min(double a,double b):获取最小值
public static double random():[0,1) :获取0,1随机数,不包含1
public static long round(double a):四舍五入
public static double sqrt(double a):开正方根
public static double pow(double a,double b):a的b次幂
public class MathDemo {
public static void main(String[] args) {
// System.out.println(abs(-100));
System.out.println(java.lang.Math.abs(-100));
//当前自定义的方法名如果和静态导入的方法名冲突,只能使用指定的包名.类名.方法名使用!
abs(20.0);
System.out.println(ceil(12.56));
System.out.println(Math.floor(11.34));
System.out.println(Math.max(10,50));
System.out.println(Math.min(10,50));
System.out.println(Math.random()) ;
System.out.println(Math.round(12.78)) ;
System.out.println(Math.pow(2,3));
System.out.println(Math.sqrt(9));
}
//自定义了一个功能abs
public static void abs(double ...a){ //a变量名:未知多少个参数
System.out.println(a) ;
}
}7.BigDecimal
对小数进行精确计算
public BigDecimal(String val) :将数字字符构造成BigDecimal对象
功能
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, RoundingMode roundingMode)
参数1:指定的除数
参数2:保留的有效位数
参数3:指定舍入模式: ROUND_HALF_UP 四舍五入
public class BigDecimalDemo {
public static void main(String[] args) {
// System.out.println(1.01/2.35);
//System.out.println(1.01- 0.336);
BigDecimal bg1 = new BigDecimal("1.01") ;
BigDecimal bg2= new BigDecimal("10.0") ;
System.out.println(bg1.divide(bg2));
System.out.println(bg1.add(bg2));
System.out.println(bg1.multiply(bg2));
System.out.println(bg1.subtract(bg2));
System.out.println("---------------------------------") ;
System.out.println(bg1.divide(bg2,2,BigDecimal.ROUND_HALF_UP));
}
}
8.选择排序
思想:使用0角标对应的元素依次和后面角标对应的元素进行比较,小的往前放,第一次比较完毕,最小值出现在最小索引处,依次比较,比较的次数:数组长度-1次
public class ArrayDemo {
public static void main(String[] args) {
//给定一个数组
int[] arr = {24, 68, 87, 57, 13};
System.out.println("排序前:");
//自己的功能
printArray(arr);
selectSort(arr); //排序
printArray(arr);
}
private static void selectSort(int[] arr) {
for (int x = 0; x < arr.length - 1; x++) {//比较次数
for (int y = x + 1; y < arr.length; y++) {//遍历后面的元素
//判断
if (arr[y] < arr[x]) {
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
public static void printArray(int[] arr){
System.out.print("[") ;
for(int x = 0 ; x < arr.length ; x++){
if(x == arr.length-1){
System.out.println(arr[x] +"]") ;
}else{
System.out.print(arr[x]+", ");
}
}
}
}9.集合
集合和数组的区别
1)长度的区别
数组长度:固定
集合长度:可变
2)存储数据类型的区别
数组:既可以存储基本数据类型,而且存储引用数据类型
int[] arr = new int[5] ;
Student[] students= new Student[3] ;
集合:只能存储引用数据类型
3)存储元素的区别:
数组:虽然以存储基本数据类型,而且存储引用数据类型,元素类型必须统一
String[] strArray = {"hello","world","JavaEE",100} ;不行,报错
集合:虽然只能存储引用数据类型,但是可以存储任何引用类型, 没有泛型<>:模拟数组的特点.
9.1 collection集合
某些集合允许重复元素(List),而其他集合不允许(Set). 有些有序和有序无序.
Collection的基本功能：
boolean add(Object e)：添加任意类型
boolean remove(Object o)：删除指定的元素
void clear()：暴力删除，将集合中所有元素删除
boolean contains(Object o)：判断集合中是否包含指定的元素
boolean isEmpty():判断是否为空,不为空,false;空,true
int size():获取集合的元素数
public class CollectionDemo {
public static void main(String[] args) {
//创建Collection集合对象:接口多态
Collection c = new ArrayList() ;
System.out.println(c) ;
//boolean add(Object e)：添加任意类型
//System.out.println(c.add("hello"));
//单独调用
c.add("hello") ;
c.add("JavaEE") ;
// c.add(100) ;//int---Integer
//c.add(new Object()) ;
c.add("world") ;
System.out.println(c) ;
//boolean remove(Object o)：删除指定的元素
System.out.println(c.remove("hello"));
System.out.println(c) ;
// void clear()：暴力删除，将集合中所有元素删除
// c.clear();
// boolean contains(Object o)：判断集合中是否包含指定的元素
System.out.println(c.contains("android")) ;
System.out.println(c.contains("world")) ;
//boolean isEmpty():判断是否为空,不为空,false;空,true
System.out.println(c.isEmpty());
//int size():获取集合的元素数
System.out.println(c.size());
System.out.println(c);
}
}9.2 Iterator迭代器
9.3 泛型
集合对象的创建同时明确数据类型,并且将运行时期异常提前到了编译时期(模拟数组定义)
写法:<引用数据类型>
作用:就是将集合的对象的创建工作,将运行时期异常,提前到编译时期,解决程序安全性.
创建集合对象:
集合<数据类型> 对象名 = new 子实现类<>()
泛型的好处:
1)提高程序安全性
2)解决黄色警告线
3)使用集合的迭代器避免强转类型强转类型转换
public class CollectionDemo2 {
public static void main(String[] args) {
// String[] str = {"hello","world","javaee",100} ;
//创建一个Collection集合
Collection c = new ArrayList() ;
//添加5个字符串
c.add("hello") ;
c.add("world") ;
c.add("JavaEE") ;
c.add("android") ;
c.add("Php") ;
//System.out.println(c);
//将集合转换成对象数组
Object[] objs = c.toArray(); //向上转型:Object obj = new String() ;
for(int x = 0 ; x < objs.length ; x ++){
//System.out.println(objs[x]) ;
//使用Collection存储5个字符串数数据,并进行遍历,并且输出字符串长度 length()
//向下转型:
String s = (String) objs[x];
System.out.println(s+"----"+s.length());
}
System.out.println("---------------------------------------------------------") ;
//使用集合存储5个学生,并且输出学生信息(姓名,年龄)
//加入泛型:就这样一个个数
Collection<Student> c1 = new ArrayList<>() ;
//创建5个学生
Student s1 = new Student("张三",23) ;
Student s2 = new Student("赵四",25) ;
Student s3 = new Student("李华",18) ;
Student s4 = new Student("刘敏",28) ;
Student s5 = new Student("张三丰",20) ;
c1.add(s1) ;
c1.add(s2) ;
c1.add(s3) ;
c1.add(s4) ;
c1.add(s5) ;
///将集合转换对象数组
Object[] objects = c1.toArray();//c1:Student元素 Object obj = new Student() ;
for(int x = 0 ; x < objects.length ; x ++){
// System.out.println(objects[x]) ;
//通过Student的getXXX()获取信息
//向下转型
Student s = (Student) objects[x];
System.out.println(s.getName()+"----"+s.getAge());
}
}
}
public class Student {
private String name ;
private int age ;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}9.3 Collection集合的高级功能
boolean addAll(Collection c):添加一个集合中的所有元素
boolean containsAll(Collection c):包含一个集合的所有元素 (思考:包含一个算包含,还是所有元素) 包含所有算包含
boolean removeAll(Collection c):删除一个算删除还是删除所有算删除? 结论:删除一个集合中包含另一个集合中的某个元素,就算删除,返回true
public class CollectionDemo {
public static void main(String[] args) {
//创建两个集合
Collection c1 = new ArrayList() ;
c1.add("abc1") ;
c1.add("abc2") ;
c1.add("abc3") ;
c1.add("abc4") ;
c1.add("abc5") ;
c1.add("abc6") ;
c1.add("abc7") ;
Collection c2 = new ArrayList() ;
// c2.add("abc1") ;
// c2.add("abc2") ;
// c2.add("abc3") ;
// c2.add("abc4") ;
c2.add("abc5") ;
c2.add("abc6") ;
c2.add("abc7") ;
System.out.println("c1:"+c1) ;
System.out.println("c2:"+c2) ;
System.out.println("--------------------------------------") ;
//boolean addAll(Collection c):添加一个集合中的所有元素
//System.out.println("addAll():"+c1.addAll(c2));
//boolean containsAll(Collection c):包含一个集合的所有元素 (思考:包含一个算包含,还是所有元素) 包含所有
//System.out.println(c1.containsAll(c2));
//boolean removeAll(Collection c):删除一个算删除还是删除所有算删除?
// System.out.println(c1.removeAll(c2));
//boolean retainAll(Collection c): 求集合中的交集元素,boolean的表达式意思是什么?
//A集合对B集合求交集,boolean 什么情况true/什么情况下false
System.out.println(c1.retainAll(c2)) ;
System.out.println("c1:"+c1) ;
System.out.println("c2:"+c2) ;
}
}
18万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
