JAVA集合框架(三)
文章目录
三. 泛型和工具类
1. 泛型概念
Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
- 常见形式有泛型类、泛型接口、泛型方法。
语法:
- <T,…>T称为类型占位符，表示一种引用类型。
好处:
- (1）提高代码的重用性
- (2）防止类型转换异常，提高代码的安全性
2. 泛型类
实例：
public class Application<T> {
public static void main(String[] args) {
//使用泛型类来创建对象
//注意：泛型只能使用引用类型，不同泛型对象之间不能相互赋值
MyGeneric<String> myGeneric = new MyGeneric<String>();
myGeneric.t="hello";
myGeneric.show("Hello World!");
System.out.println(myGeneric.getT());
MyGeneric<Integer> myGeneric1 = new MyGeneric<>();
myGeneric1.t=200;
myGeneric1.show(100);
System.out.println(myGeneric1.getT());
}
}
---------------结果---------------
Hello World!
hello
100
200
public class MyGeneric<T> {
//T是类型占位符，表示一种引用类型，如果编写多个用逗号隔开
//使用泛型
// 1.来创建对象
T t;
//2.添加方法
public void show(T t){
System.out.println(t);
}
//3.泛型作为方法的返回值
public T getT(){
return t;
}
}
3. 泛型接口
实例:
import com.mnm.collection.MyInterfaceImpl;
import com.mnm.collection.MyInterfaceImpl2;
public class Application<T> {
public static void main(String[] args) {
MyInterfaceImpl impl = new MyInterfaceImpl();
impl.sever("abcde");
MyInterfaceImpl2<Integer> impl2 = new MyInterfaceImpl2<>();
impl2.sever(20);
}
}
---------------结果---------------
abcde
20
public interface MyInterface<T> {
//泛型接口
//注意，不能泛型静态常量
String name="张三";
T sever(T t);
}
public class MyInterfaceImpl implements MyInterface<String>{
@Override
public String sever(String s) {
System.out.println(s);
return null;
}
}
public class MyInterfaceImpl2<T> implements MyInterface<T> {
@Override
public T sever(T t) {
System.out.println(t);
return null;
}
}
4. 泛型方法
实例：
import com.mnm.collection.MyGenericMethod;
public class Application<T> {
public static void main(String[] args) {
MyGenericMethod method = new MyGenericMethod();
method.show();
System.out.println(method.get("aaa"));
System.out.println(method.get(100));
}
}
---------------结果---------------
泛型方法
aaa
100
public class MyGenericMethod {
//泛型方法
//语法：<T>返回值类型
public <T> void show(){
System.out.println("泛型方法");
}
public <T> T get(T t){
return t;
}
}
5. 泛型集合
概念
- 参数化类型、类型安全的集合，强制集合元素的类型必须一致。
特点:
- 编译时即可检查，而非运行时抛出异常。访问时，不必类型转（拆箱）。
- 不同泛型之间引用不能相互赋值，泛型不存在多态
import com.mnm.collection.Student;
import java.util.ArrayList;
import java.util.Iterator;
public class Application<T> {
public static void main(String[] args) {
//泛型集合
ArrayList<String> s1 = new ArrayList<>();
s1.add("aaa");
s1.add("bbb");
s1.add("ccc");
for (String s : s1) {
System.out.println(s);
}
ArrayList<Student> s2 = new ArrayList<>();
Student student1 = new Student("aaa", 20);
Student student2 = new Student("aaa", 20);
Student student3 = new Student("aaa", 20);
s2.add(student1);
s2.add(student2);
s2.add(student3);
Iterator<Student> iterator = s2.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
---------------结果---------------
aaa
bbb
ccc
[name=aaa, age=20]
[name=aaa, age=20]
[name=aaa, age=20]
public class Student {
private String name;
private int age;
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 "[name="+name+", age="+age+"]";
}
@Override
public boolean equals(Object obj) {
//是否是同一个对象
if(this==obj){
return true;
}
//是否是同为空
if(obj==null){
return false;
}
//判断是否是Student类
if(obj instanceof Student){
Student s =(Student)obj;
//比较属性
if(this.name.equals(s.getName()) && this.age==s.getAge()){
return true;
}
}
//不满足，返回false
return false;
}
}
四. Set接口和实现类
1. Set子接口
- 特点:无序、无下标、元素不可重复。
- 方法:全部继承自Collection中的方法。
2. Set接口的使用
以HashSet为实例：
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Application {
public static void main(String[] args) {
//set接口的使用
//特点：无序，无下标，元素不可重复
//创建集合
Set<String> set = new HashSet<>();
//添加元素
set.add("张三");
set.add("李四");
set.add("王五");
set.add("王五");//重复添加不进去
System.out.println("元素个数:"+set.size());
System.out.println(set);
//删除元素
set.remove("王五");
System.out.println(set);
//遍历
System.out.println("-----增强for循环-----");
for (String s : set) {
System.out.println(s);
}
System.out.println("-----迭代器-----");
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//判断
System.out.println("包含李四吗："+set.contains("李四"));
System.out.println("是否为空："+set.isEmpty());
}
}
---------------结果---------------
元素个数:3
[李四, 张三, 王五]
[李四, 张三]
-----增强for循环-----
李四
张三
-----迭代器-----
李四
张三
包含李四吗：true
是否为空：false
3. Set实现类
HashSet[重点]
- 基于HashCode实现元素不重复。
- 当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入。
import java.util.HashSet;
import java.util.Iterator;
public class Application {
public static void main(String[] args) {
//HashSet集合的使用
//存储结构：哈希表(数组+列表+红黑树)
HashSet<Person> hashSet = new HashSet<>();
Person p1 = new Person("张三",20);
Person p2 = new Person("李四",19);
Person p3 = new Person("王五",18);
hashSet.add(p1);
hashSet.add(p2);
hashSet.add(p3);
hashSet.add(new Person("王五",18));
System.out.println("元素个数为:"+hashSet.size());
System.out.println(hashSet);
}
}
---------------结果---------------
元素个数为:4
[[name=李四 age=19], [name=王五 age=18], [name=王五 age=18], [name=张三 age=20]]
这时就要讲，hashset的存储方式：
- (1)根据hashcode计算保存的位置，如果此位置为空，则直接保存，不为空则执行(2)
- (2)在执行equals方法，如果equals为true，则认为是重复,否则形成链表
重写hashCode和equals后
import java.util.HashSet;
import java.util.Iterator;
public class Application {
public static void main(String[] args) {
//HashSet集合的使用
//存储结构：哈希表(数组+列表+红黑树)
HashSet<Person> hashSet = new HashSet<>();
Person p1 = new Person("张三",20);
Person p2 = new Person("李四",19);
Person p3 = new Person("王五",18);
hashSet.add(p1);
hashSet.add(p2);
hashSet.add(p3);
hashSet.add(new Person("王五",18));
System.out.println("元素个数为:"+hashSet.size());
System.out.println(hashSet);
}
}
---------------结果---------------
元素个数为:3
[[name=王五 age=18], [name=张三 age=20], [name=李四 age=19]]
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
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 "[name="+name+" age="+age+"]";
}
@Override
public int hashCode() {
int n1=this.name.hashCode();
int n2=this.age;
return n1+n2;
}
@Override
public boolean equals(Object obj) {
//是否是同一个对象
if(this==obj){
return true;
}
//是否是同为空
if(obj==null){
return false;
}
//判断是否是Person类
if(obj instanceof Person){
Person s =(Person) obj;
//比较属性
if(this.name.equals(s.getName()) && this.age==s.getAge()){
return true;
}
}
//不满足，返回false
return false;
}
}
IDEA中可快捷输入：Alt+Insert键
系统重写的代码
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Person)) return false;
Person person = (Person) o;
return getAge() == person.getAge() && getName().equals(person.getName());
}
@Override
public int hashCode() {
return Objects.hash(getName(), getAge());
}
小知识：
在hashCode的源码中，可以看到用到数字31，为什么用31呢？
public static int hashCode(Object a[]) {
if (a == null)
return 0;
int result = 1;
for (Object element : a)
result = 31 * result + (element == null ? 0 : element.hashCode());
return result;
}
原因：
- (1). 31是一个质数，可以减少散列冲突(数据结构课程中应该讲过，没有学过的可以了解一下散列表)
- (2). 31可以提高运行效率，31*i=(i<<5)-i，如i=1时，31=100000B-1
如有不同见解，可以写在评论区
TreeSet
- 基于排列顺序实现元素不重复。
- 实现了SortedSet接口，对集合元素自动排序。
- 元素对象的类型必须实现Comparable接口，指定排序规则。
- 通过CompareTo方法确定是否为重复元素。
TreeSet采用红黑树来排列，红黑树是平衡二叉排序树加上一些颜色来区分(也是数据结构课程中的东西，可以自行搜索视频观看)
实例一：
import java.util.Iterator;
import java.util.TreeSet;
public class Application {
public static void main(String[] args) {
//TreeSet的使用 存储结构：红黑树
TreeSet<String> treeSet = new TreeSet<>();
//添加元素
treeSet.add("def");
treeSet.add("ghi");
treeSet.add("abc");
System.out.println("元素个数为："+treeSet.size());
System.out.println(treeSet);
//删除
treeSet.remove("def");
System.out.println(treeSet);
//遍历
System.out.println("-----增强for-----");
for (String s : treeSet) {
System.out.println(s);
}
System.out.println("-----迭代器-----");
Iterator<String> iterator = treeSet.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//判断
System.out.println("是否包含def:"+treeSet.contains("def"));
System.out.println("是否为空："+treeSet.isEmpty());
}
}
---------------结果---------------
元素个数为：3
[abc, def, ghi]
[abc, ghi]
-----增强for-----
abc
ghi
-----迭代器-----
abc
ghi
是否包含def:false
是否为空：false
实例二：
import java.util.Iterator;
import java.util.TreeSet;
public class Application {
public static void main(String[] args) {
//TreeSet的使用 存储结构：红黑树
//要求：元素必须实现Comparable接口,compareTo方法返回值为0，认为是重复元素
TreeSet<Person> treeSet = new TreeSet<>();
//添加元素
Person p1 = new Person("a", 20);
Person p2 = new Person("b", 19);
Person p3 = new Person("c", 18);
Person p4 = new Person("d", 18);
treeSet.add(p1);
treeSet.add(p2);
treeSet.add(p3);
treeSet.add(p4);
System.out.println("元素个数为："+treeSet.size());
System.out.println(treeSet);
//删除
treeSet.remove(p4);
System.out.println("删除后："+treeSet);
//遍历
System.out.println("-----增强for-----");
for (Person person : treeSet) {
System.out.println(person);
}
System.out.println("-----迭代器-----");
Iterator<Person> iterator = treeSet.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//判断
System.out.println("包含p3吗："+treeSet.contains(p3));
System.out.println("是否为空："+treeSet.isEmpty());
}
}
---------------结果---------------
元素个数为：4
[[name=a age=20], [name=b age=19], [name=c age=18], [name=d age=18]]
删除后：[[name=a age=20], [name=b age=19], [name=c age=18]]
-----增强for-----
[name=a age=20]
[name=b age=19]
[name=c age=18]
-----迭代器-----
[name=a age=20]
[name=b age=19]
[name=c age=18]
包含p3吗：true
是否为空：false
import java.util.Objects;
public class Person implements Comparable<Person>{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
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 "[name="+name+" age="+age+"]";
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Person)) return false;
Person person = (Person) o;
return getAge() == person.getAge() && getName().equals(person.getName());
}
@Override
public int hashCode() {
return Objects.hash(getName(), getAge());
}
@Override
public int compareTo(Person o) {
int n1=this.getName().compareTo(o.getName());
int n2=this.age-o.getAge();
//先按姓名比较，然后按年龄比较
return n1==0?n2:n1;
}
}
Comparator接口
实例：
import java.util.Comparator;
import java.util.TreeSet;
public class Application {
public static void main(String[] args) {
//TreeSet的使用
//Comparator:实现定制比较(比较器)
//Comparable:可比较的
//创建集合,并指定了比较规则
TreeSet<Person> treeSet= new TreeSet<>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
int n1=o1.getAge()-o2.getAge();
int n2=o1.getName().compareTo(o2.getName());
return n1==0?n2:n1;
}
});
Person p1 = new Person("a", 20);
Person p2 = new Person("b", 19);
Person p3 = new Person("c", 18);
treeSet.add(p1);
treeSet.add(p2);
treeSet.add(p3);
System.out.println("元素个数:"+treeSet.size());
System.out.println(treeSet);
}
}
---------------结果---------------
元素个数:3
[[name=c age=18], [name=b age=19], [name=a age=20]]
案例：
要求：
- 使用TreeSet集合实现字符串按照长度排序，长度相同按照字典表顺序排序
- 字符串为：HelloWorld,zhangsan,lisi,wangwu,beijing,xian,nanjing
import java.util.Comparator;
import java.util.TreeSet;
public class Application {
public static void main(String[] args) {
TreeSet<String> str = new TreeSet<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
int n1=o1.length()-o2.length();
int n2=o1.compareTo(o2);
return n1==0?n2:n1;
}
});
str.add("HelloWorld");
str.add("zhangsan");
str.add("lisi");
str.add("wangwu");
str.add("beijing");
str.add("xian");
str.add("nanjing");
System.out.println("元素个数为："+str.size());
System.out.println(str);
}
}
---------------结果---------------
元素个数为：7
[lisi, xian, wangwu, beijing, nanjing, zhangsan, HelloWorld]
1671
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
