Java常用类和集合
Java常用API
概述
API（Application Programming Interface),应用程序编程接口。Java API是一本程序员的字典，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查阅API的方式，来学习Java提供的类，并得知如何使用它们。
1. Scanner类
1.1 什么是Scanner类
一个可以解析基本类型和字符串的简单文本扫描器
例如，以下代码使用户能够从System.in中读取一个数
Scanner sc = new Scanner(System.in);
int i = sc.nexInt();
System.in系统输入指的是通过键盘录入数据。
1. 2 Scanner类使用
import java.util.Scanner; //1. 导包
// Scanner类的功能：可以实现键盘输入数据到程序当中
/*
引用类型的一般使用步骤：
1. 导包
import 包路径.类名称;
如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。
只有java.lang包下的内容不需要导包，其他的包都需要import语句
2. 创建
类名称 对象名 = new 类名称();
3. 使用
对象名.成员方法
获取键盘输入的一个int数字：int num = sc.nextInt();
获取键盘输入的一个字符串: String str = sc.next();
*/
public class Demo01 {
public static void main(String[] args) {
//2. 创建
//备注： System.in代表从键盘输入
Scanner sc = new Scanner(System.in);
//3. 获取键盘输入的int数字
int num = sc.nextInt();
System.out.println("输入的int数字是：" + num);
//4. 获取键盘输入的字符串
String str = sc.next();
System.out.println("输入的字符串是： " + str);
}
}
实例：输入两个数字并返回和
import java.util.Scanner;
/*
题目：键盘输入两个int数字，并且求出和值
思路:
1. 既然需要键盘输入，那么就用Scanner
2. Scanner的三个步骤： 导包、创建、使用
3. 需要的是两个数字，所以要调用两次nextInt方法
4. 得到两个数字，就需要加在一起
5. 将结果打印输出
*/
public class Demo02 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数字：");
int a = sc.nextInt();
System.out.println("请输入第二个数字：");
int b = sc.nextInt();
int result = a + b;
System.out.println("结果是:" + result);
}
}
实例： 键盘输入三个int数字，然后求出最大值
import java.util.Scanner;
/*
题目：
键盘输入三个int数字，然后求出最大值
思路：
1. 既然是键盘输入，肯定需要用到Scanner
2. Scanner三个步骤：导包、创建、使用nextInt()方法
3. 既然是三个数字，那么调用三次nextInt()方法，得到三个int变量
4. 无法同时判断三个数字谁最大，应该转化为两个步骤
4.1 首先判断两个当中谁最大，拿到前两个的最大值
4.2 拿着前两个中的最大值，再和第三个数字比较，得到三个数字当中的最大值
5. 打印最终结果
*/
public class Demo03 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数字：");
int a = sc.nextInt();
System.out.println("请输入第二个数字：");
int b = sc.nextInt();
System.out.println("请输入第一三数字：");
int c = sc.nextInt();
//首先得到前两个数字当中的最大值
int temp = a > b ? a : b;
int max = temp > c ? temp : c;
System.out.println(max);
}
}
1.3 匿名对象
创建对象的标准格式：
类名称 对象名 = new 类名称（）;
匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
new 类名称（）；
注意事项：匿名对象只能使用一次，下次再使用不得不再创建一个新对象。
使用建议：如果确定有一个对象只需要使用一次，就可以用匿名对象。
person类：
public class Person {
String name ;
public void showName() {
System.out.println(name);
}
}
public class Demo01 {
public static void main(String[] args) {
Person one = new Person();
one.name = "aaa";
one.showName();
System.out.println("============");
new Person().name = "bbb";
new Person().showName();
}
}
运行结果:
匿名对象可以作为方法的参数，也可以作为方法的返回值
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
// 普通使用方式
// Scanner sc = new Scanner(System.in);
// int num = sc.nextInt();
// int num = new Scanner(System.in).nextInt();
// System.out.println(num);
//使用一般写法传入参数
// Scanner sc = new Scanner(System.in);
// methodParam(sc);
//使用匿名对象进行传参
// methodParam(new Scanner(System.in));
Scanner sc = methodReturn();
int i = sc.nextInt();
System.out.println(i);
}
public static void methodParam(Scanner sc) {
int num = sc.nextInt();
System.out.println("输入的是" + num);
}
//匿名对象作为方法的返回值
public static Scanner methodReturn() {
// Scanner sc = new Scanner(System.in);
// return sc;
return new Scanner(System.in);
}
}
2. Random类
random类用来生成随机数字。使用起来也是三个步骤：
-
导包
import java.util.Random;````
-
创建
Random r = new Random();
-
使用
获取一个随机的int数字(范围是int所有的返回，有正负两种）：int num = r.nextInt()
获取一个随机的int数字（参数代表了范围，左闭右开区间）：int num = r.nextInt(3)
实际上代表的含义是，[0,3)，也就是0~2
import java.util.Random;
public class Demo01 {
public static void main(String[] args) {
Random r = new Random();
int num = r.nextInt();
System.out.println("随机数是：" + num);
}
}
带有参数：
import java.util.Random;
public class Demo02 {
public static void main(String[] args) {
Random r = new Random();
for (int i = 0; i < 100; i++) {
int num = r.nextInt(10); //范围实际上是0~9
System.out.println(num);
}
}
}
一个实例
import java.util.Random;
/*
题目要求：
根据int变量n的值，来获取随机数字，范围是[1,n]，可以取到1也可以取到n。
思路：
1. 定义一个int变量n，随意赋值
2. 要使用Random，三个步骤，导包、创建、使用
3. 如果写10，那么就是0~9，然后想要的是1~10，可以发现：整体+1即可
*/
public class Demo03 {
public static void main(String[] args) {
int n = 5;
Random random = new Random();
int result = random.nextInt(n) + 1;
System.out.println(result);
}
}
3. ArrayList类
ArrayList和数组的区别：
数组的长度不可以发生改变，但是ArrayList集合的长度可以改变
对于ArrayList来说，有一个尖括号
泛型，也就是装在集合当中的所有元素，全都是统一的什么类型。
注意：泛型只能是引用类型，不能是基本类型。
注意事项：
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
如果内容是空，得到的是空的括号，[ ]
import java.util.ArrayList;
public class Demo01 {
public static void main(String[] args) {
//创建了一个ArrayList集合，集合的名称是List，里面装的全都是String字符串类型的数据
//备注，从JDK1.7开始，右侧的尖括号内可以不写内容，但是<>本身还是要写的
ArrayList<String> list = new ArrayList<>();
System.out.println(list);
//向集合中添加一些数据，需要使用add()方法。
list.add("赵丽颖");
System.out.println(list);
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马尔扎哈");
System.out.println(list);
// list.add(100);//错误写法！因为创建的时候尖括号泛型已经说了是字符串，添加进去的元素就必须都是字符串才行。
}
}
3.1 ArrayList常用方法
public boolean add(E e),向集合中添加元素，参数的类型和泛型一致
public E get(int index),向集合中获取元素，参数是索引编号，返回值就是对应位置的元素。
public E remove(int index),从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。
public int size(),获取集合的尺寸长度，返回值是集合中包含的元素个数
import java.util.ArrayList;
//备注：对于ArrayList集合来说，add添加动作一定是成功的。但是对于其他集合来说，add动作不一定成功
public class Demo02 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
System.out.println(list);
boolean success = list.add("马尔扎哈");
System.out.println(list);
System.out.println("添加的动作是否成功" + success);
list.add("盖伦");
list.add("卡特玲那");
list.add("金克丝");
list.add("杰斯");
System.out.println(list);
//从集合中获取元素:get,索引值从0开始
String name = list.get(2);
System.out.println(name);
//从集合中删除元素：remove,索引从0开始
String whoRemoved = list.remove(2);
System.out.println("被删除的人是：" + whoRemoved);
System.out.println(list);
int size = list.size();
System.out.println("集合的长度为" + size);
}
}
3.2 ArrayList存储基本数据类型
package com.dailyclass.arraylistDemo;
import java.util.ArrayList;
/*
如果希望向ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”
基本类型 包装类（引用类型，包装类都位于java.lang包下
byte Byte
int Integer [特殊]
long Long
float Float
double Double
char Character [特殊]
boolean Boolean
从JDK 1.5+开始，支持自动装箱、自动拆箱
自动装箱： 基本类型 --》 包装类型
自动拆箱： 包装类型 --》 基本类型
*/
public class Demo03 {
public static void main(String[] args) {
ArrayList<String> listA = new ArrayList<>();
//错误写法!泛型只能是应用类型，不能是基本类型
//ArrayList<int> listB = new ArrayList<>();
ArrayList<Integer> listB = new ArrayList<>();
listB.add(100);
listB.add(200);
System.out.println(listB);
int num = listB.get(1);
System.out.println(num);
}
}
练习一
生成6个 1~33之间的随机整数，添加到集合，并遍历集合
package com.dailyclass.arraylistDemo;
import java.util.ArrayList;
import java.util.Random;
/*
题目：生成6个1~33之间的随机整数，并遍历集合
思路：
1.需要存储6个数字，创建一个集合，<Integer>
2.产生随机数，需要用到Random
3.用循环6次，来产生6个随机数字，for循环
4.循环内点用r.nextInt(int n),参数是33,0~32，整体加一才是1~33
5.把数字添加到集合中：Add
6.遍历集合：for,size,get
*/
public class Demo04 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 6; i++) {
int num = r.nextInt(33) + 1;
list.add(num);
}
//遍历集合
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
练习二
自定义四个学生对象，添加到集合，并遍历。
package com.dailyclass.arraylistDemo;
import java.util.ArrayList;
/*
题目：
自定义四个学生对象，添加到集合，并遍历。
思路：
1. 自定义Student学生类，四个部分；
2. 创建一个集合，用来存储学生对象。泛型，<Student>
3. 根据类，创建4个学生对象。
4. 将4个学生对象添加到集合中：add
5. 遍历集合：for size get
*/
public class Demo05 {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
Student one = new Student("洪七公",20);
Student two = new Student("欧阳锋",21);
Student three = new Student("黄药师",22);
Student four = new Student("段智兴",23);
list.add(one);
list.add(two);
list.add(three);
list.add(four);
for (int i = 0; i < list.size(); i++) {
Student stu = list.get(i);
System.out.println(stu.getName() + stu.getAge());
}
}
}
练习三
定义以指定格式打印集合的方法（ArrayList类型作为参数），使用（）括起集合，使用@分隔每个元素。格式参照（元素@元素@元素）。
package com.dailyclass.arraylistDemo;
import java.util.ArrayList;
/*
题目：
定义以指定格式打印集合的方法（ArrayList类型作为参数），使用（）括起集合，使用@分隔每个元素。
格式参照（元素@元素@元素）。
System.out.println(list); [10, 20, 30]
printArrayList(list); {10@20@30}
*/
public class Demo06 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三丰");
list.add("宋远桥");
list.add("张无忌");
list.add("张翠山");
System.out.println(list);
printArrayList(list);
}
/*
定义方法的三要素
返回值类型，只是进行打印，没有运算，没有结果；所以用void
方法名称，printArrayList
参数列表,ArrayList
*/
public static void printArrayList(ArrayList<String> list) {
System.out.print("{");
for (int i = 0; i < list.size(); i++) {
String name = list.get(i);
if(i == list.size() - 1)
{
System.out.println(name + "}");
} else {
System.out.print(name + "@");
}
}
}
}
练习四
package com.dailyclass.arraylistDemo;
import com.oop.Demo04.A;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Random;
/*
题目：
用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合当中。
要求使用自定义的方法来实现筛选
分析：
1. 需要创建一个集合用来存储int数字：<Integr>
2. 随机数字就用Random nextInt
3. 循环二十次，把随机数字放入大集合，for循环，add方法
4. 定义一个方法，用来进行筛选。
筛选：根据大集合，筛选符合要求的元素，得到小集合
三要素
返回值类型：ArrayList小集合（里面元素个数不确定）
方法名称:getSmallList
参数列表：ArrayList大集合（装着20个随机数字）
5. 判断（if）是偶数：num % 2 == 0
6. 如果是偶数，就放到小集合中，否则不放
*/
public class Demo07 {
public static void main(String[] args) {
ArrayList<Integer> bigList = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 20; i++) {
int num = r.nextInt(100) + 1;
bigList.add(num);
}
ArrayList<Integer> smallList = new ArrayList<>();
smallList = getSmallList(bigList);
System.out.println(smallList);
}
public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList) {
ArrayList<Integer> smallList = new ArrayList<>();
for (int i = 0; i < bigList.size(); i++) {
int num = bigList.get(i);
if (num % 2 == 0) {
smallList.add(num);
}
}
return smallList;
}
}
4. String
java.lang.String类代表字符串
API当中说，java程序中的所有字符串字面值（如"abc"）都作为此类的实例实现。
其实就是说，程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是）
字符串的特点：
- 字符串的内容永不可变。【重点】
- 正是因为字符串不可改变，所以字符串是可以共享使用的。
- 字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。
4.1 字符串的创建
package com.dailyclass.stringDemo;
/*
java.lang.String类代表字符串
API当中说，java程序中的所有字符串字面值（如"abc"）都作为此类的实例实现。
其实就是说，程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是）
字符串的特点：
1. 字符串的内容永不可变。【重点】
2. 正是因为字符串不可改变，所以字符串是可以共享使用的。
3. 字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。
创建字符串的常见3+1种方式。
三种构造方法：
public String():创建一个空白字符串，不含任何内容。
public String(char[]):根据字符数组的内容来创建对应的字符串
public String(byte[]):根据字节数组的内容来创建对应的字符串
一种直接创建：
String str = "hello"; //右边直接使用双引号
注意：直接写上双引号，就是字符串对象。
*/
public class Demo01 {
public static void main(String[] args) {
//使用空参构造
String str1 = new String();//小括号留空，说明字符串什么内容都没有
System.out.println("第一个字符串为： " + str1);
//根据字符数组创建字符串
char[] chararray = {'A','B','C'};
String str2 = new String(chararray);
System.out.println("第二个字符串为: " + str2);
//根据字节数组来创建字符串
byte[] byteArray = {97, 98, 99};
String str3 = new String(byteArray);
System.out.println("第三个字符串为：" + str3);
//直接创建
String str4 = "Hello";
System.out.println("第三个字符串为： " + str4);
}
}
4.2 字符串的常量池
4.3 字符串的比较
/*
==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法
public boolean equals(Object obj);参数可以是任何对象，只有参数是一个字符串且内容相同参会给true，否则返回false
注意事项：
1. 任何对象都能用Object进行接收。
2. equals方法具有对称性。也就是a.equals(b)和b.equals(a)效果一样
3. 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
推荐： “abc”.equals(str) 不推荐：str.equals("abc")
pulbic boolean equalsIgnoreCase(String str) :忽略大小写，进行内容比较
*/
public class Demo01Equals {
public static void main(String[] args) {
String str1 = "Hello";
String str2 = "Hello";
char[] charArray = {'H','e','l','l','o'};
String str3 = new String(charArray);
System.out.println(str1.equals(str2));
System.out.println(str2.equals(str3));
System.out.println(str3.equals("Hello"));
System.out.println("Hello".equals(str1));
String str4 = "hello";
System.out.println(str1.equals(str4));
System.out.println("=============================");
String str5 = null;
System.out.println("abc".equals(str5)); //推荐,false
System.out.println(str5.equals("abc")); //不推荐,报错，空指针异常NuallPointerException
String strA = "Java";
String strB = "java";
System.out.println(strA.equals(strB));
System.out.println(strA.equalsIgnoreCase(strB));
//注意：只有英文字母区分大小写，其他都不区分大小写
System.out.println("壹".equalsIgnoreCase("一"));
}
}
4.4 字符串获取的相关方法
/*
String当中与获取相关的常用方法有：
public int length(): 获取字符串当中含有的字符个数，拿到字符串长度
public String concat(String str): 将当前字符串和参数字符串拼接成为返回值新的字符串。
public char charAt(int index): 获取指定索引位置的单个字符。（索引从0开始）
public int indexOf(String str)： 查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1
*/
public class Demo03 {
public static void main(String[] args) {
//获取字符串长度
int length = "aakjglkasjdklgjklsdgj".length();
System.out.println(length);
//拼接字符串
String str1 = "hello";
String str2 = "world";
String str3 = str1.concat(str2);
System.out.println(str1);
System.out.println(str2);
System.out.println(str3);
System.out.println("======================");
//获取指定索引位置的单个字符
char ch = "Hello".charAt(1);
System.out.println(ch);
System.out.println("======================");
//查找参数字符串在本来字符串当中出现的第一次索引位置
//如果根本没有，返回-1值
String original = "HelloWorld";
int index = original.indexOf("llo");
System.out.println(index);
System.out.println(original.indexOf("abc")); }
}
4.5 字符串的截取方法
/*
字符串的截取方法：
public String substring(int index): 截取从参数位置一直到字符串末尾，返回新的字符串。
public String substring(int begin, int end): 截取从begin开始，一直到end结束，中间的字符串
备注： [begin,end),包含左边，不包含右边。
*/
public class Demo04 {
public static void main(String[] args) {
String str1 = "HelloWorld";
String str2 = str1.substring(5);
System.out.println(str1);
System.out.println(str2);
System.out.println("=================");
String str3 = str1.substring(4, 7);
System.out.println(str3);
System.out.println("====================");
//下面这种写法，字符串的内容仍然没有改变
//下面有两个字符串:“Hello" "Java"
//strA当中保存的是地址值
//本来地址值是Hello的0X666
//后来地址值变成了Java的0X999
String strA = "Hello";
System.out.println(strA);
strA = "Java";
System.out.println(strA);
}
}
4.6 字符串转换方法
/*
String当中与转换相关的常用方法有：
public char[] toCharArray(): 将当前字符串拆分称为字符数组作为返回值;
public byte[] getBytes():获得当前字符串底层的字节数组。
public String replace(CharSequence oldString, CharSequence newString):
将所有出现的老字符串替换为新的字符串，返回替换之后的结果新字符。
备注：CharSequence意思就是说可以接受字符串类型
*/
public class Demo05 {
public static void main(String[] args) {
//转换成为字符数组
char[] chars = "Hello".toCharArray();
System.out.println(chars[0]);
System.out.println(chars.length);
System.out.println("==================");
//转换为字节数组
byte[] bytes = "abc".getBytes(StandardCharsets.UTF_8);
for (int i = 0; i < bytes.length; i++) {
System.out.println(bytes[i]);
}
System.out.println("======================");
//字符串的内容替换
String str1 = "How do you do?";
String str2 = str1.replace("o", "*");
System.out.println(str1);
System.out.println(str2);
}
}
4.7 字符串的分隔方法
/*
分割字符串的方法：
public String[] split(String regex):按照参数的规则，将字符串切分成为若干部分。
注意事项：
split方法的参数其实是一个正则表达式：今后学习。
今天要注意 ： 如果按照英文句点“.”进行划分，必须写"\\."（两个反斜杠）
*/
public class Demo06 {
public static void main(String[] args) {
String str1 = "aaa,bbb,ccc";
String[] array1 = str1.split(",");
for (int i = 0; i < array1.length; i++) {
System.out.println(array1[i]);
}
System.out.println("=-==============");
String str2 = "aaa bbb ccc";
String[] array2 = str2.split(" ");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i]);
}
System.out.println("==================");
String str3 = "XXX.YYY.ZZZ";
String[] array3 = str3.split("\\.");
System.out.println(array3.length);
for (String s : array3) {
System.out.println(s);
}
}
}
5. Arrays
/*
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作.
public static String toString(数组): 将参数数组变成字符串（按照默认格式：[元素1， 元素2，元素3，......})
public static void sort(数组): 按照默认升序（从小到大）对数组的元素进行排序。
备注：
1. 如果是数值，sort默认按照升序从小到大
2. 如果是字符串，sort默认按照字母升序
3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Compator接口的支持。（今后学习）
*/
public class Demo01 {
public static void main(String[] args) {
int[] intArray = {10, 20, 30};
//将int[]数组按照默认格式变成字符串
String intStr = Arrays.toString(intArray);
System.out.println(intStr);
int[] array1 = {2, 1, 3, 10, 6};
Arrays.sort(array1);
System.out.println(Arrays.toString(array1));
String[] array2 = {"bbb", "aaa", "ccc"};
Arrays.sort(array2);
System.out.println(Arrays.toString(array2));
}
}
6. Math
/*
java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作
public static double abs(double num):获取绝对值。
public static double ceil(double num):向上取整.
public static double floor(double num):向下取整。
public static long round(double num):四舍五入。
Math.PI代表近似的圆周率常量
*/
public class Demo01 {
public static void main(String[] args) {
//获取绝对值
System.out.println(Math.abs(3.14));
System.out.println(Math.abs(0));
System.out.println(Math.abs(-2.5));
System.out.println("===============");
//向上取整
System.out.println(Math.ceil(3.8));
System.out.println(Math.ceil(3.12));
//向下取整
System.out.println(Math.floor(128.36));
System.out.println(Math.floor(30.9));
System.out.println(Math.floor(31.0));
//四舍五入
System.out.println(Math.round(20.4));
System.out.println(Math.round(10.5));
System.out.println(Math.PI);
}
}
7. 日期时间类
7.1 Date类
毫秒值：
/*
java.util.Date:表示日期和时间的类
类Date表示特定的瞬间，精确到毫秒
毫秒：千分之一秒 1000毫秒 = 1秒
特定的瞬间：一个时间点，一刹那时间
毫秒值的作用：可以对时间和日期进行计算
2099 - 01 -01到2088-01-01中间一共有多少天
可以日期转换为毫秒进行计算，计算完毕，再把毫秒转换为日期
把日期转换为毫秒：
当前的日期：2088-01-01
时间原点（0毫秒）：1970年1月1日00:00:00（英国格林威治）
就是计算当前日期到时间原点之间一共经历了多少毫秒
把毫秒转换为日期：
1天 = 24 * 60 * 60 = 86400秒 = 86400000毫秒
注意：
中国属于东八区，会把时间增加8个小时
*/
public class Demo01 {
public static void main(String[] args) {
System.out.println(System.currentTimeMillis());//获取当前系统时间一共到1970年1月1日00:00:00经历了多少毫秒
}
}
构造方法与成员方法
import java.util.Date;
public class Demo02 {
public static void main(String[] args) {
demo01();
demo02();
demo03();
}
/*
Date类的空参数构造方法：
Date()获取的就是当前系统的时期和时间
*/
private static void demo01() {
Date date = new Date();
System.out.println(date);
}
/*
Date类的带参数的构造方法：
Date(long date):传递毫秒值，把毫秒值转换为Date日期
*/
private static void demo02(){
Date d1 = new Date(0L);
System.out.println(d1);
Date d2 = new Date(22222222222L);
System.out.println(d2);
}
/*
Date类的成员方法
Long getTime()把日期转换为毫秒
返回自1970年1月1日 00:00:00 GM以来此Date对象表示的毫秒数
*/
private static void demo03(){
Date date = new Date();
System.out.println(date.getTime());
}
}
7.2 DateFormat和SimpleDateFormat
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
java.text.DateFormat:是日期/时间格式化子类的抽象类
作用：
格式化（也就是日期-》文本）、解析（文本-》日期）
成员方法：
String format(Date date) 按照指定的模式，吧Date日期，格式化为符合模式的字符串
Date parse(String source) 把符合模式的字符串，解析为Date日期。
DateFormat类是一个抽象类，无法直接创建对象使用，可以使用DateFormat的子类
java.text.SimpleDateFormat extends DateFormat
构造方法：
SimpleDateFormat(String pattern) 用给定的模式和默认语言环境的日期格式符号构造。
参数：
String pattern：传递指定的模式
模式：区分大小写的
y 年
M 月
d 日
H 时
m 分
s 秒
写对应的模式，会把模式替换为对应的日期和时间
"yyyy-MM-dd HH:mm:ss"
注意：
模式中的字母不能更改，连接模式的符号可以改变
*/
public class Demo03DateFormat {
public static void main(String[] args) throws ParseException {
demo01();
demo02();
}
/*
使用DateFormat类中的方法parse，把文本解析为日期
Date parse(String source) 把符合模式的字符串，解析为Date日期。
使用步骤：
1. 创建SimpleDateFormat对象，构造方法中传递指定的模式
2. 调用SimpleDateFormat对象中的方法parse，把符合构造方法中模式的字符串，解析为Date日期
注意：
public Date parse(String source) throws ParseException
parse方法声明了一个异常叫ParseException解析异常
如果字符串和构造方法中的模式不一样，那么程序就会抛出异常。
调用一个抛出异常的方法，就必须处理这个异常，要么throws继续声明抛出这个异常，要么try...catch自己处理这个异常
*/
private static void demo02() throws ParseException {
// 1. 创建SimpleDateFormat对象，构造方法中传递指定的模式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 2. 调用SimpleDateFormat对象中的方法parse，把符合构造方法中模式的字符串，解析为Date日期
Date date = sdf.parse("2021-05-19 12:12:09");
System.out.println(date);
}
/*
使用DateFormat类中的方法format，把日期格式化为文本
String format(Date date) 按照指定的模式，吧Date日期，格式化为符合模式的字符串
使用步骤：
1. 创建SimpleDateFormat对象，构造方法中传递指定的模式
2. 调用SimpleDateFormat对象中的方法format，按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串（文本）
*/
private static void demo01() {
//1.创建SimpleDateFormat对象，构造方法中传递指定的模式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//2. 调用SimpleDateFormat对象中的方法format，按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串（文本）
Date date = new Date();
String text = sdf.format(date);
System.out.println(date);
System.out.println(text);
}
}
7.3 Calendar类
Calendar类的介绍
import java.util.Calendar;
/*
java.util.Calendar类：日历类
Calendar类是一个抽象类，里面提供了很多操作日历字段的方法（YEAR、MONTH、DAY_OF_MONTH、HOUR ）
Calendar类无法直接创建对象使用，里面有一个静态方法叫getInstance(),该方法反悔了Calendar类的子类对象
static Calendar getInstance()使用默认是去和语言环境获得一个日历
*/
public class Demo01Calendar {
public static void main(String[] args) {
Calendar instance = Calendar.getInstance();//多态
System.out.println(instance);
}
}
Calendar类的成员方法
/*
Calendar类的成员方法：
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对象
成员方法的参数：
int field:日历类的字段，可以使用Calendar类的静态成员变量获取
public static final int YEAR = 1; 年
public static final int MONTH = 2; 月
public static final int DATE = 5; 月中的某一天
public static final int DAY_OF_MONTH = 5; 月中的某一天
public static final int HOUR = 10; 时
public static final int MINUTE = 12; 分
public static final int SECOND = 12; 秒
*/
import java.util.Calendar;
import java.util.Date;
public class Demo02Calendar {
public static void main(String[] args) {
demo01();
demo02();
demo03();
demo04();
}
/*
public Date getTime():返回一个表示此Calendar时间值（从历元到现在的毫秒偏移值）的Date对象
把日历对象转换为日期对象
*/
private static void demo04() {
//使用getInstance方法获取Calendar对象
Calendar instance = Calendar.getInstance();
Date time = instance.getTime();
System.out.println(time);
}
/*
public abstract void add(int field, int amount):根据日历的规则，为给定的日历字段添加或减去指定的时间量
把指定的字段增加/减少指定的值
参数：
int field:传递指定的日历字段(YEAR,MONTH...)
int amount:增加、减少的具体值
正数：增加
负数：减少
*/
private static void demo03() {
//使用getInstance方法获取Calendar对象
Calendar instance = Calendar.getInstance();
instance.add(Calendar.YEAR,2);
instance.add(Calendar.MONTH,-3);
int year = instance.get(Calendar.YEAR);
System.out.println(year);
int month = instance.get(Calendar.MONTH);
System.out.println(month); //0~11-->1~12
int date = instance.get(Calendar.DATE);
System.out.println(date);
}
/*
public void set(int field, int value): 将给定的日历字段设置为给定值
参数：int field:传递指定的日历字段（YEAR，MONTH....)
int value:传递的字段设置的具体值
*/
private static void demo02() {
//使用getInstance方法获取Calendar对象
Calendar instance = Calendar.getInstance();
instance.set(Calendar.YEAR,9999);
instance.set(Calendar.MONTH,9);
instance.set(Calendar.DATE,9);
//同时设置年月日，可以使用set的重载方法
instance.set(8888,8,8);
int year = instance.get(Calendar.YEAR);
System.out.println(year);
int month = instance.get(Calendar.MONTH);
System.out.println(month); //0~11-->1~12
int date = instance.get(Calendar.DATE);
System.out.println(date);
}
/*
public int get(int field): 返回给定日历字段的值
参数：传递指定的日历字段（YEAR，MONTH....)
返回值：日历字段代表具体的值
*/
private static void demo01() {
//使用getInstance方法获取Calendar对象
Calendar instance = Calendar.getInstance();
int year = instance.get(Calendar.YEAR);
System.out.println(year);
int month = instance.get(Calendar.MONTH);
System.out.println(month); //0~11-->1~12
int date = instance.get(Calendar.DATE);
System.out.println(date);
}
}
8. Object类
8.1 toString方法
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
/*
java.lang.Object类
类 Object 是类层次结构的根类（最顶层）。每个类都使用 Object 作为超类（父类）。
所有对象（包括数组）都实现这个类的方法。
*/
public class Demo01 {
public static void main(String[] args) {
/*
Personl类默认继承了Object类，所以可以使用Object类中的toString方法
String toString()返回该对象的字符串表示
*/
Person p = new Person("张三", 10);
String s = p.toString();
System.out.println(s);//com.dailyclass.objectDemo.Person@4f3f5b24
//直接打印对象的名字，其实就是调用对象的toString方法 p = p.toString();
System.out.println(p);
//看一个类是否重写了toString方法，直接打印这个类对应对象的名字即可
//如果没有重写toString方法，那么打印的就是对象的地址值（默认）
//如果重写了toString方法，那么久按照重写的方式打印
Random random = new Random();
System.out.println(random);//java.util.Random@15aeb7ab
Scanner scanner = new Scanner(System.in);
System.out.println(scanner);//java.util.Scanner[delimiters=\p{javaWhitespace}+][position=0][match valid=false][need input=false][source closed=false][skipped=false][group separator=\x{2c}][decimal separator=\x{2e}][positive prefix=][negative prefix=\Q-\E][positive suffix=][negative suffix=][NaN string=\QNaN\E][infinity string=\Q∞\E]
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
System.out.println(list);
}
}
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
/*
直接打印对象的地址值没有意义，需要重写Object类的toString方法
打印对象的属性（name,age)
*/
// @Override
// public String toString() {
// //return "abc";
// return "Person{name="+ name +", age="+ age +"}";
// }
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
8.2 equals方法
public class Demo02 {
public static void main(String[] args) {
/*
Person类默认继承了Object类，所以可以使用Object类的equals方法
boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”
Object类equals方法的源码：
public boolean equals(Object obj) {
return (this == obj);
}
参数：
Object obj;可以传递任意的对象
方法体：
==:比较运算符，返回的就是一个布尔值true，false
基本数据类型：比较的是值
引用的数据类型： 比较的是两个对象的地址值
this是谁？哪个对象调用的方法，方法中的this就是哪个对象;p1点用的equals方法，所以this就是p1
obj是谁？传递过来的参数p2
this == obj ==> p1 == p2
*/
Person p1 = new Person("迪丽热巴",18);
Person p2 = new Person("古力娜扎",18);
// p1 = p2;
System.out.println(p1);
System.out.println(p2);
boolean b = p1.equals(p2);
System.out.println(b);
}
}
重写equals方法
import java.util.Objects;
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
/*
直接打印对象的地址值没有意义，需要重写Object类的toString方法
打印对象的属性（name,age)
*/
// @Override
// public String toString() {
// //return "abc";
// return "Person{name="+ name +", age="+ age +"}";
// }
// @Override
// public String toString() {
// return "Person{" +
// "name='" + name + '\'' +
// ", age=" + age +
// '}';
// }
/*
Object类的equals方法默认比较的是两个对象的地址值，没有意义
所以我们需要重写equals方法，比较两个对象的属性值（name, age)
对象的属性值一样时，返回true；否则返回false
问题：
隐含着一个多态
Object obj = p2 = new Person("古力娜扎“,18);
多态的弊端：无法使用子类特有的内容（属性，方法）
解决办法：可以使用向下转型（强转）把Object类型转换为Person
*/
// @Override
// public boolean equals(Object o) {
// //增加一个判断，传递的参数是this本身，直接返回true
// if (o == this) {
// return true;
// }
// //增加一个判断，传递的参数为null，直接热孺人false。
// if(o == null) {
// return false;
// }
// // 增加一个判断，是person类型再转换，防止类型转换异常ClassCastException
// if(o instanceof Person) {
// //使用向下转型（强转）把Object类型转换为Person
// Person person = (Person) o;
// //比较两个对象的属性；一个是调用方法的this(p1),一个就是p(obj = p2)
// return this.name.equals(person.name) && this.age == person.age;
// }
// //不是Person类型直接返回false
// return false;
// }
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
import java.util.Random;
public class Demo02 {
public static void main(String[] args) {
/*
Person类默认继承了Object类，所以可以使用Object类的equals方法
boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”
Object类equals方法的源码：
public boolean equals(Object obj) {
return (this == obj);
}
参数：
Object obj;可以传递任意的对象
方法体：
==:比较运算符，返回的就是一个布尔值true，false
基本数据类型：比较的是值
引用的数据类型： 比较的是两个对象的地址值
this是谁？哪个对象调用的方法，方法中的this就是哪个对象;p1点用的equals方法，所以this就是p1
obj是谁？传递过来的参数p2
this == obj ==> p1 == p2
*/
Person p1 = new Person("迪丽热巴",18);
Person p2 = new Person("迪丽热巴",18);
// p1 = p2;
System.out.println(p1);
System.out.println(p2);
Random r = new Random();
boolean b = p1.equals(p2);
System.out.println(b);
}
}
8.4 Objects类
在JDK7添加了一个Objects工具类，他提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save(空指针安全)或null-tolerant(容忍空指针的)，用于计算对象的hashcode，返回对象的字符串表示形式，比较两个对象。
在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：
- public static boolean equals(Object a, Object b):判断两个对象是否相等。
示例
import java.util.Objects;
public class Demo03 {
public static void main(String[] args) {
String s1 = null;
String s2 = "abc";
// System.out.println(s1.equals(s2));//空指针异常
System.out.println(Objects.equals(s1,s2));
}
}
9. System类
java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：
-
public static long currentTimeMillis() ：返回以毫秒为单位的当前时间 -
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length):将数组中指定的数据拷贝到另一个数组中import java.util.Arrays; public class Demo01 { public static void main(String[] args) { demo01(); demo02(); } /* public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length):将数组中指定的数据拷贝到另一个数组中 参数： src - 源数组 srcPos - 源数组中的起始位置 dest - 目标数组 destPos - 目标数据中的起始位置 Length - 要复制的数组元素的数量 练习： 将src数组中的前3个元素，复制到dest数组的前3个位置上 复制元素前：src数组元素[1,2,3,4,5],dest数组元素[6,7,8,9,10] 复制元素后：src数组[1,2,3,4,5], dest数组[1,2,3,9,10] */ private static void demo02() { //定义源数组 int[] src = {1,2,3,4,5}; //定义目标数组 int[] dest = {6,7,8,9,10}; System.out.println("复制前"+ Arrays.toString(dest)); //使用System类的方法arraycopy将src数组中前3个元素，复制到dest数组的前3个位置撒花姑娘 System.arraycopy(src, 0, dest, 0,3); System.out.println("复制后" + Arrays.toString(dest)); } /* public static long currentTimeMillis() ：返回以毫秒为单位的当前时间 用来测试程序的效率 练习： 验证for循环打印1~9999所需要使用的时间(毫秒) */ private static void demo01() { //程序执行之前，获取一次毫秒值 long s = System.currentTimeMillis(); //执行for循环 for (int i = 0; i < 9999; i++) { System.out.println(i); } long e = System.currentTimeMillis(); System.out.println(e-s); } }
10. StringBuilder类
String类：
字符串是常量；它们的值在创建之后不能更改
字符串的底层是一个被final修饰的数组，不能改变，是一个常量
private final byte[] value;
进行字符串的相加，内存中就会有多个字符串，占用空间多，效率低下
String s = "a"+"b"+"c" = “abc"
String s: "a","b","c" 三个字符串
"a"+"b" "ab"一个字符串
"ab"+"c" 一个字符串
StringBuilder类
字符串缓冲区，可以提高字符串的操作效率（看成一个长度可以变化的字符串）
底层也是一个数组，但是没有被final修饰，可以改变长度
byte[] value = new byte[16];
StringBuilder在内存中始终是一个数组，占用空间少，效率高
如果超出了StringBuilder的容量，会自动扩容
10.1 StringBuilder构造方法
java.lang.StringBuilder类：字符串缓冲区，可以提高字符串效率
构造方法：
public StringBuilder()：构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。
public StringBuilder(String str)：构造一个字符串生成器，并初始化为指定的字符串内容。该字符串生成器的初始容量为 16 加上字符串参数的长度。
public class Demo01 {
public static void main(String[] args) {
StringBuilder bu1 = new StringBuilder();
System.out.println("bu1:" + bu1);
StringBuilder bu2 = new StringBuilder("abc");
System.out.println("bu2:" + bu2);
}
}
10.2 常用方法
StringBuilder类的成员方法：
public StringBuilder append(...): 添加任意类型数据的字符串形式，并返回当前对象自身。
参数：
可以是任意的数据类型
append方法：
public class Demo02 {
public static void main(String[] args) {
//创建StringBuilder对象
StringBuilder bu1 = new StringBuilder();
//使用append方法在StringBuilder中添加数据
//append方法返回的是this,调用方法的自身
StringBuilder bu2 = bu1.append("abc");
System.out.println(bu1);
System.out.println(bu2);
System.out.println(bu1 == bu2);// true 两个对象是同一个对象
//使用append对象无需接收返回值
bu1.append("abc");
bu1.append("arr");
bu1.append("asf");
bu1.append("9.9");
System.out.println(bu1);
}
}
StringBuilder和String可以相互转换：
Stinrg -> StirngBuilder:可以使用StringBuilder的构造方法
public StringBuilder(String str)：构造一个字符串生成器，并初始化为指定的字符串内容。该字符串生成器的初始容量为 16 加上字符串参数的长度。
StringBuilder -> String :可以使用StringBuilder中的toString方法
public String toString(): 将当前StringBuilder对象转换为String对象
public class Demo03 {
public static void main(String[] args) {
//String --> StringBuilder
String str = "hello";
System.out.println(str);
StringBuilder stringBuilder = new StringBuilder(str);
stringBuilder.append("world");
System.out.println(stringBuilder);
String s = stringBuilder.toString();
System.out.println(s);
}
}
11. Collection集合
11.1 集合概述
- 集合：集合是java中提供的一种容器，可以用来存储多个数据。
集合和数组既然都是容器，它们有啥区别呢？
-
数组的长度是固定的。集合的长度是可变得。
int[] arr = new int[10];
Student[] arr = new Student[3];
ArrayList
-
数组中存储的是同一类型的元素，可以存储基本数据类型。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。
11.2 集合框架
11.3 Collection常用功能
Collection是所有单列机和的父接口，因此在Collection中定义了单列集合（List和Set）通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：
public boolean add(E e): 把给定的对象添加到当前集合中。public void clear: 清空集合中所有的元素。public boolean remove(E e): 把给定的对象在当前集合中删除。public boolean contains(E e): 判断当前集合中是否包含给定的对象。public boolean isEmpty(): 判断当前集合是否为空。public int size(): 返回集合中元素的个数。public Object[] toArray(): 把集合中的元素，存储到数组中。
public class Demo01 {
public static void main(String[] args) {
//创建一个集合对象，可以使用多态
Collection<String> coll = new ArrayList<>();
System.out.println(coll);//重写了toString方法
/*
- `public boolean add(E e)`: 把给定的对象添加到当前集合中。
返回值是一个boolean类型，一般都返回true，所以可以不用接受
*/
boolean b1 = coll.add("张三");
System.out.println(b1);
System.out.println(coll);
coll.add("李四");
coll.add("王五");
coll.add("赵六");
coll.add("田七");
System.out.println(coll);
/*
- `public boolean remove(E e)`: 把给定的对象在当前集合中删除。
返回值是一个boolean值，集合中存在元素，删除元素，返回true
集合中不存在元素，删除失败，返回false
*/
boolean b2 = coll.remove("赵六");
System.out.println(b2);
boolean b3 = coll.remove("赵四");
System.out.println(b3);
System.out.println(coll);
/*
- `public boolean contains(E e)`: 判断当前集合中是否包含给定的对象。
包含返回true
不包含返回false
*/
boolean b4 = coll.contains("李四");
System.out.println(b4);
boolean b5 = coll.contains("赵四");
System.out.println(b5);
/*
- `public boolean isEmpty()`: 判断当前集合是否为空。为空返回true否则返回false
*/
boolean b6 = coll.isEmpty();
System.out.println(b6);
// - `public int size()`: 返回集合中元素的个数。
int size = coll.size();
System.out.println(size);
// - `public Object[] toArray()`: 把集合中的元素，存储到数组中。
Object[] arr = coll.toArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
//- `public void clear`: 清空集合中所有的元素。
coll.clear();
System.out.println(coll);
}
}
12. Iterator迭代器
12.1 Iterator接口
-
迭代:即Collection集合元素的通用获取方式。在去元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续再判断，如果还有就再取出来，一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
-
java.util.Iterator接口：迭代器（对集合进行遍历）
有两个常用的方法：-
boolean hasNext()
如果仍有元素可以迭代，则返回 true。
判断集合中还有没有下一个元素，有则返回true，没有就返回false -
E next()
返回迭代的下一个元素。
取出集合中的下一个元素。Iterator迭代器，是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊
Collection接口中有一个方法，叫Iterator（），这个方法返回的就是迭代器的实现类对象。
Iteratoriterator() 返回再次collection的元素撒花姑娘进行迭代的迭代器。
-
迭代器的使用步骤（重点）：
1. 使用集合中的方法Iterator（）获取迭代器的实现类对象，使用Iterator接口接收（多态）
2. 使用Iterator接口中的方法hasNext判断还有没有下一个元素
3. 使用Iterator接口中的方法next取出集合中的下一个元素
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
java.util.Iterator接口：迭代器（对集合进行遍历）
有两个常用的方法：
boolean hasNext()
如果仍有元素可以迭代，则返回 true。
判断集合中还有没有下一个元素，有则返回true，没有就返回false
E next()
返回迭代的下一个元素。
取出集合中的下一个元素。
Iterator迭代器，是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊
Collection接口中有一个方法，叫Iterator（），这个方法返回的就是迭代器的实现类对象。
Iterator<E> iterator() 返回再次collection的元素撒花姑娘进行迭代的迭代器。
迭代器的使用步骤（重点）：
1. 使用集合中的方法Iterator（）获取迭代器的实现类对象，使用Iterator接口接收（多态）
2. 使用Iterator接口中的方法hasNext判断还有没有下一个元素
3. 使用Iterator接口中的方法next取出集合中的下一个元素
*/
public class Demo01 {
public static void main(String[] args) {
//创建一个集合对象
Collection<String> coll = new ArrayList<>();
//往集合中添加元素
coll.add("姚明");
coll.add("科比");
coll.add("麦迪");
coll.add("詹姆斯");
coll.add("艾弗森");
/*
1. 使用集合中的方法Iterator（）获取迭代器的实现类对象，使用Iterator接口接收（多态）
注意：
Iterator接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型
*/
//多态 接口 实现类对象
Iterator<String> it = coll.iterator();
// 2. 使用Iterator接口中的方法hasNext判断还有没有下一个元素
boolean b = it.hasNext();
System.out.println(b);
//3. 使用Iterator接口中的方法next取出集合中的下一个元素
String next = it.next();
System.out.println(next);
/*
发现使用迭代器取出集合中元素的代码，是一个重复的过程
所以我们可以使用循环优化
不知道集合中有多少元素，使用while循环
循环结束的条件，hasNext方法返回false
*/
while(it.hasNext()) {
String next1 = it.next();
System.out.println(next1);
}
}
}
12.2 迭代器实现原理
12.3 增强for
增强for循环（也称foreach循环）是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
格式：
for(元素的数据类型 变量 ： collection集合or数组){
//写操作代码
}
import java.util.ArrayList;
/*
增强for循环：底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写
是JDK1.5之后出现的新特性
Collection<E>extends Iterable<E>:所有的单列集合都可以使用增强for
public interface Iterator<T>实现这个接口允许对象成为“foreach”语句的目标。
增强for循环：用来遍历集合和数组
格式：
for(集合/数组的数据类型 变量名/数组名){
sout(变量名)；
*/
public class Demo02 {
public static void main(String[] args) {
demo01();
demo02();
}
private static void demo02() {
ArrayList<String> list = new ArrayList<>();
list.add("aaaa");
list.add("bbbb");
list.add("cccc");
list.add("dddd");
for (String s : list) {
System.out.println(s);
}
}
//使用增强for循环遍历数组
private static void demo01() {
int[] arr = {1,2,3,4,5};
for (int i : arr) {
System.out.println(i);
}
}
}
13. 泛型
13.2 泛型概述
在前面学习集合时，我们都知道集合中是可以存放任何对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。
13.3 使用泛型的好处
import java.util.ArrayList;
import java.util.Iterator;
public class Demo01 {
public static void main(String[] args) {
show01();
show02();
}
/*
创建集合对象，使用泛型：
好处：
1. 避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
2. 把运行期异常（代码运行之后会跑出的异常），提升到了编译器（写代码的时候会报错）
弊端：
泛型是是什么类型，只能存储什么类型的数据
*/
private static void show02() {
ArrayList<String> list = new ArrayList<>();
list.add("abc");
//list.add(1); 报错
//使用迭代器遍历list集合
Iterator<String> it = list.iterator();
while(it.hasNext()) {
String next = it.next();
System.out.println(next.length());
}
for (String s : list) {
System.out.println(s);
}
}
/*
创建集合对象，不使用泛型
好处：
集合不使用泛型，默认的类型就是Object类型，可以储存任意类型的数据
弊端：
不安全，会引发异常
*/
private static void show01() {
ArrayList list = new ArrayList();
list.add("abc");
list.add(1);
for (Object o : list) {
System.out.println(o);
//想要使用String类特有的方法，Length获取字符串长度；不能使用 多态Object obj = "abc";
//需要向下转型
//会抛出ClassCastException类型转换异常，不能把Integer类型转换为String类型。
String s = (String)o;
System.out.println(s.length());
}
}
13.4 定义和使用泛型
定义和使用含有泛型的类
定义格式：
修饰符 class 类名<代表泛型的变量>()
定义一个含有泛型的类：
/*
定义一个含有泛型的类，模拟ArrayList集合
泛型是一个未知的数据类型，当我们不确定什么什么数据类型的时候，可以使用泛型
泛型可以接受任意的数据类型，可以使用Integer，String，Student....
创建对象的时候确定泛型的数据类型
*/
public class GenericClass<E> {
private E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
使用这个类：
public class Demo02GnericClass {
public static void main(String[] args) {
//不写泛型默认为Object类型
GenericClass gc = new GenericClass();
gc.setName("只能是字符串");
Object obj = gc.getName();
//创建GenericClass对象，泛型使用Integer类型
GenericClass<Integer> gc2 = new GenericClass<>();
gc2.setName(1);
Integer name = gc2.getName();
System.out.println(name);
//创建GenericClass对象，泛型使用String类型
GenericClass<String> gc3 = new GenericClass<>();
gc3.setName("小明");
String name1 = gc3.getName();
System.out.println(name1);
}
}
含有泛型的方法
/*
定义含有泛型的方法：泛型定义在方法的修饰符和返回类型之间
格式：
修饰符<泛型> 返回值类型 方法名（参数列表（使用泛型））{
方法体
}
含有泛型的方法，在调用方法的时候确定泛型的数据类型
传递什么类型的参数，泛型就是什么类型
*/
public class GenericMethodDemo01 {
//定义一个含有泛型的方法
public <M> void method01(M m) {
System.out.println(m);
}
//定义一个含有泛型的静态方法
public static <S> void method02(S s){
System.out.println(s);
}
}
使用这个方法：
public class GnenericMethodDemo04 {
public static void main(String[] args) {
//创建GenericMethod对象
GenericMethodDemo01 gm = new GenericMethodDemo01();
/*
调用含有泛型的方法method01
传递什么类型，泛型就是什么类型
*/
gm.method01(10);
gm.method01("abc");
gm.method01(8.8);
gm.method01(true);
gm.method02("静态方法，不建议创建对象使用");
//静态方法，通过类名.方法名(参数)可以直接使用
GenericMethodDemo01.method02("静态方法");
GenericMethodDemo01.method02(1);
}
}
含有泛型的接口
定义格式：
修饰符 interface 接口名<代表泛型的变量>{}
定义一个接口
/*
定义含有泛型的接口
*/
public interface GenericInterface<I> {
public abstract void method(I i);
}
使用方式一：
/*
含有泛型的接口，第一种使用方式：定义接口的实现类，指定接口的泛型
public interface Iterator<E> {
E.next();
}
Scanner类实现了Iterator接口，并且指定接口的泛型为String，所以重写的next方法默认就是String
public final class Scanner implements Iterator<String>{
public String next(){}
}
*/
public class GenericInterfaceImpl implements GenericInterface<String>{
@Override
public void method(String o) {
System.out.println(o);
}
}
使用方式二：
/*
含有泛型的接口第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
就相当于定义了一个含有泛型的类，创建导向的时候确定泛型的类型
public interface List<E>{
boolean add(E e);
E get(int index);
}
public class ArrayList<E> implements List<E> {
public boolean add(E e){}
public E get (int index) {}
}
*/
public class GenericInterfaceImpl2<I> implements GenericInterface<I>{
@Override
public void method(I i) {
System.out.println(i);
}
}
测试：
/*
测试含有泛型的接口
*/
public class Demo02 {
public static void main(String[] args) {
//创建GenericInterfaceImpl对象
GenericInterfaceImpl gi1 = new GenericInterfaceImpl();
gi1.method("字符串");
//创建GenericInterfaceImpl2对象
GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
gi2.method(10);
GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();
gi3.method(8.8);
}
}
13.5 泛型的通配符
当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。
通配符基本使用
泛型的通配符：**不知道使用什么类型来接收的时候，此时可以使用？，？表示未知通配符。
此时只能接受数据，不能往该集合中存储数据。
import java.util.ArrayList;
import java.util.Iterator;
/*
泛型的通配符：
？：代表任意的数据类型
使用方式：
不能创建对象使用
只能作为方法的参数使用
*/
public class Demo03 {
public static void main(String[] args) {
ArrayList<Integer> list01 = new ArrayList<>();
list01.add(1);
list01.add((2));
ArrayList<String> list02 = new ArrayList<>();
list02.add("a");
list02.add("b");
printArray(list01);
printArray(list02);
}
/*
定义一个方法，能遍历所有类型的ArrayList集合
这时候我们不知道ArrayList集合使用什么数据类型，可以使用泛型的通配符？来接收数据类型
注意：
泛型没有继承概念
*/
public static void printArray(ArrayList<?> list){
//使用迭代器遍历集合
Iterator<?> it = list.iterator();
while(it.hasNext()) {
//it.next()方法，取出的元素是Object，可以接受任意的数据类型
Object o = it.next();
System.out.println(o);
}
}
}
通配符的高级使用----受限泛型
之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置，但是在JAVA的泛型中可以指定一个泛型的上限和下限。
泛型的上限：
- 格式：
类型名称<? super 类> 对象名称 - 意义：
只能接受该类型及其子类
泛型的下限：
- 格式：类型名称<? super 类> 对象名称
- 意义： 只能接受该类型及其子类
import java.util.ArrayList;
import java.util.Collection;
/*
泛型的上限限定: ? extends E 代表使用的泛型只能是E类型的子类/本身
泛型的下限限定: ? super E 代表使用的泛型只能是E类型的父类/本身
*/
public class Demo04 {
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<>();
Collection<String> list2 = new ArrayList<>();
Collection<Number> list3 = new ArrayList<>();
Collection<Object> list4 = new ArrayList<>();
getElement(list1);
//getElement(list2);//报错
getElement(list3);
//getElement(list4);//报错
//getElement2(list1);//报错
//getElement2(list2);//报错
getElement2(list3);
getElement2(list4);
/*
雷雨了之间的继承关系
Integer extends Number extends Object
String extends Object
*/
}
//泛型的上限：此时的泛型?,必须是Number类型或者Number类型的子类
public static void getElement(Collection<? extends Number> coll){}
//泛型的下限：此时的泛型?，必须是Number乐行或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}
}
14. List集合
14.1 List接口介绍及常用方法
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
java.util.List接口 extends Collection接口
List接口的特点：
1. 有序的集合，存储元素和取出元素的顺序是一致的(存储123 取出123)
2. 有索引，包含了一些带索引的方法
3. 允许储存重复的元素
List 接口中带索引的方法（特有）
- public void add(int index,E element) : 将指定的元素，添加到该集合中的指定位置上
- public E get(int index): 返回集合中指定位置的元素
- public E remove(int index): 移除列表中指定位置的元素，返回的是被移除的元素。
- public E set(int index,E element): 用指定的元素替换集合中指定位置的元素，返回值的更新前的元素。
注意：
操作索引的时候，一定要防止索引越界异常
* */
public class Demo01 {
public static void main(String[] args) {
//创建一个List集合对象，多态
List<String> list = new ArrayList<>();
//使用add方法往集合中添加元素
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("a");
//打印集合
System.out.println(list);
//- public void add(int index,E element) : 将指定的元素，添加到该集合中的指定位置上
// 在c和d之间添加一个itheima
list.add(3,"itheima");
System.out.println(list);
// - public E remove(int index): 移除列表中指定位置的元素，返回的是被移除的元素。
//移除元素
String removeE = list.remove(2);
System.out.println(removeE);
System.out.println(list);
// - public E set(int index,E element): 用指定的元素替换集合中指定位置的元素，返回值的更新前的元素。
//吧最后一个a，替换为4
String setW = list.set(4, "A");
System.out.println(setW);
System.out.println(list);
// - public E get(int index): 返回集合中指定位置的元素
// list集合遍历有3中方式
//使用普通for循环
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("==============");
//使用迭代器
Iterator<String> it = list.iterator();
while (it.hasNext()) {
String next = it.next();
System.out.println(next);
}
//使用增强for循环
for (String s : list) {
System.out.println(s);
}
}
}
14.2 ArrayList集合
java.util.ArrayList集合出具存储的结构是数组结构。元素增删慢，查找快，由于日上开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。
14.3 LinkedList集合
import java.util.LinkedList;
/*
java.util.LinkedList集合 implements List接口
LinkedList集合的特点：
1.底层是一个链表结构：查询慢，增删快
2.里面包含了大量操作首尾元素的方法
注意：使用LinkedList集合特有的风阀，不能使用多态
- public void addFirst(E e):将指定元素插入次列表的开头
- public void addLast(E e): 将指定元素添加到此列表的结尾
- public void push(E e):将元素推入此列表所表示的栈堆。
- public E getFirst(): 返回此列表的第一个元素。
- public E getLast(): 返回此列表的最后一个元素
- public E removeFirst(): 移除并返回此时列表的第一个元素。
- public E removeLast(): 移除并返回此列表的最后一个元素。
- public E pop(): 从此列表所表示的堆栈处弹出一个元素。
- public boolean isEmpty(): 如果列表不包含元素，则返回true。
* */
public class Demo02 {
public static void main(String[] args) {
show01();
show02();
show03();
}
/*
- public E removeFirst(): 移除并返回此时列表的第一个元素。
- public E removeLast(): 移除并返回此列表的最后一个元素。
- public E pop(): 从此列表所表示的堆栈处弹出一个元素。此方法相当于removeFirst
* */
private static void show03() {
//创建LinkedList集合对象
LinkedList<String> linked = new LinkedList<>();
linked.add("a");
linked.add("b");
linked.add("c");
System.out.println(linked);
String first = linked.removeFirst();
System.out.println("移除的第一个元素" + first);
String last = linked.removeLast();
System.out.println("移除的最后一个元素" + last);
System.out.println(linked);
}
/*
- public E getFirst();返回此列表的第一个元素
- public E getLast(); 返回此列表的最后一个元素
* */
private static void show02() {
//创建LinkedList集合对象
LinkedList<String> linked = new LinkedList<>();
linked.add("a");
linked.add("b");
linked.add("c");
linked.clear();//清空集合中的元素 再获取集合中的元素会报错NoSuchElementException
//public boolean isEmpty():如果列表不包含元素，则返回true
if ( !linked.isEmpty()){
String first = linked.getFirst();
System.out.println(first);
String last = linked.getLast();
System.out.println(last);
}
}
private static void show01() {
/*
- public void addFirst(E e):将指定元素插入次列表的开头
- public void addLast(E e): 将指定元素添加到此列表的结尾。此方法等效于add
- public void push(E e):将元素推入此列表所表示的栈堆。此方法等效于addFirst
*/
//创建LinkedList集合对象
LinkedList<String> linked = new LinkedList<>();
linked.add("a");
linked.add("b");
linked.add("c");
linked.add("d");
linked.add("e");
System.out.println(linked);
linked.addFirst("www");
System.out.println(linked);
}
}
15. Set接口
java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了，与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。
Set集合有多个子类，这里我们介绍其中的java.util.HashSet、java.util.LinkedHashSet这两个集合。
tips: Set集合取出元素的方式可以采用: 迭代器、增强for
15.1 HashSet介绍
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/*
java.util.Set接口 extends Collection接口
Set接口的特点：
1. 不允许存储重复的元素
2. 没有索引，没有带索引的方法，也不能使用普通的for循环遍历
java.util.HashSet集合 implements Set接口
HashSet特点：
1. 不允许存储重复的元素
2. 没有索引，没有带索引的方法，也不能使用普通的for循环遍历
3. 是一个无序的集合，存储元素和取出元素的顺序有可能不一致
4. 底层是一个哈希表结构（查询的速度非常的快）
* */
public class Demo01 {
public static void main(String[] args) {
Set<Integer> set = new HashSet<>();
//使用add方法往集合中添加元素
set.add(1);
set.add(3);
set.add(2);
set.add(1);
//使用迭代器遍历set集合
Iterator<Integer> it = set.iterator();
while(it.hasNext()){
Integer next = it.next();
System.out.println(next);//1,2,3
}
//使用增强for遍历set集合
System.out.println("=======================");
for (Integer integer : set) {
System.out.println(integer);
}
}
}
15.2 Hash值介绍
/*
哈希值：是一个十进制的整数，由系统随机给出（就是对象的地址值，是一个逻辑地址，是模拟出来得到地址，不是数据实际存储的物理地址
在Object类有一个方法，可以获取对象的哈希值
int hashCode():返回对象的哈希值
hashCode方法的源码：
public native int hashCode():
native:代表该方法调用的是本地操作系统的方法。
* */
public class Demo02 {
public static void main(String[] args) {
//Person类继承了Object类，所以可以使用Object类的hashCode方法
Person p1 = new Person();
int h1 = p1.hashCode();
System.out.println(h1);
Person p2 = new Person();
int h2 = p2.hashCode();//1
System.out.println(h2);//1
System.out.println(p1);//com.dailyclass.SetDemo.Person@1
System.out.println(p2);//com.dailyclass.SetDemo.Person@1
System.out.println(p1 == p2);//flase
/*
String类的哈希值
String类重写Object类的hashCode方法
* */
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1.hashCode());//96354
System.out.println(s2.hashCode());//96354
System.out.println("重地".hashCode());//1179395
System.out.println("通话".hashCode());//1179395
}
}
Person类：
public class Person extends Object{
//重写hashCode方法
@Override
public int hashCode() {
return 1;
}
}
HashSet存储数据结构：
15.3 HashSet存储不重复元素原理
import java.util.HashSet;
/*
Set集合不允许存储重复元素的原理
*/
public class Demo03 {
public static void main(String[] args) {
//创建HashSet集合
HashSet<String> set = new HashSet<>();
String s1 = new String("abc");
String s2 = new String("abc");
set.add(s1);
set.add(s2);
set.add("重地");
set.add("通话");
set.add("abc");
System.out.println(set);//[重地, 通话, abc]
}
}
上述代码过程及原理：
15.4 HashSet存储自定义类型元素
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equal方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一。
import java.util.HashSet;
/*
HashSet存储自定义类型元素
set集合报错元素唯一：
存储的元素(String,Integer,....Student,Person....),必须重写hashCode方法和equals方法。
要求：
同名同年龄的人，视为同一个人，只能存储一次
*/
public class Demo04 {
public static void main(String[] args) {
//创建HashSet集合存储Person
HashSet<Person> set = new HashSet<>();
Person p1 = new Person("小美女", 18);
Person p2 = new Person("小美女", 18);
Person p3 = new Person("小美女", 19);
System.out.println(p1.hashCode());//1329552164
System.out.println(p2.hashCode());//363771819
System.out.println(p1 == p2);//false
System.out.println(p1.equals(p2));//false
set.add(p1);
set.add(p2);
set.add(p3);
System.out.println(set);
}
}
Person类：
import java.util.Objects;
public class Person extends Object{
//重写hashCode方法
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public String getName() {
return name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
15.5 LinkedHashSet集合
import java.util.HashSet;
import java.util.LinkedHashSet;
/*
java.util.LinkedHashSet集合 extends HashSet集合
LinkedHashSet集合特点：
底层是一个哈希表（数组+链表/红黑树）+ 链表：多了一条链表（记录元素的存储顺序），保证元素的存储顺序），保证元素有序
*/
public class Demo05LinkedHashSet {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("www");
set.add("abc");
set.add("abc");
set.add("itcast");
System.out.println(set);//[abc, www, itcast] 无序，不允许重复
LinkedHashSet<String> linkedset = new LinkedHashSet<>();
linkedset.add("www");
linkedset.add("abc");
linkedset.add("abc");
linkedset.add("itcast");
System.out.println(linkedset);//[www, abc, itcast]有序，不允许重复
}
}
15.6 可变参数
在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，
我们可以对其简化成如下格式：
修饰符 返回值类型 方法名(参数类型... 形参名){ }
其实这个书写完全等价于
修饰符 返回值类型 方法名(参数类型[] 形参名){ }
只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。
JDK1.5以后。出现了简化操作。...应在参数上，称之为可变参数。
同盾会代表数组，但是在调用这个带有可变参数的方法是，不用创建数组（这就是简单之处），直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，再进行传递。这些动作都在编译.class文件时，自动完成了。
/*
可变参数：是JDK1.5之后出现的新特性
使用前提：
当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用可变参数
使用格式：
修饰符： 返回值类型 方法名（数据类型...变量名){ }
可变参数的原理：
可变参数底层就是一个数组，根据传递参数个数不同，会创建不用长度的数组，来粗出这些参数
传递的参数个数，可以是0个（不传递），1,2，...多个
*/
public class Demo06 {
public static void main(String[] args) {
// int i = add();
//int i = add(10);
int i = add(10,20,30,40,50,60,70,80,90,100);
System.out.println(i);
}
/*
可变参数的注意事项
1. 一个方法的参数列表，只能有一个可变参数
2. 如果方法的参数有多个，那么可变参数必须卸载参数列表的末尾
*/
// public static void method(int...a,String...b){}; 错误
/*
定义计算（0 ~ n）整数和的方法
已知：计算整数的和，数据类型已经确定int
但是参数的个数不确定，不知道要计算几个整数和，就可以使用可变参数
add();就会创建一个长度为0的数组，new int[0];
add(10);就会创建一个长度为1的数组，存储传递过来的参数new int[]{10};
add(10,20,30,40,50,60,70,80,90,100);就会创建一个长度为10的数组，存储传递过来的参数new int[]{10,20,30,40,50,60,70,80,90,100};
*/
public static int add(int...arr){
// System.out.println(arr);//[I@27d6c5e0 底层是一个数组
// System.out.println(arr.length);
//定义一个初始化的变量，记录累加求和
int sum = 0;
for (int i : arr) {
sum += i;
}
return sum;
}
//定义一个方法，计算三个int类型整数的和
public static int add(int a, int b,int c){
return a + b + c;
}
//定义一个方法，计算两个int类型整数的和
public static int add(int a, int b){
return a + b;
}
}
可变参数的特殊（终极）写法
public static method(Object...obj){}
16. Collections
16.1 常用功能
java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：public static <T> boolean addAll(Collection<T> c, T...elements):往集合中添加一些元素。public static void shuffle(List<?> list):打乱集合顺序。public static <T> void sort(List<t> list):将集合中元素按照默认规则排序。public static <T> void sort(List<T> list, Comparator<? super T>):将集合中元素按照指定规则排序。
import java.util.ArrayList;
import java.util.Collections;
/*
- `java.utils.Collections`是集合工具类，用来对集合进行操作。部分方法如下：
- `public static <T> boolean addAll(Collection<T> c, T...elements)`:往集合中添加一些元素。
- `public static void shuffle(List<?> list)`:打乱集合顺序。
*/
public class Demo01 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
//往集合中添加多个元素
// list.add("a");
// list.add("b");
// list.add("c");
// list.add("d");
// list.add("e");
//- `public static <T> boolean addAll(Collection<T> c, T...elements)`:往集合中添加一些元素。
Collections.addAll(list,"a","b","c","d","e");
System.out.println(list);
//- `public static void shuffle(List<?> list)`:打乱集合顺序。
Collections.shuffle(list);
System.out.println(list);
}
}
sort方法的使用：
import java.util.ArrayList;
import java.util.Collections;
/*
`java.utils.Collections`是集合工具类，用来对集合进行操作。
`public static <T> void sort(List<t> list)`:将集合中元素按照默认规则排序。
注意：
sor(List<T> List)使用前提
被排序的集合里边存储的元素，必须实现Comparable，重写接口中的方法compareTo定义排序的规则
Comparable接口的排序规则：
自己(this) - 参数：升序
反过来就是降序
*/
public class Demo02 {
public static void main(String[] args) {
ArrayList<Integer> list01 = new ArrayList<>();
list01.add(1);
list01.add(3);
list01.add(2);
list01.add(4);
System.out.println(list01);
Collections.sort(list01);
System.out.println(list01);
ArrayList<String> list02 = new ArrayList<>();
list02.add("a");
list02.add("c");
list02.add("b");
System.out.println(list02);
Collections.sort(list02);
System.out.println(list02);
ArrayList<Person> list03= new ArrayList<>();
list03.add(new Person("张三",18));
list03.add(new Person("李四",20));
list03.add(new Person("王五",15));
System.out.println(list03);
Collections.sort(list03);
System.out.println(list03);
}
}
Person类中重写Comparable接口的ComparaTo方法：
public class Person implements Comparable<Person>{
private String name;
private int age;
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", 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;
}
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
//重写排序的规则
@Override
public int compareTo(Person o) {
//return 0;//认为元素都是相同的
//自定义比较的规则，比较两个人的年龄(this,参数Person)
//return this.getAge() - o.getAge();//年龄升序排序
return o.getAge() - this.getAge();//年龄降序排序
}
}
Comparator:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/*
`public static <T> void sort(List<T> list, Comparator<? super T>)`:将集合中元素按照指定规则排序。
Comparator和Comparable的区别：
Comparable：自己（this）和别人（参数）比较，自己需要实现Comparable接口，重写比较规则CompareTo方法
Comparator：相当于找一个第三方的裁判，比较两个
Comparator的排序规则：
o1 - o2：升序
反过来的就是降序
*/
public class Demo03 {
public static void main(String[] args) {
ArrayList<Integer> list01 = new ArrayList<>();
list01.add(1);
list01.add(3);
list01.add(2);
System.out.println(list01);
Collections.sort(list01, new Comparator<Integer>() {
//重写比较的规则
@Override
public int compare(Integer o1, Integer o2) {
//return o1 - o2;//升序
return o2 - o1;//降序
}
});
System.out.println(list01);
ArrayList<Student> list02 = new ArrayList<>();
list02.add(new Student("迪丽热巴",18));
list02.add(new Student("古力娜扎",20));
list02.add(new Student("杨幂",17));
list02.add(new Student("杨幂",18));
System.out.println(list02);
// Collections.sort(list02, new Comparator<Student>() {
// @Override
// public int compare(Student o1, Student o2) {
// //按照年龄升序排列
// return o1.getAge() - o2.getAge();
// }
// });
Collections.sort(list02, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
//按照年龄升序排列
int result = o1.getAge() - o2.getAge();
//如果两个人年龄相同，再使用姓名的第一个字比较
if(result == 0){
result = o1.getName().charAt(0) - o2.getName().charAt(0);
}
return result;
}
});
System.out.println(list02);
}
}
17. Map集合
17.1 概述
现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。
我们通过查看Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图：
Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。Map中的集合，元素是成对存在的（理解为夫妻）。每个元素由键与值两部分组成，通过键可以找所对应的值。Collection中的集合称为单列集合，Map中的集合称为双列集合。- 需要注意的是，
Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
Map集合的特点：
1. Map集合是一个双列集合，一个元素包含两个值（一个key，一个value）
2. map集合中的元素，key和value的数据类型可以相同，也可以不同
3. Map集合中的元素，key和value是一一对应
17.2 Map常用子类
通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。
- HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的HashCode()方法、equals()方法。
- LinkedHashMap<K,V>: HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode（）方法、equals（）方法。
tips: Map接口中的集合都有两个反省变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。
HashMap集合的特点：
1. HashMap集合底层是哈希表：查询的速度特别的快
JDK1.8之前：数组+单向链表
JDK1.8之后：数组+单向链表/红黑树（链表的长度超过8）：提高查询的速度
2. HashMap集合是一个无序的集合，储存元素和取出元素的顺序有可能不一致
java.util.LinkedHashMap<K,V>集合 extends HashMap<K,V>集合
LinkedHashMap的特点：
1.LinkedHashMap集合底层是哈希表+链表（保证迭代的顺序）
2.LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的
17.3 Map接口中的常用方法
Map接口中定义了很多方法，常用的如下：
public V put(K key, V value):把指定的键与指定的值添加到Map集合中。public V remove(Object key):把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。public V get(Object key):根据指定的键，在Map集合中获取对应的值。public containsKey(Object key):判断集合中是否包含指定的键。public Set<K> keySet()：获取Map集合中所有的键，存储到Set集合中。public Set<Map, Entry<K,V> entrySet()获取到Map集合中所有的键值对对象的集合（Set集合）。
import java.util.HashMap;
import java.util.Map;
/*
java.util.Map<k,v>集合
Map集合的特点：
1. Map集合是一个双列集合，一个元素包含两个值（一个key，一个value）
2. map集合中的元素，key和value的数据类型可以相同，也可以不同
3. Map集合中的元素，key和value是一一对应
java.util.HashMap<K,V>集合 implements Map<K,V>接口
HashMap集合的特点：
1. HashMap集合底层是哈希表：查询的速度特别的快
JDK1.8之前：数组+单向链表
JDK1.8之后：数组+单向链表/红黑树（链表的长度超过8）：提高查询的速度
2. HashMap集合是一个无序的集合，储存元素和取出元素的顺序有可能不一致
java.util.LinkedHashMap<K,V>集合 extends HashMap<K,V>集合
LinkedHashMap的特点：
1.LinkedHashMap集合底层是哈希表+链表（保证迭代的顺序）
2.LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的
*/
public class Demo01 {
public static void main(String[] args) {
show01();
show02();
show03();
show04();
}
/*
public boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。
包含返回true，不包含返回false
*/
private static void show04() {
Map<String, Integer> map = new HashMap<>();
map.put("赵丽颖", 168);
map.put("杨颖", 165);
map.put("林志玲", 178);
boolean b1 = map.containsKey("赵丽颖");
System.out.println(b1);
boolean b2 = map.containsKey("赵颖");
System.out.println(b2);
}
/*
public V get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
返回值：
key存在，返回对应的value值
key不存在，返回null
*/
private static void show03() {
Map<String, Integer> map = new HashMap<>();
map.put("赵丽颖", 168);
map.put("杨颖", 165);
map.put("林志玲", 178);
Integer v1 = map.get("杨颖");
System.out.println(v1);
Integer v2 = map.get("迪丽热巴");
System.out.println(v2);
}
/*
public V remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
返回值： V
key存在，v返回被删除的值
key不存在，v返回null
*/
private static void show02() {
//创建Map集合对象
Map<String, Integer> map = new HashMap<>();
map.put("赵丽颖", 168);
map.put("杨颖", 165);
map.put("林志玲", 178);
System.out.println(map);
Integer v1 = map.remove("林志玲");
System.out.println(v1);
System.out.println(map);
//int v2 = map.remove("林志颖");// 自动拆箱 NullPointerException
Integer v2 = map.remove("林志颖");
System.out.println(v2);
}
/*
public V put(K key, V value) :将指定的值与此映射中的指定键关联（可选操作）。
返回值：V
存储键值对的时候，key不重复，返回值V是null
存储键值对的时候，key重复，会使用新的value替换map中重复的value，返回被替换的value值。
*/
private static void show01() {
//创建Map集合对象，多态
Map<String,String> map = new HashMap<>();
String v1 = map.put("李晨", "范冰冰1");
System.out.println(v1);//null
String v2 = map.put("李晨", "范冰冰2");
System.out.println(v2);//范冰冰1
System.out.println(map);
map.put("冷锋","龙小云");
map.put("杨过","小龙女");
map.put("尹志平","小龙女");
System.out.println(map);//{杨过=小龙女, 尹志平=小龙女, 李晨=范冰冰2, 冷锋=龙小云}
}
}
17.4 Map集合遍历键找值方式
键找值方式：即通过元素中的键，获取键所对应的值
分析步骤：
- 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示：
keyset() - 遍历键的Set集合，得到每一个键。
- 根据键，获取键所对应的值。方法提示：
get(K key)
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
Map集合第一种遍历方式：通过键找值的方式
Map集合中的方法:
Set<K> keySet() 返回此映射中包含的键的 Set 视图。
实现步骤：
1. 使用Map集合中的方法KeySet(),把map集合所有的key取出来，存储到一个Set集合中。
2. 遍历set集合，获取Map集合中的每一个key
3. 通过Map集合中的方法get(key)，通过key找到value。
*/
public class Demo02 {
public static void main(String[] args) {
//创建Map集合对象
Map<String, Integer> map = new HashMap<>();
map.put("赵丽颖", 168);
map.put("杨颖", 165);
map.put("林志玲", 178);
//1. 使用Map集合中的方法KeySet(),把map集合所有的key取出来，存储到一个Set集合中。
Set<String> set = map.keySet();
// 2. 遍历set集合，获取Map集合中的每一个key
//使用迭代器遍历Set集合
Iterator<String> it = set.iterator();
while(it.hasNext()){
String next = it.next();
//3. 通过Map集合中的方法get(key)，通过key找到value。
Integer integer = map.get(next);
System.out.println(integer);
}
System.out.println("=============");
//使用增强for遍历Set集合
for (String s : set) {
//3. 通过Map集合中的方法get(key)，通过key找到value。
Integer integer = map.get(s);
System.out.println(integer);
}
System.out.println("===========");
for (String s : map.keySet()) {
System.out.println(map.get(s));
}
}
}
17.5 Entry键值对对象
我们已经知道，Map中存放的是两种对象，一种称为key（键），一种称为value（值），它们在Map中是意义对应关系，这一对对象又称作Map中的一个Entry（项）。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的值。
既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值的方法：
public K getKey():获取Entry对象中的键。public V getValue():获取Entry对象中的值。
在Map集合中也提供了获取所有Entry对象的方法：
public Set<Map.Entry<K,V>> entrySet():获取到Map集合中所有的键值对对象的集合（Set集合）。
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
Map集合遍历的第二种方式，使用Entry对象遍历
Map集合中的方法：
Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图。
实现步骤：
1. 使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来，存储到一个Set集合中。
2. 遍历Set集合，获取每一个Entry对象
3. 使用Entry对象中的方法getKey()和getValue()获取键与值
*/
public class Demo03 {
public static void main(String[] args) {
//创建Map集合对象
Map<String, Integer> map = new HashMap<>();
map.put("赵丽颖", 168);
map.put("杨颖", 165);
map.put("林志玲", 178);
//1. 使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来，存储到一个Set集合中。
Set<Map.Entry<String, Integer>> set = map.entrySet();
//2. 遍历Set集合，获取每一个Entry对象
//使用迭代器遍历Set集合
Iterator<Map.Entry<String, Integer>> it = set.iterator();
while(it.hasNext()){
Map.Entry<String, Integer> entry = it.next();
//3. 使用Entry对象中的方法getKey()和getValue()获取键与值
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + "=" + value);
}
System.out.println("=====================");
for (Map.Entry<String, Integer> entry : set) {
//3. 使用Entry对象中的方法getKey()和getValue()获取键与值
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + "=" + value);
}
}
}
17.6 HashMap存储自定义类型键值
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
HashMap存储自定义类型键值
Map集合保证key是唯一的：
作为key的元素，必须重写hashCode方法和equals方法，以保证key唯一
*/
public class Demo04 {
public static void main(String[] args) {
show01();
show02();
}
/*
HashMap存储自定义类型键值
key： Person类型
Person类必须重写hashCode方法和equals方法，以保证key唯一
value： String类型
value可以重复（同名同年龄的人视为同一个）
*/
private static void show02() {
//创建HashMap集合
HashMap<Person, String> map = new HashMap<>();
//网集合中添加元素
map.put(new Person("女王",18),"英国");
map.put(new Person("秦始皇",18),"泰国");
map.put(new Person("普金",18),"俄罗斯");
map.put(new Person("女王",18),"毛里求斯");
//使用entrySet和增强for遍历Map集合
Set<Map.Entry<Person, String>> set = map.entrySet();
for (Map.Entry<Person, String> entry :set){
Person key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "-->" +value);
}
}
/*
HashMap存储自定义类型键值
key: String类型
String类重写hashCode方法和equals方法，可以保证key唯一
value：Person类型
value可以重复（同名同年龄的人视为同一个）
*/
private static void show01() {
//创建HashMap集合
HashMap<String, Person> map = new HashMap<>();
//网集合中添加元素
map.put("北京",new Person("张三",10));
map.put("上海",new Person("李四",10));
map.put("广州",new Person("王五",20));
map.put("北京",new Person("赵六",10));
//使用keySet加增强for遍历Map集合
Set<String> set = map.keySet();
for (String key : set) {
Person value = map.get(key);
System.out.println(key + "-->" +value);
}
}
}
Person类需要重写hashCode方法和equals方法
import java.util.Objects;
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
}
17.7 LinkedHashMap
我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？
在HashMap下面有一个子类LinkedHashMap， 它是链表和哈希表组合的一个数据存储结构。
import java.util.HashMap;
import java.util.LinkedHashMap;
/*
java.util.LinkedHashMap<K,V> extends HashMap<K,V>
Map 接口的哈希表和连接列表实现，具有可预知的迭代顺序。
底层原理：
哈希表+链表（记录元素的顺序）
*/
public class Demo05 {
public static void main(String[] args) {
HashMap<String,String> map = new HashMap<>();
map.put("a","a");
map.put("c","c");
map.put("b","b");
map.put("a","d");
System.out.println(map);//key不允许重复，无序
LinkedHashMap<String,String> linked = new LinkedHashMap<>();
linked.put("a","a");
linked.put("c","c");
linked.put("b","b");
linked.put("a","d");
System.out.println(linked);//key不允许重复，有序，按照存入的顺序
}
}
17.8 HashTable集合
import java.util.HashMap;
import java.util.Hashtable;
/*
java.util.HashTable<K,V>集合 implements Map<K,V>接口
HashTable:底层也是一个哈希表，是一个线程安全的集合，是单线程集合，速度慢
HashMap:底层是一个哈希表，是一个线层不安全的集合，是多线程的集合，速度快
HashMap集合（之前学的所有的集合）：可以存储null值，null键
Hashtable集合，不能存储null值，null键
HashTable和Vector集合一样，在jdk1.2版本之后被更先进的集合（HashMap，ArrayList)取代了
HashTable的子类Properties依然活跃在历史舞台
Properties集合是一个唯一和IO流相结合的集合
*/
public class Demo06 {
public static void main(String[] args) {
HashMap<String,String> map = new HashMap<>();
map.put(null,"a");
map.put("b",null);
map.put(null,null);
System.out.println(map);
Hashtable<String,String> table = new Hashtable<>();
//table.put(null,"a");//NullPointerException
//table.put("b",null);//NullPointerException
//table.put(null,null);//NullPointerException
}
}
18 补充知识点
18.1 JDK9对集合添加的优化
通常，我们在代码中创建一个集合（例如，List或Set），并直接用一些元素填充它。实例化集合，几个add方法调用，使得代码重复。
public class Demo01 {
public static void main(String[] args) {
list<String> list = new ArrayList<>();
list.add("abc");
list.add("def");
list.add("ghi");
System.out.println(list);
}
}
java9,添加了几种集合工厂方法，更方便创建少量元素的集合、map实例。新的List、Set、Map的静态工厂方法可以更方便地创建集合的不可变实例。
例子：
public class HelloJDK9 {
public static void main(String[] args) {
Set<String> str1 = Set.of("a","b","c");
//str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变得集合
System.out.println(str1);
Map<String,Integer> str2 = Map.of("a",1,"b",2);
System.out.println(str2);
List<String> str3 = List.of("a","b");
System.out.println(str3);
}
}
import java.util.List;
import java.util.Map;
import java.util.Set;
/*
JDK9的新特性：
List接口，Set接口，Map接口：里面增加了一个静态的方法of，可以给集合一次性添加多个元素
static <E> List<E> of (E....elements)
使用前提：
当集合中存储的元素的个数已经确定了，不再改变时使用
注意：
1. of方法只适用于List接口，Set接口，Map接口，不适用于接口的实现类
2. of方法的返回值是一个不能改变的集合，集合不能再使用add，put方法添加元素，会抛出异常
3. Set接口和Map接口在调用of方法的时候，不能有重复的元素，否则会抛出异常。
*/
public class Demo07 {
public static void main(String[] args) {
List<String> list = List.of("a", "b", "c", "d");
System.out.println(list);
//list.add("e");//UnsupportedOperationException: 不支持操作异常
//Set<String> set = Set.of("a", "b", "c", "d", "a");//.IllegalArgumentException:非法参数异常,有重复的元素
Set<String> set = Set.of("a", "b", "c", "d");
System.out.println(set);
//set.add("e");//UnsupportedOperationException: 不支持操作异常
//Map<String, Integer> map = Map.of("张三", 18, "李四", 19, "王五", 20,"张三",19);//IllegalArgumentException:非法参数异常,有重复的元素
Map<String, Integer> map = Map.of("张三", 18, "李四", 19, "王五", 20);
System.out.println(map);
//map.put("赵四",30);//UnsupportedOperationException: 不支持操作异常
}
}
