Java集合框架
2021/12/4 1:16:41
本文主要是介绍Java集合框架，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
目录
集合的概念
Collection接口
1.Collection父接口
2.使用迭代器遍历集合
List接口与实现类
1.列表迭代器
2.List接口实现类
泛型和工具类
⚠️注意
1.泛型类
2.泛型接口
3.泛型方法
4.泛型集合
Set接口与实现类
1.Hashset
2.TreeSet
3.Comparator接口
Map接口与实现类
1.Map父接口
2.HashMap
3.TreeMap
4.Collections工具类
集合的概念
对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。
和数组的区别：
-
数组长度固定，集合长度不固定
-
数组可以存储基本类型和引用类型，集合只能存储引用类型。
Collection接口
1.Collection父接口
-
特点：代表一组任意类型的对象，无序、无下标、不能重复
-
方法：
-
boolean add(Object obj)：添加一个对象
-
boolean addAll(Collection c)：将一个集合中的所有对象添加到此集合中
-
void Clear()：清空此集合中所有对象
-
boolean contains(Object o)：检查此集合中是否有o对象
-
boolean equals(Object o)：比较此集合中是否与指定对象相等
-
boolean isEmpty()：判断此集合是否为空
-
boolean remove(Object o)：在此集合中移除o对象
-
int size()：返回集合中的元素个数
-
Object [] toArray()：将此集合转换成数组
-
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo01 {
//Collection接口的使用
//1.添加元素
//2.删除元素
//3.遍历元素
//4.判断
public static void main(String[] args) {
//创建集合
Collection conllection=new ArrayList();
//添加元素
conllection.add("apple");
conllection.add("orange");
conllection.add("banana");
System.out.println("元素个数"+conllection.size());
System.out.println(conllection);
//删除元素
conllection.remove("apple");
System.out.println(conllection);
//遍历元素[重点]
//使用增强for遍历集合（增强for不需要下标）
for(Object obj:conllection){
System.out.println(obj);
}
//使用迭代器（专门用来迭代集合或遍历集合的方法）
Iterator it=conllection.iterator();
while(it.hasNext()){
String object=(String)it.next();
System.out.println(object);
//不能使用collection删除方法，会报并发错误
//it.remove();
}
System.out.println(conllection.size());
//判断
System.out.println(conllection.contains("apple"));
System.out.println(conllection.isEmpty());
}
}
/*
输出结果：
元素个数3
[apple, orange, banana]
[orange, banana]
orange
banana
orange
banana
2
false
false
*/
2.使用迭代器遍历集合
Iterator有三个方法用于遍历集合
-
hasNext()：判断有没有下一个元素
-
next()：获取下一个元素
-
remove()：删除当前元素
import javax.swing.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo02 {
public static void main(String[] args) {
//新建一个Collection对象
Collection collection=new ArrayList();
Student stu1=new Student("tom",21);
Student stu2=new Student("jerry",17);
Student stu3=new Student("young",20);
//1添加学生数据
collection.add(stu1);
collection.add(stu2);
collection.add(stu3);
collection.add(stu3);
System.out.println(collection.toString());
//2删除
collection.remove(stu2);
System.out.println(collection.toString());
//3遍历
//1增强for
for(Object obj:collection){
Student s=(Student)obj;
System.out.println(s.toString());
}
//2迭代器
Iterator it=collection.iterator();
while(it.hasNext()){
Student s2=(Student)it.next();
System.out.println(s2.toString());
}
}
}
/*
输出结果：
[Student[name=tom,age=21], Student[name=jerry,age=17], Student[name=young,age=20], Student[name=young,age=20]]
[Student[name=tom,age=21], Student[name=young,age=20], Student[name=young,age=20]]
Student[name=tom,age=21]
Student[name=young,age=20]
Student[name=young,age=20]
Student[name=tom,age=21]
Student[name=young,age=20]
Student[name=young,age=20]
*/
List接口与实现类
-
特点：有序、有下标、元素可以重复。
-
方法
-
void add(int index,Object o)：在index位置上插入对象o
-
boolean addAll(int index,Collection c)：将一个集合中的全部元素添加到此集合中的index位置上
-
Object get(int index)：返回集合中指定位置的元素
-
List subList(int fromIndex,int tIndex)：返回fromIndex和toIndex之间的元素。
-
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class Demo03 {
//List自接口的使用
public static void main(String[] args) {
List list=new ArrayList<>();
//1.添加集合元素
list.add("apple");
list.add("huawei");
list.add("oppo");
list.add("oppo");
list.add("oppo");
System.out.println(list.size());
System.out.println(list.toString());
//2.删除
list.remove("oppo");
list.remove(1);
System.out.println(list.toString());
//3.遍历【重点】
//3.1for遍历
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
//3.2增强for
for(Object obj:list){
System.out.println(obj);
}
//3.3迭代器
Iterator it=list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//3.4使用列表迭代器
ListIterator lit=list.listIterator();
while(lit.hasNext()){
//从前往后
System.out.println(lit.nextIndex());
System.out.println(lit.next());
}
//从后往前遍历
while(lit.hasPrevious()){
System.out.println(lit.previousIndex());
System.out.println(lit.previous());
}
//4判断
System.out.println(list.contains("oppo"));
System.out.println(list.isEmpty());
//5获取位置
System.out.println(list.indexOf("apple"));
}
}
/*
输出结果：
5
[apple, huawei, oppo, oppo, oppo]
[apple, oppo, oppo]
apple
oppo
oppo
apple
oppo
oppo
apple
oppo
oppo
0
apple
1
oppo
2
oppo
2
oppo
1
oppo
0
apple
true
false
0
*/
1.列表迭代器
-
列表迭代器可以向前向后任意方向遍历。
-
还可以添加、删除、修改元素。
import java.util.ArrayList;
import java.util.List;
public class Demo04 {
public static void main(String[] args) {
List list=new ArrayList();
//1.集合不能保存数字类型，在添加数字类型的时候会自动进行一个操作，自动装箱
list.add(10);
list.add(20);
list.add(30);
list.add(40);
list.add(50);
System.out.println(list.toString());
//2.删除操作
list.remove(new Integer(20));
System.out.println(list.toString());
//3补充方法sublist,含头部含尾
List sublist=list.subList(0,2);
System.out.println(sublist.toString());
}
}
/*
输出结果：
[10, 20, 30, 40, 50]
[10, 30, 40, 50]
[10, 30]
*/
2.List接口实现类
ArrayList
-
ArrayList【重点】
-
数组结构实现，查询快，增删慢；
-
JDK1.2版本，运行效率快，线程不安全；
-
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class Demo05 {
public static void main(String[] args) {
ArrayList al=new ArrayList();
//1.添加元素
Student s1=new Student("a",10);
Student s2=new Student("b",20);
Student s3=new Student("c",30);
al.add(s1);
al.add(s2);
al.add(s3);
System.out.println(al.size());
System.out.println(al.toString());
//2.删除元素
al.remove(new Student("a",10));//重写equals方法
System.out.println(al.size());
//3.遍历元素【重点】
//3.1迭代器
Iterator it=al.iterator();
while(it.hasNext()){
Student s=(Student)it.next();
System.out.println(s.toString());
}
//3.2列表迭代器
ListIterator lit=al.listIterator();
while(lit.hasNext()){
Student s=(Student)lit.next();
System.out.println(s.toString());
}
while (lit.hasPrevious()){
Student s=(Student)lit.previous();
System.out.println(s.toString());
}
//4.判断
System.out.println(al.contains(new Student("b",20)));
System.out.println(al.isEmpty());
//5.查找
System.out.println(al.indexOf(new Student("b",20)));
}
}
/*
输出结果：
3
[Student[name=a,age=10], Student[name=b,age=20], Student[name=c,age=30]]
2
Student[name=b,age=20]
Student[name=c,age=30]
Student[name=b,age=20]
Student[name=c,age=30]
Student[name=c,age=30]
Student[name=b,age=20]
true
false
0
-1
*/
Vector
-
Vector
-
数组结构实现，查询快、增删慢；
-
JDK1.0版本，运行效率慢、线程安全
-
import java.util.Enumeration;
import java.util.Vector;
public class Demo06 {
public static void main(String[] args) {
//创建集合
Vector vec = new Vector();
vec.add("草莓");
vec.add("苹果");
vec.add("香蕉");
System.out.println(vec.size());
//遍历
//枚举器
Enumeration en=vec.elements();
while(en.hasMoreElements()){
Object obj=en.nextElement();
System.out.println(obj);
}
//判断
System.out.println(vec.contains("西瓜"));
//其他方法
}
}
/*
输出结果：
3
草莓
苹果
香蕉
false
*/
LinkedList
-
LinkedList
-
链表结构实现，增删快、查询慢。
-
import java.util.Iterator;
import java.util.LinkedList;
public class Demo07 {
public static void main(String[] args) {
//创建对象
LinkedList ll=new LinkedList();
Student s1=new Student("a",10);
Student s2=new Student("b",20);
Student s3=new Student("c",30);
Student s4=new Student("c",30);
//添加
ll.add(s1);
ll.add(s2);
ll.add(s3);
System.out.println(ll.size());
System.out.println(ll.toString());
//删除
ll.remove(new Student("a",10));
System.out.println(ll.size());
//遍历
//for
for(int i=0;i<ll.size();i++){
System.out.println(ll.get(i));
}
//增强for
for(Object o:ll){
Student stu = (Student) o;
System.out.println(stu);
}
//迭代器
Iterator it=ll.iterator();
while(it.hasNext()){
Student s= (Student) it.next();
System.out.println(s.toString());
}
//判断
//获取
System.out.println(ll.indexOf(s2));
}
}
/*
输出结果：
3
[Student[name=a,age=10], Student[name=b,age=20], Student[name=c,age=30]]
2
Student[name=b,age=20]
Student[name=c,age=30]
Student[name=b,age=20]
Student[name=c,age=30]
Student[name=b,age=20]
Student[name=c,age=30]
0
*/
泛型和工具类
-
Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
-
常见形式有泛型类、泛型接口、泛型方法。
-
语法：<T,...>T称为类型占位符，表是一种引用类型。
-
好处：
-
提高代码的重用性
-
防止类型转化异常，提高代码的安全性
-
⚠️注意
-
泛型只能是引用类型。
-
不同泛型类型对象之间不能相互复制。
1.泛型类
//创建一个泛型类
//泛型类
public class MyGeneric<T> {
//使用泛型T
//1.0创建变量
T t;
//2.0作为方法的参数
public void show(T t){
System.out.println(t);
}
//泛型作为方法的返回值
public T getT(){
return t;
}
}
public class Demo08 {
public static void main(String[] args) {
//使用泛型类创建对象
MyGeneric<String> mg=new MyGeneric<>();
mg.t="hello";
mg.show("你好");
String s=mg.getT();
System.out.println(s.toString());
MyGeneric<Integer> mg2=new MyGeneric<>();
mg2.t=20;
mg2.show(30);
}
}
/*
输出结果：
你好
hello
30
*/
2.泛型接口
1.先创建一个泛型接口
//泛型接口
public interface MyInterface<T> {
String name="张三";
public T server(T t);
}
2.在创建一个接口实现类
可以在实现类中确定泛型类型
public class MyInterfaceImp implements MyInterface<String> {
@Override
public String server(String s) {
System.out.println(s);
return s;
}
}
也可以不确定，继续创建一个泛型类
public class MyInterfaceImp2<T> implements MyInterface<T> {
@Override
public T server(T t) {
System.out.println(t);
return t;
}
}
最终实现类里面，分别用两种类创建对象，发现他们的不同
public class Test {
public static void main(String[] args) {
MyInterfaceImp imp1=new MyInterfaceImp();
imp1.server("xxxxxx");
MyInterfaceImp2<String> imp2= new MyInterfaceImp2<>();
imp2.server("aaaaaa");
}
}
/*
输出结果：
xxxxxx
aaaaaa
*/
3.泛型方法
public class MyGenericMethod {
//泛型方法
public <T> T show(T t){
System.out.println("泛型方法"+t);
return t;
}
}
public class Test {
public static void main(String[] args) {
MyGenericMethod mm=new MyGenericMethod();
mm.show("中国加油");
mm.show(200);
mm.show(3.14);
}
}
/*
输出结果：
泛型方法中国加油
泛型方法200
泛型方法3.14
*/
4.泛型集合
-
概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致。
-
特点：
-
编译时即可检查，而非运行时抛出的异常。
-
访问时，不必类型转换（拆箱）。
-
不同泛型之间引用不能相互转换，泛型不存在多态。
-
public class Demo09 {
public static void main(String[] args) {
ArrayList<String> al=new ArrayList<>();
al.add("xxx");
al.add("yyy");
// al.add(10);
//al.add(20);
for(String o:al){
System.out.println(o);
}
ArrayList<Student> al2=new ArrayList<>();
Student s1=new Student("a",1);
Student s2=new Student("b",2);
Student s3=new Student("c",3);
al2.add(new Student("c",4));
al2.add(s1);
al2.add(s2);
al2.add(s3);
Iterator<Student> it= al2.iterator();
while(it.hasNext()){
Student s=it.next();
System.out.println(s.toString());
}
}
}
/*
输出结果：
xxx
yyy
Student[name=c,age=4]
Student[name=a,age=1]
Student[name=b,age=2]
Student[name=c,age=3]
*/
Set接口与实现类
-
特点：无序、无下标、元素不可重复。
-
方法：全部继承于Collection接口
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Demo01 {
public static void main(String[] args) {
Set<String> set=new HashSet<>();
//1.添加数据
set.add("苹果");
set.add("华为");
set.add("小米");
System.out.println("数据个数"+set.size());
System.out.println(set.toString());
//2.删除
//set.remove("小米");
//3.遍历【重点】
//1.增强for
for(String str:set){
System.out.println(str);
}
//2.迭代器遍历
Iterator<String> it=set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//4.判断
System.out.println(set.contains("华为"));
System.out.println(set.isEmpty());
}
}
/*
输出结果：
数据个数3
[苹果, 华为, 小米]
苹果
华为
小米
苹果
华为
小米
true
false
*/
1.Hashset
-
基于HashCode实现元素不重复
-
当存入元素的哈希码相同时，会调用equals进行确认，如果是true，则拒绝存入后者。
import java.util.HashSet;
import java.util.Iterator;
public class Demo02 {
public static void main(String[] args) {
//演示hashset集合的使用
//哈希表（数组+链表）
HashSet<String> hs=new HashSet<>();
hs.add("刘德华");
hs.add("梁朝伟");
hs.add("林志颖");
hs.add("周润发");
//hs.add("周润发");
System.out.println(hs.size());
System.out.println(hs.toString());
hs.remove("刘德华");
System.out.println(hs.toString());
for(String str:hs){
System.out.println(str);
}
Iterator<String> it=hs.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println(hs.contains("郭富城"));
System.out.println(hs.isEmpty());
}
}
/*
输出结果：
4
[梁朝伟, 林志颖, 周润发, 刘德华]
[梁朝伟, 林志颖, 周润发]
梁朝伟
林志颖
周润发
梁朝伟
林志颖
周润发
false
false
*/
import java.util.HashSet;
import java.util.Iterator;
public class Demo03 {
public static void main(String[] args) {
HashSet<Person> hs=new HashSet<>();
Person p1=new Person("刘德华",20);
Person p2=new Person("李沐阳",30);
Person p3=new Person("周润发",40);
Person p4=new Person("王茜",50);
hs.add(p1);
hs.add(p2);
hs.add(p3);
hs.add(p4);
System.out.println(hs.size());
System.out.println(hs.toString());
hs.add(new Person("王茜",50));//重写hashcode和equals方法
hs.remove(p1);
System.out.println(hs.toString());
for(Person per:hs){
System.out.println(per);
}
Iterator<Person> it=hs.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println(hs.contains(p1));
}
}
/*
4
[Student[name=周润发,age=40], Student[name=刘德华,age=20], Student[name=王茜,age=50], Student[name=李沐阳,age=30]]
[Student[name=周润发,age=40], Student[name=王茜,age=50], Student[name=李沐阳,age=30]]
Student[name=周润发,age=40]
Student[name=王茜,age=50]
Student[name=李沐阳,age=30]
Student[name=周润发,age=40]
Student[name=王茜,age=50]
Student[name=李沐阳,age=30]
false
*/
⚠️为了避免添加重复的元素，Person类中需要重写equals方法和hashcode方法
@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);
}
2.TreeSet
-
基于排列顺序实现元素不重复。
-
实现了SortedSet接口，对集合元素自动排序。
-
元素对象的类型必须实现Comparable接口，指定排序规则。
-
通过CompareTo方法确定是否为重复元素。
import java.util.Iterator;
import java.util.TreeSet;
public class Demo04 {
public static void main(String[] args) {
//treeset的使用
TreeSet<String> ts = new TreeSet<>();
//添加元素
ts.add("good");
ts.add("bonjour");
ts.add("hello");
ts.add("hi");
System.out.println("元素个数" + ts.size());
System.out.println(ts.toString());
//添加重复元素
ts.add("hi");
System.out.println(ts.size());//失败
//删除
ts.remove("hi");
System.out.println(ts.toString());
//遍历
for (String str : ts) {
System.out.println(str);
}
Iterator<String> it=ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
/*
输出结果:
元素个数4
[bonjour, good, hello, hi]
4
[bonjour, good, hello]
bonjour
good
hello
bonjour
good
hello
*/
import java.util.Iterator;
import java.util.TreeSet;
public class Demo05 {
public static void main(String[] args) {
TreeSet<Person> ts=new TreeSet<>();
Person p1=new Person("李沐阳",21);
Person p2=new Person("王茜",23);
Person p3=new Person("李鑫文",19);
Person p4=new Person("大哥",20);
Person p5=new Person("大哥",20);
//添加
ts.add(p1);
ts.add(p2);
ts.add(p3);
ts.add(p4);
System.out.println("人数"+ts.size());
System.out.println(ts.toString());
ts.remove(new Person("大哥",20));
System.out.println(ts.size());
//遍历
for(Person per:ts){
System.out.println(per);
}
Iterator<Person> it=ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
/*
输出结果：
人数4
[Student[name=大哥,age=20], Student[name=李沐阳,age=21], Student[name=李鑫文,age=19], Student[name=王茜,age=23]]
3
Student[name=李沐阳,age=21]
Student[name=李鑫文,age=19]
Student[name=王茜,age=23]
Student[name=李沐阳,age=21]
Student[name=李鑫文,age=19]
Student[name=王茜,age=23]
*/
⚠️：需要实现Comparable接口
因此在Person类中必须实现接口且重写CompareTo方法
@Override
public int compareTo(Object o) {
Person p=(Person) o;
int n1=this.getName().compareTo(p.getName());
int n2=this.age-p.getAge();
return n1==0?n2:n1;
}
3.Comparator接口
-
Comparale：可比较
-
Comparator：实现定制比较（比较器）
import java.util.Comparator;
import java.util.TreeSet;
public class Demo06 {
public static void main(String[] args) {
TreeSet<Person> ts=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("李沐阳",21);
Person p2=new Person("王茜",23);
Person p3=new Person("李鑫文",19);
Person p4=new Person("大哥",20);
Person p5=new Person("大哥",20);
ts.add(p1);
ts.add(p2);
ts.add(p3);
ts.add(p4);
ts.add(p5);
System.out.println(ts.size());
System.out.println(ts.toString());
}
}
/*
输出结果：
4
[Student[name=李鑫文,age=19], Student[name=大哥,age=20], Student[name=李沐阳,age=21], Student[name=王茜,age=23]]
*/
案例（定制按长度比较）
import java.util.Comparator;
import java.util.TreeSet;
public class Demo07 {
public static void main(String[] args) {
TreeSet<String> ts=new TreeSet<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
int n1=o1.length()-o2.length();
int n2=o2.compareTo(o2);
return n1==0?n2:n1;
}
});
ts.add("helloworld");
ts.add("iphone");
ts.add("beijing");
ts.add("tomcat");
ts.add("xian");
ts.add("changsha");
ts.add("wuxi");
for(String str:ts){
System.out.println(str);
}
}
}
/*
输出结果：
xian
iphone
beijing
changsha
helloworld
*/
Map接口与实现类
特点：
-
用于存储任意键值对（Key-Value）
-
键：无序、无下标、不允许重复（唯一）
-
值：无序、无下标、允许重复
1.Map父接口
-
特点：存储一对数据（Key- Value），无序、无下标、键不可以重复、值可以重复。
-
方法：
-
V put(K key,V value)//将对象存入集合中，关联键值。key重复则覆盖原值。
-
Object get(Object key)//根据键获取对应的值。
-
Set<K>//返回所有key。
-
Collection<V> values()//返回包含所有值的Collection集合。
-
Set<Map.Entry<K.V>>//键值匹配的Set集合。
-
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo01 {
public static void main(String[] args) {
Map<String,String> map=new HashMap<>();
//添加元素
map.put("cn","中国");
map.put("uk","英国");
map.put("usa","美国");
System.out.println(map.size());
System.out.println(map.toString());
//删除元素
map.remove("usa");
System.out.println(map.size());
//遍历元素
//1:keySet()
Set<String> ks=map.keySet();
for(String str:ks){
System.out.println(str+"="+map.get(str));
}
//2.使用entryset()
Set<Map.Entry<String,String>> mn=map.entrySet();
for(Map.Entry<String,String> entry:mn){
System.out.println(entry.getKey()+entry.getValue());
}
}
}
/*
输出结果：
3
{usa=美国, uk=英国, cn=中国}
2
uk=英国
cn=中国
uk英国
cn中国
*/
2.HashMap
-
JDK1.2版本，线程不安全，运行效率快，允许用null 作为key或者value。
-
Hashtable:JDK1.0版本，线程安全，运行效率慢；不允许null作为key或是value
package jihe3;
import java.util.HashMap;
import java.util.Map;
HashMap的使用；存储结构：（数组+链表+红黑树）
public class Demo02 {
public static void main(String[] args) {
//创建集合
HashMap<Student,String> student=new HashMap<>();
//添加元素
Student s1=new Student(100,"孙悟空");
Student s2=new Student(1200,"沙悟净");
Student s3=new Student(1300,"猪八戒");
student.put(s1,"北京");
student.put(s2,"上海");
student.put(s3,"南京");
student.put(s3,"广州");
student.put(new Student(1300,"猪八戒"),"广州");//重写hashcode和equals方法
System.out.println("元素个数"+student.size());
System.out.println(student.toString());
//删除
student.remove(s1);
System.out.println("删除之后"+student.size());
//3.1增强for遍历
for(Student stu:student.keySet()){
System.out.println(stu.toString()+"========"+student.get(stu));
}
//3.2entrySet()
for(Map.Entry<Student,String> entry:student.entrySet()){
System.out.println(entry.getKey()+"======="+entry.getValue());
}
//判断
System.out.println(student.containsKey(s1));
System.out.println(student.containsValue("南京"));
}
}
/*
输出结果：
元素个数3
{Student{age=100, name='孙悟空'}=北京, Student{age=1300, name='猪八戒'}=广州, Student{age=1200, name='沙悟净'}=上海}
删除之后2
Student{age=1300, name='猪八戒'}========广州
Student{age=1200, name='沙悟净'}========上海
Student{age=1300, name='猪八戒'}=======广州
Student{age=1200, name='沙悟净'}=======上海
false
false
*/
3.TreeMap
-
实现了SortedMap接口（是Map的子接口），可以对key自动排序。
package jihe3;
import OOP.Demo17.Stu;
import java.util.Map;
import java.util.TreeMap;
public class Demo03 {
public static void main(String[] args) {
TreeMap<Student,String> tm=new TreeMap<>();
Student s1=new Student(100,"孙悟空");
Student s2=new Student(1200,"沙悟净");
Student s3=new Student(1300,"猪八戒");
tm.put(s1,"北京");
tm.put(s2,"上海");
tm.put(s3,"深圳");
tm.put(new Student(1300,"猪八戒"),"深圳");
System.out.println(tm.size());
System.out.println(tm.toString());
for(Student key:tm.keySet()){
System.out.println(key+"========"+tm.get(key));
}
for (Map.Entry<Student,String> entry:tm.entrySet()){
System.out.println(entry.getKey()+"======="+entry.getValue());
}
}
}
/*
输出结果：
3
{Student{age=100, name='孙悟空'}=北京, Student{age=1200, name='沙悟净'}=上海, Student{age=1300, name='猪八戒'}=深圳}
Student{age=100, name='孙悟空'}========北京
Student{age=1200, name='沙悟净'}========上海
Student{age=1300, name='猪八戒'}========深圳
Student{age=100, name='孙悟空'}=======北京
Student{age=1200, name='沙悟净'}=======上海
Student{age=1300, name='猪八戒'}=======深圳
*/
4.Collections工具类
概念：集合工具类，定义了除了存取以外的集合常用方法
-
方法：
-
public static void reverse(List<?> list)//反转集合中元素的顺序
-
public static void shuffle(List<?> list)//随机重置元素的顺序
-
public static void sort()List<?> list//升序排序（元素必须实现Comparable接口）
-
package jihe3;
import java.util.*;
public class Demo04 {
public static void main(String[] args) {
List<Integer> list=new ArrayList<>();
list.add(20);
list.add(30);
list.add(40);
list.add(50);
list.add(60);
//sort排序
System.out.println("排序前"+list.toString());
Collections.sort(list);
System.out.println("排序后"+list.toString());
//binarySearch查询
int i=Collections.binarySearch(list,50);
System.out.println(i);
//copy复制
List<Integer> list2=new ArrayList<>();
for (int j=0;j<list.size();j++){
list2.add(0);
}
Collections.copy(list2,list);
System.out.println(list2.toString());
//reverse反转
Collections.reverse(list);
System.out.println("反转后"+list.toString());
//shuffle打乱
Collections.shuffle(list);
System.out.println("打乱后"+list.toString());
//补充，list转为数组
Integer[] arr=list.toArray(new Integer[0]);
System.out.println(arr.length);
System.out.println(Arrays.toString(arr));
//数组转为集合
String[] name={"张三","李四","王武"};
List<String> list3=Arrays.asList(name);//集合是一个受限集合，不能添加和删除
//基本类型转集合时，要把它写成包装类
System.out.println(list3.toString());
}
}
/*
输出结果：
排序前[20, 30, 40, 50, 60]
排序后[20, 30, 40, 50, 60]
3
[20, 30, 40, 50, 60]
反转后[60, 50, 40, 30, 20]
打乱后[30, 40, 20, 50, 60]
5
[30, 40, 20, 50, 60]
[张三, 李四, 王武]
*/
这篇关于Java集合框架的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-11-27消息中间件底层原理资料详解
- 2024-11-27RocketMQ底层原理资料详解：新手入门教程
- 2024-11-27MQ底层原理资料详解：新手入门教程
- 2024-11-27MQ项目开发资料入门教程
- 2024-11-27RocketMQ源码资料详解：新手入门教程
- 2024-11-27本地多文件上传简易教程
- 2024-11-26消息中间件源码剖析教程
- 2024-11-26JAVA语音识别项目资料的收集与应用
- 2024-11-26Java语音识别项目资料：入门级教程与实战指南
- 2024-11-26SpringAI：Java 开发的智能新利器
