java基础--容器（09）

2401_89707442

1939人浏览 · 2025-10-03 19:50:17

2401_89707442 · 2025-10-03 19:50:17 发布

一，泛型

参数化类型，把类型当做是参数一样传递。<数据类型>只能是引用类型

1.泛型的好处

代码可读性更好【不用强制转换】

程序更加安全【只要编译时期没有警告，运行时期就不会出现ClassCastException异常】

2.泛型类

01泛型标记

02泛型类的使用

public class 类名<泛型标识符号> {
 }
 public class 类名<泛型标识符号,泛型标识符号> {
 }

public class Generic<T> {
 private T  flag;
 public void setFlag(T flag){
 this.flag = flag;
    }
 public T getFlag(){
 return this.flag;
    }
 }

 public class Test {
 public static void main(String[] args) {
 //创建对象时，指定泛型具体类型。
Generic<String> generic = new 
Generic<>();
 generic.setFlag("admin");
 String flag = generic.getFlag();
 System.out.println(flag);
 15
 //创建对象时，指定泛型具体类型。
Generic<Integer> generic1 = new 
Generic<>();
 generic1.setFlag(100);
 Integer flag1 = generic1.getFlag();
 System.out.println(flag1);
    }
 }

3.泛型接口

public interface IGeneric<T> {
 T getName(T name);
 }

public interface IGeneric<T> {
 T getName(T name);
 }

//在实现接口时传递具体数据类型
public class IgenericImpl implements 
Igeneric<String> {
 @Override
 public String getName(String name) {
 return name;
    }
 }
 //在实现接口时仍然使用泛型作为数据类型
