一、Object类
●
Object类是所有Java类的祖先（根基类）。每个类都使用 Object 作为超类
（父类）。
所有对象（包括数组）都继承实现这个类的方法。
●
如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类
●
toString方法
输出一个对象，但是对象在内存中存储，是不能输出的， 只能把对象信息以字符串形式输出 当输出一个对象时，会默认调用此对象的toString(), 如果类中没有定义toString()，会调用Object类中toString(), Object类中toString()，是把对象在内存的哈希值返回(以16进制返回)com.ffuc.javaapi.objectdemo.Person@1b6d3586 我们自己类中可以对Object类中的toString()进行重写，后面调用时，就调用自己类中的toString
package com.ffuc.javaapi.objectdemo;
public class Person extends Object{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
//如果没有重写，则会调用Object类中的toString()输出地址
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object obj){
if (obj instanceof Person){
Person person = (Person)obj;
return this.name.equals(person.name)&&this.age == person.age;
}
return false;
}
}
package com.ffuc.javaapi.objectdemo;
public class TestPerson1 {
public static void main(String[] args) {
Person person = new Person("小米",18);
Object person1 = new Person("",17);
System.out.println();
System.out.println(person);
}
}
●
Object类中定义有public String toString()方法，其返回值是 String 类
型，描述当前对象的有关信息。
●
当需要通过输出语句输出一个对象时,如System.out.println(person），
将自动调用该对象类的 toString()方法,如果该类中没有重写toString(),那
么默认调用Object类中的toString(),默认输出对象hashCode值.
●
可以根据需要在用户自定义类型中重写toString()方法。
● equals
方法
== 用于比较等号两边是否相等 基本类型进行比较时，是比较两边变量值是否相等 引用类型进行比较时，是比较两边地址是否相等
boolean equals(Object obj) 判断两个对象是否相等
Object类中的equals
public boolean equals(Object obj) {
return (this == obj);
}默认比较的是两个对象的地址是否相等，我们就可以使用==代替它
在其他类中，一般都是重写equals()，把它改造为比较对象中的内容相等
package com.ffuc.javaapi.objectdemo;
public class TestPerson2 {
public static void main(String[] args) {
/*
== 用于比较等号两边是否相等
基本类型进行比较时，是比较两边变量值是否相等
引用类型进行比较时，是比较两边地址是否相等
*/
int a = 10;
int b = 10;
System.out.println(a==b);//返回true
Person person1 = new Person("小明",17);
Person person2 = new Person("小明",17);
System.out.println(person1==person2);//返回false
//因为创建了两个对象，==用于引用类型时比较的是等号两边的地址，person1与person2的地址不相等
System.out.println(person1.equals(person2));//false
/*
boolean equals(Object obj) 判断两个对象是否相等
Object类中的equals
public boolean equals(Object obj) {
return (this == obj);
}默认比较的是两个对象的地址是否相等，我们就可以使用==代替它
在其他类中，一般都是重写equals()，把它改造为比较对象中的内容相等
*/
String中已经重写equals方法
String s1 = new String("a");
String s2 = new String("a");
System.out.println(s1.equals(s2));//true
}
}
● Object
类中定义有：
● public boolean equals(Object obj)
方法
,
判断对象是否相等的逻辑。
public boolean equals(Object obj) {
return (this == obj);
}
● Object
中的
equals
方法默认使用
==
比较
,
比较的是对象地址
,
这点需
要注意
.
● JDK
提供的一些类，如
String
，
Date
等，重写了
Object
的
equals
方
法，调用这些类的
equals
方法，
x.equals (y) ,
当
x
和
y
所引用的对象
是同一类对象且属性内容相等返回
true
否则返回
false
。
二、Arrays类
●
java.util.Arrays类用于操作数组工具类，里面定义了常见操作数组的静态方法.
●
equals 方法
比较两个数组对象中元素是否相等.
而数组对象中的equals用来判断与另一个数组对象是否相等。
long[]a = {1,2,3,4,5};
long[]b = {1,2,3,4,5};
System.out.println(Arrays.equals(a,b));
●
sort －排序
●
作用于数组的所有元素
public static void sort(type[] a)
●
作用于数组指定范围内的元素
public static void sort(type[] a, int fromIndex(包括), int
toIndex(不包括))
将指定的类型数组所有元素按数字升序进行排序。
int []a = {5,3,1,4,2,6};
Arrays.sort(a);// 排序范围是0 -- length-1
System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 5, 6]
System.out.println();
int[]b = {8,9,5,2,6,4,3};
Arrays.sort(b,0,4);// 排序数组中索引是0 -- 3的值
System.out.println(Arrays.toString(b));//[2, 5, 8, 9, 6, 4, 3]
l
自定义对象排序
自定义类实现Comparable接口
重写compareTo方法
/*
用来指定排序规则
可以执行用类中那个属性作为排序的项
这个方法在sort()方法的底层调用，来判断大小
*/
@Override
public int compareTo(Student o) {
return this.id-o.id;
} public static void main(String[] args) {
Student s1 = new Student(1,"小明");
Student s2 = new Student(2,"小明");
Student s3 = new Student(3,"小明");
Student s4 = new Student(4,"小明");
Student s5= new Student(5,"小明");
Student []students = new Student[5];
students[0] = s4;
students[1] = s1;
students[2] = s5;
students[3] = s2;
students[4] = s3;
Arrays.sort(students);
System.out.println(Arrays.toString(students));
//[Student{id=1, name='小明'}, Student{id=2, name='小明'}, Student{id=3, name='小明'}, Student{id=4, name='小明'}, Student{id=5, name='小明'}]
binarySearch -使用二分搜索算法搜索指定数组
public static int binarySearch(type[] a, type key)
public static int binarySearch(long[] a,int fromIndex,int toIndex,long key)
●
参数：
a - 要搜索的数组。
key - 要搜索的值。
fromIndex - 要排序的第一个元素的索引（包括）。
toIndex - 要排序的最后一个元素的索引（不包括）。
●
如果key在数组中，则返回搜索值的索引；否则返回负数,表示不存在
/*
binarySearch() 二分查找法 查找数组中所需找到的值，并返回该值在数组中的位置,若没有找到则返回负数
*/
int[]c = {9,10,25,64,1};
Arrays.sort(c);
int Index = Arrays.binarySearch(c,64);
System.out.println("查找的数在数组中的索引为："+Index);//3
int Index2 = Arrays.binarySearch(c,0,3,64);
System.out.println("查找的数在数组中的索引为："+Index2);
//查找的数不在查找范围中，返回负数，-4
●
copyOf方法
●
数组复制,将指定数组中的元素复制到一个指定长度的新数组中,并返回
新数组.
●
static int[] copyOf(int[] a, int newLength)
/*
copyOf 将上一个数组内的元素重新赋值进一个指定长度的新数组中
*/
int[]c = {1,2,3,4,5};
int []d = Arrays.copyOf(c,10);
System.out.println(Arrays.toString(d));//[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
●
fill方法
●
将指定的int值分配给指定的int数组的每个元素。
● fill(int[] a,int val)
/*
fill 将指定的值分配给指定的数组中
*/
Arrays.fill(d,1);
System.out.println(Arrays.toString(d));//[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
toString() 方法
●
public static String toString(type[] a)
●
返回指定数组内容的字符串表示形式。
package com.ffuc.javaapi.arraysdemo;
import java.util.Arrays;
/*
我们一个类要进行排序，那么这个类必须实现Comparable接口，指定一个排序的方法(这样所有的类都使用同一的方法进行排序了)
*/
public class Student implements Comparable<Student>{
private int id;
private String name;
public Student(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
package com.ffuc.javaapi.arraysdemo;
import java.lang.reflect.Array;
import java.util.Arrays;
public class Arraysdemo3 {
public static void main(String[] args) {
Student s1 = new Student(1,"小明");
Student s2 = new Student(2,"小明");
Student s3 = new Student(3,"小明");
Student s4 = new Student(4,"小明");
Student s5= new Student(5,"小明");
Student []students = new Student[5];
students[0] = s4;
students[1] = s1;
students[2] = s5;
students[3] = s2;
students[4] = s3;
Arrays.sort(students);
System.out.println(Arrays.toString(students));
String str1 = "小明";
String str2 = "小亮";
System.out.println(str1.compareTo(str2));//字符串比较大小
}
}
三、基本数据类型包装类
●
Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面
向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设
计类时为每个基本数据类型设计了一个对应的类进表示，这样八个和基
本数据类型对应的类统称为包装类.
●
包装类（如：Integer，Double等）这些类封装了一个相应的基本数据
类型数值，并为其提供了一系列操作方法。
对于包装类来说，这些类的用途主要包含两种：
●
作为和基本数据类型对应的类的类型存在。
●
包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操
作方法。
●
包装类常用属性方法
●
以下方法以
java.lang.Integer
为例
public static final int MAX_VALUE
最大的
int
型数（
2
31
-1
）
public static final int MIN_VALUE
最小的
int
型数（
-2
31
）
构造方法
Integer(int a);
Integer(String a);
比较方法
static int compareTo(Integer a);
boolean equals(Object);
int max(int a,int b);
int min(int a,int b);
转换方法
static toBinaryString(int i);
static String toHexString(int i);
static String toOctalString(int i);
int intValue(); 包装类转换为基本类
static int parseInt(String s); 将String转换为int
String toString();
static Integer valueOf(int i) 将基本类转换为包装类
static Integer valueOf(String s)
package com.ffuc.javaapi.basetype;
public class MyInt {
private int value = 0;
public MyInt(int value) {
this.value = value;
}
}
package com.ffuc.javaapi.basetype;
public class Testinteger {
public static void main(String[] args) {
/*
基本类型包装类
java中的基本数据类型使用8个关键字声明的，不是面对对象的
int a = 10;
java语言是面对对象的，可以为每个基本类型定义一个类来进行表示
这样我们在类中还是保持有一个基本类型变量存储数据
同时还可以提供许多方法对变量进行操作(将十进制转为二进制)
Integer.parseInt返回基本int类型
*/
Integer integer1 = new Integer(10);
Integer integer2 = new Integer("20");
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
System.out.println(Integer.SIZE);
System.out.println(Integer.BYTES);
System.out.println(integer1);
//构造Integer对象 里面包着了一个基本类型值，用该对象表示一个int值
System.out.println(integer2);
//一类是静态方法
//对输入的数进行操作
System.out.println(Integer.toBinaryString(2));// 10 将输入的数转换为二进制
System.out.println(Integer.toHexString(17));// 11 将输入的数转换为十六进制
System.out.println(Integer.toOctalString(9));// 11 将输入的数转换为八进制
//一类是非静态
System.out.println(integer1.equals(integer2));
System.out.println(integer1.compareTo(integer2));
//转换的方法 包装类型 转 基本类型
int aa = integer1.intValue();
int bb = Integer.parseInt("20");//将String类型转化为int
//把基本类型 转为包装类型
int cc = 10;
Integer dd = new Integer(cc);
Integer ee = Integer.valueOf(cc);
}
}
四、装箱和拆箱
●
装箱和拆箱Auto-boxing/unboxing
●
装箱
自动将基本数据类型转换为包装器类型
装箱的时候自动调用的是Integer的valueOf(int)方法
●
拆箱
自动将包装器类型转换为基本数据类型
拆箱的时候自动调用的是Integer的intValue方法
package com.ffuc.javaapi.Stringdemo;
public class zxdemo1 {
public static void main(String[] args) {
Integer a = new Integer(10);
Integer b = new Integer("15");
/*自动拆箱
将 包装类 转换为 基本类型
系统默认调用intValue();方法
*/
int aa = a.intValue();
int bb = b;//系统会默认运行b.intValue();方法
/*自动装箱
将 基本类型 转换为 包装类
系统默认调用valueOf();方法
如果基本类型的值在-127--128之间，系统会从缓存数据中直接抽取Integer对象，
减少创建对象次数
如果不在-127 -- 128之间，每次都会创建新对象
如果基本类型值相等，此时获取的是同一对象
*/
int cc = 200;
Integer d = new Integer(cc);
Integer c = cc;//自动装箱 系统会默认调用valueOf(int);方法
System.out.println(d==cc);//false cc的值大于128，所以重新创建了一个对象
}
}
五、String类
●
String类概述
字符串是由多个字符组成的一串数据(字符序列)的字符串常量,java中所有字
符串都是String类的实例.
●
有两种创建形式：
●
第一种:
String s = "abc";
先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找
有没有"abc", 如果没有则在常量池中添加”abc”, s引用变量指向常量池中
的”abc”，如果常量池中有,则直接指向改地址即可,不用重新创建.
●
第二种:
一概在堆中创建新对象，值存储在堆内存的对象中。
String s = new String("abc");
package com.ffuc.javaapi.Stringdemo;
public class String2 {
public static void main(String[] args) {
/*
String 是字符串对象，底层是char数组 private final char value[];
*/
String s = "abc";
String ss = "abc";
/*
这种创建对象方法
系统会先在内存中进行寻找，如果没有相同内容，则会重新创建对象
如果内容相同，则会指向同一对象
*/
System.out.println(s==ss);//true
System.out.println(s.equals(ss));//true
String s1 = new String("abc");
String s2 = new String("abc");
/*
这种创建对象方法只能创建两个对象，所以 == 中返回false
*/
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true equals比较的是内容
//String 如果定义过了，内容就无法改变
String a = "小明";
a+="喜欢";
a+="小花";
/*
这里创建了三个对象，地址不同
*/
System.out.println(a);
}
}
●
构造方法
public String()
public String(String str)
public String(byte[] bytes)
public String(char[] value)
package com.ffuc.javaapi.Stringdemo;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.SplittableRandom;
public class String3 {
public static void main(String[] args) throws UnsupportedEncodingException {
/*String 构造方法
public String();
public String(String s);
public String(byte[] bytes);
public String(char[] value);
*/
String s1 = new String();
String s2 = new String("abc");
/*
String s3 = "睡觉";
byte []bytes = s3.getBytes();//将字符 转换 字节数组
System.out.println(Arrays.toString(bytes));
String s4 = new String(bytes);//将字节数组 转换 字符
System.out.println(s4.toString());
*/
String s3 = "睡觉";
byte []bytes = s3.getBytes("GBK");//将字符 转换 字节数组
System.out.println(Arrays.toString(bytes));
String s4 = new String("GBK");//将字节数组 转换 字符
System.out.println(s4.toString());
}
}
●
判断功能
boolean equals(Object obj) 判断字符串中内容是否相等
boolean equalsIgnoreCase(String str) 在不区分大小写的情况下， 判断字符串中内容是否相等
boolean contains(String str) 查看字符串中是否含有指定字符
boolean isEmpty() 判断字符串的值是否是 ""
boolean startsWith(String prefix) 判断是否以指定字符开头
boolean endsWith(String suffix) 判断是否以指定字符结尾
boolean equals(Object obj) 判断字符串中内容是否相等
boolean equalsIgnoreCase(String str) 在不区分大小写的情况下， 判断字符串中内容是否相等
boolean contains(String str) 查看字符串中是否含有指定字符
boolean isEmpty() 判断字符串的值是否是 ""
boolean startsWith(String prefix) 判断是否以指定字符开头
boolean endsWith(String suffix) 判断是否以指定字符结尾
package com.ffuc.javaapi.Stringdemo;
public class String4 {
public static void main(String[] args) {
String s1 = new String("abcd");
String s2 = new String("abcD");
System.out.println(s1.equals(s2));//flase 大小写不同
System.out.println(s1.equalsIgnoreCase(s2));//true
System.out.println(s1.contains("ab"));//true 必须是顺序相同
System.out.println(s1.contains("ad"));//flase 顺序不同
System.out.println(s1.startsWith("ab"));//true
System.out.println(s1.endsWith("cD"));//flase 区分大小写
}
}
●获取功能
int length() 获取字符串长度
char charAt(int index) 获取指定位置上的字符
int indexOf(String str) 获取指定字符首次出现的位置
int indexOf(String str,int fromIndex) 在指定位置开始，获取指定字符首次出现的位置
int lastIndex() 从后向前，找到指定字符的位置并返回
String substring(int start) 从指定位置开始 截取一串字符串副本直到结束
String substring(int start,int end) 从指定位置开始 截取一串字符串副本直到指定结尾位置结束
int length() 获取字符串长度
char charAt(int index) 获取指定位置上的字符
int indexOf(String str) 获取指定字符首次出现的位置
int indexOf(String str,int fromIndex) 在指定位置开始，获取指定字符首次出现的位置
int lastIndex() 从后向前，找到指定字符的位置并返回
String substring(int start) 从指定位置开始 截取一串字符串副本直到结束
String substring(int start,int end) 从指定位置开始 截取一串字符串副本直到指定结尾位置结束
package com.ffuc.javaapi.Stringdemo;
public class String5 {
public static void main(String[] args) {
String s1 = new String("让我们一起摇摆,摇起来");
System.out.println(s1.length());
System.out.println(s1.charAt(3));
for (int i = 0; i < s1.length(); i++) {
System.out.println(s1.charAt(i));
}
System.out.println(s1.indexOf(","));
System.out.println(s1.indexOf("摆",2));
System.out.println(s1.lastIndexOf("摇"));
System.out.println(s1.substring(3));
System.out.println(s1.substring(3,6));
}
}
● 转换功能
byte[] getBytes() 将字符转为byte数组
char[] toCharArray() 将字符转为char数组
static String valueOf(char[] chs)
static String valueOf(int a) 将传入的参数转换为字符串类型
String toLowerCase() 将英文字母变为小写
String toUpperCase() 将英文字母变为大写
String concat(String str) 拼接指定的字符串到原字符后面，并且返回其中一个新的字符串对象
Stirng[] split(分割符); 以特定的符号进行分割
byte[] getBytes() 将字符转为byte数组
char[] toCharArray() 将字符转为char数组
static String valueOf(char[] chs)
static String valueOf(int a) 将传入的参数转换为字符串类型
String toLowerCase() 将英文字母变为小写
String toUpperCase() 将英文字母变为大写
String concat(String str) 拼接指定的字符串到原字符后面，并且返回其中一个新的字符串对象
Stirng[] split(分割符); 以特定的符号进行分割
package com.ffuc.javaapi.Stringdemo;
import java.util.Arrays;
import java.util.SplittableRandom;
public class String6 {
public static void main(String[] args) {
String s1 = String.valueOf(1000);
for (int i = 0; i < s1.length(); i++) {
System.out.println(s1.charAt(i));
}
int a = Integer.parseInt(s1);
System.out.println(a);
s1 = String.valueOf("你好，在乎".toCharArray());
System.out.println(s1);
String s2 = new String("ac;bd;gh");
System.out.println(s2.toLowerCase());
System.out.println(s2.toUpperCase());
String s3 = s2.concat("!!!");//相当于 s2+="!!!"
System.out.println(s3);
String []strings = s2.split(";");
System.out.println(Arrays.toString(strings));
}
}
●
替换功能
String replace(char old,char new)
String replace(String old,String new)
replaceAll(String regex, String replacement)
replaceFirst(String regex, String replacement)
●
去除字符串两空格
String trim()
package com.ffuc.javaapi.Stringdemo;
public class String7 {
public static void main(String[] args) {
String s1 = " 你好，老6";
System.out.println(s1.replace("6","8"));
System.out.println(s1.replaceAll("\\d","六"));
System.out.println(s1.replaceFirst("6","c"));
System.out.println(s1.trim());
}
}
六、StringBuffer类
因为String声明的对象值，一旦给定就不能改变
每次拼接都需要重新创建对象，重新创建对象耗时，占用空间
StringBufffer声明的对象的值可以随意改变
char []value 没有经过final修饰，每次拼接是都是对此数组进行赋值，不需要重新创建对象
只有当对象空间占满时，才会重新创建对象
● 添加功能
public StringBuffer append(String str)// 在字符串后面加上指定字符
public StringBuffer insert(int offset,String str) 在指定位置添加字符，注意添加位置前不可为空
public StringBuffer append(String str)// 在字符串后面加上指定字符
public StringBuffer insert(int offset,String str) 在指定位置添加字符，注意添加位置前不可为空
●
删除功能
public StringBuffer deleteCharAt(int index) 删除指定字符串
public StringBuffer delete(int start,int end) 将指定开头到指定结尾位置的字符删除
public StringBuffer delete(int start,int end) 将指定开头到指定结尾位置的字符删除
●
替换功能
public StringBuffer replace(int start,int end,String str) 将指定区域的字符串替换成指定字符串●
●反转功能
public StringBuffer reverse() 将字符串整体顺序反转
●
截取功能
public String substring(int start)
public String substring(int start,int end)
●
截取功能和前面几个功能的不同
返回值类型是
String
类型，本身没有发生改变
● StringBuilder
类功能和
StringBuffer
功能完全一致
, StringBuffer
是线程
安全的
package com.ffuc.javaapi.Stringdemo;
public class stringBuffer1 {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer("abcd");//创建长度为16+"abcd"的char数组
StringBuffer s2 = new StringBuffer();//空参创建方法 长度为16的底层数组
*/
StringBuffer s1 = new StringBuffer(10);//指定数组的长度
/*
● 添加功能
*/
s1.append("我");
s1.append("一定要成为");
s1.append("神奇宝贝大师");
s1.insert(0,"A");
/*
● 删除功能
*/
s1.deleteCharAt(5);
s1.delete(0,5);
/*
● 替换功能
*/
s1.replace(5,6,"功");
/*
● 反转功能
*/
s1.reverse();
/*
● 截取功能
*/
String s2 = s1.substring(1,5);
System.out.println(s2);
System.out.println(s1);
}
}
String类StringBuffer类StringBuilder区别
● String
：是字符常量
,
适用于少量的字符串操作的情况
● StringBuilder
：适用于单线程下在字符缓冲区进行大量操作的情况
● StringBuffer
：适用多线程下在字符缓冲区进行大量操作的情况
package com.ffuc.javaapi.Stringdemo;
public class stringbuilder {
public static void main(String[] args) {
/*
String 对象值不可以改变
StringBuffer 对象值可以改变且不需要创建新对象， 方法上加了锁，在多线程上执行(任务)是安全的 synchronized锁
StringBuilder 对象值可以改变且不需要创建新对象，方法上没加锁，适合单线程上执行
*/
//StringBuilder s1 = new StringBuilder();
//StringBuilder s1 = new StringBuilder("abcd");
StringBuilder s1 = new StringBuilder(10);
s1.append("");
s1.insert(0,"aij");
System.out.println(s1);
}
}
七、Math类
● java.lang.Math
提供了一系列静态方法用于科学计算；其方法的参数和
返回值类型一般为
double
型。
abs
绝对值
sqrt
平方根
pow(double a, double b) a
的
b
次幂
max(double a, double b)
min(double a, double b)
random()
返回
0.0
到
1.0
的随机数
long round(double a) double
型的数据
a
转换为
long
型（四舍五入）
package com.ffuc.javaapi.Stringdemo;
public class Mathdemo {
public static void main(String[] args) {
System.out.println(Math.abs(-3.2));//绝对值 有int long float double
System.out.println(Math.sqrt(9));//平方根 double
System.out.println(Math.pow(2,5));//2的5次幂
System.out.println(Math.max(10,5));//比大小
System.out.println(Math.random());//随机生成0-1的数
System.out.println(Math.round(9.4));//四舍五入
System.out.println(Math.floor(9.9));//9 向下取整
System.out.println(Math.ceil(9.1));//10 向上取整
}
}
八、Random类
●
Random类概述
此类用于产生随机数
●
构造方法
public Random()
l
成员方法
public int nextInt()
public int nextInt(int n)
package com.ffuc.javaapi.Stringdemo;
import java.util.Arrays;
import java.util.Random;
public class Randomdemo {
public static void main(String[] args) {
Random random = new Random();
System.out.println(random.nextBoolean());//随机返回true 或者 false
System.out.println(random.nextInt());//在int类型范围内返回随机数
System.out.println(random.nextInt(100)+1);//在1-规定范围+1内返回随机数
byte []bytes = new byte[20];
random.nextBytes(bytes);
System.out.println(Arrays.toString(bytes));
}
}
九、Date类/Calendar类/ SimpleDateFormat类
●
Date类
●
使用Date类代表当前系统时间
Date d = new Date();
Date d = new Date(long d);
package com.ffuc.javaapi.Stringdemo;
import java.util.Date;
public class Datedemo {
public static void main(String[] args) {
Date date = new Date();
//方法上有删除线，表示方法已弃用，有新的类代替，但可以继续使用
System.out.println(date.getDate());//分钟
System.out.println(date.getDay());
System.out.println(date.getHours());
System.out.println(date.getSeconds());//秒
//获取了1970年0月0日0:00至程序运行时刻的毫秒值
System.out.println(date.getTime());//1708844968570
Date date1 = new Date();
//表示程序运行运行毫秒值的差值
System.out.println(date1.getTime() - date.getTime());
Date date2 = new Date(1708844968570L);
System.out.println(date2);
}
}
Calendar类
●
Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建
对象的过程对程序员来说是透明的，只需要使用getInstance方法创建
即可。
Calendar c1 = Calendar.getInstance();
c1.get(Calendar. YEAR);
package com.ffuc.javaapi.Stringdemo;
import java.util.Calendar;
public class Calendardemo {
public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();//GregorianCalendar
System.out.println(calendar);
calendar.set(2024,3,11);
System.out.println(calendar.get(Calendar.YEAR));
System.out.println(calendar.get(Calendar.DATE));
System.out.println(calendar.get(Calendar.MONTH));
System.out.println(calendar.get(Calendar.DAY_OF_WEEK));
System.out.println(calendar.get(Calendar.HOUR));
System.out.println(calendar.getTimeInMillis());
System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
}
}
●
SimpleDateFormat 日期格式化类
●
构造方法
SimpleDateFormat(格式); // yyyy-MM-dd
●
日期转字符串
Date now=new Date();
myFmt.format(now);
●
字符串转日期
myFmt.parse(“2018-02-10”);
字符串日期格式与 指定格式必须一致
例如:String s = “2018-03-15”;
new SimpleDateFormat(“yyyy-MM-dd”)
package com.ffuc.javaapi.Stringdemo;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatdemo {
public static void main(String[] args) throws ParseException {
/*
把字符串日期 转换为 Date对象
*/
String s = "2024-02-01";
SimpleDateFormat sim = new SimpleDateFormat("yyyy-MM-dd");
Date date1 = sim.parse(s);
System.out.println(date1);
/*
把Date对象 转换为 指定格式的字符串
*/
Date date = new Date();
SimpleDateFormat sim2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");//2024年02月25日 16:03:43 星期日
String s1 = sim2.format(date);
System.out.println(s1);
}
}
十、BigInteger类
●
在 Java 中，有许多数字处理的类，比如 Integer类，但是Integer类有一定的局限性。
●
我们都知道 Integer 是 Int 的包装类，int 的最大值为 2^31-1。若希望描述更大的
整数数据时，使用Integer 数据类型就无法实现了，所以Java中提供了BigInteger 类。
●
BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意
精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而
不会丢失任何信息。
●
BigInteger类位于java.math包中
●
构造方法
BigInteger(String val) /BigInteger(byte[] val) ...
基本运算方法
add()，subtract()，multiply()，divide()
package com.ffuc.javaapi.Stringdemo;
import java.math.BigInteger;
public class BigIntegerdemo {
public static void main(String[] args) {
BigInteger bigInteger = new BigInteger("99999999999999999999999999");
BigInteger bigInteger1 = new BigInteger("111111111111111111111111111111");
BigInteger bigInteger2 = bigInteger.multiply(bigInteger1);
System.out.println(bigInteger2);
}
}
十一、BigDecimal类
●
在计算机中float 还是double都是浮点数，而计算机是二进制的，浮点数会失
去一定的精确度。
●
根本原因是:十进制浮点值没有完全相同的二进制表示形式;十进制浮点值的二进
制表示形式不精确,只能无限接近于那个值.
System.out.println((0.1 + 0.2)==0.3);//结果是?
但是，在项目中，我们不可能让这种情况出现，特别是金融项目，因为涉及金
额的计算都必须十分精确，你想想，如果你的支付宝账户余额显示
193.99999999999998，那是一种怎么样的体验？
•
Java在java.math包中提供的API类BigDecimal
•
构造方法
BigDecimal(String val)
基本运算方法
add()，subtract()，multiply()，divide()
package com.ffuc.javaapi.Stringdemo;
import java.math.BigDecimal;
public class BigDecimaldemo {
public static void main(String[] args) {
System.out.println("0.3+0.36");
BigDecimal bigDecimal = new BigDecimal("0.3");
BigDecimal bigDecimal1 = new BigDecimal("0.36");
System.out.println(bigDecimal.add(bigDecimal1));
}
}
十二、正则表达式
正则表达式(Regular Expression)简称Regex 正则表达式是一种规则(模式)匹配语法 是用一些正则表达式定义的特殊符号来定义一种规则，然后去匹配某个字符串 如果字符串与规则相匹配 则返回true 否则false
package com.ffuc.javaapi.Stringdemo;
public class regexdemo {
public static void main(String[] args) {
/*
验证手机号是否属于中国大陆 长度11 首个数字是否是1 第二位是否是35789 其余全是数字
*/
String s = new String("17809121038");
System.out.println(s.matches("[0-9]*"));// * 重复零次或更多次
System.out.println(s.matches("[0-9]+"));// + 重复一次或者更多次
System.out.println(s.matches("[0-9]?"));// ? 重复零次或者一次
System.out.println(s.matches("[0-9]{11}"));// {n} 至少重复n次
System.out.println(s.matches("[0-9]{1,}"));// {n,} 重复n次或者更多次
System.out.println(s.matches("[0-9]{1,11}"));// {n,m} 重复n次到m次
System.out.println(s.matches("1[35789]\\d{9}"));// 验证手机号是否属于中国大陆 长度11 首个数字是否是1 第二位是否是35789 其余全是数字
}
}
正则表达式(Regular Expression)简称Regex
正则表达式是一种规则(模式)匹配语法
是用一些正则表达式定义的特殊符号来定义一种规则，然后去匹配某个字符串
如果字符串与规则相匹配 则返回true 否则false
[0-9] [a-z] [A-z] [357] [a-z0-9]* + ? {n} {n,} {n,m}
\d 匹配数字 \D匹配非数字
\w 匹配数字 字母下划线 \W匹配非数字 非字母下划线
\s 匹配空格符号 \S匹配非空格符号
|逻辑或
.匹配任意字符，使用时需要转义 \\.
[\\u4e00-\\u9fa5]
package com.ffuc.javaapi.Stringdemo;
public class regexdemo2 {
public static void main(String[] args) {
String s = new String("acdab");
System.out.println(s.matches("[a-z]*"));
System.out.println(s.matches("[a-z]+"));
System.out.println(s.matches("[a-zA-Z]?"));
System.out.println(s.matches("\\w"));
}
}
1025
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
