API
API(Application Programming Interface) 是JDK中提供的使用类的说明文档。这些类将底层的代码实现封装了起来
String 类
java.lang.String
类代表字符串。Java程序中所有的字符串文字(例如 “abc” )都可以被看作是实现此类的实
例。
类 String 中包括用于检查各个字符串的方法,比如用于比较字符串,搜索字符串,提取子字符串以及创建具有翻
译为大写或小写的所有字符的字符串的副本。
public class StringDemo01 {
public static void main(String[] args) {
//public String():创建一个空白字符串对象,不含有任何内容
String s1 = new String();
System.out.println("s1:" + s1);
//public String(char[] chs):根据字符数组的内容,来创建字符串对象
char[] chs = {'a', 'b', 'c'};
String s2 = new String(chs);
System.out.println("s2:" + s2);
//public String(byte[] bys):根据字节数组的内容,来创建字符串对象
byte[] bys = {97, 98, 99};
String s3 = new String(bys);
System.out.println("s3:" + s3);
//String s = “abc”; 直接赋值的方式创建字符串对象,内容就是abc
String s4 = "abc";
System.out.println("s4:" + s4);
}
}
判断功能的方法
public boolean equals (Object anObject) | 将此字符串与指定对象进行比较 |
---|---|
public boolean equalsIgnoreCase (String anotherString) | 将此字符串与指定对象进行比较,忽略大小写 |
/*
判断功能的方法举例
s1.equals(s2):比较s1和s2的内容是否一模一样,如果一样返回true,否则返回false
s1.equalsIgnoreCase(s2):比较s1和s2的内容是否相同,但是不区分大小写
s1.contains(s2): 判断s1中是否包含s2,包含则返回true,不包含则返回false
*/
public class String_Demo01 {
public static void main(String[] args) {
// 创建字符串对象
String s1 = "hello";
String s2 = "hello";
String s3 = "HELLO";
// boolean equals(Object obj):比较字符串的内容是否相同
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false
System.out.println("-----------");
//boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
System.out.println(s1.equalsIgnoreCase(s2)); // true
System.out.println(s1.equalsIgnoreCase(s3)); // true
System.out.println("-----------");
}
}
Object 是” 对象”的意思,也是一种引用类型。作为参数类型,表示任意对象都可以传递到方法中。
字符串的比较:==号和equals的作用
== 比较基本数据类型:比较的是具体的值
- == 比较引用数据类型:比较的是对象地址值
- equals 比较String类型: 比较的是对象的内容是否相同
/*
使用 == 做比较:
基本类型:比较的是数据值是否相同
引用类型:比较的是地址值是否相同
public boolean equals(Object anObject):
将此字符串与指定对象进行比较。由于我们比较的是字符串对象,所以参数直接传递一个字符串
*/
public class StringDemo02 {
public static void main(String[] args) {
//构造方法的方式得到对象
char[] chs = {'a', 'b', 'c'};
String s1 = new String(chs);
String s2 = new String(chs);
//直接赋值的方式得到对象
String s3 = "abc";
String s4 = "abc";
//比较字符串对象地址是否相同
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s3 == s4);
System.out.println("--------");
//比较字符串内容是否相同
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println(s3.equals(s4));
}
}
获取功能的方法
public int length () :返回此字符串的长度。
- public String concat (String str) :将指定的字符串连接到该字符串的末尾。
- public char charAt (int index) :返回指定索引处的 char值。
- public int indexOf (String str) :返回指定子字符串第一次出现在该字符串内的索引。
- public String substring (int beginIndex) :返回一个子字符串,从beginIndex开始截取字符串到字符串结尾。
- public String substring (int beginIndex, int endIndex) :返回一个子字符串,从beginIndex到endIndex截取字符串。含beginIndex,不含endIndex。
/*
获取功能的方法
- public int length () :返回此字符串的长度。
举例:s.length() 获取s中的字符的数量
- public String concat (String str) :将指定的字符串连接到该字符串的末尾。
举例:s1.cocat(s2) 把s2连接到s1的末尾
- public char charAt (int index) :返回指定索引处的 char值。
举例:s1.charAt(5) 获取s1中索引为5的字符
- public int indexOf (String str) :返回指定子字符串第一次出现在该字符串内的索引。
举例:s1.indexOf(s2) 查找s2在s1中第一次出现的位置,如果不存在,返回-1
- public String substring (int beginIndex) :返回一个子字符串,从beginIndex开始截取字符串到
字符串结尾。
举例:s1.substring(5) 截取s1字符串从索引5开始一直到最后的内容
- public String substring (int beginIndex, int endIndex) :
返回一个子字符串,从beginIndex到endIndex截取字符串。含beginIndex,不含endIndex。
举例:s1.substring(5,10) 截取s1字符串从索引5开始一直到索引10之间的内容(包含5,不包含10)
*/
public class String_Demo02 {
public static void main(String[] args) {
//创建字符串对象
String s = "helloworld";
// int length():获取字符串的长度,其实也就是字符个数
System.out.println(s.length());
System.out.println("--------");
// String concat (String str):将将指定的字符串连接到该字符串的末尾.
String s = "helloworld";
String s2 = s.concat("**hello java");
System.out.println(s2);// helloworld**hello java
// char charAt(int index):获取指定索引处的字符
System.out.println(s.charAt(0));
System.out.println(s.charAt(1));
System.out.println("--------");
// int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回-1
System.out.println(s.indexOf("l"));
System.out.println(s.indexOf("owo"));
System.out.println(s.indexOf("ak"));
System.out.println("--------");
// String substring(int start):从start开始截取字符串到字符串结尾
System.out.println(s.substring(0));
System.out.println(s.substring(5));
System.out.println("--------");
// String substring(int start,int end):从start到end截取字符串。含start,不含end。
System.out.println(s.substring(0, s.length()));
System.out.println(s.substring(3,8));
}
}
转换功能的方法
- public char[] toCharArray () :将此字符串转换为新的字符数组。
- public byte[] getBytes () :使用平台的默认字符集将该 String编码转换为新的字节数组。
- public String replace (CharSequence target, CharSequence replacement) :将与target匹配的字符串使
用replacement字符串替换。
/*
转换功能的方法
- public char[] toCharArray () :把字符串变成对应的字符数组。
举例:s1.toCharArray() 把s1变成字符数组
- public byte[] getBytes () :把字符串变成对应的字节数组。
举例:s1.getBytes() 把s1变成字节数组
- public String replace (String oldStr, String newStr) :把字符串中的所有的oldStr替换成
newStr。
举例:s1.replace("a","A") 把s1中的所有的"a"替换成"A"
*/
public class String_Demo03 {
public static void main(String[] args) {
//创建字符串对象
String s = "abcde";
// char[] toCharArray():把字符串转换为字符数组
char[] chs = s.toCharArray();
for(int x = 0; x < chs.length; x++) {
System.out.println(chs[x]);
}
System.out.println("-----------");
// byte[] getBytes ():把字符串转换为字节数组
byte[] bytes = s.getBytes();
for(int x = 0; x < bytes.length; x++) {
System.out.println(bytes[x]);
}
System.out.println("-----------");
// 替换字母hello为大写HELLO
String str = "hello world, hello java";
String replace = str.replace("hello", "HELLO");
System.out.println(replace); // HELLO world, HELLO java
System.out.println("-----------");
}
}
分割功能的方法
- public String[] split(String regex) :将此字符串按照给定的regex(规则)拆分为字符串数组
String 类的练习
模拟用户登录
已知用户名和密码,请用程序实现模拟用户登录。总共给三次机会,登录之后,给出相应的提示
/*
思路:
1:已知用户名和密码,定义两个字符串表示即可
2:键盘录入要登录的用户名和密码,用 Scanner 实现
3:拿键盘录入的用户名、密码和已知的用户名、密码进行比较,给出相应的提示。字符串的内容比较,用
equals() 方法实现
4:用循环实现多次机会,这里的次数明确,采用for循环实现,并在登录成功的时候,使用break结束循环
*/
public class StringTest01 {
public static void main(String[] args) {
//已知用户名和密码,定义两个字符串表示即可
String username = "admin";
String password = "1234";
//用循环实现多次机会,这里的次数明确,采用for循环实现,并在登录成功的时候,使用break结束循环
for (int i = 2; i >= 0; i--) {
//键盘录入要登录的用户名和密码,用 Scanner 实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名:");
String name = sc.nextLine();
System.out.println("请输入密码:");
String pwd = sc.nextLine();
//拿键盘录入的用户名、密码和已知的用户名、密码进行比较,给出相应的提示。字符串的内容比较,用equals() 方法实现
if (name.equals(username) && pwd.equals(password)) {
System.out.println("登录成功");
break;
} else {
if (i == 0) {
System.out.println("你的账户被锁定,请与管理员联系");
} else {
//2,1
System.out.println("登录失败,你还有" + i + "次机会");
}
}
}
}
}
字符串反转
/*
思路:
1:键盘录入一个字符串,用 Scanner 实现
2:定义一个方法,实现字符串反转。返回值类型 String,参数 String s
3:在方法中把字符串倒着遍历,然后把每一个得到的字符拼接成一个字符串并返回
4:调用方法,用一个变量接收结果
5:输出结果
*/
public class StringTest05 {
public static void main(String[] args) {
//键盘录入一个字符串,用 Scanner 实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String line = sc.nextLine();
//调用方法,用一个变量接收结果
String s = reverse(line);
//输出结果
System.out.println("s:" + s);
}
//定义一个方法,实现字符串反转
/*
两个明确:
返回值类型:String
参数:String s
*/
public static String reverse(String s) {
//在方法中把字符串倒着遍历,然后把每一个得到的字符拼接成一个字符串并返回
String ss = "";
for(int i=s.length()-1; i>=0; i--) {
ss += s.charAt(i);
}
return ss;
}
}
Object类
java.lang.Object
类是Java语言中的根类,每个类都使用 Object 作为超类。所有对象(包括数组)都实现这个
类的方法。
如果一个类没有特别指定父类, 那么默认则继承自Object类。
native 本地方法
在Object类的源码中定义了 native 修饰的方法, native 修饰的方法称为本地方法
。
本地方法的特点:
- 被 native修饰的方法,非Java语言编写,是由C++语言编写。
- 本地方法在运行时期进入本地方法栈内存,本地方法栈是一块独立内存的区域。
- 本地方法的意义是和操作系统进行交互。
private static native void registerNatives();
static {
registerNatives();
}
当程序运行的时候,Object类会最先被加载到内存中。类进入内存后首先加载自己的静态成员,static代码块中调
用了本地方法 registerNatives() ,和操作系统进行交互。
native方法可以看做是对java方法的扩展,native方法不是由java去实现的,是由操作系统去实现的.java只能调用本地
方法
https://www.cnblogs.com/KingIceMou/p/7239668.html
toString() 方法
public String toString() | 返回该对象的字符串表示 |
---|
Object类toString()方法源码:
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
源码分析:
- getClass().getName() 返回类的全限定名字。
- hashCode() 方法返回int值,可以暂时理解为对象的内存地址。
- Integer.toHexString() 将int类型的值转成十六进制。
因此调用对象的 toString()方法将看到内存的地址值。
创建Person类,并调用方法toString()
public static void main(String[] args){
Person person = new Person();
String str = person.toString();
System.out.println(str);
System.out.println(person);
}
通过程序运行得到结论: 在输出语句中打印对象,就是在调用对象的toString()方法。
toString()方法的重写
由于toString方法返回的结果是内存地址,而在开发中,内存地址并没有实际的应用价值,经常需要按照对象的属
性得到相应的字符串表现形式,因此也需要重写它。
public class Person {
private String name;
private int age;
@Override
public String toString() {
return "Person" + name + ":" + age;
}
// 省略构造器与Getter Setter
}
equals 方法
public boolean equals(Object obj) | 指示其他某个对象是否与此对象“相等” |
---|
Object类equals()方法源码:
public boolean equals(Object obj) {
return (this == obj);
}
源码分析:
- this 是当前对象,哪个对象调用的equals方法就表示哪个对象。
- obj 表述传递的参数,参数类型Object,可以传递任意类型对象。
- this==obj 比较两个对象的内存地址是否相同
equals方法默认比较两个对象的内存地址
是否相同,相同则返回true。
equals()方法的重写
实际应用中,比较内存地址是否相同并没有意义,我们可以定义对象自己的比较方式,比较对象中成员变量的值是
否相同。需要对方法进行重写。
需求:重写equals()方法,比较两个对象中姓名和年龄是否相同,如果姓名和年龄都相同返回true,否则返回
false。
public class Person {
private String name;
private int age;
@Override
public boolean equals(Object obj) {
//判断两个对象地址若相同,即为同一个对象
if (this == obj)
return true;
//obj对象为空,无需比较,返回false
if (obj == null)
return false;
//obj如果是Person类型对象,则强制转换
if (obj instanceof Person) {
Person person = (Person) obj;
//比较两个对象的name属性和age属性,如果相等,返回true
return this.name.equals(person.name) && this.age == person.age;
}
return false;
}
}
Date类
java.util.Date
类 表示特定的瞬间,精确到毫秒。1000毫秒等于1秒。
Date 类构造方法
- public Date() :从运行程序的此时此刻到时间原点经历的毫秒值,转换成Date对象,分配Date对象并初始化
此对象,以表示分配它的时间(精确到毫秒)。 - public Date(long date) :将指定参数的毫秒值date,转换成Date对象,分配Date对象并初始化此对象,以
表示自从标准基准时间(称为“历元(epoch)”,即1970年1月1日00:00:00 GMT)以来的指定毫秒数。
public static void main(String[] args) {
// 创建日期对象,把当前的时间
System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2020
// 创建日期对象,把当前的毫秒值转成日期对象
System.out.println(new Date(0)); // Thu Jan 01 08:00:00 CST 1970
}
Date 类的常用方法
- public long getTime() 把日期对象转换成对应的时间毫秒值。
- public void setTime(long time) 把方法参数给定的毫秒值设置给日期对象。
public static void main(String[] args) {
//创建日期对象
Date date = new Date();
//public long getTime()获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
System.out.println(date.getTime());
//public void setTime(long time):设置时间,给的是毫秒值
date.setTime(0);
System.out.println(date);
}
日期对象和毫秒值的相互转换
日期是不能进行数学计算的,但是毫秒值可以,在需要对日期进行计算时,可以现将日期转成毫秒值后在进行计
算。
日期对象转成毫秒值:
- Date date = new Date() ; date.getTime()
- System.currentTimeMillis()
毫秒值转成日期对象:
- Date date = new Date(long 毫秒值)
- date.setTime(long 毫秒值)
DateFormat类
java.text.DateFormat
是日期/时间格式化子类的抽象类,我们通过这个类可以帮我们完成日期和文本之间的转
换,也就是可以在Date对象与String对象之间进行来回转换。
- 格式化 :按照指定的格式,把Date对象转换为String对象。
- 解析 :按照指定的格式,把String对象转换为Date对象。
构造方法
由于DateFormat为抽象类,不能直接使用,所以需要常用的子类 java.text.SimpleDateFormat 。这个类需要一个
模式(格式)来指定格式化或解析的标准。构造方法为:
- public SimpleDateFormat(String pattern) :用给定的模式和默认语言环境的日期格式符号构造
SimpleDateFormat。
参数pattern是一个字符串,代表日期时间的自定义格式。
常用的格式规则为:
转换方法
- String format(Date date) 传递日期对象,返回格式化后的字符串。
- Date parse(String str) 传递字符串,返回日期对象。
public static void main(String[] args) throws ParseException {
//格式化:从 Date 到 String
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String s = sdf.format(d);
System.out.println(s);
System.out.println("--------");
//从 String 到 Date
String ss = "2048-08-09 11:11:11";
//ParseException
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date dd = sdf2.parse(ss);
System.out.println(dd);
}
*Calendar日历类
java.util.Calendar
是日历类,在Date后出现,替换掉了许多Date的方法。该类将所有可能用到的时间信息封装
为静态成员变量,方便获取。日历类就是方便获取各个时间属性的。
日历对象获取方式
Calendar是抽象类,不能创建对象,需要使用子类对象。 java.util.GregorianCalendar 类是Calendar的子类,
但是创建日历对象需要根据本地的时区,语言环境来创建,比较困难,Calendar类提供了静态方法 getInstance()
直接获取子类的对象。
public static Calendar getInstance()
:使用默认时区和语言环境获得一个日历。
Calendar cal = Calendar.getInstance();
常用方法
- public int get(int field) :返回给定日历字段的值。
- public void set(int field, int value) :将给定的日历字段设置为给定值。
- public abstract void add(int field, int amount) :根据日历的规则,为给定的日历字段添加或减去指
定的时间量。 - public Date getTime() :返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象。
日历字段
Calendar类中提供很多静态成员,直接类名调用,代表给定的日历字段:
字段值 | 含义 |
---|---|
YEAR | 年 |
MONTH | 月(从0开始,可以+1使用) |
DAY_OF_MONTH | 月中的天(几号) |
HOUR | 时(12小时制) |
HOUR_OF_DAY | 时(24小时制) |
MINUTE | 分 |
SECOND | 秒 |
DAY_OF_WEEK | 周中的天(周几,周日为1,可以-1使用) |
public static void main(String[] args) {
// 创建Calendar对象
Calendar cal = Calendar.getInstance();
// 获取年
int year = cal.get(Calendar.YEAR);
//设置年份为2020年
cal.set(Calendar.YEAR, 2020);
//将年份修改为2000年
cal.add(Calendar.YEAR,-20)
//将日历对象转换为日期对象
Date d = cal.getTime();
System.out.println(d);
}
Calendar 类练习
- 案例需求
获取任意一年的二月有多少天 - 案例分析:
可以将日历设置到任意年的三月一日
向前偏移一天
获取偏移后的日历即可 - 代码实现
public static void main(String[] args) {
//键盘录入任意的年份
Scanner sc = new Scanner(System.in);
System.out.println("请输入年:");
int year = sc.nextInt();
//设置日历对象的年、月、日
Calendar c = Calendar.getInstance();
c.set(year, 2, 1);
//3月1日往前推一天,就是2月的最后一天
c.add(Calendar.DATE, -1);
//获取这一天输出即可
int date = c.get(Calendar.DATE);
System.out.println(year + "年的2月份有" + date + "天");
}
基本类型包装类
Java提供了两个类型系统,基本类型与引用类型。使用基本类型在于效率,然而很多情况,会创建对象使用,因为
对象可以做更多的功能,如果想要我们的基本类型像对象一样操作,就可以使用基本类型对应的包装类,如下:
Integer 类
- Integer 类概述
包装一个对象中的原始类型 int 的值 - Integer 类构造方法及静态方法
方法名 | 说明 |
---|---|
public Integer(int value) | 根据 int 值创建 Integer 对象(过时) |
public Integer(String s) | 根据 String 值创建 Integer 对象(过时) |
public static Integer valueOf(int i) | 返回表示指定的 int 值的 Integer 实例 |
public static Integer valueOf(String s) | 返回一个保存指定值的 Integer 对象 String |
public static void main(String[] args) {
//public Integer(int value):根据 int 值创建 Integer 对象(过时)
Integer i1 = new Integer(100);
System.out.println(i1);
//public Integer(String s):根据 String 值创建 Integer 对象(过时)
Integer i2 = new Integer("100");
//Integer i2 = new Integer("abc"); //NumberFormatException
System.out.println(i2);
System.out.println("--------");
//public static Integer valueOf(int i):返回表示指定的 int 值的 Integer 实例
Integer i3 = Integer.valueOf(100);
System.out.println(i3);
//public static Integer valueOf(String s):返回一个保存指定值的Integer对象 String
Integer i4 = Integer.valueOf("100");
System.out.println(i4);
}
装箱与拆箱
基本类型与对应的包装类对象之间,来回转换的过程称为”装箱“与”拆箱“:
- 装箱 :从基本类型转换为对应的包装类对象。
- 拆箱 :从包装类对象转换为对应的基本类型。
用Integer与 int为例:(看懂代码即可)
基本数值---->包装对象
Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法
包装对象---->基本数值
int num = i.intValue();
由于我们经常要做基本类型与包装类之间的转换,从Java 5(JDK 1.5)开始,基本类型与包装类的装箱、拆箱动作
可以自动完成。例如:
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边:将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后,再次装箱,把基本数值转成对象。