public class IGenericImpl2<T> implements 
IGeneric<T>{
 @Override
 public T getName(T name) {
 return name;
    }

public class Test {
 public static void main(String[] args) {
 IGeneric<String> igeneric= new 
IGenericImpl();
 String name = 
igeneric.getName("oldlu");
 System.out.println(name);
 11
 IGeneric<String> igeneric1 = new 
IGenericImpl2<>();
 String name1 = 
igeneric1.getName("itbz");
 System.out.println(name1);
    }
 }

4泛型方法

1.非静态方法

 //无返回值方法
public <泛型标识符号> void getName(泛型标识符号 
name){
 }
 //有返回值方法
public <泛型标识符号> 泛型标识符号 getName(泛型标
识符号 name){
 }

public class MethodGeneric {
 public <T> void setName(T name){
 System.out.println(name);
    }
 public <T> T getAge(T age){
 return age;
    }
 }

public class Test2 {
 public static void main(String[] args) {
 MethodGeneric methodGeneric = new 
MethodGeneric();
 methodGeneric.setName("oldlu");
 Integer age = 
methodGeneric.getAge(123);
 System.out.println(age);

2.静态方法

 //无返回值静态方法
public static <泛型标识符号> void setName(泛型标
识符号 name){
 }
 //有返回值静态方法
public static <泛型标识符号> 泛型表示符号 
getName(泛型标识符号 name){
 }

public class MethodGeneric {
 public static <T> void setFlag(T flag){
 System.out.println(flag);
    }
 }
 public static <T> T getFlag(T flag){
 return flag;
    }

public class Test4 {
 public static void main(String[] args) {
 MethodGeneric.setFlag("oldlu");
 Integer flag1 = 
MethodGeneric.getFlag(123123);
 System.out.println(flag1);
    }
 }

3.泛型方法与可变参数

public <泛型标识符号> void showMsg(泛型标识符
号... agrs){
 }

public class MethodGeneric {
 public <T> void method(T...args){
 for(T t:args){
 System.out.println(t);
        }
    }
 }

public class Test5 {
 public static void main(String[] args) {
 MethodGeneric methodGeneric = new 
MethodGeneric();
 String[] arr = new String[]
 {"a","b","c"};
 Integer[] arr2 = new Integer[]
 {1,2,3};
 methodGeneric.method(arr);
 methodGeneric.method(arr2);
    }
 }

5.泛型中的通配符

1.无界通配符

“?”表示类型通配符，用于代替具体的类型。它只能在“<>”中使用。可以解决当具体类型不确定的问题。

 public void showFlag(Generic<?> generic){
 }

 public class Generic<T> {
 private T  flag;
 public void setFlag(T flag){
 this.flag = flag;
    }
 public T getFlag(){
 return this.flag;
    }
 }

 public class ShowMsg {
 public void showFlag(Generic<?> generic){
 }
 System.out.println(generic.getFlag());
    }

 public class Test3 {
 public static void main(String[] args) {
 ShowMsg showMsg = new ShowMsg();
 Generic<Integer> generic = new 
Generic<>();
 generic.setFlag(20);
 showMsg.showFlag(generic);
 Generic<Number> generic1 = new 
Generic<>();
 generic1.setFlag(50);
 showMsg.showFlag(generic1);
 16
 Generic<String> generic2 = new 
Generic<>();
 generic2.setFlag("oldlu");
 showMsg.showFlag(generic2);
    }
 }

2.通配符上下限限定

上限

对通配符的上限的限定：：<? exteds 类型>

？实际类型可以是上限限定中所约定的类型，也可以是约定类型的子类型；

 public void showFlag(Generic<? extends 
Number> generic){
 }

public class ShowMsg {
 public void showFlag(Generic<? extends 
Number> generic){
 }
 System.out.println(generic.getFlag());
    }

public class Test4 {
 public static void main(String[] args) {
 ShowMsg showMsg = new ShowMsg();
 Generic<Integer> generic = new 
Generic<>();
 generic.setFlag(20);
 showMsg.showFlag(generic);
 Generic<Number> generic1 = new 
Generic<>();
 generic1.setFlag(50);
 showMsg.showFlag(generic1);
    }
 }

下限

对通配符的下限的限定：<? super 类型>

public void showFlag(Generic<? super Integer> 
generic){
 }

 public class ShowMsg {
 public void showFlag(Generic<? super 
Integer> generic){
 }
 System.out.println(generic.getFlag());

 public class Test6 {
 public static void main(String[] args) {
 ShowMsg showMsg = new ShowMsg();
 Generic<Integer> generic = new 
Generic<>();
 generic.setFlag(20);
 showMsg.showFlag(generic);
 12
 Generic<Number> generic1 = new 
Generic<>();
 generic1.setFlag(50);
 showMsg.showFlag(generic1);
    }
 }

6.泛型局限性和常见错误

1.基本类型不能用于泛型

2.不能通过类型参数创建对象

T elm = new T(); 运行时类型参数T会被替换成型的对象，容易引起误解，java干脆禁止这种写法。

二。容器或集合

结构图

单例集合

双例集合

1.单例集合

1.Collection接口中定义的方法

2.List接口

01.List接口特点

List是有序、可重复的容器。

02.List接口中的常用方法

03.ArrayList容器

特点：查询效率高，增删效率低，线程不安全

001。基本使用

public class ArrayListTest {
 public static void main(String[] args) {
 //实例化ArrayList容器
List<String> list  = new ArrayList<>
 ();
 //添加元素
boolean flag1 = list.add("oldlu");
 boolean flag2 = list.add("itbz");
 boolean flag3 = list.add("sxt");
 boolean flag4 = list.add("sxt");
 System.out.println(flag1+"\t"+flag2+"\t"+fl
 ag3+"\t"+flag4);
 //删除元素
boolean flag4 = 
list.remove("oldlu");
 System.out.println(flag4);
 //获取容器中元素的个数
int size = list.size();
 System.out.println(size);
 //判断容器是否为空
boolean empty = list.isEmpty();
 System.out.println(empty);
 //容器中是否包含指定的元素
boolean value = 
list.contains("itbz");
 System.out.println(value);
 //清空容器
list.clear();
 Object[] objects1 = list.toArray();
 System.out.println(Arrays.toString(objects1
 ));
    }
 }

002.索引操作


 public class ArrayListTest2 {
 public static void main(String[] args) {
 //实例化容器
List<String> list = new ArrayList<>
 ();
 //添加元素
list.add("oldlu");
 list.add("itbz");
 //向指定位置添加元素
list.add(0,"sxt");
 System.out.println("获取元素");
 String value1 = list.get(0);
 System.out.println(value1);
 System.out.println("获取所有元素方式
一");
二");
 //使用普通for循环
for(int i=0;i<list.size();i++){
 System.out.println(list.get(i));
        }
 System.out.println("获取所有元素方式
//使用Foreach循环
for(String str:list){
 System.out.println(str);
        }
 System.out.println("元素替换");
 list.set(1,"kevin");
 for(String str:list){
 System.out.println(str);
        }
 System.out.println("根据索引位置删除元
素);
 ");
位置");
的位置");
 String value2 = list.remove(1);
 System.out.println(value2);
 System.out.println("---------------
for(String str:list){
 System.out.println(str);
        }
 System.out.println("查找元素第一次出现的
int value3 = list.indexOf("sxt");
 System.out.println(value3);
 System.out.println("查找元素最后一次出现
list.add("sxt");
 for(String str:list){
 System.out.println(str);
        }
 int value4 = 
list.lastIndexOf("sxt");
 System.out.println(value4);
    }
 }

003.并集，交集，差集

并集

//并集操作：将另一个容器中的元素添加到当前
List<String> a  = new ArrayList<>();
 a.add("a");
 a.add("b");
 a.add("c");
 List<String> b = new ArrayList<>();
 b.add("a");
 b.add("b");
 b.add("c");
 //a并集b
 a.addAll(b);
 for(String str :a){
 System.out.println(str);
        }

交集

 //交集操作：保留相同的，删除不同的
List<String> a1  = new ArrayList<>
 ();
 a1.add("a");
 a1.add("b");
 a1.add("c");
 List<String> b1 = new ArrayList<>();
 b1.add("a");
 b1.add("d");
 b1.add("e");
 //交集操作
a1.retainAll(b1);
 for(String str :a1){
 System.out.println(str);

        }

差集

//差集操作：保留不同的，删除相同的
List<String> a2  = new ArrayList<>
 ();
 a2.add("a");
 a2.add("b");
 a2.add("c");
 List<String> b2= new ArrayList<>();
 b2.add("b");
 b2.add("c");
 b2.add("d");
 a2.removeAll(b2);
 for(String str :a2){
 System.out.println(str);
        }

04.LinkedList容器

特点：查询效率低，增删效率高，线程不安全

双向链表也叫双链表，是链表的一种，它的每个数据节点中都有两个指针，分别指向前一个节点和后一个节点。所以，从双向链表中的任意一个节点开始，都可以很方便地找到所有节点。

每个节点都应该有3部分内容：

class  Node<E> {
    Node<E>  previous;    
    E  element; 
    Node<E> next;         
}
         
//前一个节点
//本节点保存的数据
//后一个节点

001List标准

 public class LinkedListTest {
 public static void main(String[] args) {
 //实例化LinkedList容器
List<String> list = new LinkedList<>
 ();
 //添加元素
boolean a = list.add("a");
 boolean b = list.add("b");
 boolean c = list.add("c");
 list.add(3,"a");
 System.out.println(a+"\t"+b+"\t"+c);
 for(int i=0;i<list.size();i++){
 System.out.println(list.get(i));
        }
    }
 }

002非List标准

 public class LinkedListTest2 {
 public static void main(String[] args) {
 System.out.println("------
LinkedList-------------");
 //将指定元素插入到链表开头
LinkedList<String> linkedList1 = new 
LinkedList<>();
 linkedList1.addFirst("a");
 linkedList1.addFirst("b");
 linkedList1.addFirst("c");
 for (String str:linkedList1){
 System.out.println(str);
        }
 System.out.println("----------------------");
 //将指定元素插入到链表结尾
LinkedList<String> linkedList = new 
LinkedList<>();
 linkedList.addLast("a");
 linkedList.addLast("b");
 linkedList.addLast("c");
 for (String str:linkedList){
 System.out.println(str);
        }
 System.out.println("---------------------------");
 //返回此链表的第一个元素
System.out.println(linkedList.getFirst());
 //返回此链表的最后一个元素
System.out.println(linkedList.getLast());
 System.out.println("-----------------------");
 //移除此链表中的第一个元素，并返回这个元素
linkedList.removeFirst();
 //移除此链表中的最后一个元素，并返回这个元
素
 linkedList.removeLast();
 for (String str:linkedList){
 System.out.println(str);
        }
 System.out.println("-----------------------");
 linkedList.addLast("c");
 //从此链表所表示的堆栈处弹出一个元素,等效于
removeFirst
 linkedList.pop();
 for (String str:linkedList){
 System.out.println(str);
        }
 System.out.println("-------------------");
 //将元素推入此链表所表示的堆栈  这个等效于
addFisrt(E e)
 linkedList.push("h");
 for (String str:linkedList){
 System.out.println(str);
        }
    }
 }

3.set接口

01.set接口特点

无序，不可重复

02.HashSet容器

001.基本方法

public class HashSetTest {
 public static void main(String[] args) {
 //实例化HashSet
 Set<String> set = new HashSet<>();
 //添加元素
set.add("a");
 set.add("b1");
 set.add("c2");
 set.add("d");
set.add("a");
 //获取元素,在Set容器中没有索引，所以没有对
应的get(int index)方法
for(String str: set){
 System.out.println(str);
        }
 System.out.println("--------------------");
 //删除元素
boolean flag = set.remove("c2");
 System.out.println(flag);
 for(String str: set){
 System.out.println(str);
        }
 System.out.println("------------------------");
 int size = set.size();
 System.out.println(size);
    }
 }

002.HashSet存储自定义对象

public class Users {
 private String username;
 private int userage;
 public Users(String username, int 
userage) {
 this.username = username;
 this.userage = userage;
    }
 public Users() {
    }
 @Override
 public boolean equals(Object o) {
 if (this == o) return true;
 if (o == null || getClass() != 
o.getClass()) return false;
 Users users = (Users) o;
 if (userage != users.userage) return 
false;
 return username != null ? 
username.equals(users.username) : 
users.username == null;
    }
 @Override
 public int hashCode() {
 int result = username != null ? 
username.hashCode() : 0;
 result = 31 * result + userage;
 return result;
    }
 public String getUsername() {
 return username;
    }
 {
    }
 public int getUserage() {
 return userage;
    }
 public void setUsername(String username) 
this.username = username;
 public void setUserage(int userage) {
 this.userage = userage;
    }
 @Override
 public String toString() {
 return "Users{" +
 "username='" + username + 
'\'' +
 ", userage=" + userage +
 '}';
    }
 }

003.HashSet中存储对象

 public class HashSetTest2 {
 public static void main(String[] args) {
 //实例化HashSet
 Set<Users> set = new HashSet<>();
 private transient HashMap<E,Object> map;
 69
 Users u = new Users("oldlu",18);
 Users u1 = new Users("oldlu",18);
 set.add(u);
 set.add(u1);
 System.out.println(u.hashCode());
 System.out.println(u1.hashCode());
 for(Users users:set){
 System.out.println(users);
        }

03.TreeSet容器

001基本用法

public class TreeSetTest {
 public static void main(String[] args) {
 //实例化TreeSet
 Set<String> set = new TreeSet<>();
 //添加元素
set.add("c");
 set.add("a");
 set.add("d");
 set.add("b");
 set.add("a");
 //获取元素
 for(String str :set){
 System.out.println(str);
        }
}

002通过元素自身实现比较规则

创建User类

public class Users implements 
Comparable<Users>{
 private String username;
 private int userage;
 public Users(String username, int 
userage) {
 this.username = username;
 this.userage = userage;
    }
 public Users() {
    }
 @Override
 public boolean equals(Object o) {
 System.out.println("equals...");
 if (this == o) return true;
 if (o == null || getClass() != 
o.getClass()) return false;
 Users users = (Users) o;
 if (userage != users.userage) return 
false;
 return username != null ? 
username.equals(users.username) : 
users.username == null;
    }
 @Override
 public int hashCode() {
 int result = username != null ? 
username.hashCode() : 0;
 result = 31 * result + userage;
 return result;
    }
 public String getUsername() {
 return username;
    }
 public void setUsername(String username) 
{
 this.username = username;
    }
 public int getUserage() {
 return userage;
    }
 public void setUserage(int userage) {
 this.userage = userage;
    }
 @Override
 public String toString() {
 return "Users{" +
 "username='" + username + 
'\'' +
 ", userage=" + userage +
 '}';
    }
 //定义比较规则
//正数：大，负数：小，0：相等
@Override
 public int compareTo(Users o) {
 if(this.userage > o.getUserage()){
 return 1;
        }
 if(this.userage == o.getUserage()){
 return 
this.username.compareTo(o.getUsername());
        }
 return -1;
    }
}

Set<Users> set1 = new TreeSet<>();
 Users u = new Users("oldlu",18);
 Users u1 = new Users("admin",22);
 Users u2 = new Users("sxt",22);
 set1.add(u);
 set1.add(u1);
 set1.add(u2);
 for(Users users:set1){
 System.out.println(users);
 }

003通过比较器实现比较规则

创建Student类

 public class Student {
 private String name;
 private int age;
 public Student(String name, int age) {
 this.name = name;
 this.age = age;
    }
 public Student() {
    }
 @Override
 public String toString() {
 return "Student{" +
 "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;
    }
 @Override
 public boolean equals(Object o) {
 if (this == o) return true;
 if (o == null || getClass() != 
o.getClass()) return false;
 Student student = (Student) o;
 if (age != student.age) return 
false;
 return name != null ? 
name.equals(student.name) : student.name == 
null;
    }
 @Override
 public int hashCode() {
 int result = name != null ? 
name.hashCode() : 0;
 result = 31 * result + age;
 return result;
    }
 }

创建比较器

 public class StudentComparator implements 
Comparator<Student> {
 //定义比较规则
@Override
 public int compare(Student o1, Student 
o2) {
 if(o1.getAge() > o2.getAge()){
 return 1;
        }
 if(o1.getAge() == o2.getAge()){
 return 
o1.getName().compareTo(o2.getName());
        }
 return -1;
    }
 }

public class TreeSetTest3 {
 public static void main(String[] args) {
 //创建TreeSet容器，并给定比较器对象
Set<Student> set = new TreeSet<>(new 
StudentComparator());
 Student s = new Student("oldlu",18);
 Student s1 = new 
Student("admin",22);
 Student s2 = new Student("sxt",22);
 set.add(s);
 set.add(s1);
 set.add(s2);
 for(Student student:set){
 System.out.println(student);
        }
    }
 }

04.单例集合使用案例

产生1-10之间的随机数([1,10]闭区间)，将不重复的10个随机数放到容器中

使用List类型容器实现

public class ListDemo {
 public static void main(String[] args) {
 List<Integer> list = new ArrayList<>
 ();
 while(true){
 //产生随机数
int num = (int)
 (Math.random()*10+1);
 //判断当前元素在容器中是否存在
if(!list.contains(num)){
 list.add(num);
           }
 //结束循环
if(list.size() == 10){
 break;
           }
       }
 for(Integer i:list){
 System.out.println(i);
       }
    }
 }

使用Set类型容器实现

public class SetDemo {
 public static void main(String[] args) {
 Set<Integer> set = new HashSet<>();
 while(true){
 int num = (int)
 (Math.random()*10+1);
 //将元素添加容器中，由于Set类型容器是
不允许有重复元素的，所以不需要判断。
set.add(num);
 //结束循环
if(set.size() == 10){
 break;
            }
        }
 for(Integer i:set){
 System.out.println(i);
        }
    }
 }

2.双例集合

特点：双例集合的存储特征是以key与value结构为单位进行存储。

1.Map接口中常用的方法

2.HashMap

01.HashMap容器的使用

HashMap采用哈希算法实现，是Map接口最常用的实现类。由于底层采用了哈希表存储数据，我们要求键不能重复，如果发生重复，新的键值对会替换旧的键值对。 HashMap在查找、删除、修改方面都有非常高的效率。

public class HashMapTest {
 public static void main(String[] args) {
 //实例化HashMap容器
Map<String,String> map = new 
HashMap<>();
 ");
 //添加元素
map.put("a","A");
 map.put("b","B");
 map.put("c","C");
 map.put("a","D");
 //获取容器中元素数量
int size = map.size();
 System.out.println(size);
 System.out.println("--------------
 //获取元素
//方式一
String v = map.get("a");
 System.out.println(v);
 System.out.println("--------------
");
 "+v1);---");
 //方式二
Set<String> keys = map.keySet();
 for(String key:keys){
 String v1 = map.get(key);
 System.out.println(key+" ---- 
        }
 System.out.println("---------------
//方式三
Set<Map.Entry<String,String>> 
entrySet = map.entrySet();
 for(Map.Entry<String,String> 
entry:entrySet){
 String key = entry.getKey();
 String v2 = entry.getValue();
 System.out.println(key+" ---------- "+v2);
        }
 System.out.println("--------------------");
 //Map容器的并集操作
 Map<String,String> map2 = new 
HashMap<>();
 map2.put("f","F");
 map2.put("c","CC");
 map.putAll(map2);
 Set<String> keys2 = map.keySet();
 for(String key:keys2){
 System.out.println("key: "+key+" 
Value: "+map.get(key));
        }
 System.out.println("--------------
");
 //删除元素
String v3 = map.remove("a");
 System.out.println(v3);
 Set<String> keys3 = map.keySet();
 for(String key:keys3){
 System.out.println("key: "+key+" 
Value: "+map.get(key));
        }
 System.out.println("-------------------");
 //判断Key是否存在
boolean b = map.containsKey("b");
 System.out.println(b);
 //判断Value是否存在
boolean cc = 
map.containsValue("CC");
 System.out.println(cc);
    }
 }

3.TreeMap

TreeMap和HashMap同样实现了Map接口，所以，对于API的用法来说是没有区别的。HashMap效率高于TreeMap；TreeMap是可以对键进行排序的一种容器，在需要对键排序时可选用TreeMap。 TreeMap底层是基于红黑树实现的。

在使用TreeMap时需要给定排序规则：

元素自身实现比较规则

通过比较器实现比较规则

01元素自身实现比较规则

 public class Users implements 
Comparable<Users>{
 private String username;
 private int userage;
 public Users(String username, int 
userage) {
 this.username = username;
 this.userage = userage;
    }
 public Users() {
    }
 @Override
 public boolean equals(Object o) {
 System.out.println("equals...");
 if (this == o) return true;
 if (o == null || getClass() != 
o.getClass()) return false;
 Users users = (Users) o;
 if (userage != users.userage) return 
false;
 return username != null ? 
username.equals(users.username) : 
users.username == null;
    }
 @Override
 public int hashCode() {
 int result = username != null ? 
username.hashCode() : 0;
 result = 31 * result + userage;
 return result;
    }
 public String getUsername() {
 return username;
    }
 public void setUsername(String username) 
{
 this.username = username;
    }
 public int getUserage() {
 return userage;
    }
 public void setUserage(int userage) {
 this.userage = userage;
    }
 @Override
 public String toString() {
 return "Users{" +
 "username='" + username + 
'\'' +
 ", userage=" + userage +
 '}';
    }
 //定义比较规则
//正数：大，负数：小，0：相等
@Override
 public int compareTo(Users o) {
 if(this.userage < o.getUserage()){
 return 1;
        }
 if(this.userage == o.getUserage()){
 return 
this.username.compareTo(o.getUsername());
        }
 return -1;
    }
 }

 public class TreeMapTest {
 public static void main(String[] args) {
 //实例化TreeMap
 Map<Users,String> map = new 
TreeMap<>();
 Users u1 = new Users("oldlu",18);
 Users u2 = new Users("admin",22);
 Users u3 = new Users("sxt",22);
 map.put(u1,"oldlu");
 map.put(u2,"admin");
 map.put(u3,"sxt");
 Set<Users> keys = map.keySet();
 for(Users key :keys){
 System.out.println(key+" --------- "+map.get(key));
        }
    }
 }

02通过比较器实现比较规则

public class Student {
 private String name;
 private int age;
 public Student(String name, int age) {
 this.name = name;
 this.age = age;
    }
 public Student() {
    }
 @Override
 public String toString() {
 return "Student{" +
 "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;
    }
 @Override
 public boolean equals(Object o) {
 if (this == o) return true;
 if (o == null || getClass() != 
o.getClass()) return false;
 Student student = (Student) o;
 if (age != student.age) return 
false;
 return name != null ? 
name.equals(student.name) : student.name == 
null;
    }
 @Override
 public int hashCode() {
 int result = name != null ? 
name.hashCode() : 0;
 result = 31 * result + age;
 return result;
    }
 }

public class StudentComparator implements 
Comparator<Student> {
 //定义比较规则
 @Override
 public int compare(Student o1, Student 
o2) {
 if(o1.getAge() > o2.getAge()){
 return 1;
        }
 if(o1.getAge() == o2.getAge()){
 return 
o1.getName().compareTo(o2.getName());
        }
 return -1;
    }
 }

public class TreeMapTest {
 public static void main(String[] args) {
 Map<Student,String> treeMap = new 
TreeMap<>(new StudentComparator());
 Student s1 = new Student("oldlu",18);
 Student s2 = new Student("admin",22);
 Student s3 = new Student("sxt",22);
 treeMap.put(s1,"oldlu");
 treeMap.put(s2,"admin");
 treeMap.put(s3,"sxt");
 Set<Student> keys1 = treeMap.keySet();
 for(Student key :keys1){
 System.out.println(key+" ---- 
"+treeMap.get(key));
      }
    }
 }

三。迭代器

1.Iterator迭代器接口介绍

Collection接口继承了Iterable接口，在该接口中包含一个名为 iterator的抽象方法，所有实现了Collection接口的容器类对该方法做了具体实现。iterator方法会返回一个Iterator接口类型的迭代器对象，在该对象中包含了三个方法用于实现对单例容器的迭代处理。

2.Iterator对象工作原理

3.Iterator接口定义了如下方法

boolean hasNext(); //判断游标当前位置的下一个位置是否还有元素没有被遍历；

Object next(); //返回游标当前位置的下一个元素并将游标移动到下一个位置；

void remove(); //删除游标当前位置的元素，在执行完next后该操作只能执行一次；

4.Iterator迭代器的使用

01.迭代List接口类型容器

public class IteratorListTest {
 public static void main(String[] args) {
 //实例化容器
List<String> list  = new ArrayList<>
 ();
 list.add("a");
 list.add("b");
 list.add("c");
 //获取元素
//获取迭代器对象
Iterator<String> iterator = 
list.iterator();
 //方式一:在迭代器中，通过while循环获取元素
while(iterator.hasNext()){
 String value = iterator.next();
 System.out.println(value);
        }
 System.out.println("-------------------------------");
 //方法二：在迭代器中，通过for循环获取元素
for(Iterator<String> it = 
list.iterator();it.hasNext();){
 String value = it.next();
 System.out.println(value);
        }
    }
 }

02.迭代Set接口类型容器

public class IteratorSetTest {
 public static void main(String[] args) {
 //实例化Set类型的容器
Set<String> set  = new HashSet<>();
 set.add("a");
 set.add("b");
 set.add("c");
 //方式一：通过while循环
//获取迭代器对象
Iterator<String> iterator = 
set.iterator();
 while(iterator.hasNext()){
 String value = iterator.next();
 System.out.println(value);
        }
 System.out.println("-------------------------");
 //方式二：通过for循环
for(Iterator<String> it = 
set.iterator();it.hasNext();){
 String value = it.next();
 System.out.println(value);
        }
    }
 }

03迭代Map接口类型容器

 public class IteratorMapTest {
 public static void main(String[] args) {
 //实例化HashMap容器
Map<String, String> map = new 
HashMap<String, String>();
 //添加元素
map.put("a", "A");
 map.put("b", "B");
 map.put("c", "C");
 //遍历Map容器方式一
Set<String> keySet = map.keySet();
 for (Iterator<String> it = 
keySet.iterator(); it.hasNext();){
 String key = it.next();
 String value = map.get(key);
 System.out.println(key+" ------------- "+value);
        }
 System.out.println("------------------------");
 //遍历Map容器方式二
Set<Map.Entry<String, String>> 
entrySet = map.entrySet();
 Iterator<Map.Entry<String, String>> 
iterator = entrySet.iterator();
 while(iterator.hasNext()){
 Map.Entry entry = 
iterator.next();
 System.out.println(entry.getKey()+" ------------ "+ entry.getValue());
        }
    }
 }

04在迭代器中删除元素

 public class IteratorRemoveTest {
 public static void main(String[] args) {
 List<String> list = new ArrayList<>
 ();
 list.add("a");
 list.add("b");
 list.add("c");
 list.add("d");
 Iterator<String> iterator = 
list.iterator();
 while(iterator.hasNext()){
 //不要在一次循环中多次调用next方法。
String value = iterator.next();
 iterator.remove();
        }
 System.out.println("---------------
");
 for(Iterator<String> it = 
list.iterator();it.hasNext();){
 System.out.println(it.next());
 list.add("dddd");
        }
    }
 }

5.遍历集合的而方法总结

遍历List方法一：普通for循环遍历List

for(int i=0;i<list.size();i++){//list为集合的对
象名
String temp = (String)list.get(i);
 System.out.println(temp);
 }

方法二：增强for循环(使用泛型！)

 for (String temp : list) {
 System.out.println(temp);
 }

遍历List方法三：使用Iterator迭代器(1)

for(Iterator iter= 
list.iterator();iter.hasNext();){
 String temp = (String)iter.next();
 System.out.println(temp);
 }

遍历List方法四：使用Iterator迭代器(2)

 Iterator  iter =list.iterator();
 while(iter.hasNext()){
 Object  obj =  iter.next();
 iter.remove();//如果要遍历时，删除集合中的元
素，建议使用这种方式！
System.out.println(obj);
 }

遍历Set方法一：增强for循环

for(String temp:set){
 System.out.println(temp);
 }

遍历Set方法二：使用Iterator迭代器

 for(Iterator iter = 
set.iterator();iter.hasNext();){
 String temp = (String)iter.next();
 System.out.println(temp);
 }

遍历Map方法一：根据key获取value

 Map<Integer, Man> maps = new HashMap<Integer, 
Man>();
 Set<Integer>  keySet =  maps.keySet();
 for(Integer id : keySet){
 System.out.println(maps.get(id).name);
 }

遍历Map方法二：使用entrySet

 Set<Map.Entry<Integer, Man>>  ss = 
maps.entrySet();
 for (Iterator<Map.Entry<Integer, Man>> 
iterator = ss.iterator(); 
iterator.hasNext();) {
 Map.Entry e =  iterator.next(); 
System.out.println(e.getKey()+"-
"+e.getValue()); 
}

四，Collection工具类

public class CollectionsTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>
 ();
 list.add("c");
 list.add("b");
 list.add("a");
 //对元素排序
Collections.sort(list);
 for(String str:list){
 System.out.println(str);
        }
 System.out.println("-------------------");
 ();---");
 List<Users> list2 = new ArrayList<>
 Users u = new Users("oldlu",18);
 Users u2 = new Users("sxt",22);
 Users u3 = new Users("admin",22);
 list2.add(u);
 list2.add(u2);
 list2.add(u3);
 //对元素排序
Collections.sort(list2);
 for(Users user:list2){
 System.out.println(user);
        }
 System.out.println("---------------
List<Student> list3 = new 
ArrayList<>();
 Student s = new Student("oldlu",18);
 Student s1 = new Student("sxt",20);
 Student s2 = new 
Student("admin",20);
 list3.add(s);
 list3.add(s1);
 list3.add(s2);
 Collections.sort(list3,new 
StudentComparator());
 for(Student student:list3){
 System.out.println(student);
        }
 System.out.println("-------------------");
 List<String> list4 = new ArrayList<>
 ();
 }
list4.add("a");
 list4.add("b");
 list4.add("c");
 list4.add("d");
 //洗牌
Collections.shuffle(list4);
 for(String str:list4){
 System.out.println(str);
        }

码道开发者社区

码道开发者社区，聚焦华为云码道 CodeArts 代码智能体，沉淀 Agent、Skill、鸿蒙开发实战内容，供开发者查阅资料、交流技术、分享工程实践

更多推荐

AI 已经能直接改设计稿了:Windows部署Penpot，接入Codex MCP实测

码道开发者社区

【AI 业务流架构师】AI 业务流架构师方法论：Agentic AI 范式转移与业务编排思维

2026 年，Anthropic CEO Dario Amodei 在 Code with Claude 大会上的一个判断广为流传：一个人运营一家十亿美元级公司的概率是 70%–80%。这句话听起来像科幻小说的设定，但它背后是一个正在发生的结构性变化——AI 把"执行"的成本压到了历史低点，同时把"编排"的价值推到了前台。这意味着我们需要一套新的思考框架，来回答两个问题：一个人如何拥有一个公司的产

码道开发者社区

Codex CLI实战从一句模糊需求到可执行可测试可验收的开发任务把“帮我优化一下”变成 Codex 能执行、团队能复核、测试能证明的工程任务

码道开发者社区

所有评论(0)

查看更多评论

2401_89707442

@2401_89707442

已为社区贡献2条内容

java基础--容器（09）

2401_89707442

一，泛型

1.泛型的好处

2.泛型类

01泛型标记

02泛型类的使用

3.泛型接口

4泛型方法

1.非静态方法

2.静态方法

3.泛型方法与可变参数

5.泛型中的通配符

1.无界通配符

2.通配符上下限限定

上限

下限

6.泛型局限性和常见错误

二。容器或集合

1.单例集合

1.Collection接口中定义的方法

2.List接口

01.List接口特点

02.List接口中的常用方法

03.ArrayList容器

001。基本使用

002.索引操作

003.并集，交集，差集

04.LinkedList容器

001List标准

002非List标准

3.set接口

01.set接口特点

02.HashSet容器

001.基本方法

002.HashSet存储自定义对象

003.HashSet中存储对象

03.TreeSet容器

001基本用法

002通过元素自身实现比较规则

003通过比较器实现比较规则

04.单例集合使用案例

2.双例集合

1.Map接口中常用的方法

2.HashMap

01.HashMap容器的使用

3.TreeMap

01元素自身实现比较规则

02通过比较器实现比较规则

三。迭代器

1.Iterator迭代器接口介绍

2.Iterator对象工作原理

3.Iterator接口定义了如下方法

4.Iterator迭代器的使用

01.迭代List接口类型容器

02.迭代Set接口类型容器

03迭代Map接口类型容器

04在迭代器中删除元素

5.遍历集合的而方法总结

四，Collection工具类

所有评论(0)

温馨提示：您尚未绑定手机号

2401_89707442