API
API(Application Programming Interface) : 应用程序编程接口
也称之为 : 帮助文档
快速使用步骤
- 打开帮助文档
- 点击显示，找到索引，看到输入框：要学习什么内容，你就在框里面输入什么内容
-
举例：Random
- java.lang包下的类在使用的时候是不需要导包的
- 看类的描述：
-
Random类是用于生成随机数的类
- 看构造方法：
-
Random():无参构造方法 Random r = new Random();
- 看成员方法：
-
public int nextInt(int n):产生的是一个[0,n)范围内的随机数
- 调用方法：
看返回值类型：人家返回什么类型，你就用什么类型接收
看方法名：名字不要写错了
看形式参数：人家要几个参数，你就给几个，人家要什么数据类型的，你就给什么数据类型的
-
int number = r.nextInt(100);
Scanner类
用Scanner类的方法可以完成接收键盘录入的数据,接收的数据类型为基本数据类型和字符串类型.
import java.util.Scanner;
/*
* Scanner:用于获取键盘录入数据。(基本数据类型，字符串数据)
* public String nextLine()：获取键盘录入字符串数据
*/
public class ScannerDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入一个字符串数据：");
String line = sc.nextLine(); //对sc对象调用nextline并用String接收
//输出结果
System.out.println("line:"+line);
Object类
类的描述
- Object类:类层次结构的根类，所有的类都直接的或者间接的继承自该类
- 构造方法：Object()
toString()方法
创建一个Student类；
当我们直接输出对象名，发现输出底层调用的是该对象的toString()
public class ObjectDemo {
public static void main(String[] args) {
Student s = new Student();//创建一个Student对象
s.setName("林青霞");
s.setAge(30);
System.out.println(s);
//在这里其实是输出底层调用的是该对象的toString()
//即System.out.println(s.toString());
/*
public void println(Object x) { //Object x = s;
String s = String.valueOf(x);
synchronized (this) {
print(s);
newLine();
}
}
public static String valueOf(Object obj) { //Object obj = x;
return (obj == null) ? "null" : obj.toString();
}
*/
}
}
查看API，我们发现建议所有子类都重写toString()
因此选择自动生成的/重写Object类的toString()方法
public class Student {
private String name;
private int age;
public Student() {}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
equals()方法
==:
- 可以比较基本数据类型：比较的是基本数据类型的值是否相同；
- 可以比较引用数据类型，比较的是引用数据类型的地址值是否相同；
比较对象的内容是否相同：
-
public boolean equals(Object obj)
注意：
Object类中的equals()方法默认比较的是对象的地址是否相同
如果我们想比较对象的内容是否相同，就必须自己重写该方法
可以通过自动生成重写该方法
public class ObjectDemo {
public static void main(String[] args) {
Student s1 = new Student("林青霞", 30);
Student s2 = new Student("林青霞", 30);
//System.out.println(s1 == s2);//false
//此时比较的是s1和s2的地址值是否相同
System.out.println(s1.equals(s2));//false
/*
public boolean equals(Object obj) {
//this -- s1
//obj -- s2
return (this == obj);
}
*/
}
}
在Student类中重写equals()方法
public class Student {
private String name;
private int age;
public Student() {}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
//s1.equals(s2)
//this -- s1
//obj -- s2
if (this == obj)
return true; //地址都一样就是同一个对象了
if (obj == null)
return false;
//比较的是对象是否是同一个类的对象
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj; //other -- s2
//比较内容是否相同
if (age != other.age) //this.age -- s1.age
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
//字符串的equals()方法比较的是字符串的内容是否相同
return false;
return true;
}
}
String类
概述：
“abc”：String类的一个实例，或者是String类的一个对象
“abc”：字符串字面值，可以看成是一个字符串对象
字符串：是常量，一旦被赋值，就不能被改变
字符串本质：字符数组
构造方法
- 把字符串数据封装成字符串对象：
-
String(String original)
- 把字符数组的数据封装成字符串对象：
-
String(char[] value)
- 把字符数组的一部分数据封装成字符串对象：
-
String(char[] value, int index, int count)
代码演示
public class StringDemo {
public static void main(String[] args) {
//String(String original):把字符串数据封装成字符串对象
String s1 = new String("hello");
System.out.println(s1);
System.out.println("----------");
//String(char[] value):把字符数组的数据封装成字符串对象
char[] value = {'h','e','l','l','o'};
String s2 = new String(value);
System.out.println(s2);
System.out.println("----------");
//String(char[] value, int index, int count)
//把字符数组的一部分数据封装成字符串对象
//String s3 = new String(value,0,value.length);
String s3 = new String(value,0,3);
System.out.println(s3);
System.out.println("----------");
//最常用的！！
String s4 = "hello";
System.out.println(s4);
}
}
创建String类对象的方式和区别
-
通过构造方法创建对象：字符串对象是在堆内存
-
通过直接赋值的方式创建对象：字符串对象是在方法区的常量池
代码：
public class StringDemo {
public static void main(String[] args) {
//构造方法：堆内存
String s1 = new String("hello");
String s2 = new String("hello");
//直接赋值：方法区的常量池
String s3 = "hello";
String s4 = "hello";
System.out.println(s1 == s2);//false
System.out.println(s1 == s3);//false
System.out.println(s3 == s4);//true
}
}
注：字符串的内容存储在方法区的常量池，这样做是为了方便字符串数据的复用。
图解：
方法练习
模拟用户登陆
-
需求
模拟用户登录，给三次机会，并提示还有几次 -
方法
boolean equals(Object obj): 比较字符串的内容是否相同
boolean equalsIgnoreCase(String str): 比较字符串的内容是否相同，忽略大小写 -
代码
import java.util.Scanner;
public class StringTest {
public static void main(String[] args) {
//定义两个字符串对象，用于存储已经存在的用户名和密码
String username = "admin";
String password = "admin";
for(int x=0; x<3; x++) {
//键盘录入用户名和密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");
String name = sc.nextLine();
System.out.println("请输入密码：");
String pwd = sc.nextLine();
//拿键盘录入的用户名和密码去跟已经存在的用户名和密码进行比较
if(username.equals(name) && password.equals(pwd)) {
System.out.println("登录成功");
break;
}else {
if((2-x) == 0){
System.out.println("你的帐号被锁定，请与管理员联系");
}else {
System.out.println("登录失败，你还有"+(2-x)+"次机会");
}
}
}
}
}
遍历字符串
-
需求：
遍历字符串(获取字符串中的每一个字符) -
方法：
public char charAt(int index): 返回指定索引处的值
public int length(): 返回字符串中的字符个数，字符串的长度 -
代码
public class StringTest2 {
public static void main(String[] args) {
//要遍历字符串，首先先创建一个字符串
String s = "abcde";
//public int length():返回字符串中的字符个数（字符串的长度）
for(int x=0; x<s.length(); x++) {
System.out.println(s.charAt(x));
}
}
}
字符串的拼接
-
需求：
把数组中的数据按照指定个格式拼接成一个字符串 -
例如：
-
int[] arr = {1,2,3}; 输出结果：[1, 2, 3] （字符串形式） -
思路
-
1. 定义一个int类型的数组 2. 写方法：把数组中的元素按照指定的格式拼接成一个字符串 3. 输出结果 -
代码：
public class StringTest3 {
public static void main(String[] args) {
//定义一个int类型的数组
int[] arr = {1,2,3};
//调用方法
String result = arrayToString(arr);
//输出结果
System.out.println("result:"+result);
}
public static String arrayToString(int[] arr) {
String s = "";
//[1, 2, 3]
s+="[";
for(int x=0; x<arr.length; x++) {
if(x==arr.length-1) {
s += arr[x];
}else {
s += arr[x];
s += ", ";
}
}
s+="]";
return s;
}
}
字符串反转
-
需求：
字符串反转 -
例如：
-
键盘录入“abc” 输出结果：“cba” -
思路：
-
1. 键盘录入字符串数据 2. 写方法：实现字符串数据的反转（把字符串倒着遍历，在把每一个得到的字符拼接成一个字符串） 3. 调用方法 4. 输出结果 -
代码：
public class StringTest4 {
public static void main(String[] args) {
//键盘录入字符串数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String s = sc.nextLine();
//写方法实现字符串数据的反转
//调用方法
String result = reverse(s);
//输出结果
System.out.println("result:"+result);
}
public static String reverse(String s) {
//把字符串倒着遍历，在把每一个得到的字符拼接成一个字符串
String ss = "";
for(int x=s.length()-1; x>=0; x--) {
ss += s.charAt(x);
}
return ss;
}
}
StringBuilder类
概述
-
StringBuilder: 是一个可变的字符串；字符串缓冲区类
-
String 和 StringBuilder的区别：
【String的内容是固定的】
【StringBuilder的内容是可变的】 -
+=拼接字符串耗内存
每次拼接都会产生新的字符串对象,而利用StringBuilder来拼接字符串自始至终用的都是同一个StringBuilder容器 -
图解：
构造方法
- public StringBuilder()
- public StringBuilder(String str)
构造方法的使用示例：
public class StringBuilderDemo {
public static void main(String[] args) {
//public StringBuilder()
StringBuilder sb = new StringBuilder();
System.out.println("sb:"+sb);
System.out.println(sb.length());
System.out.println("----------------");
//public StringBuilder(String str)
StringBuilder sb2 = new StringBuilder("helloworld");
System.out.println("sb2:"+sb2);
System.out.println(sb2.length());
}
}
成员方法
- public String toString(): 返回此序列中数据的 字符串表示形式
- public StringBuilder append(任意类型): 添加数据，并返回对象本身
- public StringBuilder reverse(): 字符串本身进行反转
使用示例
public class StringBuilderDemo {
public static void main(String[] args) {
//创建对象
StringBuilder sb = new StringBuilder();
//链式编程
sb.append("hello").append("world").append(true).append(100);
System.out.println("sb:"+sb);
//public StringBuilder reverse()
sb.reverse();
System.out.println("sb:"+sb);
}
}
案例
String和StringBuilder相互转换
StringBuilder – String
-
public String toString(): 通过toString()就可以实现把StringBuilder转换为String
String – StringBuilder
-
public StringBuilder(String s): 通过构造方法就可以实现把String转换为StringBuilder
public class StringBuilderTest {
public static void main(String[] args) {
//StringBuilder -- String
StringBuilder sb = new StringBuilder();
sb.append("hello");
//public String toString()
String s = sb.toString();
System.out.println(s);
//String -- StringBuilder
/*
String s = "hello";
StringBuilder sb = new StringBuilder(s);
System.out.println(sb);
*/
}
}
数组拼接成字符串
例如
-
int[] arr = {1,2,3}; 输出：[1, 2, 3]
代码
public class StringBuilderTest2 {
public static void main(String[] args) {
//定义一个int类型的数组
int[] arr = {1,2,3};
//写方法实现把数组中的元素按照指定的格式拼接成一个字符串
//调用方法
String result = arrayToString(arr);
//输出结果
System.out.println("result:"+result);
}
public static String arrayToString(int[] arr) {
StringBuilder sb = new StringBuilder();
//[1, 2, 3]
sb.append("[");
for(int x=0; x<arr.length; x++) {
if(x==arr.length-1) {
sb.append(arr[x]);
}else {
sb.append(arr[x]).append(", ");
}
}
sb.append("]");
String s = sb.toString();
return s;
}
}
字符串反转
代码
public class StringBuilderTest3 {
public static void main(String[] args) {
//键盘录入一个字符串数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String s = sc.nextLine();
//写方法实现字符串数据的反转
//调用方法
String result = myReverse(s);
//输出结果
System.out.println("result:"+result);
}
public static String myReverse(String s) {
//String -- StringBuilder -- reverse() -- String
/*
StringBuilder sb = new StringBuilder(s);
sb.reverse();
String ss = sb.toString();
return ss;
*/
return new StringBuilder(s).reverse().toString();
}
}
Arrays类
概述
Arrays类：提供了对数组操作的各种方法
构造方法
-
在帮助文档中没有看到Arrays类的构造方法：
Arrays类中有构造方法，只不过构造方法被private修饰，外界是无法使用的。因此帮助文档中没有显示。 -
可以通过查看源码的方式找到：
private Arrays() {} -
工具类的设计思想：
-
构造方法私有； 成员都用static修饰； （例如Math，Collections，Arrays类等）
成员方法
public static String toString(int[] a): 把数组转成字符串
public static void sort(int[] a): 对数组进行升序排序
import java.util.Arrays;
public class ArraysDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = {24,69,80,57,13};
//public static String toString(int[] a):把数组转成字符串
System.out.println("排序前："+Arrays.toString(arr));
//public static void sort(int[] a):对数组进行升序排序
Arrays.sort(arr);
System.out.println("排序后："+Arrays.toString(arr));
}
}
包装类
概述
为了对基本数据类型进行更多更方便的操作，Java就针对每一种基本数据类型提供了一个对应的引用类型
基本类型包装类
基本数据类型包装类最常见的用法：和字符串之间进行相互转换
Byte -- byte
Short -- short
Integer -- int
Long -- long
Float -- float
Double -- double
Character -- char
Boolean -- boolean
Integer 类
Integer类在对象中包装了一个基本类型 int 的值
构造方法
-
Integer(int value) Integer(String s) 注意：这个字符串s 必须由数字字符组成 -
示例
public class IntegerDemo {
public static void main(String[] args) {
//Integer(int value)
int value = 100;
Integer i = new Integer(value);
System.out.println(i); //100
System.out.println("------------");
//Integer(String s)
String s = "100";
Integer ii = new Integer(s);
System.out.println(ii);
}
}
案例
int和String类型相互转换
int – String
-
String类中：public static String valueOf(int i)
String – int
-
Integer类中：public static int parseInt(String s) -
代码
public class IntegerDemo {
public static void main(String[] args) {
//int -- String
int number = 100;
//方式1
String s1 = "" + number;
System.out.println(s1);
//方式2
//public static String valueOf(int i)
String s2 = String.valueOf(number);
System.out.println(s2);
System.out.println("--------------");
//String -- int
String s = "100";
//方式1
//String -- Integer -- int
Integer i = new Integer(s);
//public int intValue()
int x = i.intValue();
System.out.println(x);
//方式2
//public static int parseInt(String s)
int y = Integer.parseInt(s);
System.out.println(y);
}
}
字符串中数据排序
例如
-
我有如下一个字符串:“91 27 46 38 50” 请写代码实现最终输出结果是：“27 38 46 50 91”
思路
-
1. 定义一个字符串对象 2. 把字符串中的数字数据存储到一个int类型的数组中 3. 对int数组进行排序 4. 把排序后的数组中的元素进行拼接得到一个字符串 5. 输出字符串
代码
public class IntegerDemo {
public static void main(String[] args) {
//定义一个字符串对象
String s = "91 27 46 38 50";
//把字符串中的数字数据存储到一个int类型的数组中
//public String[] split(String regex)
String[] strArray = s.split(" "); //按照空格进行分割
//定义一个int类型的数组
//将字符串中的数字数据存储到一个int类型的数组中
int[] arr = new int[strArray.length];
for(int x=0; x<arr.length; x++) {
arr[x] = Integer.parseInt(strArray[x]);
}
//对int数组进行排序
Arrays.sort(arr);
//把排序后的数组中的元素进行拼接得到一个字符串
StringBuilder sb = new StringBuilder();
for(int x=0; x<arr.length; x++) {
if(x==arr.length-1) {
sb.append(arr[x]);
}else {
sb.append(arr[x]).append(" ");
}
}
String result = sb.toString();
//输出字符串
System.out.println("result:"+result);
}
JDK5新特性
-
自动装箱：把基本数据类型转换为对应的包装类类型
public static Integer valueOf(int i) -
自动拆箱：把包装类类型转换为对应的基本数据类型
public int intValue() -
注意：在使用包装类类型的新特性的时候，如果做操作，最好先判断是否为null
-
开发中的原则：只要是对象，在使用前就必须进行不为null的判断
Date类
Date表示特定的瞬间，精确到毫秒
构造方法
- Date(): 根据当前时间创建的日期对象
- Date(long date): 根据给定的毫秒值创建对象，从1970 年 1 月 1 日 00:00:00 开始
示例
public class DateDemo {
public static void main(String[] args) {
//Date()
Date d = new Date();
System.out.println(d);
//Date(long date)
long date = 1000 * 60 * 60;
Date dd = new Date(date);
System.out.println(dd);
}
}
成员方法
- public long getTime(): 获取的是毫秒值（从1970年1月1日 00:00:00开始的）
-
从Date得到一个毫秒值： getTime() - public void setTime(long time): 设置时间，给的是毫秒值ms
-
从一个毫秒值得到一个Date对象： 1. 构造方法：Date(long date) 2. setTime(long time)
示例：
public class DateDemo2 {
public static void main(String[] args) {
//创建对象
Date d = new Date();
//public long getTime()
System.out.println(d.getTime());
//public void setTime(long time)
d.setTime(1000*60*60);
System.out.println(d.getTime());
}
}
SimpleDateFormat类
概述
是一个以与语言环境有关的方式来格式化和解析日期的具体类
它允许进行格式化（日期 -> 文本）；解析（文本 -> 日期）
- 格式化（日期 -> 文本）: Date – String
public final String format(Date date) - 解析（文本 -> 日期）: String – Date
public Date parse(String source)
构造方法
- SimpleDateFormat(): 用默认的模式
-
SimpleDateFormat sdf = new SimpleDateFormat(); - SimpleDateFormat(String pattern):用给定的模式
-
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
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
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String s = sdf.format(d);
System.out.println(s);
*/
//String -- Date
String str = "2080-08-08 12:23:45";
//把一个字符串解析为日期的时候，请注意模式字符串和给定的日期字符串的格式要匹配
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf.parse(str);
System.out.println(d);
}
}
练习
制作工具类DateUtil
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
* 工具类
*
* 构造方法私有
* 成员方法静态
*/
public class DateUtil {
private DateUtil() {}
// 把日期转换为指定格式的字符串
public static String dateToString(Date date, String format) {
SimpleDateFormat sdf = new SimpleDateFormat(format);
String s = sdf.format(date);
return s;
}
// 把指定格式的字符串解析为日期
public static Date stringToDate(String s,String format) throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat(format);
Date d= sdf.parse(s);
return d;
}
}
测试工具类
import java.text.ParseException;
import java.util.Date;
public class DateUtilTest {
public static void main(String[] args) throws ParseException {
Date d = new Date();
String s = DateUtil.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
System.out.println(s);
String s2 = DateUtil.dateToString(d, "yyyy年MM月dd日");
System.out.println(s2);
String s3 = DateUtil.dateToString(d, "HH:mm:ss");
System.out.println(s3);
String str = "2080-08-08 12:23:34";
Date dd = DateUtil.stringToDate(str, "yyyy-MM-dd HH:mm:ss");
System.out.println(dd);
}
}
扫一扫
4489
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
