常用类
1.Object类
概述：
1.类层次的根类
2.所有类都直接或间接的继承该类
构造方法：
1.public Objetc();
2.所有子类都默认访问父类的无参构造方法
Object类的成员方法
public int hashCode() ：获得该对象的哈希值
public final Class getClass() : 返回当前类调用该方法时所对应的对象
public String toString()：返回该对象的字符串表达形式
public boolean equals(Object obj):比较两个对象是否相等
protected void finalize()：垃圾回收器回收对象前会先执行该方法（了解）
protected Object clone()：复制一个对象，首先要重写clone()方法，并且 实现Cloneable接口（标记接口）
package Wang.unit01.neibulei.ObjectDemo;
/**
* Object类
* 概述：
* 1.类层次的根类
* 2.所有类都直接或间接的继承该类
*/
public class ObjectText1 {
public static void main(String[] args) {
//public int hashCode() ：获得该对象的哈希值
ObjectText1 objectText1 =new ObjectText1();
int i = objectText1.hashCode();
System.out.println(i);
ObjectText1 objectText11=new ObjectText1();
int s = objectText11.hashCode();
System.out.println(s);
ObjectText1 objectText12=new ObjectText1();
int a =objectText12.hashCode();
System.out.println(a);
}
}
package Wang.unit01.neibulei.ObjectDemo;
/**
* Class getClass():
* Class 类中：
* String getName();返回该类的类名
*/
public class ObjectText2 {
public static void main(String[] args) {
//public final Class getClass() : 返回当前类调用该方法时所对应的对象
ObjectText2 demo = new ObjectText2();
String name = demo.getClass().getName();
System.out.println(name);
System.out.println(demo);//调用toString()方法
}
}
package Wang.unit01.neibulei.ObjectDemo;
/**
* String toString():返回该对象的字符串表示
* 组成 getClass().getName() + '@' +Integer.toHexString(hashCode())
* 注意事项：
* 1.输出语句中只放一个对象名，它会默认的调用该对象的toString（）方法
* 2.建议所有子类都重写此方法，一般重写内容为子类的所有属性信息
*/
public class ObjectText3 {
public static void main(String[] args) {
ObjectText3 demo = new ObjectText3();
System.out.println(demo);
String name = demo.getClass().getName();
String sc =Integer.toHexString(demo.hashCode());
System.out.println(name+'@'+sc);
}
}
public boolean equals(Object obj):比较两个对象是否相等
源码：
面试题：简述 == 和 equals 的 区别
==：
基本数据类型：比较值是否想同
引用数据类型：比较对象的地址是否相同
equals：
只能比较引用数据类型
一般情况，与==效果相同
但是，我们可以根据需求重写equals方法，去比较对象的属性值是否相同
2. Scanner类
概述：
•用于接收用户键盘输入的一个工具类
构造方法：
•new Scanner(System.in)
基本格式：
•hasNextXxx():判断输入字符是否含有指定的数据类型。
•nextXxx():接收键盘输入的数据。
3. String类
概述：
•字符串是由多个字符组成的一串数据（字符序列）
•字符串可以看成字符数组
构造方法：
•public String()
•public String(byte[] bytes)
•public String(byte[] bytes,int offset,int length)
•public String(char[] value)
•public String(char[] value,int offset,int count)
•public String(String original)
String类的判断方法
1.boolean equals(Object obj)：比较字符串是否相同
2.boolean equalsIgnoreCase(String str)：比较字符串是否相同（忽略大小写）
3.boolean contains(String str)：判断 A字符串中是否包含str
4.boolean startsWith(String str)：判断字符串是否以“str”开头
5.boolean endsWith(String str)：是否以”str“结尾
6.boolean isEmpty()：判断字符串是否为空
String类的获取的方法
1.int length()：获取字符串长度
2.char charAt(int index)：获取指定位置索引的字符
3.int indexOf(int ch)：返回指定字符在此字符串中第一次出现的索引
4.int indexOf(String str)：返回指定的字符串在当前字符串第一次出现的索引
5.int indexOf(int ch,int fromIndex)：返回指定字符在指定位置后第一次出现的索引
6.int indexOf(String str,int fromIndex)：返回指定字符串在指定位置后第一次出现的索引
7.String substring(int start)：从指定位置截取当前字符串
8.String substring(int start,int end)：从指定开始位置 截取到指定结束位置
package Wang.unit01.neibulei.StringDemo;
import org.junit.Test;
public class StringTest3 {
/**
* String类的判断方法
* boolean equals(Object obj)：比较字符串是否相同
*
* boolean equalsIgnoreCase(String str)：比较字符串是否相同（忽略大小写）
*
* boolean contains(String str)：判断 A字符串中是否包含str
*
* boolean startsWith(String str)：判断字符串是否以“str”开头
*
* boolean endsWith(String str)：是否以”str“结尾
*
* boolean isEmpty()：判断字符串是否为空
*/
@Test
public void test(){
//boolean equals(Object obj):比较字符串是否相同；比较两个对象是否相等
String name = "zhaotong";
boolean a = name.equals("zhaotong");
System.out.println("equals(比较字符串是否相同):"+a);
boolean b = name.equals("zhaowei");
System.out.println("equals(比较字符串是否相同):"+b);
//boolean equalsIgnoreCase(String str):比较字符串是否相同（忽略大小写）
boolean c = "zhao".equalsIgnoreCase("ZHAO");
System.out.println("equalsIgnoreCase(比较字符串是否相同（忽略大小写）):"+c);
//boolean contains(String str)：判断 A字符串中是否包含str
System.out.println("contains(判断A字符串中是否包含str):"+name.contains("oto"));
//boolean startsWith(String str)：判断字符串是否以“str”开头
System.out.println("startsWith(判断字符串是否以“str”开头):"+name.startsWith("zh"));
System.out.println(name.startsWith("LOL"));
//boolean endsWith(String str)：是否以”str“结尾
System.out.println("endsWith(是否以”str“结尾):"+name.endsWith("ng"));
System.out.println(name.endsWith("to"));
//boolean isEmpty()：判断字符串是否为空
System.out.println("isEmpty(判断字符串是否为空):"+"".isEmpty());
System.out.println("isEmpty(判断字符串是否为空):"+" ".isEmpty());
//报错空指针异常
//String s =null;
//System.out.println(s.isEmpty());
System.out.println("------------------------------------------------------------");
}
/**
* String类的获取的方法
* int length()：获取字符串长度
* char charAt(int index)：获取指定位置索引的字符
* int indexOf(int ch)：返回指定字符在此字符串中第一次出现的索引
* int indexOf(String str)：返回指定的字符串在当前字符串第一次出现的索引
* int indexOf(int ch,int fromIndex)：返回指定字符在指定位置后第一次出现的索引
* int indexOf(String str,int fromIndex)：返回指定字符串在指定位置后第一次出现的索引
* String substring(int start)：从指定位置截取当前字符串
* String substring(int start,int end)：从指定开始位置 截取到指定结束位置(顾前不顾后)
*/
@Test
public void test2(){
String wisdom = "HelloWorld";
//int length()：获取字符串长度
System.out.println("length()：获取字符串长度:"+wisdom.length());
//char charAt(int index)：获取指定位置索引的字符
System.out.println("charAt(int index)：获取指定位置索引的字符:"+wisdom.charAt(5));
//int indexOf(int ch)：返回指定字符在此字符串中第一次出现的索引
System.out.println("indexOf(int ch)：返回指定字符在此字符串中第一次出现的索引:"+wisdom.indexOf("o"));
// int indexOf(String str)：返回指定的字符串在当前字符串第一次出现的索引
System.out.println("indexOf(String str)：返回指定的字符串在当前字符串第一次出现的索引:"+wisdom.indexOf("ll"));
// int indexOf(int ch,int fromIndex)：返回指定字符在指定位置后第一次出现的索引
System.out.println("indexOf(int ch,int fromIndex)：返回指定字符在指定位置后第一次出现的索引:"+wisdom.indexOf("o",4));
// int indexOf(String str,int fromIndex)：返回指定字符串在指定位置后第一次出现的索引
System.out.println("indexOf(String str,int fromIndex)：返回指定字符串在指定位置后第一次出现的索引:"+wisdom.indexOf("or",4));
// String substring(int start)：从指定位置截取当前字符串
System.out.println("substring(int start)：从指定位置截取当前字符串:"+wisdom.substring(5));
// String substring(int start,int end)：从指定开始位置 截取到指定结束位置(顾前不顾后)
System.out.println("substring(int start,int end)：从指定开始位置 截取到指定结束位置(顾前不顾后):"+wisdom.substring(4,6));
}
}
模拟登录系统
package Wang.unit01.neibulei.StringDemo;
import org.junit.Test;
import java.util.Scanner;
public class StringDemo {
/*
需求：模拟登陆系统
*/
public static void main(String[] args) {
String name = "屈波";
String mi = "123456";
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
System.out.println("请用户输入用户名");
String name1 = sc.next();
System.out.println("请输入密码");
String mi1 = sc.next();
if (name.equals(name1) && mi.equals(mi1)) {
System.out.println("登陆成功");
break;
} else {
if ((2 - i) != 0) {
System.out.println("登录失败，请重新输入，还有" + (2 - i) + "次机会");
} else {
System.out.println("您的賬戶已被凍結");
}
}
}
}
}
String类的转换的方法
1.byte[] getBytes()：把字符串转换为字节数组
2.char[] toCharArray()：把字符串转化为字符数组
3.static String valueOf(char[] chs)：把字符数组转化为字符串
4.static String valueOf(int i)：把任意数据类型转化为字符串
5.String toLowerCase()：将字符串转化为小写
6.String toUpperCase()：将字符串转化为大写
7.String concat(String str)：将两个字符串拼接起来
String****类的其他常用方法
替换功能
•String replace(char old,char new)
•String replace(String old,String new)
去除字符串两端的空格
•String trim()
按字典顺序比较两个字符串
•int compareTo(String str)
•int compareToIgnoreCase(String str)
package Wang.unit01.neibulei.StringDemo;
import org.junit.Test;
/**
* String类的转换的方法
* byte[] getBytes()：把字符串转换为字节数组
*
* char[] toCharArray()：把字符串转化为字符数组
*
* static String valueOf(char[] chs)：把字符数组转化为字符串
*
* static String valueOf(int i)：把任意数据类型转化为字符串
*
* String toLowerCase()：将字符串转化为小写
*
* String toUpperCase()：将字符串转化为大写
*
* String concat(String str)：将两个字符串拼接起来
*/
public class StringText5 {
@Test
public void test(){
String name = "ZhaoTong";
//byte[] getBytes()：把字符串转换为字节数组
byte[] bytes = name.getBytes();
System.out.print("getBytes()：把字符串转换为字节数组:");
System.out.print("[");
for (byte b:bytes){
System.out.print(b+",");
}
System.out.println("]");
System.out.println("--------------------------------------");
//char[] toCharArray()：把字符串转化为字符数组
char[] chars = name.toCharArray();
System.out.print("toCharArray()：把字符串转化为字符数组");
System.out.print("[");
for (char b:chars){
System.out.print(b+",");
}
System.out.println("]");
// static String valueOf(char[] chs)：把字符数组转化为字符串
System.out.println("valueOf(char[] chs)：把字符数组转化为字符串:"+String.valueOf(chars));
//static String valueOf(int i)：把任意数据类型转化为字符串
System.out.println("valueOf(int i)：把任意数据类型转化为字符串:"+String.valueOf(5));
System.out.println("valueOf(int i)：把任意数据类型转化为字符串:"+String.valueOf(3.1415926));
System.out.println("valueOf(int i)：把任意数据类型转化为字符串:"+String.valueOf(100000));
System.out.println("valueOf(int i)：把任意数据类型转化为字符串:"+String.valueOf(false));
//String toLowerCase()：将字符串转化为小写
System.out.println("toLowerCase()：将字符串转化为小写:"+name.toLowerCase());
//String toUpperCase()：将字符串转化为大写
System.out.println("toUpperCase()：将字符串转化为大写:"+name.toUpperCase());
//String concat(String str)：将两个字符串拼接起来
String str = "剑气纵横三万里，一剑光寒十九州";
System.out.println("concat(String str)：将两个字符串拼接起来:"+name.concat(str));
}
@Test
public void test2(){
/**
* 替换功能
* String replace(char old,char new)
* String replace(String old,String new)
*/
String s = "仙之巅，傲世间，有我安澜便有天";
System.out.println(s.replace("安澜","赵童"));
System.out.println(s.replace('安','z'));
/**
* 去除字符串两端的空格
* String trim()
*/
String a =" 一粒尘可填海，一根草斩尽日月星辰，弹指间天翻地覆 ";
System.out.println(a);
System.out.println(a.trim());
//按字典顺序比较两个字符串
//int compareTo(String str)
//int compareToIgnoreCase(String str)
String name ="abcd";
System.out.println(name.compareTo("abc"));
System.out.println(name.compareTo("Abc"));
System.out.println(name.compareToIgnoreCase("ABC"));
}
}
统计字符串中大写字母、小写字母、数字各有多少个
package Wang.unit01.neibulei.StringDemo;
import org.junit.Test;
/**
* 统计字符串中大写字母、小写字母、数字各有多少个
* 1.字符串，统计变量
* 2.字符串的遍历
* 3.比较判断字符
*/
public class StringDemo1 {
public static void main(String[] args) {
String statement = "Can12You34Speak56Chinese78?";
int big = 0;//统计大写字母的数量
int litter = 0;//统计小写字母的数量
int number = 0;//统计数字的数量
//遍历字符串
for (int i=0;i<statement.length();i++){
//获取每一个字符
char s = statement.charAt(i);
//判断比较
if (s<='z'&&s>='a'){
litter++;
}else if (s>='A'&&s<='Z'){
big++;
}else if (s >= '0' && s<='9' ){
number++;
}
}
System.out.println("大写字母数量："+big);
System.out.println("小写字母数量："+litter);
System.out.println("数字数量："+number);
}
}
**1.**把数组中的数据按照指定格式输出
2.把字符串反转输出
3**.统计大的字符串中，小字符串出现的次数**
package Wang.unit01.neibulei.StringDemo;
import org.junit.Test;
public class StringText4 {
@Test
public void test(){
int[] array ={1,2,3};
System.out.print("[");
for (int i=0;i<array.length;i++){
if (i==2){
System.out.print(array[i]);
}else{
System.out.print(array[i]+",");
}
}
System.out.println("]");
String str = "love";
char[] chars = str.toCharArray();
for ( int min =0,max= chars.length-1;min<max;min++,max--){
char temp = chars[min];
chars[min]=chars[max];
chars[max]=temp;
}
System.out.println(String.valueOf(chars));
}
@Test
public void test2(){
String longStr="zhaozhaotongqubozhaotongqubozhaotong";
String shortStr="zhao";
int count = 0;
int index = longStr.indexOf(shortStr);
while(index!=-1){
count++;
int newIndex=index+shortStr.length();
longStr = longStr.substring(newIndex);
index=longStr.indexOf(shortStr);
}
System.out.println(count);
}
}
4. StringBuffer类概述及构造函数
概述：
1.我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既降低了执行效率，又浪费系统资源。而StringBuffer就可以解决这个问题
2.线程安全的可变字符序列
构造方法：
•public StringBuffer()
•public StringBuffer(int capacity)
•public StringBuffer(String str)
StringBuffer类常用方法
添加功能
•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 replace(int start,int end,String str)
反转功能
public StringBuffer reverse()
package Wang.unit01.neibulei.StringBuffer;
import org.junit.Test;
/**
* 线程安全（多线程）
* 安全---同步---数据安全
* 不安全---不同步---数据的访问效率
* 我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既降低了执行效率，又浪费系统资源。而StringBuffer就可以解决这个问题
*/
public class StringBufferDemo {
/**
* 构造方法：
* public StringBuffer()无参构造方法
* public StringBuffer(int capacity)指定容量的字符串缓冲区对象
* public StringBuffer(String str)构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
*
* 方法
* public int capacity():返回当前容量--------理论值
* public int length（）：返回长度（字符串）---实际值
*/
@Test
public void test(){
StringBuffer sb = new StringBuffer();
//public StringBuffer()无参构造方法
System.out.println("sb:"+sb);
System.out.println("capacity():返回当前容量:"+sb.capacity());
System.out.println("length（）：返回长度（字符串）:"+sb.length());
//public StringBuffer(int capacity)指定容量的字符串缓冲区对象
StringBuffer sb2 = new StringBuffer(25);
System.out.println("capacity():返回当前容量:"+sb2.capacity());
System.out.println("length（）：返回长度（字符串）:"+sb2.length());
//public StringBuffer(String str)构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
StringBuffer sb3 = new StringBuffer("负尽千重罪，练就不死心");
System.out.println("capacity():返回当前容量:"+sb3.capacity());
System.out.println("length（）：返回长度（字符串）:"+sb3.length());
}
@Test
public void test2(){
StringBuffer sb = new StringBuffer("HelloWorld");
//添加功能
//public StringBuffer append(String str)将指定的字符串追加到此字符序列。
System.out.println("append(String str)将指定的字符串追加到此字符序列:"+sb.append("!"));
//public StringBuffer insert(int offset,String str)将字符串插入此字符序列中。
System.out.println("insert(int offset,String str)将字符串插入此字符序列中:"+sb.insert(10,"java"));
//删除功能
//public StringBuffer deleteCharAt(int index)移除此序列的子字符串中的字符
System.out.println("deleteCharAt(int index):"+sb.deleteCharAt(10));
//public StringBuffer delete(int start,int end)移除此序列指定位置的 char。此序列将缩短一个 char。 (顾前不顾后)
System.out.println("delete(int start,int end):"+sb.delete(10,13));
//替换功能
//public StringBuffer replace(int start,int end,String str)
// 使用给定 String 中的字符替换此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end - 1 处的字符，如果不存在这种字符，则一直到序列尾部。
System.out.println("replace(int start,int end,String str):"+sb.replace(5,10,"java"));
//反转功能
// public StringBuffer reverse()将此字符序列用其反转形式取代。
System.out.println("reverse():"+sb.reverse());
}
}
截取方法
•public String substring(int start)
•public String substring(int start,int end)
注意：
与之前方法的不同指出
•返回值类型不同
•截取内容并不影响原内容数据
package Wang.unit01.neibulei.StringBuffer;
/**
* 截取方法
* public String substring(int start)
* public String substring(int start,int end)(顾前不顾后)
*/
public class StringBufferDemo2 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("Hello").append("World").append("Java!");
System.out.println("sb:"+sb);
System.out.println("-----------------------------------");
//public String substring(int start)
String s = sb.substring(5);
System.out.println("s:"+s);
System.out.println("sb:"+sb);
System.out.println("-----------------------------------");
// public String substring(int start,int end)
String s1 = sb.substring(5, 10);
System.out.println("s1:"+s1);
System.out.println("sb:"+sb);
System.out.println("-----------------------------------");
}
}
1.String 与 StringBuffer****的相互转换
package Wang.unit01.neibulei.StringBuffer;
/**
* 1.String 与 StringBuffer的相互转换
*/
public class StringBufferDemo3 {
public static void main(String[] args) {
//1.String--------StringBuffer
//a.构造方法 public StringBuffer(String str)
String s = "ZhaoTong";
StringBuffer sb = new StringBuffer(s);
System.out.println(sb);
//b.public StringBuffer append(String str)
StringBuffer sc = new StringBuffer();
System.out.println(sc.append(s));
//2.StringBuffer--------String
//a.构造方法 public String(StringBuffer buffer)
StringBuffer sd = new StringBuffer("TangKang");
String s2 = new String(sd);
System.out.println(s2);
//b.使用toString()方法
String s3 =sd.toString();
System.out.println(s3);
}
}
3.判断字符串是否是对称字符串
package Wang.unit01.neibulei.StringBuffer;
public class StringBufferText1 {
public static void main(String[] args) {
int[] arr = {11,22,33,44,55,66};
String s =arrayToString(arr);
System.out.println(s);
String b =arrayToStringBuffer(arr);
System.out.println(b);
String s2 = "abcdacba";
System.out.println(method(s2));
StringBuffer sv = new StringBuffer("zhaoqahz");
System.out.println(sv.reverse());
boolean equals = sv.toString().equals(sv.reverse());
System.out.println(equals);
}
//方法1
public static String arrayToString(int[] arr){
//1.定义字符串对象
String s ="";
//2.拼接“[”
s=s.concat("[");
//3.遍历数组
for (int i=0;i< arr.length;i++){
if (i!= arr.length-1){
s=s.concat(arr[i]+",");
}else{
s=s.concat(arr[i]+"]");
}
}
return s;
}
//方法2StringBuffer
public static String arrayToStringBuffer(int[] arr){
//定义StringBuffer对象
StringBuffer a = new StringBuffer();
//2.拼接“[”
a.append("[");
//3.遍历数组
for (int i=0;i< arr.length;i++){
if (i!= arr.length-1){
a.append(arr[i]).append(",");
}else{
a.append(arr[i]).append("]");
}
}
String s=new String(a);
return s;
}
//判断字符串是否对称
//abcNcba ,jfjfkkkh;
public static boolean method(String str){
//字符串转化为字符数组
char[] chars = str.toCharArray();
boolean flag = true;
for (int min=0,max=chars.length-1;min<=max;min++,max--){
if (chars[min]!=chars[max]){
flag = false;
break;
}
}
return flag;
}
}
### **基本类型包装类**概述
#### 包装类概述
•将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
•常用操作：用于基本数据类型与字符串之间的转换
#### 基础数据类型对应的包装类型
byte --- Byte short --- Short int --- Integer
long --- Long float --- Float double --- Double
boolean --- Boolean
```java
package zhaotongit.unit01.neibulei.Integer;
/**
* 需求1：计算一个数的二进制，八进制，十六进制
* 需求2：判断一个数是否在int的取值范围内
*
* 基本类型的包装类：将我们的基本数据类型包装成一个类，好处是可以添加相关方法，简化操作
* byte --- Byte short --- Short int --- Integer
* long --- Long float --- Float double --- Double
*/
public class IntegerDemo {
public static void main(String[] args) {
//需求1：计算一个数的二进制，八进制，十六进制
int num = 888;
//二进制
System.out.println(Integer.toBinaryString(num));
//八进制
System.out.println(Integer.toOctalString(num));
//十六进制
System.out.println(Integer.toHexString(num));
//需求2：判断一个数是否在int的取值范围内
//表示 int 类型能够表示的最大值。
System.out.println(Integer.MAX_VALUE);
//表示 int 类型能够表示的最小值。
System.out.println(Integer.MIN_VALUE);
}
}
Integer概述****及构造
Integer概述
•Integer 类在对象中包装了一个基本类型 int 的值
•该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法
构造方法
•public Integer(int value)
•public Integer(String s)
package Wang.unit01.neibulei.Integer;
import org.junit.Test;
/**
* Integer构造方法:
* public Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。
*
* public Integer(String s)
* throws NumberFormatException构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
* 注意：字符串中只能含有数字，不能含有其他字符
*/
public class IntegerDemo2 {
@Test
public void test(){
//public Integer(int value)
Integer integer = new Integer(66);
System.out.println(integer.toString());
//public Integer(String s)
Integer integer2 = new Integer("66");
//Integer integer2 = new Integer("adwad66");
System.out.println(integer2.toString());
}
}
Integer成员方法
package Wang.unit01.neibulei.Integer;
/**
* int类型和String类型的相互转换
* int – String
* String – int
* 其他方法：
* public int intValue()
* public static int parseInt(String s)
* public static String toString(int i)
* public static Integer valueOf(int i)
* public static Integer valueOf(String s)
*/
public class IntegerDemo3 {
public static void main(String[] args) {
//1.int – String
//方法1
int num = 99;
String s1 =num+"";
System.out.println("s1:"+s1);
//方法2 String的valueOf方法
String s2 =String.valueOf(num);
System.out.println("s2:"+s2);
//方法3 public static String toString(int i)
String s3 = Integer.toString(num);
System.out.println("s3:"+s3);
//方法4 public String toString()
Integer integer = new Integer(num);
String s4 = integer.toString();
System.out.println(s4);
//String – int
//public Integer(String s)
//方法1 public int intValue()
Integer in = new Integer(s1);
int i = in.intValue();
System.out.println("i:"+i);
//2 public static int parseInt(String s)
int c =Integer.parseInt(s1);
System.out.println("c:"+c);
}
}
自动装箱
注意：
编译器在执行自动装箱时，会先进行判断该值是否在127~-128之间（byte常量值），如果在范围内，直接从常量池中返回相应的值，如果不在则创建新的对象
package Wang.unit01.neibulei.Integer;
/**
* 正对包装类
* 自动拆箱：将包装类转换成相应的基本数据类型
* 自动装箱：将基本数据类型转换为相应的包装类
* 注意：
* 在使用自动拆箱时，建议先判断是否为null,然后再使用
*/
public class IntegerDemo4 {
public static void main(String[] args) {
Integer integer = new Integer(996);
Integer i2 =100;//自动装箱
i2 +=998;//先做了一次自动拆箱，再做自动装箱
System.out.println(i2);
System.out.println(integer);
/**
* Integer inte = null;
* inte += 10;
*/
}
}
Character类概述及其构造方法
Character类概述
Character 类在对象中包装一个基本类型 char 的值
此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然
构造方法
public Character(char value)
Character类成员方法
public static boolean isUpperCase(char ch)
public static boolean isLowerCase(char ch)
public static boolean isDigit(char ch)
public static char toUpperCase(char ch)
public static char toLowerCase(char ch)
package Wang.unit01.neibulei.Character;
/**
* Character类概述及其构造方法
* Character类概述
* Character 类在对象中包装一个基本类型 char 的值
* 此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然
* 构造方法
* public Character(char value)
* 成员方法
* public static boolean isUpperCase(char ch)判断字符是否为大写
* public static boolean isLowerCase(char ch)判断字符是否为小写
* public static boolean isDigit(char ch)判断字符是否为数字
* public static char toUpperCase(char ch)将字符转换为大写
* public static char toLowerCase(char ch) 将字符转换为小写
*/
public class CharacterDemo {
public static void main(String[] args) {
Character character =new Character('a');
//public static boolean isUpperCase(char ch)判断字符是否为大写
System.out.println(Character.isUpperCase('a'));
System.out.println(Character.isUpperCase('A'));
System.out.println(Character.isUpperCase('0'));
System.out.println("-------------------------------------------");
//public static boolean isLowerCase(char ch)判断字符是否为小写
System.out.println(Character.isLowerCase('a'));
System.out.println(Character.isLowerCase('A'));
System.out.println(Character.isLowerCase('0'));
System.out.println("-------------------------------------------");
//public static boolean isDigit(char ch)判断字符是否为数字
System.out.println(Character.isDigit('a'));
System.out.println(Character.isDigit('A'));
System.out.println(Character.isDigit('0'));
System.out.println("-------------------------------------------");
//public static char toUpperCase(char ch)将字符转换为大写
System.out.println(Character.toUpperCase('a'));
System.out.println(Character.toUpperCase('B'));
System.out.println(Character.toUpperCase('c'));
System.out.println("-------------------------------------------");
//public static char toLowerCase(char ch) 将字符转换为小写
System.out.println(Character.toLowerCase('A'));
System.out.println(Character.toLowerCase('w'));
System.out.println(Character.toLowerCase('R'));
}
}
正则表达式
正则表达式：
是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用
举例：校验qq号码.
1:要求必须是5-15位数字
2:0不能开头
package Wang.unit01.neibulei.Regex;
import java.util.Scanner;
/**
* 校验qq号：
* 1.不能以“0”开头
* 2.要求必须是5--15位数字
*/
public class RegexDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入QQ号：");
String s = sc.next();
System.out.println(qq(s));
}
public static boolean qq(String qq) {
String regex = "[1-9]\\d{4,14}";
boolean b = qq.matches(regex);
return b;
}
}
规则字符在java.util.regex Pattern类中
常见组成规则
字符
字符类
预定义字符类
边界匹配器
数量词
1.字符
x 字符 x 例：a就代表字符 'a'
\\ 反斜线字符
\t 制表符 ('\u0009')
\n 新行（换行）符 ('\u000A')
\r 回车符 ('\u000D')
2.字符类
[abc] a、b 或 c（简单类） 单匹配
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[0-9] 0到9的字符都包括在内
3.预定义字符类
. 任何字符
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w
4.边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边
5.数量词
X? X，一次或一次也没有 0或1
X* X，零次或多次 0或多
X+ X，一次或多次 1或多
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
分割功能
public String[] split(String regex)
package Wang.unit01.neibulei.Regex;
import java.util.Arrays;
/**
* 分割功能
* public String[] split(String regex)
*/
public class RegexDemo3 {
public static void main(String[] args) {
//练习一：12-23-34-56-67
String s1 = "12-23-34-56-67";
String regex1 = "-";
String[] a1 = s1.split(regex1);
for (int i =0;i< a1.length;i++){
System.out.println(a1[i]);
}
System.out.println("----------");
//练习二：12，65，66，55
String s2 ="12,65,66,55";
String regex2 = ",";
String[] a2 = s2.split(regex2);
for (int i =0;i< a2.length;i++){
System.out.println(a2[i]);
}
System.out.println("----------");
//练习三：12.65.66.55
String s3 ="12.65.66.55";
String regex3 = "\\.";
String[] a3 = s3.split(regex3);
for (int i =0;i< a3.length;i++){
System.out.println(a3[i]);
}
System.out.println("----------");
//练习四：12 11 33 66
String s4 ="12 11 33 66";
String regex4 =" +";
String[] a4 = s4.split(regex4);
for (int i =0;i< a4.length;i++){
System.out.println(a4[i]);
}
System.out.println("----------");
//练习五：12\11\33\66
String s5 ="12\\11\\33\\66";
String regex5 ="\\\\";
String[] a5 = s5.split(regex5);
for (int i =0;i< a5.length;i++){
System.out.println(a5[i]);
}
System.out.println("----------");
}
}
判断功能
public boolean matches(String regex)
package Wang.unit01.neibulei.Regex;
import java.util.Scanner;
//判断功能
//public boolean matches(String regex)
//校验手机号
//13992794421,15129506219,13991766970,18526996321
public class RegexDemo2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入手机号：");
String s=scanner.next();
String regex = "[1][358]\\d{9}";
System.out.println(s.matches(regex));
}
}
package Wang.unit01.neibulei.Regex;
/**
* public String replaceAll(String regex,String replacement)使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
*/
public class RegexDemo4 {
public static void main(String[] args) {
//替换字符中的sb,sB,Sb,SB
String s ="zxcvsbnmasdSbkjhkjhSBkjklSjjksB";
String regex = "[sS][Bb]";
String newS =s.replaceAll(regex,"**");
System.out.println(newS);
}
}
获取功能
Pattern和Matcher类的使用
package Wang.unit01.neibulei.Regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 获取功能
* Pattern和Matcher类的使用
*/
public class RegexDemo5 {
public static void main(String[] args) {
//练习
String s ="wo shi zhao tong dai she shou hao";
String regex ="\\b\\w{3}\\b";
Pattern pattern=Pattern.compile(regex);
Matcher m =pattern.matcher(s);
// boolean b = m.find();
// System.out.println(b);
// String s1 = m.group();
// System.out.println(s1);
// b = m.find();
// System.out.println(b);
// s1 = m.group();
// System.out.println(s1);
while(m.find()){
String s1 = m.group();
System.out.println(s1);
}
}
}
Math 类
Math类概述
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 double pow(double a,double b)
•public static double random()
•public static int round(float a)
•public static double sqrt(double a)
package Wang.unit01.neibulei.Math;
/**
* Math类概述:
* Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
*
* 成员属性
* public static final double e
* public static final double PI
*
* 成员方法
* 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 double pow(double a,double b)：a的b次幂
* public static double random()：生成随机数（0.0--1.0）
* public static int round(float a)：四舍五入
* public static double sqrt(double a)：正平方根
*/
public class MathDemo {
public static void main(String[] args) {
System.out.println("Π:"+Math.PI);
System.out.println("E:"+Math.E);
int num = 135;
int num2 = -121;
System.out.println("求绝对值:"+Math.abs(num));
System.out.println("求绝对值:"+Math.abs(num2));
System.out.println();
double a = 21.5;
System.out.println("向上取整:"+Math.ceil(a));
System.out.println("向下取整:"+Math.floor(a));
System.out.println();
System.out.println("求俩数的最大值:"+Math.max(num,num2));
System.out.println();
System.out.println("a的b次幂:"+Math.pow(2,2));
System.out.println();
System.out.println("生成随机数（0.0--1.0）:"+Math.random());
System.out.println();
System.out.println("四舍五入:"+Math.round(a));
System.out.println();
System.out.println("正平方根:"+Math.sqrt(a));
}
}
Random类概述
此类用于产生随机数,此类的实例用于生成伪随机数流。
如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
构造方法
public Random()
public Random(long seed)
成员方法
public int nextInt()
public int nextInt(int n)
package Wang.unit01.neibulei.Random;
import java.util.Random;
/**
* Random
* 构造方法:
* public Random()
* public Random(long seed)
*
成员方法
public int nextInt()
public int nextInt(int n)
*/
public class RandomDemo {
public static void main(String[] args) {
Random random = new Random();
for (int i=0;i<5;i++){
System.out.println(random.nextInt());
}
for (int i=0;i<5;i++){
System.out.println(random.nextInt(10));
}
System.out.println("-----------------------------");
Random random2 =new Random(222);
for (int i=0;i<5;i++){
System.out.println(random2.nextInt(10));
}
System.out.println("-----------------------------");
Random random3 =new Random(222);
for (int i=0;i<5;i++){
System.out.println(random3.nextInt(10));
}
}
}
System类
System类概述：
System 类包含一些有用的类字段和方法。它不能被实例化。
成员方法：
public static void gc()
public static void exit(int status)
public static long currentTimeMillis()
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
package Wang.unit01.neibulei.System;
import java.util.Arrays;
/**
* 成员方法
* public static void gc():运行垃圾回收器。
* public static void exit(int status)终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。
* public static long currentTimeMillis()返回以毫秒为单位的当前时间。当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）。
* public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
* 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。从 src 引用的源数组到 dest 引用的目标数组，数组组件的一个子序列被复制下来。被复制的组件的编号等于 length 参数。
* src - 源数组。
* srcPos - 源数组中的起始位置。
* dest - 目标数组。
* destPos - 目标数据中的起始位置。
* length - 要复制的数组元素的数量。
*/
public class SystemDemo {
public static void main(String[] args) {
// System.out.println("今天是个好日子！");
// System.exit(0);
// System.out.println("可若是就是没钱啊！");
long start = System.currentTimeMillis();
for (int i=0;i<100000;i++){
System.out.println(i);
}
long end =System.currentTimeMillis();
System.out.println("总耗时："+(end-start)+"毫秒");
int[] scrArr = {1,23,5,6,9,8,90,51};
int[] destArr ={2,4,6,8,10,12};
System.arraycopy(scrArr,2,destArr,3,2);
System.out.println(Arrays.toString(scrArr));
System.out.println(Arrays.toString(destArr));
}
}
BigInteger类
可以让超过Integer范围内的数据进行运算
构造方法
public BigInteger(String val)
package Wang.unit01.neibulei.BigInteger;
import java.math.BigInteger;
public class BigIntegerDemo {
public static void main(String[] args) {
Integer integer = new Integer(100);
System.out.println(integer);
System.out.println("--------------");
System.out.println(Integer.MAX_VALUE);//2147483647
// Integer integer2 = new Integer(2147483648);
// System.out.println(integer2);
BigInteger bigInteger = new BigInteger("2147483648");
System.out.println(bigInteger);
}
}
成员方法
public BigInteger add(BigInteger val)
public BigInteger subtract(BigInteger val)
public BigInteger multiply(BigInteger val)
public BigInteger divide(BigInteger val)
public BigInteger[] divideAndRemainder(BigInteger val)
package Wang.unit01.neibulei.BigInteger;
import java.math.BigInteger;
/**
* public BigInteger add(BigInteger val):返回其值为 (this + val) 的 BigInteger。
* public BigInteger subtract(BigInteger val)返回其值为 (this - val) 的 BigInteger。
* public BigInteger multiply(BigInteger val)返回其值为 (this * val) 的 BigInteger。
* public BigInteger divide(BigInteger val)返回其值为 (this / val) 的 BigInteger。
* public BigInteger[] divideAndRemainder(BigInteger val)返回包含 (this / val) 后跟 (this % val) 的两个 BigInteger 的数组。
*/
public class BigIntegerDemo2 {
public static void main(String[] args) {
BigInteger bigInteger = new BigInteger("155");
BigInteger big = new BigInteger("50");
//public BigInteger add(BigInteger val)加
BigInteger add = bigInteger.add(big);
System.out.println("加："+add);
//public BigInteger subtract(BigInteger val)
BigInteger subtract = bigInteger.subtract(big);
System.out.println("减："+subtract);
//public BigInteger multiply(BigInteger val)
BigInteger multiply = bigInteger.multiply(big);
System.out.println("乘:"+multiply);
//public BigInteger divide(BigInteger val)
BigInteger divide = bigInteger.divide(big);
System.out.println("除:"+divide);
//public BigInteger[] divideAndRemainder(BigInteger val)
BigInteger[] b =bigInteger.divideAndRemainder(big);
System.out.println("商："+b[0]);
System.out.println("余数："+b[1]);
}
}
BigDecimal类
由于在运算的时候，float类型和double很容易丢失精度。所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal类
BigDecimal类概述
不可变的、任意精度的有符号十进制数。
构造方法
public BigDecimal(String val)
成员方法
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,introundingMode)
package Wang.unit01.neibulei.BigDecimal;
import java.math.BigDecimal;
/**
* BigDecimal
* 构造方法
* public BigDecimal(String val)
* 成员方法
*
* 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)：返回一个 BigDecimal，其值为 (this / divisor)，其标度为指定标度。如果必须执行舍入，以生成具有指定标度的结果，则应用指定的舍入模式。
* divisor - 此 BigDecimal 要除以的值。
* scale - 要返回的 BigDecimal 商的标度。
* roundingMode - 要应用的舍入模式。
* ROUND_UP, ROUND_DOWN, ROUND_CEILING, ROUND_FLOOR, ROUND_HALF_UP, ROUND_HALF_DOWN, ROUND_HALF_EVEN, ROUND_UNNECESSARY
*
*/
public class BigDecimalDemo {
public static void main(String[] args) {
// System.out.println( 0.09 + 0.01);
// System.out.println( 1.0 - 0.55);
// System.out.println( 1.109 * 100);
// System.out.println( 1.301/100);
BigDecimal b = new BigDecimal("1.8109");
BigDecimal c = new BigDecimal("1.0101");
BigDecimal a = new BigDecimal("100");
BigDecimal d = new BigDecimal("0.001");
//public BigDecimal add(BigDecimal augend)：加
System.out.println(b.add(c));
//public BigDecimal subtract(BigDecimal subtrahend)：减
System.out.println(b.subtract(c));
//public BigDecimal multiply(BigDecimal multiplicand)：乘
System.out.println(b.multiply(a));
//public BigDecimal divide(BigDecimal divisor)：除
System.out.println(b.divide(d));
//public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)：
System.out.println(b.divide(a,5,BigDecimal.ROUND_HALF_UP));
}
}
Date类
Date类概述:
类 Date 表示特定的瞬间，精确到毫秒
构造方法
•public Date()
•public Date(long date)
成员方法
•public long getTime()
•public void setTime(long time)
package Wang.unit01.neibulei.Date;
import java.util.Date;
/**
* 构造方法
* public Date():分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
* public Date(long date):分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
* 成员方法
* public long getTime()返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
* public void setTime(long time)设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。
*/
public class DateDemo {
public static void main(String[] args) {
//创建对象
Date d = new Date();
System.out.println(d);
Date date = new Date(System.currentTimeMillis());
System.out.println(date);
long time =1000*60*60;
Date date2 = new Date(time);
System.out.println(date2);
//public long getTime()返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
System.out.println(d.getTime());
//public void setTime(long time)设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。
long time2 = 565115;
d.setTime(time);
System.out.println(d.getTime());
d.setTime(time2);
System.out.println(d.getTime());
}
}
DateFormart类
DateFormat类概述
•DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。
•是抽象类，所以使用其子类SimpleDateFormat
•SimpleDateFormat构造方法
•public SimpleDateFormat()
•public SimpleDateFormat(String pattern)
成员方法
•public final String format(Date date)
•public Date parse(String source)
package Wang.unit01.neibulei.DateFormatDemo;
/**
* Date----String(格式化）
* public final String format(Date date)
*
* String----Date(解析)
* public Date parse(String source)
*
* 因为DateFormat是一个抽象类，所以我们要学习SimpleDateFormat。
*/
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。
* 是抽象类，所以使用其子类SimpleDateFormat
* SimpleDateFormat构造方法
* public SimpleDateFormat() 默认
* public SimpleDateFormat(String pattern) 按照给定模式
*
*
* 成员方法
* public final String format(Date date)
* public Date parse(String source)
*/
public class DateFormatDemo {
public static void main(String[] args) throws ParseException {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
System.out.println(dateFormat);
//创建日期对象
Date d = new Date();
System.out.println(d);
String s = dateFormat.format(d);
System.out.println(s);
//解析
String s2 ="2020-11-30 23:01:55";
SimpleDateFormat dateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date parse = dateFormat2.parse(s2);
System.out.println(parse);
}
}
Calendar类
Calendar类概述
•Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
成员方法
•public static Calendar getInstance()
•public int get(int field)
•public void add(int field,int amount)
•public final void set(int year,int month,int date)
package Wang.unit01.neibulei.Calendar;
import java.util.Calendar;
/**
* Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
*/
public class CalendarDemo {
public static void main(String[] args) {
//创建对象
Calendar rightNew = Calendar.getInstance();
int year = rightNew.get(Calendar.YEAR);
int month = rightNew.get(Calendar.MONTH);
int day = rightNew.get(Calendar.DAY_OF_MONTH);
System.out.println(year+"年"+(month+1)+"月"+day+"日");
}
}
package Wang.unit01.neibulei.Calendar;
import java.time.Year;
import java.util.Calendar;
/**
*
成员方法
public static Calendar getInstance()
public int get(int field)
public void add(int field,int amount)
public final void set(int year,int month,int date)
*/
public class CalendarDemo2 {
public static void main(String[] args) {
Calendar rightNew = Calendar.getInstance();
int year = rightNew.get(Calendar.YEAR);
int month = rightNew.get(Calendar.MONTH);
int day = rightNew.get(Calendar.DAY_OF_MONTH);
System.out.println(year+"年"+(month+1)+"月"+day+"日");
// //7年前的今天
// rightNew.add(Calendar.YEAR,-7);
// year=rightNew.get(Calendar.YEAR);
// month = rightNew.get(Calendar.MONTH);
// day = rightNew.get(Calendar.DAY_OF_MONTH);
// System.out.println(year+"年"+(month+1)+"月"+day+"日");
//3年后的15天前
rightNew.add(Calendar.YEAR,3);
rightNew.add(Calendar.DAY_OF_MONTH,-15);
year=rightNew.get(Calendar.YEAR);
month = rightNew.get(Calendar.MONTH);
day = rightNew.get(Calendar.DAY_OF_MONTH);
System.out.println(year+"年"+(month+1)+"月"+day+"日");
rightNew.set(2008,5,6);
year=rightNew.get(Calendar.YEAR);
month = rightNew.get(Calendar.MONTH);
day = rightNew.get(Calendar.DAY_OF_MONTH);
System.out.println(year+"年"+(month+1)+"月"+day+"日");
}
}
1783
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
