文章目录
Java中常用基础类
1. API
API(Application Programming Interface)，应用程序编程接口。Java API是一本程序员的 字典 ，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们。
- Java中的API，就是JDK提供的各种功能的Java类。
- JDK帮助文 JAVA_API_CN.chm
- 官网地址：http://www.oracle.com/technetwork/java/api-141528.html
2. Scanner类
Scanner类一个可以解析基本类型和字符串的简单文本扫描器,扫描控制台的输入,带入到程序中。(输入的内容，不管你输入的是什么，扫描器拿到的全部都是字符串，然后进行的强制的类型转换.)
我们在使用Idea开发的时候，常用的junit的测试但是IntelliJ IDEA控制台junit不能用Scanner输入。如果想要使用它，需要进行一下配置：解决IntelliJ IDEA控制台junit不能用Scanner输入
System.in获取键盘输入的数据流 系统输入指的是通过键盘录入数据。
Scanner类常用的方法：
scanner.nextInt();获取一个整型的数据scanner.next();获取的是字符串–next()方法读取到空白符就结束；scanner.nextLine();nextLine一次读取一行–nextLine()读取到回车结束也就是“\r”
public static void main(String[] args) {
//创建一个扫描器。System.in获取键盘输入的数据流
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();//获取一个整型的数据
System.out.println("num = " + num);
String str = scanner.next();//.next获取的是字符串。
System.out.println("str = " + str);
/**
next()方法读取到空白符就结束；nextLine()读取到回车结束也就是“\r”
*/
String str1 = scanner.nextLine();//nextLine一次读取一行。
System.out.println("str1 = " + str1);
}
3. Random类
Random类常用方法:
random.nextInt();在int值范围生成随机数random.nextInt(521);[0,521)random.nextInt(10) + 20;[20,30)
/**
* Random r = new Random();
* 获取一个int类型的随机数，（作用范围是int的范围） int num = r.nextInt();
* 如果获取一个int类型的随机数（作为范围0-3之间。[0,3)） int num = r.nextInt(3);
*/
public static void main(String[] args) {
//创建一个Random对象，注意Math有一个random()方法
Random random = new Random();
int num1 = random.nextInt();//在int值范围生成随机数
System.out.println("num1 = " + num1);
int num2 = random.nextInt(521);//[0,521)
System.out.println("num2 = " + num2);
for (int i = 0; i < 10; i++) {
int num = random.nextInt(10);//[0,10)
System.out.println("num = " + num);
}
//3-8 [3,8) -3 [0,5) random.nextInt(5) + 3;
int num3 = random.nextInt(5) + 3;
System.out.println("num3 = " + num3);
//20-30 [20,30)
int num4 = random.nextInt(10) + 20;
System.out.println("num4 = " + num4);
}
二分法猜数字：1-100以内的一个数字。
public static void main(String[] args) {
Random random = new Random();
int num1 = random.nextInt(100) + 1;//[1,100)
Scanner scanner = new Scanner(System.in);
int i = 1;
while (true) {
System.out.println("请输入你第" + (i++) + "次猜测的值：");
int num2 = scanner.nextInt();
if (num1 == num2) {
System.out.println("恭喜你猜了" + i + "猜对了，随机值为：" + num1);
break;
} else if (num1 > num2) {
System.out.println("猜小了");
} else {
System.out.println("猜大了");
}
}
}
4. String类
String 类代表字符串，Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。程序中所有用双引号引起来的字符串，都是String的对象。（就算没有写new ,也是String类的对象）
特点：
字符串的内容永不可变。
因为字符串的内容不可以改变。所以字符串是可以共享使用的。
字符串从效果上来说的话有点类似于char[],但是底层的实现用的是byte[];
4.1 创建字符串对象的方式
//第一种创建字符串等方式：创建一个空白字符串
String str = new String();
//第二种创建字符串的方式：创建一个byte[]的字符串
byte[] bytes = new byte[]{97, 98, 99, 100};
String str1 = new String(bytes);
//第三种创建字符串的方式： 根据字符数组的内容，创建一个对应的字符串。
char[] chars = new char[] {'a', 'b', 'c', 'd'};
String str2 = new String(chars);
//第四种创建字符串的方式：字面量的方式创建,右边直接使用双引号的形式
String str = "hello"；
4.2 字符串常量
字符串常量池：程序中直接写上上引号的字符串，就存储在字符串常量池中。
如果是基本数据类型：== 比较的数值
如果是引用数据类型：== 比较的是内存地址。
String 专门给我们提供了一个方法用于字符串的比较：
- 使用equals方法来完成字符串的比较。字符串使用equals比较的时候，比较是字符串里面的每一个字符。
4.3 字符串类常用方法
.length(); //获得字符串的长度
str1.concat(String str2); //字符串的拼接一般不用，因为和“+”效果一样
.charAt (int index); //获取某个索引处的字符
.indexOf(String str); //查找str在字符串中的首次出现的位置。如果没有查找到对应的字符串，那么返回的索引号为**-1**
String str = "mmaiddd";
//.length()获取字符串的长度
System.out.println("str.length = " + str.length());//7
//concat();字符串的拼接
String str1 = "520";
//String concat = str.concat(str1);//
String concat = str + str1;//推荐使用字符串拼接用 +
System.out.println("concat = " + concat);
//charAt(); 获取指定索引号位置的字符；
char c = "mmaiddd".charAt(1);
System.out.println("c = " + c);//m
//indexOf();查找某字符串在本字符串中第一次出现的位置的索引
//如果没有查找到对应的字符串，那么返回的索引号为-1
int mmIndex = "mmanddd,mmanddd,ddandmm,ddandmm".indexOf("mm");
System.out.println("mmIndex = " + mmIndex);//0
.substring(int index); // 截取字符串，从字符串索引为index的位置开始截取，一直截取到最后, 原始的字符串没有发生任何变化。
substring(int begin, int end); //字符串截取, 包前不包后[ begin , end )
String str = "Hello justweb";
//截取字符串，从字符串索引为6的位置开始截取，一直截取到最后。
String subString = str.substring(6);
System.out.println("subString = " + subString);//justweb
//原始的字符串没有发生任何变化。
System.out.println("str = " + str);//Hello justweb
String str2 = "Hello world";
//包前不包后[3,4)
String substring1 = str2.substring(3, 4);
System.out.println("substring1 = " + substring1);//l
- .toCharArray(); //将当前的字符串拆分成字符数组并返回。
- .getBytes(); //将字符串转成字节数组。
- .replace (oldString,newString); //替换字符串
- public String[] split(String regex) //将此字符串按照给定的regex（规则）拆分为字符串数组
public static void main(String[] args) {
String str1 = "hello justweb";
// 将字符串转成字节数组
char[] chars = str1.toCharArray();
// Arrays.toString(chars) = [h, e, l, l, o, , j, u, s, t, w, e, b]
System.out.println("Arrays.toString(chars) = " + Arrays.toString(chars));
// 将字符串转成字节数组
byte[] bytes = str1.getBytes();
// Arrays.toString(bytes) = [104, 101, 108, 108, 111, 32, 106, 117, 115, 116, 119, 101, 98]
System.out.println("Arrays.toString(bytes) = " + Arrays.toString(bytes));
// 替换文本replace
String str2 = "你好，帮我问候一下你的家人。";
String str3 = str2.replace("家人", "**");
// str3 = 你好，帮我问候一下你的**。
System.out.println("str3 = " + str3);
String s = "aa|bb|cc";
// ["aa","bb","cc"]
String[] strArray = s.split("|");
}
5. Arrays类
工具类
java.util.Arrays此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。操作数组的方法：
boolean equals(int[] a,int[] b);判断两个数组是否相等void fill(int[] a,int val);填充到数组中void sort(int[] a);（快速排序）对数组进行排序。int binarySearch(int[] a,int key);对排序后的数组进行二分法检索指定的值String toString(int[] a);输出数组信息。
public static void main(String[] args) {
int[] arr1 = new int[]{1, 2, 3, 4};
int[] arr2 = new int[]{1, 2, 3, 4};
// 判断两个数组是否相等
boolean flag = Arrays.equals(arr1, arr2);
// true
System.out.println("flag = " + flag);
int[] arr3 = new int[5];
//填充到数组中
Arrays.fill(arr3, 6);
//6 6 6 6 6
System.out.println(Arrays.toString(arr3));
//自己也可以封装,[1 , 3)
Arrays.fill(arr3, 1, 3, 8);//6 8 8 6 6
System.out.println(Arrays.toString(arr3))
int[] arr4 = new int[]{1, 4, 5, 2, 3, 6};
//底层是经过调优的快速排序法
Arrays.sort(arr4);
System.out.println(Arrays.toString(arr4));
//使用二分查找，数据基本有序。
int[] arr5 = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
int i = Arrays.binarySearch(arr5, 8);
System.out.println("i = " + i);
}
Arrays.sort();
对基本数据类型数组的排序
数字排序：
int[] intArray = new int[]{1,56,-5,33}; Arrays.sort(intArray); System.out.println(Arrays.toString(intArray));反向排序
// Arrays类之只是提供了默认的升序排列，没有提供相应的降序排列方法 Arrays.sort(strArray, Collections.reverseOrder());对对象数组的排序：要实现对对象数组的排序，要先实现Comparable或者Comparator接口。下面先简单了解以下这两个接口以及它们的差别，后面会再接触到。
- Comparable 是排序接口,若一个类实现了Comparable接口，就意味着“该类支持排序”。
- 即然实现Comparable接口的类支持排序，假设现在存在“实现Comparable接口的类的对象的List列表(或数组)”，则该List列表(或数组)可以通过 Collections.sort（或 Arrays.sort）进行排序。
6. Math类
- 工具类
java.lang.Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。- 基本运算的方法:
Math.abs(‐5);取绝对值Math.ceil(a);向上取整- **
Math.floor(a);**向下取整- **
Math.round(a);**四舍五入Math.PIπ
7. ArrayList类
java.util.ArrayList是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。ArrayList中可不断添加元素，其大小也自动增长.
7.1 引入——数组的特点
- 数组的长度是固定的，无法适应数据变化的需求
- 为了解决这个问题，Java提供了另一个容器 java.util.ArrayList 集合类,让我们可以更便捷的存储和操作对
象数据。- 引入ArrayList，模拟其底层实现：
public class DemoArrayList {
// 数组初始长度
public static int initNum = 8;
// 扩展为原来长度的1.5倍。
public static int initExtend;
// 初始化数组
public static int[] arr2 = new int[initNum];
// 数组下标
public static int index = 0;
public static void main(String[] args) {
//定义一个数组，将 1,3,5,7,9,11,15个数字添加到数组中。
extend(1);
extend(3);
extend(5);
extend(7);
extend(9);
extend(11);
// 添加第7个数
int[] arr4 = extend(15);
System.out.println("Arrays.toString(arr4) = " + Arrays.toString(arr4));
}
/**
* 我们发现实现数组的动态扩容，其实是根据我们添加到数组的具体情况来进行适当扩容的
* 当然我们也可以根据自己的情况和需求来改变扩容策略。
*/
public static int[] extend(int num) {
// 数组初始长度为initNum = 8
// 当数组的长度等于或大于初始长度的时候，进行以下操作
if (size >= initNum) {
// 对数组进行扩容1.5倍
initNum = initNum + initNum >> 2;
// 新建数组
int[] arr3 = new int[initNum];
// 将原来的数组复制到新数组中
for (int i = 0; i < arr2.length; i++) {
arr3[i] = arr2[i];
}
//让arr2指向新数组
arr2 = arr3;
}
// 向数组中添加数据
arr2[size++] = num;
// 返回数组
return arr2;
}
}
7.1 ArrayList基础
对于
java.util.ArrayList <E>来说 有一个 代表的就是泛型
- 泛型：指定在集合中的元素必须是什么数据类型的。
- 要求：泛型必须是引用数据类型，不能是基本数据类型，所以，
- 如果填写数值的话要使用对应的数值的包装类作为泛型。
ArrayList<String>，ArrayList<Student>查看构造方法
public ArrayList()：构造一个内容为空的集合。// 基本格式: ArrayList<String> list = new ArrayList<String>();
7.3 常用方法和遍历
对于元素的操作,基本体现在——增、删、查。常用的方法有：
public boolean add(E e)：将指定的元素添加到此集合的尾部。public void add(int index, E element)：在此列表中的指定位置插入指定的元素。 将当前位于该位置的元素（如果有）和任何后续元素（向其索引添加一个）移动。public E remove(int index)：移除此集合中指定位置上的元素。返回被删除的元素。public E get(int index)：返回此集合中指定位置上的元素。返回获取的元素。public E set(int index,E element)：用指定的元素替换此列表中指定位置的元素。public int size()：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。
7.4 如何存储基本数据类型
- ArrayList对象不能存储基本类型，只能存储引用类型的数据。类似
<int>不能写，但是存储基本数据类型对应的包装类型是可以的。所以，想要存储基本类型数据，<>中的数据类型，必须转换后才能编写，转换写法如下：- 我们发现，只有 Integer 和 Character 需要特殊记忆，其他基本类型只是首字母大写即可。
| 基本类型 | 基本类型包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
7.5 ArrayList底层简单分析
其他内容会对其底层进行详细的分析。
// 初始容量(添加一个元素后)
private static final int DEFAULT_CAPACITY = 10;
// 集合刚创建的时候的，元素的数据为{};
private static final Object[] EMPTY_ELEMENTDATA = {};
// 默认数组元素的内容
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}
// 真正存储数据的数组。
Object[] elementData ;
// 添加的元素的个数。
int size
8. Date类
- 在使用println方法时，会自动调用Data类中的toString方法。Date类对Object类中的toString方法进行了覆··盖重写所以结果为指定格式的字符串。
- new Date(); 返回的是当前时间–
Thu May 14 14:41:13 CST 2020- new Date(0); 时间元年CST –
Thu Jan 01 08:00:00 CST 1970
- 由于我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒。
- date.getTime(); 返回的是定义的时间零点到当前时间的毫秒值–
1589438473138
public static void main(String[] args) {
Date date = new Date();
// 返回的是当前时间
System.out.println("date = " + date);
// 返回的是定义的时间零点到当前时间的毫秒值
System.out.println("date.getTime() = " + date.getTime());
Date date1 = new Date(0);
// 时间元年CST（China Standard Time）
System.out.println("date1 = " + date1);
}
9. DateFormat 类
java.text.DateFormat是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。由于DateFormat为抽象类，不能直接使用，所以需要常用的子类
java.text.SimpleDateFormat 。
- 格式化：
public String format(Date date);按照指定的格式，从Date对象转换为String对象。- 解析：
public Date parse（String source）;按照指定的格式，从String对象转换为Date对象。
SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
// DateFormat类常用方法
// 把Date对象转换成String
format.format();
// 把String转换成Date对象
format.parse();
9.1 请使用日期时间相关的API，计算出一个人已经出生了多少天。
思路：
获取当前时间对应的毫秒值
获取自己出生日期对应的毫秒值
两个时间相减（当前时间– 出生日期）
public static void function() throws Exception {
System.out.println("请输入出生日期 格式 YYYY‐MM‐dd");
// 获取出生日期,键盘输入
String birthdayString = new Scanner(System.in).next();
// 将字符串日期,转成Date对象
// 创建SimpleDateFormat对象,写日期模式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy‐MM‐dd");
// 调用方法parse,字符串转成日期对象
Date birthdayDate = sdf.parse(birthdayString);
// 获取今天的日期对象
Date todayDate = new Date();
// 将两个日期转成毫秒值,Date类的方法getTime
long birthdaySecond = birthdayDate.getTime();
long todaySecond = todayDate.getTime();
long secone = todaySecond‐birthdaySecond;
if (secone < 0){
System.out.println("还没出生呢");
} else {
System.out.println(secone/1000/60/60/24);
}
}
10. Calendar 类
java.util.Calendar 是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。
获取方式Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象。
// 使用默认时区和语言环境获得一个日历 Calendar calendar = 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对象。
| 字段值 | 含义 |
|---|---|
| YEAR | 年 |
| MONTH | 月（从0开始，可以+1使用） |
| DAY_OF_MONTH | 月中的天（几号） |
| HOUR | 时（12小时制） |
| HOUR_OF_DAY | 时（24小时制） |
| MINUTE | 分 |
| SECOND | 秒 |
| DAY_OF_WEEK | 周中的天（周几，周日为1，可以使-1 使用） |
get/set方法
- get方法用来获取指定字段的值
- set方法用来设置指定字段的值
public class CalendarUtil {
public static void main(String[] args) {
// 创建Calendar对象
Calendar cal = Calendar.getInstance();
// 设置年
int year = cal.get(Calendar.YEAR);
// 设置月
int month = cal.get(Calendar.MONTH) + 1;
// 设置日
int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
System.out.print(year + "年" + month + "月" + dayOfMonth + "日");
}
}
public class CalendarMethod {
public static void main(String[] args) {
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, 2020);
// 2020年1月17日
System.out.print(year + "年" + month + "月" + dayOfMonth + "日");
}
}
- add方法可以对指定日历字段的值进行加减操作，如果第二个参数为正数则加上偏移量，如果为负数则减去偏移量。
public class Demo08CalendarMethod {
public static void main(String[] args) {
Calendar cal = Calendar.getInstance();
// 2018年1月17日
System.out.print(year + "年" + month + "月" + dayOfMonth + "日");
// 使用add方法
cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
cal.add(Calendar.YEAR, ‐3); // 减3年
// 2015年1月18日;
System.out.print(year + "年" + month + "月" + dayOfMonth + "日");
}
}
Calendar中的getTime方法并不是获取毫秒时刻，而是拿到对应的Date对象。
public class Demo09CalendarMethod {
public static void main(String[] args) {
Calendar cal = Calendar.getInstance();
Date date = cal.getTime();
System.out.println(date); // Tue Jan 16 16:03:09 CST 2018
}
}
- 西方星期的开始为周日，中国为周一。
- 在Calendar类中，月份的表示是以0-11代表1-12月。
- 日期是有大小关系的，时间靠后，时间越大。
11. System类
java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作。- 在System类的API文档中，常用的方法有：
public static long currentTimeMillis()：返回以毫秒为单位的当前时间.public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中
- src ： 数据源
- srcPos : 起始位置
- dest ： 目标位置
- destPos： 起始复制位置
- length : 复制长度
public static void main(String[] args) {
int[] arr1 = {1,2,3,4,5,6};
int[] arr2 = {7,8,9,10,11};
System.arraycopy(arr1,0,arr2,0,4);
// [1, 2, 3, 4, 11]
System.out.println(Arrays.toString(arr2));
}
3633
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
