1、集合的概述
1.1、集合的由来
- 当需要在Java程序中记录单个数据内容时，则声明一个变量。
- 当需要在Java程序中记录多个类型相同的数据内容时，声明一个一维数组。
- 当需要在Java程序中记录多个类型不同的数据内容时，则创建一个对象。
- 当需要在Java程序中记录多个类型相同的对象数据时，创建一个对象数组。(也可以准备一个集合)
- 当需要在Java程序中记录多个类型不同的对象数据时，则准备一个集合。
1.2、集合的框架结构
- Java中集合框架顶层框架是：java.util.Collection集合 和 java.util.Map集合。
- 其中Collection集合中存取元素的基本单位是：单个元素。
- 其中Map集合中存取元素的基本单位是：单对元素。
2、Collection集合
2.1、基本概念
- java.util.Collection接口是List接口、Queue 接口以及Set接口的父接口，因此该接口里定义的方法既可用于操作List集合，也可用于操作Queue集合和Set集合。
2.2、常用的方法
import java.util.ArrayList;
import java.util.Collection;
/**
* @author XiceSberg
* @date 2020/8/12 17:47
* @description
*/
public class CollectionTest {
public static void main(String[] args) {
//Collection是接口，接口不能实例化，也不能创建对象
//Collection c1=new Collection();
//接口类型得引用指向实现类得对象，形成多态
Collection c1=new ArrayList();
System.out.println("集合中得c1:"+c1);//自动调用toString()方法 []
//向集合中添加元素
Boolean b1=c1.add(new String("one"));
System.out.println(c1); //[one]
System.out.println("b1:"+b1);
Boolean b2=c1.add(Integer.valueOf(2));
System.out.println(c1);
System.out.println("b2:"+b2);
Collection c2=new ArrayList();
c2.add("three");
c2.add(4);
System.out.println(c2); //[one, 2]
//将c2中所有元素全部添加到集合c1中
c1.addAll(c2);
//将c2集合整体添加到集合c1中
c1.add(c2);
System.out.println(c1); //[one, 2, three, 4, [three, 4]]
}
}import java.util.Objects;
/**
* @author XiceSberg
* @date 2020/8/12 20:40
* @description
*/
public class Person {
private String name;
private int age;
public Person() {
}
public Person(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 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 +
'}';
}
} c1.add(new Person("张飞",30));
//打印出来得是每个元素对应得toString方法
System.out.println(c1); //[one, 2, three, 4, [three, 4], Person{name='张飞', age=30}]
b1=c1.contains(new String("one"));
System.out.println("b1:"+b1);//true
b1=c1.contains("two");
System.out.println(b1); //false
//当为类对象得时候就有坑
b1=c1.contains(new Person("张飞",30));
System.out.println(b1); //false;为什么呢？此处Person没有重写equals
// contains方法的工作原理是：Objects.equals(o, e)，其中o代表contains方法的形式参数，e代表集合中的每个元素
// 也就是contains的工作原理就是 拿着参数对象与集合中已有的元素依次进行比较，比较的方式调用Objects中的equals方法
// 而该方法equals的工作原理如下：
/*
public static boolean equals(Object a, Object b) { 其中a代表Person对象，b代表集合中已有的对象
return (a == b) || (a != null && a.equals(b));
元素包含的第一种方式就是：Person对象与集合中已有对象的地址相同
第二种方式就是：Person对象不为空，则Person对象调用equals方法与集合中已有元素相等
}
*/
// 当Person类中没有重写equals方法时，则调用从Object类中继承下来的equals方法，比较两个对象的地址 false
// 当Person类中重写equals方法后，则调用重写以后的版本，比较两个对象的内容 true Collection c3=new ArrayList();
c3.add(4);
System.out.println(c3);
//判断集合中是否包含集合c3中得所有元素，只要集合c3中得所有元素都在c1集合中就返回true,反之为false
b1=c1.containsAll(c3);
System.out.println(b1);//true
c3.add("five");
b1=c1.containsAll(c3);
System.out.println(b1);//false
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
//判断集合c1是否包含集合c2中得所有元素
b1=c1.containsAll(c2);
System.out.println(b1); //true: addAll(将集合中元素一个一个放入) false:add (将集合整体放入)
//判断集合c1是否包含集合c2这个整体为单位得元素
b1=c1.contains(c2);
System.out.println(b1); //false: addAll(将集合中元素一个一个放入) true:add (将集合整体放入) // 计算两个集合的交集并保留到当前集合中
System.out.println("c2 = " + c2); // [three, 4]
System.out.println("c3 = " + c3); // [4, five]
// 也就是让集合自己和自己取交集，还是自己，也就是当前集合中的元素没有发生改变
b1 = c2.retainAll(c2);
System.out.println("b1 = " + b1); // false 表示当前集合中的元素没有发生改变
System.out.println("c2 = " + c2); // [three, 4]
// 计算集合c2和c3的交集并保留到集合c2中，取代集合c2中原有的数值
b1 = c2.retainAll(c3);
System.out.println("b1 = " + b1); // true 当前集合的元素发生了改变
System.out.println("c2 = " + c2); // [4]
System.out.println("c3 = " + c3); // [4, five] // 实现集合中单个元素的删除操作
// [one, 2, Person{name='zhangfei', age=30}, three, 4]
System.out.println("c1 = " + c1);
// 删除参数指定的单个元素
b1 = c1.remove(1);
System.out.println("b1 = " + b1); // false
// [one, 2, Person{name='zhangfei', age=30}, three, 4]
System.out.println("c1 = " + c1);
b1 = c1.remove("one");
System.out.println("b1 = " + b1); // true
// [2, Person{name='zhangfei', age=30}, three, 4]
System.out.println("c1 = " + c1);
// remove方法的工作原理：Objects.equals(o, e)
//因为重写了equals所以没有出现问题
b1 = c1.remove(new Person("zhangfei", 30));
System.out.println("b1 = " + b1); // true
// [2, three, 4]
System.out.println("c1 = " + c1);
// 实现集合中所有元素的删除操作
System.out.println("c3 = " + c3); // [4, five]
// 从集合c1中删除集合c3中的所有元素，本质上就是一个一个元素进行删除，有元素则删除，否则不删除
b1 = c1.removeAll(c3);
System.out.println("b1 = " + b1); // true
// [2, three]
System.out.println("c1 = " + c1);
System.out.println("c3 = " + c3); // [4, five]
// 笔试考点 删除整体对象c3
b1 = c1.remove(c3);
System.out.println("b1 = " + b1); // false
System.out.println("c1 = " + c1); // [2, three] //判断两集合是否相等
Collection c4=new ArrayList();
c4.add(1);
c4.add(2);
Collection c5=new ArrayList();
c5.add(1);
c5.add(2);
boolean b5 = c4.equals(c5);
System.out.println(b5); //true
//实现集合和数组类型之间得转换 通常认为；集合是用于取代数组得结构
//实现集合向数组类型得转换
Object[] objects = c5.toArray();
System.out.println("数组中得元素:"+Arrays.toString(objects)); //数组中得元素:[1, 2]
Collection objects1 = Arrays.asList(objects);
System.out.println("集合中得元素:"+objects1); //集合中得元素:[1, 2]- 代码中得注释需要详细了解
3、Iterator接口
3.1、基本概念
- java.util.Iterator接口主要用于描述迭代器对象，可以遍历Collection集合中的所有元素。
- java.util.Collection接口继承Iterator接口，因此所有实现Collection接口的实现类都可以使用该迭代器对象。
3.2、常用的方法
| 方法声明 | 功能介绍 |
| boolean hasNext() | 判断集合中是否有可以迭代/访问的元素 |
| E next() | 用于取出一个元素并指向下一个元素 |
| void remove() | 用于删除访问到的最后一个元素 |
// 1.准备一个Collection集合并放入元素后打印
Collection c1 = new ArrayList();
c1.add("one");
c1.add(2);
c1.add(new Person("zhangfei", 30));
// 遍历方式一： 自动调用toString方法 String类型的整体
System.out.println("c1 = " + c1); // [one, 2, Person{name='zhangfei', age=30}]
System.out.println("------------------------------------------------");
// 2.遍历方式二：使用迭代器来遍历集合中的所有元素 更加灵活
// 2.1 获取当前集合中的迭代器对象
Iterator iterator1 = c1.iterator();
/*
// 2.2 判断是否有元素可以访问
System.out.println(iterator1.hasNext()); // true
// 2.3 取出一个元素并指向下一个
System.out.println("获取到的元素是：" + iterator1.next()); // one
System.out.println(iterator1.hasNext()); // true
System.out.println("获取到的元素是：" + iterator1.next()); // 2
System.out.println(iterator1.hasNext()); // true
System.out.println("获取到的元素是：" + iterator1.next()); // Person{name='zhangfei', age=30}
System.out.println(iterator1.hasNext()); // false
System.out.println("获取到的元素是：" + iterator1.next()); // 编译ok，运行发生NoSuchElementException没有这样的元素异常
*/
while (iterator1.hasNext()) {
System.out.println("获取到的元素是：" + iterator1.next());
} //由于上个循环已经使得迭代器走到了最后，因此需要重置迭代器
iterator=c1.iterator();
//使用迭代器来模拟toString方法的打印效果
StringBuilder str1=new StringBuilder();
str1.append("[");
while (iterator.hasNext())
{
Object next = iterator.next();
if(!iterator.hasNext())
{
str1.append(next).append("]");
}else
{
str1.append(next).append(",").append(" ");
}
}
System.out.println("str1:"+str1); //不断地去获取集合中的元素并判断，当元素值为"one"时则删除该元素
iterator=c1.iterator();
while (iterator.hasNext())
{
Object next = iterator.next();
if("one".equals(next))
{
iterator.remove(); //使用迭代器的remove方法删除元素没问题
//c1.remove(obj); // 使用集合的remove方法编译ok，运行发生ConcurrentModificationException并发修改异常
}
}
System.out.println("删除后集合中的元素有：" + c1); // [2, Person{name='zhangfei', age=30}] 4、for each循环
4.1、基本概念
- Java5推出了增强型for循环语句，可以应用数组和集合的遍历。
- 是经典迭代的“简化版”。
4.2、语法格式
for(元素类型 变量名 : 数组/集合名称) {
循环体;
}
4.3、执行流程
- 不断地从数组/集合中取出一个元素赋值给变量名并执行循环体，直到取完所有元素为止。
//使用 for each结构实现集合和数组中元素的遍历 代码简单且方法灵活
// 由调试源码可知：该方式确实是迭代器的简化版
for (Object obj : c1) {
System.out.println("取出来的元素是：" + obj);
}
int[] arr=new int[]{11,22,33,44};
for (int i :
arr) {
System.out.println("i = " + i);
i = 66; // 修改局部变量i的数值，并不是修改数组中元素的数值
}
System.out.println("数组中的元素有：" + Arrays.toString(arr));5、List集合
5.1、基本概念
- java.util.List集合是Collection集合的子集合，该集合中允许有重复的元素并且有先后放入次序。
- 该集合的主要实现类有：ArrayList类、LinkedList类、Stack类、Vector类。
- 其中ArrayList类的底层是采用动态数组进行数据管理的，支持下标访问，增删元素不方便。
- 其中LinkedList类的底层是采用双向链表进行数据管理的，访问不方便，增删元素方便。
- 可以认为ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上有一定的差别，ArrayList更适合于机访问而LinkedList更适合于插入和删除；在性能要求不是特别苛刻的情形下可以忽略这个差别。
- 其中Stack类的底层是采用动态数组进行数据管理的，该类主要用于描述一种具有后进先出特征的数据结构，叫做栈(last in first out LIFO)。
- 其中Vector类的底层是采用动态数组进行数据管理的，该类与ArrayList类相比属于线程安全的类，效率比较低，以后开发中基本不用。
5.2、常用的方法
List lt1=new LinkedList();
lt1.add(0,"one");
lt1.add(1,2);
lt1.add(2,3);
String str1 = (String) lt1.get(0);
System.out.println("str1:"+str1);
//String str2= (String) lt1.get(2);
//System.out.println("str2:"+str2); //ClassCastException 类型转换错误
StringBuilder sb1=new StringBuilder();
sb1.append("[");
for(int i=0;i<lt1.size();i++)
{
Object obj = lt1.get(i);
if(lt1.size()-1 == i)
{
sb1.append(obj).append("]");
}else
{
sb1.append(obj).append(",").append(" ");
}
}
System.out.println("lt1:"+lt1); //lt1:[one, 3, 3]
System.out.println("one第一次出现得索引位置:"+lt1.indexOf("one")); //0
lt1.add("one");
System.out.println("lt1:"+lt1);
System.out.println("one方向查找得索引位置:"+lt1.lastIndexOf("one")); //3- 子集合和当前集合共用同一块内存空间
Integer two = (Integer) lt1.set(1, "two");
System.out.println("被修改得元素:"+two); //2
System.out.println("修改后得集合中得元素:"+lt1); //修改后得集合中得元素:[one, two, 3, one]
String four = (String) lt1.set(3, "four");
System.out.println("被修改得元素:"+four); //one
System.out.println("修改后得集合中得元素:"+lt1); //修改后得集合中得元素:[one, two, 3, four]
//使用remove方法将集合中的所有元素删除
//for (int i = 0; i < lt1.size(); /*i++*/) {
/* for (int i = lt1.size()-1; i >= 0; i--) {
//System.out.println("被删除的元素是：" + lt1.remove(i)); // one two three four 删除元素后，后面的元素补位
//System.out.println("被删除的元素是：" + lt1.remove(0));
System.out.println("被删除的元素是：" + lt1.remove(i));
}
System.out.println("最终集合中的元素有：" + lt1); // [啥也没有]*/
//获取当前集合中的子集合，也就是将集合中的一部分内容获取出来，子集合和当前集合共用同一块内存空间
// 表示获取当前集合lt1中下标从1开始到3之间的元素，包含1但不包含3
List lt2 = lt1.subList(1, 3);
System.out.println("lt2 = " + lt2); // [two, three]
// 删除lt2中元素的数值
String str2 = (String) lt2.remove(0);
System.out.println("被删除的元素是：" + str2); // two
System.out.println("删除后lt2 = " + lt2); // [three]
System.out.println("删除后lt1 = " + lt1); // [one, three, four]
// 1.准备一个Stack类型的对象并打印
Stack s1 = new Stack();
Stack s2 = new Stack();
System.out.println("s1 = " + s1); // [啥也没有]
System.out.println("s2 = " + s2); // [啥也没有]
System.out.println("-----------------------------------------------");
// 2.将数据11、22、33、44、55依次入栈并打印
for (int i = 1; i <= 5; i++) {
Object obj = s1.push(i * 11);
System.out.println("入栈的元素是：" + obj);
//System.out.println("栈中的元素有：" + s1); // 11 22 33 44 55
}
System.out.println("-----------------------------------------------");
// 3.查看栈顶元素值并打印
//Object obj2 = s1.peek();
//System.out.println("获取到的栈顶元素是：" + obj2); // 55
System.out.println("-----------------------------------------------");
// 4.对栈中所有元素依次出栈并打印
int len = s1.size();
for (int i = 1; i <= len; i++) {
Object to = s1.pop();
//System.out.println("出栈的元素是：" + to); // 55 44 33 22 11
s2.push(to);
}
System.out.println("-----------------------------------------------");
// 5.最终打印栈中的所有元素
//System.out.println("s1 = " + s1); // [啥也没有]
System.out.println("-----------------------------------------------");
len = s2.size();
for (int i = 1; i <= len; i++) {
Object to = s2.pop();
System.out.println("出栈的元素是：" + to); // 11 22 33 44 55
}6、Queue集合
6.1、基本概念
- java.util.Queue集合是Collection集合的子集合，与List集合属于平级关系。
- 该集合的主要用于描述具有先进先出特征的数据结构，叫做队列(first in first out FIFO)。
- 该集合的主要实现类是LinkedList类，因为该类在增删方面比较有优势。
6.2、常用的方法
| 方法声明 | 功能介绍 |
| boolean offer(E e) | 将一个对象添加至队尾，若添加成功则返回true |
| E poll() | 从队首删除并返回一个元素 |
| E peek() | 返回队首的元素（但并不删除） |
// 1.准备一个Queue集合并打印
Queue queue = new LinkedList();
System.out.println("队列中的元素有：" + queue); // [啥也没有]
System.out.println("----------------------------------------------------------");
// 2.将数据11、22、33、44、55依次入队并打印
for (int i = 1; i <= 5; i++) {
boolean b1 = queue.offer(i * 11);
//System.out.println("b1 = " + b1);
System.out.println("队列中的元素有：" + queue); // 11 22 33 44 55
}
System.out.println("----------------------------------------------------------");
// 3.然后查看队首元素并打印
System.out.println("对首元素是：" + queue.peek()); // 11
System.out.println("----------------------------------------------------------");
// 4.然后将队列中所有数据依次出队并打印
int len = queue.size();
for (int i = 1; i <= len; i++) {
System.out.println("出队的元素是：" + queue.poll()); // 11 22 33 44 55
}
System.out.println("----------------------------------------------------------");
// 5.查看队列中最终的元素
System.out.println("队列中的元素有：" + queue); // [啥也没有]7、泛型机制（熟悉）
7.1、基本概念
- 通常情况下集合中可以存放不同类型的对象，是因为将所有对象都看做Object类型放入的，因此从集合中取出元素时也是Object类型，为了表达该元素真实的数据类型，则需要强制类型转换，而强制类型转换可能会引发类型转换异常。
- 为了避免上述错误的发生，从Java5开始增加泛型机制，也就是在集合名称的右侧使用<数据类型>的方式来明确要求该集合中可以存放的元素类型，若放入其它类型的元素则编译报错。
- 泛型只在编译时期有效，在运行时期不区分是什么类型。
// 1.准备一个支持泛型机制的List集合，明确要求集合中的元素是String类型
List<String> lt1 = new LinkedList<String>();
// 2.向集合中添加元素并打印
lt1.add("one");
System.out.println("lt1 = " + lt1); // [one]
//lt1.add(2); Error
// 3.获取集合中的元素并打印
String s = lt1.get(0);
System.out.println("获取到的元素是：" + s); // one
System.out.println("----------------------------------------------------");
// 2.准备一个支持Integer类型的List集合
List<Integer> lt2 = new LinkedList<Integer>();
lt2.add(1);
lt2.add(2);
//lt2.add("3"); Error
System.out.println("lt2 = " + lt2); // [1, 2]
Integer integer = lt2.get(0);
System.out.println("获取到的元素是：" + integer); // 1
System.out.println("----------------------------------------------------");
// Java7开始的新特性： 菱形特性 就是后面<>中的数据类型可以省略
List<Double> lt3 = new LinkedList<>();
// 笔试考点
// 试图将lt1的数值赋值给lt3，也就是覆盖lt3中原来的数值，结果编译报错：集合中支持的类型不同
//lt3 = lt1; Error7.2、底层原理
- 泛型的本质就是参数化类型，也就是让数据类型作为参数传递，其中E相当于形式参数负责占位，而使用集合时<>中的数据类型相当于实际参数，用于给形式参数E进行初始化，从而使得集合中所有的E被实际参数替换，由于实际参数可以传递各种各样广泛的数据类型，因此得名为泛型。
- 如：
//其中i叫做形式参数，负责占位 其中E叫做形式参数，负责占位
//int i = 10; E = String;
//int i = 20; E = Integer;
public static void show(int i) { public interface List {
... ...
} }
//其中10叫做实际参数，负责给形式参数初始化 //其中String叫做实际参数
show(10); List lt1 = ...;
show(20); List lt2 = ...;7.3、自定义泛型接口
- 泛型接口和普通接口的区别就是后面添加了类型参数列表，可以有多个类型参数，如：<E, T, .. >等。
7.4、自定义泛型类
- 泛型类和普通类的区别就是类名后面添加了类型参数列表，可以有多个类型参数，如：<E, T, .. >等。
- 实例化泛型类时应该指定具体的数据类型，并且是引用数据类型而不是基本数据类型。
- 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型。
- 子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型。
/**
* @author XiceSberg
* @date 2020/8/14 15:46
* @description 自定义泛型类Person，其中T相当于形式参数负责占位，具体数值由实参决定
* @param <T> 看做是一种名字为T的数据类型即可
*/
public class Person<T> {
private String name;
private int age;
private T sex;
public Person() {
}
public Person(String name, int age, T sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
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 T getSex() {
return sex;
}
public void setSex(T sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", sex=" + sex +
'}';
}
}
/**
* @author XiceSberg
* @date 2020/8/14 15:48
* @description
*/
public class PersonTest {
public static void main(String[] args) {
// 1.声明Person类型的引用指向Person类型的对象
Person p1=new Person("张飞",30,"男");
System.out.println(p1); //Person{name='张飞', age=30, sex=男}
// 3.在创建对象的同时指定数据类型，用于给T进行初始化
Person<String> p2=new Person<>();
p2.setSex("女");
System.out.println(p2); //Person{name='null', age=0, sex=女}
// 4.使用Boolean类型作为性别的类型
Person<Boolean> p3=new Person<>();
p3.setSex(true);
System.out.println(p3); //Person{name='null', age=0, sex=true}
}
}public class SubPerson extends Person{ }// 不保留泛型并且没有指定类型，此时Person类中的T默认为Object类型 擦除
//main方法中的调用
SubPerson sp1=new SubPerson();
sp1.setSex("男"); //Object sex
//==========================================================
public class SubPerson extends Person<String>{ }// 不保留泛型但指定了泛型的类型，此时Person类中的T被指定为String类型
//main方法中的调用
SubPerson sp1=new SubPerson();
sp1.setSex("女"); //String sex
//==========================================================
public class SubPerson<T> extends Person<T>{ }// 保留父类的泛型 可以在构造对象时来指定T的类型
//main方法中的调用
SubPerson<Boolean> sp2=new SubPerson<>();
sp2.setSex(true); //Boolean sex
//==========================================================
public class SubPerson<T,T2> extends Person<T>{ }// 保留父类的泛型，同时在子类中增加新的泛型
//main方法中的调用
SubPerson<Boolean,String> sp2=new SubPerson<>();
sp2.setSex(true); //Boolean sex7.5、自定义泛型方法
- 泛型方法就是我们输入参数的时候，输入的是泛型参数，而不是具体的参数。我们在调用这个泛型方法的时需要对泛型参数进行实例化。
- 泛型方法的格式：
=》[访问权限] <泛型> 返回值类型 方法名([泛型标识 参数名称]) { 方法体; }
- 在静态方法中使用泛型参数的时候，需要我们把静态方法定义为泛型方法。
//自定义实现将参数指定数组中的所有元素打印出来
public static <T1> void printArray(T1[] arr){
for (T1 tt : arr) {
System.out.println("tt:"+tt);
}
}
// 不是泛型方法，该方法不能使用static关键字修饰，因为该方法中的T需要在new对象时才能明确类型
public /*static*/ T getGender() {
return gender;
}
Integer[] it={11,22,33,44};
Person.printArray(it);7.6、泛型在继承上的体现
- 如果B是A的一个子类或子接口，而G是具有泛型声明的类或接口，则G并不是G的子类型！
- 比如：String是Object的子类，但是List并不是List的子类。
7.7、通配符的使用
- 有时候我们希望传入的类型在一个指定的范围内，此时就可以使用泛型通配符了。
- 如：之前传入的类型要求为Integer类型，但是后来业务需要Integer的父类Number类也可以传入。
- 泛型中有三种通配符形式：
=》<?> 无限制通配符：表示我们可以传入任意类型的参数。
=》<? extends E> 表示类型的上界是E，只能是E或者是E的子类。
=》<? super E> 表示类型的下界是E，只能是E或者是E的父类。
public class Animal {
}
public class Dog extends Animal {
}
import java.util.LinkedList;
import java.util.List;
public class GenericTest {
public static void main(String[] args) {
// 1.声明两个List类型的集合进行测试
List<Animal> lt1 = new LinkedList<>();
List<Dog> lt2 = new LinkedList<>();
// 试图将lt2的数值赋值给lt1，也就是发生List<Dog>类型向List<Animal>类型的转换
//lt1 = lt2; Error: 类型之间不具备父子类关系
System.out.println("---------------------------------------------");
// 2.使用通配符作为泛型类型的公共父类
List<?> lt3 = new LinkedList<>();
lt3 = lt1; // 可以发生List<Animal>类型到List<?>类型的转换
lt3 = lt2; // 可以发生List<Dog>类型到List<?>类型的转换
// 向公共父类中添加元素和获取元素
//lt3.add(new Animal()); Error: 不能存放Animal类型的对象
//lt3.add(new Dog()); Error: 不能存放Dog类型的对象， 不支持元素的添加操作
Object o = lt3.get(0); // ok，支持元素的获取操作，全部当做Object类型来处理
System.out.println("---------------------------------------------");
// 3.使用有限制的通配符进行使用
List<? extends Animal> lt4 = new LinkedList<>();
// 不支持元素的添加操作
//lt4.add(new Animal());
//lt4.add(new Dog());
//lt4.add(new Object());
// 获取元素
Animal animal = lt4.get(0);
System.out.println("---------------------------------------------");
List<? super Animal> lt5 = new LinkedList<>();
lt5.add(new Animal());
lt5.add(new Dog());
//lt5.add(new Object()); Error: 超过了Animal类型的范围
Object object = lt5.get(0);
}
}8、Set集合（熟悉）
8.1、基本概念
- java.util.Set集合是Collection集合的子集合，与List集合平级。
- 该集合中元素没有先后放入次序，且不允许重复。
- 该集合的主要实现类是：HashSet类 和 TreeSet类以及LinkedHashSet类。
- 其中HashSet类的底层是采用哈希表进行数据管理的。
- 其中TreeSet类的底层是采用红黑树进行数据管理的。
- 其中LinkedHashSet类与HashSet类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。
8.2、常用的方法
- 参考Collection集合中的方法即可！
8.3、元素放入HashSet集合的原理
- 使用元素调用hashCode方法获取对应的哈希码值，再由某种哈希算法计算出该元素在数组中的索引位置。
- 若该位置没有元素，则将该元素直接放入即可。
- 若该位置有元素，则使用新元素与已有元素依次比较哈希值，若哈希值不相同，则将该元素直接放入。
- 若新元素与已有元素的哈希值相同，则使用新元素调用equals方法与已有元素依次比较。
- 若相等则添加元素失败，否则将元素直接放入即可。
Set<String> s1=new HashSet<>();
System.out.println(s1);//[啥也没有]
boolean b1 = s1.add("two");
System.out.println(b1); //true
System.out.println(s1); //[two]
//从打印结果上可以看到元素没有先后放入次序（表面）
b1 = s1.add("one");
System.out.println(b1); //true
System.out.println(s1); //[one,two]
b1 = s1.add("three");
System.out.println(b1); //true
System.out.println(s1); //[one,two,three]
//验证元素不能重复
b1 = s1.add("one");
System.out.println(b1); //false
System.out.println(s1); //[one,two,three] Set<String> s1=new LinkedHashSet<>();
System.out.println(s1);//[啥也没有]
boolean b1 = s1.add("two");
System.out.println(b1); //true
System.out.println(s1); //[two]
//从打印结果上可以看到元素没有先后放入次序（表面）
b1 = s1.add("one");
System.out.println(b1); //true
System.out.println(s1); //[two,one]
b1 = s1.add("three");
System.out.println(b1); //true
System.out.println(s1); //[two,one,three]
- 思考：为什么要求重写equals方法后要重写hashCode方法呢？
- 解析： 当两个元素调用equals方法相等时证明这两个元素相同，重写hashCode方法后保证这两个元 素得到的哈希码值相同，由同一个哈希算法生成的索引位置相同，此时只需要与该索引位置已有元 素比较即可，从而提高效率并避免重复元素的出现。
8.4、TreeSet集合的概念
- 二叉树主要指每个节点最多只有两个子节点的树形结构。
- 满足以下3个特征的二叉树叫做有序二叉树。
a.左子树中的任意节点元素都小于根节点元素值；
b.右子树中的任意节点元素都大于根节点元素值；
c.左子树和右子树的内部也遵守上述规则；
- 由于TreeSet集合的底层采用红黑树进行数据的管理，当有新元素插入到TreeSet集合时，需要使用新元素与集合中已有的元素依次比较来确定新元素的合理位置。
- 比较元素大小的规则有两种方式：
- 使用元素的自然排序规则进行比较并排序，让元素类型实现java.lang.Comparable接口；
- 使用比较器规则进行比较并排序，构造TreeSet集合时传入java.util.Comparator接口；
- 自然排序的规则比较单一，而比较器的规则比较多元化，而且比较器优先于自然排序；
public static void main(String[] args) {
// 1.准备一个TreeSet集合并打印
Set<String> s1 = new TreeSet<>();
System.out.println("s1 = " + s1); // [啥也没有]
// 2.向集合中添加String类型的对象并打印
boolean b1 = s1.add("aa");
System.out.println("b1 = " + b1); // true
System.out.println("s1 = " + s1); // [aa]
b1 = s1.add("cc");
System.out.println("b1 = " + b1); // true
System.out.println("s1 = " + s1); // [aa, cc]
b1 = s1.add("bb");
System.out.println("b1 = " + b1); // true
// 由于TreeSet集合的底层是采用红黑树实现的，因此元素有大小次序，默认从小到大打印
System.out.println("s1 = " + s1); // [aa, bb, cc]
System.out.println("----------------------------------------------------------");
// 4.准备一个比较器对象作为参数传递给构造方法
// 匿名内部类： 接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };
/*
Comparator<Student> comparator = new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) { // o1表示新增加的对象 o2表示集合中已有的对象
return o1.getAge() - o2.getAge(); // 表示按照年龄比较
}
};
*/
// 从Java8开始支持Lambda表达式: (参数列表) -> { 方法体 }
Comparator<Student> comparator = (Student o1, Student o2) -> { return o1.getAge() - o2.getAge(); };
// 3.准备一个TreeSet集合并放入Student类型的对象并打印
//Set<Student> s2 = new TreeSet<>();
Set<Student> s2 = new TreeSet<>(comparator);
s2.add(new Student("zhangfei", 35));
s2.add(new Student("zhangfei", 30));
s2.add(new Student("guanyu", 35));
s2.add(new Student("liubei", 40));
System.out.println("s2 = " + s2);
}public class Student implements Comparable<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 int compareTo(Student o) {
//return 0; // 调用对象和参数对象相等，调用对象就是新增加的对象
//return -1; // 调用对象小于参数对象
//return 1; // 调用对象大于参数对象
//return this.getName().compareTo(o.getName()); // 比较姓名
//return this.getAge() - o.getAge(); // 比较年龄
/*
int ia = this.getName().compareTo(o.getName());
if (0 == ia) {
return this.getAge() - o.getAge();
}
return ia;
*/
int ia = this.getName().compareTo(o.getName());
return 0 != ia? ia : this.getAge() - o.getAge();
}
}
9、Map集合（重点）
9.1、基本概念
- java.util.Map<K,V>集合中存取元素的基本单位是：单对元素，其中类型参数如下：
- K - 此映射所维护的键(Key)的类型，相当于目录。
- V - 映射值(Value)的类型，相当于内容。
- 该集合中key是不允许重复的，而且一个key只能对应一个value。
- 该集合的主要实现类有：HashMap类、TreeMap类、LinkedHashMap类、Hashtable类、Properties类。
- 其中HashMap类的底层是采用哈希表进行数据管理的。
- 其中TreeMap类的底层是采用红黑树进行数据管理的。
- 其中LinkedHashMap类与HashMap类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。
- 其中Hashtable类是古老的Map实现类，与HashMap类相比属于线程安全的类，且不允许null作为key或者value的数值。
- 其中Properties类是Hashtable类的子类，该对象用于处理属性文件，key和value都是String类型的。
- Map集合是面向查询优化的数据结构, 在大数据量情况下有着优良的查询性能。
- 经常用于根据key检索value的业务场景。
9.2、常用的方法
public static void main(String[] args) {
// 1.准备一个Map集合并打印
Map<String, String> m1 = new HashMap<>();
// 自动调用toString方法，默认打印格式为：{key1=value1, key2=value2, ...}
System.out.println("m1 = " + m1); // {啥也没有}
// 2.向集合中添加元素并打印
String str1 = m1.put("1", "one");
System.out.println("原来的value数值为：" + str1); // null
System.out.println("m1 = " + m1); // {1=one}
str1 = m1.put("2", "two");
System.out.println("原来的value数值为：" + str1); // null
System.out.println("m1 = " + m1); // {1=one, 2=two}
str1 = m1.put("3", "three");
System.out.println("原来的value数值为：" + str1); // null
System.out.println("m1 = " + m1); // {1=one, 2=two, 3=three}
// 实现了修改的功能
str1 = m1.put("1", "eleven");
System.out.println("原来的value数值为：" + str1); // one
System.out.println("m1 = " + m1); // {1=eleven, 2=two, 3=three}
System.out.println("-------------------------------------------------------------");
// 3.实现集合中元素的查找操作
boolean b1 = m1.containsKey("11");
System.out.println("b1 = " + b1); // false
b1 = m1.containsKey("1");
System.out.println("b1 = " + b1); // true
b1 = m1.containsValue("one");
System.out.println("b1 = " + b1); // false
b1 = m1.containsValue("eleven");
System.out.println("b1 = " + b1); // true
String str2 = m1.get("5");
System.out.println("str2 = " + str2); // null
str2 = m1.get("3");
System.out.println("str2 = " + str2); // three
System.out.println("-------------------------------------------------------------");
// 4.实现集合中元素的删除操作
str2 = m1.remove("1");
System.out.println("被删除的value是：" + str2); // eleven
System.out.println("m1 = " + m1); // {2=two, 3=three}
System.out.println("-------------------------------------------------------------");
// 5.获取Map集合中所有的key并组成Set视图,视图得作用是原数据不变
Set<String> s1 = m1.keySet();
// 遍历所有的key
for (String ts : s1) {
System.out.println(ts + "=" + m1.get(ts));
}
System.out.println("-------------------------------------------------------------");
// 6.获取Map集合中所有的Value并组成Collection视图
Collection<String> co = m1.values();
for (String ts : co) {
System.out.println("ts = " + ts);
}
System.out.println("-------------------------------------------------------------");
// 7.获取Map集合中所有的键值对并组成Set视图
Set<Map.Entry<String, String>> entries = m1.entrySet();
for (Map.Entry<String, String> me : entries) {
System.out.println(me);
}
}9.3、元素放入HashMap集合的原理
- 使用元素的key调用hashCode方法获取对应的哈希码值，再由某种哈希算法计算在数组中的索引位置。
- 若该位置没有元素，则将该键值对直接放入即可。
- 若该位置有元素，则使用key与已有元素依次比较哈希值，若哈希值不相同，则将该元素直接放入。
- 若key与已有元素的哈希值相同，则使用key调用equals方法与已有元素依次比较。
- 若相等则将对应的value修改，否则将键值对直接放入即可。
9.4、相关的常量
- DEFAULT_INITIAL_CAPACITY : HashMap的默认容量是16。
- DEFAULT_LOAD_FACTOR：HashMap的默认加载因子是0.75。
- threshold：扩容的临界值，该数值为：容量*填充因子，也就是12。
- TREEIFY_THRESHOLD：若Bucket中链表长度大于该默认值则转化为红黑树存储，该数值是8。
- MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量，该数值是64。
10、Collections类
10.1、基本概念
- java.util.Collections类主要提供了对集合操作或者返回集合的静态方法。
10.2、常用的方法
// 1.准备一个集合并初始化
List<Integer> lt1 = Arrays.asList(10, 30, 20, 50, 45);
// 2.实现集合中元素的各种操作
System.out.println("集合中的最大值是：" + Collections.max(lt1)); // 50
System.out.println("集合中的最小值是：" + Collections.min(lt1)); // 10
// 实现集合中元素的反转
Collections.reverse(lt1);
System.out.println("lt1 = " + lt1); // [45, 50, 20, 30, 10]
// 实现两个元素的交换
Collections.swap(lt1, 0, 4);
System.out.println("交换后：lt1 = " + lt1); // [10, 50, 20, 30, 45]
// 实现元素的排序
Collections.sort(lt1);
System.out.println("排序后：lt1 = " + lt1); // [10, 20, 30, 45, 50]
// 随机置换
Collections.shuffle(lt1);
System.out.println("随机置换后：lt1 = " + lt1); // [30, 10, 45, 20, 50] 随机
// 实现集合间元素的拷贝
//List<Integer> lt2 = new ArrayList<>(20);
List<Integer> lt2 = Arrays.asList(new Integer[10]);
System.out.println("lt1的大小是：" + lt1.size());
System.out.println("lt2的大小是：" + lt2.size());
// 表示将lt1中的元素拷贝到lt2中
Collections.copy(lt2, lt1);
System.out.println("lt2 = " + lt2);笔试考点
- List集合和Set集合是Collection集合得两个子集合，Collection是个集合工具类。
- List集合中的元素有先后放入次序，并且可以重复。
- Set集合中的元素没用先后放入次序，并且不可以重复。
- 泛型参数只能是引用数据类型不能是基础数据类型
- 泛型是JAVA语言中的语法糖，只存在于编译期
- 使用泛型可以避免类型转换引发的类型转换异常
- DEFAULT_INITIAL_CAPACITY：hashMap的默认容量是16.
- DEFAULT_LOAD_FACTOR：HashMap的默认加载因子是0.75
- threshold：扩容的临界值，该数值为：容量*填充因子，也就是12
- MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量，该数值是64
扫一扫
1815
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
