基础类库
概念：
java大师为了提高程序员的开发效率 在jre中定义的一个类库
学习方法：
1：学会使用api
2：反复多做每个类的练习题
3：熟悉每个类的作用+常用方法
api
application programming interface: 类和接口的集合
:类和接口中方法的使用说明书(声明)
Object
整个类结构的父类
public class Demo02Object {
public static void main(String[] args) {
//Object常用方法1： int hashCode() ：获取当前对象的10进制内存地址
Demo02Object obj1=new Demo02Object();
Demo02Object obj2=new Demo02Object();
int hc=obj1.hashCode();
System.out.println("hc="+hc);//2018699554
System.out.println(obj1);//打印对象对应的是：类型@地址 com.zhiyou100.day05_oop.Demo02Object@7852e922
//Object常用方法2：Class getClass() ：获取当前类的字节码文件对象(class文件)
Class c1=obj1.getClass();//获取的是：com.zhiyou100.day05_oop.Demo02Object.class文件对应的对象
//Class类的方法：String getName();获取类的全称
// String getSimpleName();获取类名
System.out.println("getName="+c1.getName());
System.out.println("getSimpleName="+c1.getSimpleName());
//Object常用方法3：String toString()：获取当前对象的字符串表示形式
// 打印对象、对象字符串拼接 默认调用的是对象的toString方法
System.out.println("obj1.toString() = "+obj1.toString());
System.out.println("obj1 = "+obj1);// com.zhiyou100.day05_oop.Demo02Object@7852e922
System.out.println("myToString(obj1) = "+myToString(obj1));
//Object常用方法4： boolean equals(Object obj) ：判断当前引用和参数引用是否指向同一个对象
obj1=obj2;
System.out.println(obj1.equals(obj2));
}
//写一个模拟object的toString的方法：类名@16进制内存地址
public static String myToString(Object o) {
//获取类的字节码文件对象
Class c=o.getClass();
//获取类名：
String name=c.getName();
//获取对象的10进制内存地址
int hc=o.hashCode();
//把10进制转换为16进制字符串
String strHc=to16(hc);
return name+"@"+strHc;
}
//写一个方法把参数十进制数转换为16进制字符串
public static String to16(int n) {
//创建一个字符数组 装16进制的所有字符
char[] arr= {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
//1---1 ....9----9 10---a 15----f 16----10
//获取n的m进制：循环拿n余m 再除m 直到0
int k=n;
String result="";
while(true) {
if(k==0) {break;}
result=arr[k%16]+result;
k=k/16;
}
System.out.println(n+" 16进制是："+result);
return result;
}
//写一个方法把参数十进制数转换为2进制字符串
public static String to2(int n) {
//获取n的m进制：循环拿n余m 再除m 直到0
int k=n;
String result="";
while(true) {
if(k==0) {break;}
result=k%2+result;
k=k/2;
}
System.out.println(n+" 二进制是："+result);
return result;
}
}
Object练习
public class Demo03Object {
public static void main(String[] args) {
Student s1=new Student(18, "韩梅梅", '女');
Student s2=new Student(18, "韩梅梅", '女');
System.out.println(s1.equals(s2));//所有属性相同 返回true
System.out.println(s1);//打印对象 默认调用的是toString方法
}
}
class Student{
int age;
String name;
char sex;
public Student(int age, String name, char sex) {
this.age = age;
this.name = name;
this.sex = sex;
}
//重写Object类的equals方法
//1 方法声明必须和父类相同
public boolean equals(Object o) {
//2 判断参数对象的类型是不是当前类的类型
if(!(o instanceof Student)) {return false;}
//3 向下转型
Student s=(Student)o;
//4 根据规则判断
//基本数据类型判断是否相等用==
//字符串判断是否相同 用字符串的equals方法
return this.age==s.age&&this.sex==s.sex&&this.name.equals(s.name);
}
//重写toString方法 返回所有属性的值
public String toString() {
return "Student name="+name+",age="+age+",sex="+sex;
}
}
Math类
* Math:与数学运算相关的所有方法和属性
* 特点：1 所有的成员都是静态的：
* 2 构造方法私有的：不能实例化
* 属性： 1 E :自然对数
* 2 PI:圆周率
* 方法：
* 1 绝对值
* static double abs(double a)
* 2 幂运算
* static double cbrt(double a) 对a开立方
* static double pow(double a, double b) 求a的b次方
* static double sqrt(double a) 对a开平方
* 3 近似值
* static double ceil(double a) 获取大于等于参数a的最小整数
* static double floor(double a) 获取小于等于参数a的最大整数
* static double rint(double a) 获取a的四舍六入 五取偶数
* static long round(double a) 四舍五入
* 4 随机
* static double random() :随机范围[0.0,1.0)
方法练习
//Class c;//可以使用有两种：当前项目的类+jre基础类库中的类
//属性
System.out.println("Math.E="+Math.E);//2.718281828459045
System.out.println("Math.PI="+Math.PI);//3.141592653589793
//方法1：绝对值
System.out.println("绝对值："+Math.abs(-1));
System.out.println("绝对值："+Math.abs(1));
//方法2：幂运算
for (int i =1; i <=10; i++) {
System.out.println(i+"开平方="+Math.sqrt(i));
System.out.println(i+"开平方="+Math.pow(i, 0.5));
System.out.println(i+"开立方="+Math.cbrt(i));
System.out.println(i+"开立方="+Math.pow(i, 1.0/3));
System.out.println(i+"的平方"+Math.pow(i, 2));
}
//方法3：近似值
for (int i =10; i < 40; i++) {
double n=i/10.0;
// System.out.println("Math.ceil("+n+")="+Math.ceil(n));
// System.out.println("Math.floor("+n+")="+Math.floor(n));
// System.out.println("Math.rint("+n+")="+Math.rint(n));
System.out.println("Math.round("+n+")="+Math.round(n));
}
//方法4：随机
for (int i = 0; i <10; i++) {
//System.out.println(i+":::::"+Math.random());
//随机0到5
//System.out.println(i+"::::"+Math.floor(Math.random()*6));
//System.out.println(i+"::::"+(int)(Math.random()*6));
//随机1到5
// System.out.println(i+":::::::::"+(int)(Math.random()*5+1));
//随机1到7
//System.out.println((int)(Math.random()*7+1));
//随机年龄：18-25
//System.out.println((int)(Math.random()*8+18));
//随机分数：[0.0,100.0]
System.out.println((int)(Math.random()*1001)/10.0);
}
//[0,1)------[a,b]整数范围
//[0,1)----乘以范围(b-a+1)---->[0,b-a+1)
// ----加上起始值a--------->[a,b+1)
// ----强制转换为int------->[a,b]
System类
* System：和系统相关的所有属性和方法
* 特点：1 所有成员都是静态的
* 2 无法实例化
* 属性：
* static PrintStream err ：错误输出流 把系统的输出信息输出到控制台consloe中 字体红色 用于报错信息
* static PrintStream out ：标准输出流 把系统的输出信息输出到控制台consloe中
* err:字体红色：：：：和out打印顺序无法预知(两个线程)
static InputStream in ：标准键盘输入流
方法：
static long currentTimeMillis() ：获取当前时间的毫秒值 相当于历元：：
1970-1-1 0:0:0
static void exit(int status) ： 程序停止： 参数为0表示正常终止
参数非0 异常终止
static void gc() ： 获取垃圾回收器对象
方法详解
public class Demo03System {
public static void main(String[] args) {
// Mather.son.show();
// System.out.println();
System.err.println("err:::11");
System.err.println("err:::12");
System.err.println("err:::13");
System.out.println("out:::::::11");
System.out.println("out:::::::12");
System.out.println("out:::::::13");
//System.out.println(1/0);//java.lang.ArithmeticException: / by zero
//System.exit(0);
//获取系统输入流监控器对象
// Scanner sr=new Scanner(System.in);
// //阻塞方法：next nextInt：：：程序等待用户执行输入操作 只有执行了此操作 程序才继续执行
// System.out.println("请输入一个字符：：");
// String str=sr.next();
// System.out.println("输入的内容是："+str);
// int n=sr.nextInt();
// System.out.println("输入的整数是："+n);//InputMismatchException
long ms=System.currentTimeMillis();
System.out.println(ms);//1611545788920
System.out.println(ms/1000/3600/24/365);//51
}
}
class Mather{
static Son son;
static {
son=new Son();son.name="tom";
}
}
class Son{
String name;
void show() {
System.out.println(name+"show");
}
}
Scanner
tudent s=new Student();
//创建一个输入流的监控器对象
Scanner sr=new Scanner(System.in);
System.out.println("请输入一个字符串：");
String str=sr.next();//阻塞方法
System.out.println("请输入一个整数：");
int n=sr.nextInt(); //阻塞方法
s.name=str;
s.age=n;
String 类
构造方法
* Srting:字符串类：jre中最重要的类
* 注意事项： 1 创建字符串对象两种方式：
* 方式一：通过双引号 String s="1abna";
* 方式二：通过构造方法：String s=new String("aaa");
* 2 字符串对象是常量：字符串对象一旦创建 字符序列不能更改
* String s="a"+1+2+2+4+"c"; //7个字符串对象
* 构造方法：
* 1： 无参数的构造方法
* String() ：创建一个空序列的字符串对象
* 2： 参数是数组：char int byte
* String(char[] value)
String(char[] value, int offset, int count)
String(byte[] bytes) :
通过平台默认编码集 把字节数组转换为字符串
String(byte[] bytes, String charsetName) :
通过指定编码集 把字节数组转换为字符串
String(byte[] bytes, int offset, int length)
String(byte[] bytes, int offset,
int length,String charsetName)
String(int[] codePoints, int offset, int count)
3：获取与参数字符串对象相同序列的字符串对象
String(String original)
构造方法的代码
public static void main(String[] args)throws UnsupportedEncodingException {
String s1=new String();//通过构造方法 创建一个字符串对象 字符序列是空的
String s2=""; //通过双引号 创建一个字符串对象 字符序列是空的
String s3=" "; //通过双引号 创建一个字符串对象 字符序列中有一个字符 ' '
String s4=null; //没有创建字符串对象 引用的地址栏=存放的是常量值null
//没有指向任何对象
char[] arr1= {'a','b','c','d','1','2'};
String ss=new String(arr1);
System.out.println("ss="+ss);
ss=new String(arr1,2,3);
System.out.println("ss="+ss);
byte[] arr2= {48,49,90,91,101,102,103};
ss=new String(arr2);
System.out.println("ss="+ss);
ss=new String(arr2,"UTF-8");
//程序通过一个字符串表示编码集的名字 编译器无法判断此名字的编码集是否存在
//在方法声明上通过throws UnsupportedEncodingException 警告可能会出错
//Unhandled exception type UnsupportedEncodingException
//所有的编码表兼容ascii码表
System.out.println("ss="+ss);
String sss=new String("123");//创建了几个字符串对象
//先通过双引号创建一个字符串对象123
//再通过new调用构造方法 创建一个"123"的副本对象
}
普通方法
1 判断：
1.1 大小比较
int compareTo(String anotherString) :拿当前字符串和参数字符串比较 逐个字符按编解码比较
int compareToIgnoreCase(String str) :拿当前字符串和参数字符串比较 不区分大小写
1.2 判断是否包含
boolean contains(CharSequence s) :判断当前字符串是否包含参数字符串序列
1.3 判断结尾和开头
boolean endsWith(String suffix) :判断当前字符串是否以参数字符串结尾
boolean startsWith(String prefix) : 判断是否以prefix开头
1.4 判断字符序列是否相同
boolean equals(Object anObject) :字符串序列判断是否相同
boolean equalsIgnoreCase(String anotherString) :字符串序列判断是否相同 不区分大小写
1.5 判断是否为空
boolean isEmpty() : 判断是否为空字符序列
2 获取：
2.1获取字符个数
int length() : 获取字符个数
2.2 根据下标获取字符
char charAt(int index) :根据下标获取字符
2.3 获取字节数组
byte[] getBytes() :获取字节数组 根据平台默认编码集
byte[] getBytes(String charsetName) :获取字节数组 根据指定编码集
2.4 由字符获取下标
int indexOf(int ch) :获取参数字符第一次出现的位置
int indexOf(int ch, int fromIndex) :从fromIndex位置处开始 获取参数字符第一次出现的位置
int indexOf(String str) :获取参数字符串第一次出现的位置
int indexOf(String str, int fromIndex) :从fromIndex位置处开始 获取参数字符串第一次出现的位置
int lastIndexOf(int ch) :倒着找
int lastIndexOf(int ch, int fromIndex) :倒着找
int lastIndexOf(String str) :倒着找
int lastIndexOf(String str, int fromIndex) :倒着找
注意：参数字符/字符串不存在 返回-1
2.5 切割或者字符串数组
String[] split(String regex) :使用regex切割当前字符串 获取子串数组
2.6 截取子串
String subSequence(int beginIndex, int endIndex) : 获取子串
String substring(int beginIndex) : 获取子串
String substring(int beginIndex, int endIndex) : 获取子串
2.7 获取字符数组
char[] toCharArray() : 转换为字符数组
2.8 获取参数对象的字符串表示形式
static String valueOf(Object b) : 获取参数对象的字符串形式
3 转换:
3.1 字符串拼接：等价于字符串连接符+
String concat(String str) :字符串拼接
3.2 替换
String replace(char oldChar, char newChar): 使用 newChar替换所有的oldChar
String replace(String target, String replacement) :使用 replacement替换所有的target
3.3 大小写转换
String toLowerCase() : 所有字母小写
String toUpperCase() : 所有字母大写
3.4 去除两边的空格
String trim() : 去除两边空格
字符串练习
public class ZuoYe01 {
//* 7：写一个方法static String changeStr(String s);去除叠词：："123111222444766"--"12312476"
static String changeStr3(String s) {
String ss="";
for (int i = 0; i < s.length(); i++) {
char c=s.charAt(i);//获取当前字符
if(i==0) {
ss+=c;
}else {
char cc=s.charAt(i-1);
ss+=(cc==c?"":c);
}
}
return ss;
}
//* 7：写一个方法static String changeStr(String s);去除叠词：："eeejjjjyutttttrrrrwwwbbuk"--"e3j4yut5r4w3b2uk"
//* 6：写一个方法static String changeStr(String s);获取s中所有全部但不重复的字符：："12312345123"--"12345"
static String changeStr2(String s) {
String ss="";
for (int i = 0; i < s.length(); i++) {
char c=s.charAt(i);
// if(ss.indexOf(c)==-1) {
// ss+=c;
// }
if(!ss.contains(String.valueOf(c))) {
ss+=c;
}
}
return ss;
}
//5：写一个方法 static void getDay(String s);打印s表示的年月日 s的格式：xxxx年xx月xx日
static void getDay(String s) {
//获取年：
String year=s.substring(0, s.indexOf('年'));
String month=s.substring(s.indexOf('年')+1,s.indexOf('月'));
String day=s.substring(s.indexOf('月')+1, s.indexOf('日'));
System.out.println("年="+year);
System.out.println("月="+month);
System.out.println("日="+day);
}
//* 4：写一个方法 static String changeStr(String s); 大写转换为小写 小写转换为大写 删除数字
static String changeStr(String s) {
String ss="";//定义一个空字符串 接受结果
for (int i = 0; i <s.length(); i++) {
char c=s.charAt(i);//获取当前字符
if(c>='a'&&c<='z') {
ss+=(char)(c-('a'-'A'));
}else if(c>='A'&&c<='Z') {
ss+=(char)(c+('a'-'A'));
}else if(c<'0'||c>'9') {
ss+=c;
}
}
return ss;
}
//* 3：写一个方法 static String myTrim(String s);模拟字符串的trim（去除两边的空格）方法
static String myTrim(String s) {
//获取子串：从第一个非空字符开始 到最后一个非空字符结束
int start=-1,end=s.length()-1;
for (int i = 0; i < s.length(); i++) {
char c=s.charAt(i);
if(c!=' ') {
start=i;break;
}
}
if(start==-1) {
return "";
}
for (int i = s.length()-1; i >=0; i--) {
char c=s.charAt(i);
if(c!=' ') {
end=i;break;
}
}
//截取子串
return s.substring(start, end+1);
}
//* 2：写一个方法 static void getCount(String s);打印s中数字字符 字母字符 其他字符出现的次数
static void getCount(String s) {
int sz=0,zm=0,qt=0;
for (int i = 0; i <s.length(); i++) {
char c=s.charAt(i);
if(c>='0'&&c<='9') {
sz++;
}else if((c>='a'&&c<='z')||(c>='A'&&c<='Z')) {
zm++;
}else{
qt++;
}
}
System.out.println(s+"中数字有"+sz+"个，字母有"+
zm+"个，其他字符"+qt+"个!");
}
//* 1：写一个方法 static void getCount(String s,char c);打印c字符在s中出现的次数
static void getCount(String s,char c) {
int count=0;
for (int i = 0; i < s.length(); i++) {
char cc=s.charAt(i);
count+=cc==c?1:0;
}
System.out.println(s+"中字符"+c+"出现的次数是："+count);
}
//1 写一个方法：猜字游戏 先随机一个数字 然后让用户通过键盘输入一个数字
//判断输入的数字是否猜中 如果没有猜中就告诉他太大或者太小 最后打印猜对需要的次数
public static void game() {
//随机一个数字
int n=(int)(Math.random()*10+0);//乘以范围 加上起始值 强制转换为int
int ciShu=0;
Scanner sr=new Scanner(System.in);
while(true) {
System.out.println("请输入一个数字：");
int num=sr.nextInt();
ciShu++;
if(num==n) {
System.out.println("猜对了：使用次数为："+ciShu);
break;
}
System.out.println("太"+(num>n?"大":"小")+"了");
}
}
}
//2 创建一个老师类：属性：名字 年龄 性别 工资 所有属性私有化封装
// 重写toString方法：打印内容如： 我叫韩寒 是一名男老师 今年30岁 每月工资是1000元
// 重写equals方法 要求当名字相同 性别相同 年龄相差1岁以内 工资相差100元以内 为同一个人
// 提供两个构造方法：一个有参数的给所有属性赋值
// 一个无参数的：所有属性都随机 名字随机4个字符（数字+字母） 工资(3000.0-5000.0) 年龄(30-40) 性别(男-女)
class Teacher{
private int age;
private char sex;
private float salary;
private String name;
public String toString() {
return "我叫"+name+" 是一名"+sex+"老师 今年"+age+"岁 每月工资是"+salary+"元! ";
}
//1 方法声明必须和父类完全相同
public boolean equals(Object o) {
//2 判断参数对象的类型
if(!(o instanceof Teacher)) {
return false;
}
//3向下转型
Teacher t=(Teacher)o;
//4条件判断
//return this.name.equals(t.name)&&this.sex==t.sex&&this.age-t.age>=-1&&this.age-t.age<=1
// &&this.salary-t.salary<=100&&this.salary-t.salary>=-100;
return this.name.equals(t.name)&&this.sex==t.sex&&Math.abs(this.age-t.age)<=1
&&Math.abs(this.salary-t.salary)<=100;
}
//自动生成getset方法::alt+shift+s
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public float getSalary() {
return salary;
}
public void setSalary(float salary) {
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Teacher(int age, char sex, float salary, String name) {
this.age = age;
this.sex = sex;
this.salary = salary;
this.name = name;
}
public Teacher() {
// 一个无参数的：所有属性都随机 名字随机4个字符（数字+字母） 工资(3000.0-5000.0) 年龄(30-40) 性别(男-女)
this.name=randomName();
this.age=(int)(Math.random()*11+30);
this.salary=(int)(Math.random()*20001+30000)/10.0f;
this.sex=Math.random()>0.5?'男':'女';
}
private String randomName() {
char[] arr=new char[62];
for (int i = 0; i < 10; i++) {
arr[i]=(char)('0'+i);
}
for (int i = 0; i < 26; i++) {
arr[i+10]=(char)('a'+i);
}
for (int i = 0; i < 26; i++) {
arr[i+36]=(char)('A'+i);
}
String s="";
for (int i = 1; i <=4; i++) {
char c=arr[(int)(Math.random()*arr.length)];
s+=c;
}
return s;
}
}
public class ZuoYe02 {
//* 12:写一个方法 把参数字符串反转："123456"--->"654321"
public static String reverse(String s) {
String ss="";
for (int i = 0; i < s.length(); i++) {
char c=s.charAt(i);
ss=c+ss;
}
System.out.println(s+":::::"+ss);
return ss;
}
//先比较长度 s1长度大于s2 就返回1 小于 就返回-1
// 如果长度相同：再逐个字符按编码集做比较 s1大 就返回1 s1小 返回-1 相同返回0
public static int myCompareto(String s1,String s2) {
if(s1.length()!=s2.length()) {
return s1.length()>s2.length()?1:-1;
}
for (int i = 0; i < s1.length(); i++) {
char c1=s1.charAt(i);
char c2=s2.charAt(i);
if(c1!=c2) {
return c1>c2?1:-1;
}
}
return 0;
}
//* 9：写一个方法static int getInt(String s);获取参数字符串中所有数字对应的最大整数："ab1hy75tr0"----7510
static int getInt2(String s) {
//创建一个空字符串 记录所有的数字字符
String ss="";
for (int i = 0; i < s.length(); i++) {
char c=s.charAt(i);
ss+=(c>='0'&&c<='9')?c:"";
}
//由ss获取一个char数组 对数组排序
char[] arr=ss.toCharArray();
for (int i = 0; i < arr.length-1; i++) {
for (int j = i+1; j < arr.length; j++) {
if(arr[i]<arr[j]) {
char k=arr[i];arr[i]=arr[j];arr[j]=k;
}
}
}
//由排序后的数组 获取一个整数
int result=0;
for (int i = arr.length-1,k=1; i >=0; i--,k*=10) {
result+=k*(arr[i]-'0');
}
System.out.println(s+":::"+result);
return result;
}
//* 8：写一个方法static int getInt(String s);获取参数字符串对应的整数："123"----123
static int getInt(String s) {
//'1'----1
//需要把字符1 转换为整数1
//需要按位数乘以10的次方
int result=0;
for (int i = s.length()-1,k=1; i >=0; i--,k*=10) {
char c=s.charAt(i);
int n=c-'0';
result+=n*k;
}
System.out.println("result="+result);
return result;
}
//* 7：写一个方法static String changeStr(String s);去除叠词：："eeejjjjyutttttrrrrwwwbbuk"--"e3j4yut5r4w3b2uk"
static String changeStr(String s) {
String ss="";
int count=1;
for (int i = 0; i < s.length(); i++) {
char c=s.charAt(i);//获取当前字符
if(i==0) {
ss+=c;
}else {
char cc=s.charAt(i-1);//获取当前字符前面的字符
if(cc==c) {
count++;
}else {
ss+=count>1?count:"";//把count加入ss
ss+=c;//当前字符加氟ss
count=1;//count重新值为1 记录的是当前字符的次数
}
}
}
ss+=count>1?count:"";//把最后一个字符的次数加入ss
System.out.println(s+":::"+ss);
return ss;
}
}
Date
* Date:日期
* 特点：
* 1 有两个Date:java.sql.Date和java.util.Date(今天学的)
* 2 有多个方法是已过时的(不易于实现国际化/建议通过Calendar类来替代)
* 3 年月日参照数据不同：指定年时+1900 指定月(0-11)
*
* 构造方法：
* 1 无参数：
* Date() 获取当前时间
* 2 参数是年月日时分秒
* Date(int year, int month, int date, int hrs, int min, int sec)
* 3 参数是毫秒值：相当于历元(1970-1-1 0:0:0)
* Date(long date)
*
* 普通方法：
* 1 比较
* boolean after(Date when)
boolean before(Date when)
int compareTo(Date anotherDate) :
当前时间对象大 返回正数 当前时间对象小 返回负数 时间相同返回0
boolean equals(Object obj) ：
判断当前引用和参数引用指向的时间对象是否为同一个时间点
2 获取和设置时间参数:注意年-1900 月-1
int getXxx()
void setXxx(value)
3 日期和毫秒值之间的转换
long getTime();获取当前时间对象对应的毫秒值
void setTime(long time);把当前时间对象表示的时间设置为参数毫秒值对应的时间
4 获取本地系统设置的时间格式对应的字符串
String toLocaleString() ;
//写一个方法：由date获取一个字符串：xxxx-xx-xx 星期x xx:xx:xx
private static String str2Date(Date d) {
//获取时间参数
int year=d.getYear()+1900;
int month=d.getMonth()+1;
int day=d.getDate();
int week=d.getDay();
int hour=d.getHours();
int minute=d.getMinutes();
int second=d.getSeconds();
String weeks="日一二三四五六";
//拼凑字符串
String str=year+"-"+month+"-"+day+" 星期"+weeks.charAt(week)+" "+hour+":"+minute+":"+second;
System.out.println(str);
return str;
}
SimpleDateFormat
public class Demo02SimpleDateFormat {
/*SimpleDateFormat:实现日期与字符串之间的相互转换
*格式化：由Date对象获取一个指定格式的字符串
*解析： 由指定格式的字符串获取一个日期对象
*构造方法：
* SimpleDateFormat(String pattern) ： pattern指定字符串格式
* pattern来指定字符串中那部分是时间什么参数：：通过一些预定义的字符来表示
*
* y--年
* M--月
* d--日
* E--星期
* H--时
* m--分
* s--秒
*
*普通方法：
* String format(Date date)：由参数date获取一个指定格式的字符串---格式化
* Date parse(String source) throws ParseException：由参数字符串获取一个date对象---解析
*
*
* */
public static void main(String[] args)throws ParseException{//1234-12-11 星期x 12:12:14
//准备模式--指定字符串的格式
String pattern="yyyy-MM-dd E HH:mm:ss";
//创建日期格式化对象
SimpleDateFormat sdf=new SimpleDateFormat(pattern);
Date date=new Date();
//格式化
String str=sdf.format(date);
System.out.println(str);
//解析
str="2021-01-26 星期二 14:01:07";
date=sdf.parse(str);//Unhandled exception type ParseException
System.out.println(date.toLocaleString());
}
}
练习
package com.zhiyou100.day07_basicclass;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo03LianXi {
public static void main(String[] args) {
// TODO Auto-generated method stub
dysw1("2000-1-4");
getWeek();
getDJS();
}
// 2 写一个方法 打印今天是周几?(比如是周二) 然后再判断今天是今年的第几个周二
public static void getWeek() {
String weeks="日一二三四五六";
Date date=new Date();
int week=date.getDay();
System.out.println(date.toLocaleString()+":::是星期"+weeks.charAt(week));
//是本年的第几个星期2
//获取今年的第一天
Date date0=new Date(date.getYear(), 1-1, 1);
//获取第一天的星期
int week0=date0.getDay();
//获取今天和第一天之间的差值
long chaTime=date.getTime()-date0.getTime();
int chaDays=(int)(chaTime/1000/3600/24);
int cs=chaDays/7;
System.out.println("今天是今年的第"+(cs+1)+"个星期"+weeks.charAt(week));
}
// 1 写一个方法 static void daYuShaiWang(String s);
// 判断从2000年1月1日开始三天打渔两天晒网 到s(格式是xxxx-xx-xx)表示的时间
// 是打渔还是晒网
public static void dysw1(String s) {
//截取子串
String yearStr=s.substring(0, s.indexOf('-'));
String monthStr=s.substring(s.indexOf('-')+1, s.lastIndexOf('-'));
String dayStr=s.substring(s.lastIndexOf('-')+1);
//把字符串转换为int
int year=str2Int(yearStr);
int month=str2Int(monthStr);
int day=str2Int(dayStr);
//由年月日获取日期
Date date1=new Date(year-1900, month-1, day);
//获取2000年1月1日的日期对象
Date date2=new Date(2000-1900, 1-1, 1);
//获取两个日期之间的天的差数
int days=(int)((date1.getTime()-date2.getTime())/1000/3600/24);
//获取余数
int ys=days%5;
System.out.println(s+"对应的时间是在"+(ys==4||ys==3?"晒网":"打渔"));
}
private static int str2Int(String s) {
int result=0;
for (int i = s.length()-1,k=1; i >=0; i--,k*=10) {
result+=(s.charAt(i)-'0')*k;
}
return result;
}
// 3 写一个方法 打印：当前时间xxxx年xx月xx日 星期x xx点xx分xx秒 过年(阴历年2021-2-12)倒计时：xx天
public static void getDJS() {
//获取当前时间
Date date=new Date();
//创建一个日期格式化对象 并指定字符串格式如：xxxx年xx月xx日 星期x xx点xx分xx秒
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 E HH点mm分ss秒");
String str=sdf.format(date);
//获取过年的date
Date nian=new Date(2021-1900, 2-1, 12);
//获取毫秒值之差
long cha=nian.getTime()-date.getTime();
//获取天数
long days=cha/1000/3600/24;
System.out.println("当前时间"+str+" 过年(阴历年2021-2-12)倒计时："+days+"天");
}
}
练习
package com.zhiyou100.day07_basicclass;
public class ZuoYe03 {
// 1 编写敏感词过滤程序
// 在网络程序中，如聊天室、聊天软件等，经常需要对一些用户所提交的聊天内容中的敏感性词语进行过滤。
// 如“性”、“色情”、“爆炸”、“恐怖”、“枪”等，这些都不可以在网上进行传播，
// 需要过滤掉或者用其他词语替换掉。
// 提示：将敏感词保存到一个字符串数组中,
// 遍历字符串数组 然后使用String的replace方法来替换
public static void guoLv(String s) {
String[] mgcs= {"性","色情","爆炸","枪","恐怖"};
for (int i = 0; i < mgcs.length; i++) {
s=s.replace(mgcs[i], "*");
}
System.out.println(s);
}
// 2 在注册时通常要验证用户名和密码是否合法，运用学习过的知识完成如下操作：
// 用户名长度大于等于6位，必须包含数字和英文字母
// 密码长度大于等于8位，必须包含特殊符合_或者$，英文字母以及数字
// 以上两个条件同时成立注册才能成功。
public static boolean regist(String name,String pwd) {
//判断用户名
boolean pdName=pd(name,6);
boolean pdPwd1=pd(pwd,8);
//判断密码是不是包含_或者$
boolean pdPwd2=false;
for (int i = 0; i < pwd.length(); i++) {
char c=pwd.charAt(i);
if(c=='_'||c=='$') {
pdPwd2=true;
}
}
return pdPwd2&&pdPwd1&&pdName;
}
//写一个方法 对参数字符串进行长度判断 并必须包含数字和字母
private static boolean pd(String s,int length) {
//判断长度
if(s.length()<length) {return false;}
//判断字母和数字
boolean sz=false,zm=false;
for (int i = 0; i <s.length(); i++) {
char c=s.charAt(i);
if(c>='0'&&c<='9') {
sz=true;
}else if((c>='a'&&c<='z')||(c>='A'&&c<='Z')) {
zm=true;
}
}
return sz&&zm;
}
public static void main(String[] args) {
guoLv("特朗普拿着抢进行恐怖色情危险性活动！");
}
}
2： 包装类之Integer
/*java为了实现完全面向对象
*为八种基本数据类型提供八种包装类
*基本数据类型 包装类
*byte Byte
*short Short
*char Character
*int Integer
*long Long
*float Float
*double Double
*boolean Boolean
*
*包装类作用：实现基本数据类型与字符串之间转换
*八种包装类方法完全类似：只用学习Integer和Character
*包装类对象、基本数据类型常量值、字符串对象
* */
int n=1;Integer i1;
//1 ：基本数据类型--->包装类对象
//1.1 构造方法：Integer(int value)
i1=new Integer(n);
System.out.println(i1);//打印对象 默认调用的是对象的tostring方法 1
//1.2 静态方法：static Integer valueOf(int i)
i1=Integer.valueOf(n);
//1.3 自动装箱：编译器自动由基本数据获取对应的包装类对象
i1=n;//编译器自动实现：i1=new Integer(n);
//2：包装类对象--->基本数据类型
//2.1 普通方法： int intValue()
n=i1.intValue();
//2.2 自动拆箱：编译器自动由包装类对象获取对应的基本类型数据
n=i1;
//3：字符串对象--->包装类对象
//3.1 构造方法：Integer(String s)
String s="123";
i1=new Integer(s);
System.out.println(i1);//123
//3.2 静态方法：static Integer valueOf(String s)
// static Integer valueOf(String s, int radix)
i1=Integer.valueOf("1234");
System.out.println(i1);//1234
i1=Integer.valueOf("111",2);
System.out.println(i1);//7
//4：包装类对象--->字符串对象
//4.1 普通方法：String toString()
s=i1.toString();
//4.2 连接""
s=i1+"";
//5：基本数据类型--->字符串
//5.1 静态方法： static String toBinaryString(int i):获取i的二进制
// static String toHexString(int i) :获取i的十六进制
// static String toOctalString(int i) :获取i的八进制
// static String toString(int i, int radix) :获取i的radix进制
for (int i =1; i <100; i++) {
//System.out.println(i+" 二进制 "+Integer.toBinaryString(i));
//System.out.println(i+" 十六进制 "+Integer.toHexString(i));
//System.out.println(i+" 八进制 "+Integer.toOctalString(i));
System.out.println(i+" 三进制 "+Integer.toString(i,3));
}
//5.2 连接""
//6：字符串--->基本数据类型
//6.1 静态方法：static int parseInt(String s)
n=Integer.parseInt("1234");
n=Integer.parseInt("1234a");//NumberFormatException
//"1.1"
double d=Double.parseDouble("1.1");
//面试题：
Integer i11=11,i12=11;
System.out.println(i11==i12);//true
i11=211;i12=211;
System.out.println(i11==i12);//false
for (int i = -200; i <200; i++) {
i11=i;i12=i;
System.out.println(i+" "+(i11==i12));
}
//自动装箱时 ：当值的取值为[-128,127]之间时使用的是相同对象 在这个范围之外的话 每装箱一次就是一个新的对象
==和equals的区别
//==和equals的区别
//==操作基本数据类型 判断的是值是否相同
int a=1,b=2; System.out.println(a==b);
//==操作引用数据类型 判断的是两个引用是否指向同一个对象
Object o1=new Object();Object o2=new Object(); System.out.println(o1==o2);
//equals是方法 只能操作引用数据类型
//equals是Object类的方法(判断两个引用是否指向同一个对象)：可以被子类重写
System.out.println(o1.equals(o2));
字符串常量池
//创建字符串对象有两种方式：通过双引号+通过构造方法
String s1="123a",s2="123a";
String ss1=new String("123a");
String ss2=new String("123a");
System.out.println("s1==s2 "+(s1==s2));//true
System.out.println("ss1==ss2 "+(ss1==ss2));//false
System.out.println("s1==ss2 "+(s1==ss2));//false
System.out.println("s1.equals(s2) "+(s1.equals(s2)));//equals判断字符序列是否相同
System.out.println("ss1.equals(ss2) "+(ss1.equals(ss2)));
System.out.println("s1.equals(ss2) "+(s1.equals(ss2)));
//字符串常量池：当通过双引号创建字符串对象时 先判断此字符序列在字符串常量池中是否存在
// 如果存在直接使用 如果不存在 再创建
String s0=new String("1235");//创建了两个对象
//先通过双引号在 字符串常量池中创建一个"1235"
//再通过new 创建一个和"1235"相同序列的副本对象
2：字符串缓冲区
2.1 概念
*字符串缓冲区：StringBuffer+StringBuilder
*字符串String:String创建的对象是常量：：：字符串对象一旦创建字符序列不能更改
* 在进行字符串拼接时 会在内存中形成好多字符串对象
*字符串缓冲区：字符串序列可以更改
*字符串缓冲区：字符串创建后 字符序列可以更改
*字符串缓冲区：StringBuffer StringBuilder是等价类(api兼容 方法完全相同)
*区别： 版本不同：StringBuffer jdk1.0 StringBuilder jdk1.5
* 是否支持多线程：StringBuffer支持多线程 线程安全 效率低
* StringBuilder不支持多线程 线程不安全 效果高
*
*
面试题：String、StringBuffer StringBuilder的区别:
三者共同点：都是final类，都不允许被继承。
StringBuffer支持多线程，线程安全
StringBuilder不支持多线程，线程不安全，速度比StringBuffer快得多。
StringBuffer和StringBuilder两者共同之处：可以通过append、insert进行字符串的操作。
String实现了三个接口：Serializable、Comparable<String>、CharSequence
StringBuilder只实现了两个接口Serializable、CharSequence，相比之下String的实例可以通过compareTo方法进行比较，其他两个不可以。
在执行速度方面：
StringBulider>StringBuffer>String
安全方面：
StringBuffer 安全
StringBuilder 不安全
2.2 构造方法
//StringBuffer构造方法
//1 StringBuffer() :创建一个空序列的字符串缓冲区
StringBuffer stb1=new StringBuffer();
//2 StringBuffer(String) :创建一个与参数字符串相同序列的字符串缓冲区
StringBuffer stb2=new StringBuffer("1234");
2.3 普通方法
//StringBuffer与String相同的方法
//1 char charAt(int index) :获取参数下标处的字符
//2 int indexOf(String str) :获取str第一次出现的位置
// int indexOf(String str, int fromIndex) :从fromIndex位置处开始找 获取str第一次出现的位置
// int lastIndexOf(String str) :倒着找
// int lastIndexOf(String str, int fromIndex) :倒着找
//3 int length() :获取字符个数
//4 String substring(int start, int end) 截取从start到end-1处的子串
//StringBuffer特有的普通方法
//1 StringBuffer append(Object obj) : 字符串拼接 返回的是当前对象
//stb2=stb2+"1";//字符串缓冲区不能用连接符
StringBuffer stb3=stb2.append(56);
System.out.println(stb2==stb3);//true
stb2.append("1").append(1).append(true);//可以轻松实现方法链
//2 StringBuffer delete(int start, int end):删除start到end-1处的字符
stb1=new StringBuffer("abcdefghijk");
stb1.delete(1, 3);
System.out.println(stb1);//adefghijk
//3 StringBuffer deleteCharAt(int index) :删除指定下标处的字符
System.out.println(stb1.deleteCharAt(0));//defghijk
//4 StringBuffer insert(int offset, Object o): 在 offset位置处插入o
stb1=new StringBuffer("abcdefghijk");
//System.out.println(stb1.insert(0, "00"));//00abcdefghijk
//System.out.println(stb1.insert(11, "00"));//abcdefghijk00
System.out.println(stb1.insert(stb1.length(), "00"));//abcdefghijk00
//5 StringBuffer replace(int start, int end, String str): 用str替换start到end-1处的所有字符
stb1=new StringBuffer("abcdefghijkbc");
System.out.println(stb1.replace(1, 3, ""));//adefghijkbc
//6 StringBuffer reverse() :反转
System.out.println(stb1.reverse());//cbkjihgfeda
//7 void setCharAt(int index, char ch) : 替换index下标处的字符为ch
stb1=new StringBuffer("abcdefghijkbc");
stb1.setCharAt(1, '0');
System.out.println(stb1);//a0cdefghijkbc
2.4 练习
public class LianXi01 {
public static void main(String[] args) {
StringBuffer stb=new StringBuffer("1231231231234455111");
replace(stb,'1','0');
System.out.println(stb);
}
//当需要大量的字符串拼接时 考虑使用字符串缓冲区
//练习1： 写一个方法实现字符串转换：大小写转换 删除数字：只能使用字符串缓冲区
public static String change(String s) {
//字符串---》字符串缓冲区 通过构造方法
//字符串缓冲区---》字符串 toString方法
StringBuffer stb=new StringBuffer(s);
//遍历字符串缓冲区
for (int i = 0; i < stb.length(); i++) {
//获取当前字符
char c=stb.charAt(i);
//判断当前字符串的类型
if(Character.isUpperCase(c)) {
c=Character.toLowerCase(c);
stb.setCharAt(i,c);
}else if(Character.isLowerCase(c)) {
c=Character.toUpperCase(c);
stb.setCharAt(i,c);
}else if(Character.isDigit(c)) {
stb.deleteCharAt(i);
i--;
}
}
return stb.toString();
}
//练习2：写一个字符串的replace方法：void replace(StringBuffer stb,char old,char new);
static void replace(StringBuffer stb,char oldChar,char newChar) {
while(true) {
int index=stb.indexOf(oldChar+"");
if(index==-1) {
return;
}
stb.setCharAt(index, newChar);
}
}
}
3：Calendar
public class Demo03Calendar {
public static void main(String[] args) {
//日历：Calendar
/*
* 注意事项：
* 1 Calendar是抽象类 不能创建对象
* 通过静态方法static Calendar getInstance() 获取一个子类对象
* 2 Calendar类把与时间相关的所有参数都列出来 实现国际化
* */
Calendar c1=Calendar.getInstance();//获取的是calendar的子类对象
DemoFu df=DemoFu.getInstance();
System.out.println(c1);
//java.util.GregorianCalendar[time=1614061897053,areFieldsSet=true,areAllFieldsSet=true,
//lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,
//dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,
//minimalDaysInFirstWeek=1,ERA=1,YEAR=2021,MONTH=1,WEEK_OF_YEAR=9,WEEK_OF_MONTH=4,
//DAY_OF_MONTH=23,DAY_OF_YEAR=54,DAY_OF_WEEK=3,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=2,
//HOUR_OF_DAY=14,MINUTE=31,SECOND=37,MILLISECOND=53,ZONE_OFFSET=28800000,DST_OFFSET=0]
//Date类不易于实现国际化
//Calendar方法
//1 void add(int field, int amount) :在指定时间参数 添加一个量
c1.add(Calendar.YEAR, 1);//年+1
System.out.println(c1);
//2 时间比较
//boolean after(Object when)
//boolean before(Object when)
//int compareTo(Calendar anotherCalendar)
//3 设置和获取时间参数
// int get(int field) ;
// void set(int field,int value);
c1=Calendar.getInstance();
c1.set(Calendar.YEAR,c1.get(Calendar.YEAR)-1);//去年的今天
System.out.println(myCalendarString(c1));//2021-1-23 星期3 14:45:55
//4 日历和日期之间的转换
// void setTime(Date date) ：把当前日历对象设置为参数日期表示的时间
// Date getTime(): 获取当前日历对象相同时间对应的Date对象
Date d=new Date(0);//历元
c1.setTime(d);
System.out.println(myCalendarString(c1));
c1=Calendar.getInstance();
d=c1.getTime();
System.out.println(d.toLocaleString());//2021-2-23 14:55:26
//5日历与毫秒值之间的转换
//void setTimeInMillis(long millis): 把当前日历对象设置为参数毫秒值表示的时间
//long getTimeInMIllis()：获取当前日历对象相同时间对应的毫秒值
c1.setTimeInMillis(0);
System.out.println(myCalendarString(c1));
}
static String myCalendarString(Calendar c) {
//xxxx-xx-xx 星期x xx:xx:xx
int year=c.get(Calendar.YEAR);
int month=c.get(Calendar.MONTH)+1;//月份从0开始
int day=c.get(Calendar.DAY_OF_MONTH);
int week=c.get(Calendar.DAY_OF_WEEK);//星期从1到7 为 日一二三四五六
int hour=c.get(Calendar.HOUR_OF_DAY);
int minute=c.get(Calendar.MINUTE);
int second=c.get(Calendar.SECOND);
String weeks=" 日一二三四五六";
String s=year+"-"+month+"-"+day+" 星期"+weeks.charAt(week)+" "+hour+":"+minute+":"+second;
return s;
}
}
//Calendar类设计思想
abstract class DemoFu{
static DemoFu getInstance() {
return new DemoZi();
}
void show() {}
abstract void hai();
}
class DemoZi extends DemoFu{
void hai() {}
}
301
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
