集合之遍历集合的方法和去重_collection遍历去重-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_45509218/article/details/109565671

本文主要介绍了Java中集合的遍历方式，包括List集合的遍历与去重、Set的遍历方法及其去重策略，以及Map的遍历方法。通过实例详细解析了如何有效地遍历和去除集合中的重复元素。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

集合的遍历方式与去重

1.List集合的遍历方法

public class ListDemo1 {

	public static void main(String[] args) {
		
		/*
		List集合的遍历方式
		1)Collection集合的方法Object[]toArray
		2)Collection集合的迭代器Iterator iterator
		3)size()+Object get(int index):普通for循环
		4)列表迭代器:ListIterator listiterator()
		5)增强for循环
		*/

		List<String> list=new ArrayList<String>();
				
				String s1="白眉鹰王";
				String s2="青翼蝠王";
				String s3="金毛狮王";
				String s4="紫衫龙王";
				
				list.add(s1);
				list.add(s2);
				list.add(s3);
				list.add(s4);
				
	//Collection集合的方法Object[]toArray
	
		Object[]obj=list.toArray();
		for(int x=0;x<obj.length;x++) {
			String s=(String) obj[x];
			System.out.println(s);
		}
		
		System.out.println("------------------");
		
	//Collection集合的迭代器Iterator iterator
		Iterator<String> it =list.iterator();
		while(it.hasNext()) {
			String s=it.next();
			System.out.println(s);
		}
		
		System.out.println("---------------------");
		
	//size()+Object get(int index):普通for循环
		for(int x=0;x<list.size();x++) {
			String s=list.get(x);
			System.out.println(s);
		}
		
		System.out.println("-------------------------");
		
	//列表迭代器:ListIterator listiterator()
		ListIterator<String> lis=list.listIterator();
		while(lis.hasNext()) {
			String s=lis.next();
			System.out.println(s);
		}
		
        System.out.println("-----------------------------");
		
		//增强for循环
		for(String s:list) {
			System.out.println(s);
		}
	}
}

1.1集合的去重

import com.java_01.Student;


/*
 * 去重
 */
public class ListDemo {

	public static void main(String[] args) {
		
		List <Student> list=new ArrayList<Student>();
		
		Student s1=new  Student("白眉鹰王",35);
		Student s2=new Student("青翼蝠王",32);
		Student s3=new Student("金毛狮王",38);
		Student s4=new Student("紫衫龙王",31);
		Student s5=new  Student("白眉鹰王",37);
		Student s6=new Student("青翼蝠王",32);
		Student s7=new Student("金毛狮王",38);
		Student s8=new Student("紫衫龙王",31);
		
		list.add(s1);
		list.add(s2);
		list.add(s3);
		list.add(s4);
		list.add(s5);
		list.add(s6);
		list.add(s7);
		list.add(s8);
		
创建新的集合		
		//创建新的集合,通过contains判断
		List<Student>list2=new ArrayList<Student>();
		
		Iterator<Student>it=list.iterator();
		while(it.hasNext()) {
			
			Student st=it.next();
			if(!list2.contains(st)) {
				list2.add(st);
			}
		}
		
		///遍历
		Iterator<Student>it1=list2.iterator();
		while(it1.hasNext()) {
			Student s=it1.next();
			System.out.println(s.getName()+"-"+s.getAge());
		}
		
		System.out.println("----------------------------");
        
        
通过equals判断		
		//通过equals判断,注意在Student类中重写equals方法
		for(int x=0;x<list.size()-1;x++) {
			for(int y=x+1;y<list.size();y++) {
				if(list.get(x).equals(list.get(y))) {
					list.remove(y);
					y--;
				}
				
			}
		}
		
		//遍历
		Iterator<Student>ite=list.iterator();
		while(ite.hasNext()) {
			Student ss=ite.next();
			System.out.println(ss.getName()+"-"+ss.getAge());
		}
	}
}

2.Set的遍历方法以及去重

1.TreeSet的遍历方式:
		注://TreeSet遍历时,需要在资源类实现Comparable<>接口方法
		   //TreeSet遍历时,会自动去重和排序 
	主代码块:
            public class TreesetDemo {

            public static void main(String[] args) {

                TreeSet<Student> ts =new TreeSet<Student>();

                Student s1=new Student("张三丰",65);
                Student s2=new Student("丘处机",53);
                Student s3=new Student("王重阳",45);

                ts.add(s1);
                ts.add(s2);
                ts.add(s3);

                for(Student s:ts) {
                    System.out.println(s.getName()+"-"+s.getAge());
                }	
            }
        }
	学生类代码块:
        public class Student implements Comparable<Student> {

            private String name;
            private int age;
            public Student() {
                super();
            }
            public Student(String name, int age) {
                super();
                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;
            }
            /* (non-Javadoc)
             * @see java.lang.Object#toString()
             */
            @Override
            public String toString() {
                return "Student [" + (name != null ? "name=" + name + ", " : "") + "age=" + age + "]";
            }
       /**
	 * 重写Comparable接口中的compareTo方法
	 */
	@Override
	public int compareTo(Student s) { //s:后面需要进来的学生对象
		//return 0;
		//自己的比较业务!
		//提供一个条件:主要条件:按照学生的年龄从到大排序
		//年龄:int类型       
		int num = this.age - s.age ;  //41 - 37 > 0 ? 
										//37-37 
		
		//自己分析次要条件:
		//如果年龄相同的话:姓名不一定一样!  姓名:String 
		//如果年龄相同,按照姓名的字典顺序比较,如果不相同
		int num2 = (num==0)? (this.name.compareTo(s.name)): num ;
		
		return num2 ;
	}
	
	
	

2.HashSet的遍历方法:
           注: //HashSet遍历时,需要重写hashcode()和equals()
              //HashSet遍历时,只去重,不排序
	主代码块:
            public class HashsetDemo {

            public static void main(String[] args) {

                Set<Student> ht = new HashSet<Student>();


                Student s1=new Student("张三丰",65);
                Student s2=new Student("丘处机",53);
                Student s3=new Student("王重阳",45);
                Student s4=new Student("张三丰",65);

                ht.add(s1);
                ht.add(s2);
                ht.add(s3);
                ht.add(s4);

                for(Student s:ht) {
                    System.out.println(s.getName()+"-"+s.getAge());
                }
            }
        }

	学生代码块:
        public class Student implements Comparable<Student> {

            private String name;
            private int age;
            public Student() {
                super();
            }
            public Student(String name, int age) {
                super();
                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;
            }


            //HashSet遍历时,需要重写hashcode()和equals()
            /* (non-Javadoc)
             * @see java.lang.Object#hashCode()
             */
            @Override
            public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + age;
                result = prime * result + ((name == null) ? 0 : name.hashCode());
                return result;
            }
            /* (non-Javadoc)
             * @see java.lang.Object#equals(java.lang.Object)
             */
            @Override
            public boolean equals(Object obj) {
                if (this == obj)
                    return true;
                if (obj == null)
                    return false;
                if (getClass() != obj.getClass())
                    return false;
                Student other = (Student) obj;
                if (age != other.age)
                    return false;
                if (name == null) {
                    if (other.name != null)
                        return false;
                } else if (!name.equals(other.name))
                    return false;
                return true;
            }
        }

3.Map的遍历方法

方式1:(推荐的方式:Map常用的方式)
  			Set<K> keySet():获取所有的键的集合
  		   V get(Object key):通过键获取对应的值
 
  遍历Map集合方式1:
           方式1:Set<K> keySet():获取所有的键的集合
                 Set<String> set = map.keySet()  ;
                     //通过键在值
                 for(String key : set) {
                    //通过键获取值
                     V get(Object key):通过键获取对应的值
                     String value = map.get(key) ;
                     System.out.println(key+"="+value);
                   }
		
        例:
            /*	
             * 方式1:
             * 		Set<K> keySet():获取所有键的集合
             * 		V get(Object key):通过键获取对应的值
             */

            //创建Map集合对象
            Map<String,String> map=new HashMap<String,String>();
            //添加键值对元素
            map.put("郭靖", "黄蓉");
            map.put("杨过", "小龙女");
            map.put("张无忌", "赵敏");

            //遍历Map集合
            //Set<K>keySet():获取所有键的集合
            Set<String> set=map.keySet();
             //通过键获取值
            for(String key:set) {
                //V get(Object key):通过键获取值
                String value=map.get(key);
                System.out.println(key+"-"+value);
            }





			
 遍历Map集合方式2:		
		方式2遍历
  			Set<Map.Entry<K,V>> entrySet():获取当前Map集合中所有的键值对对象
  					
  				K getKey() :通过键值对对象获取键
  				V getValue():通过键值对对象获取值
 
            获取所有的键值对对象
            Set<Map.Entry<String, String>> entrySet = map.entrySet() ;
            //遍历
            for(Map.Entry<String, String> entry :entrySet) {
                //获取到了所有的键值对对象:一一获取
                //K getKey():通过键值对对象获取键
                String key = entry.getKey() ;
                //V Value():通过键值对对象获取值
                String value = entry.getValue() ;
                System.out.println(key+"="+value);
            }
 
 
		例:
             /*    方式2遍历:
             * 	Set<Map.Entry<K,V>>entrySet():获取当前Map集合中所有的键值对对象
             * 		K getKey():通过键值对对象获取键
             * 		V getValue():通过键值对对象获取值
             */
			//创建Map集合
            Map<String,String> map=new HashMap<String,String>();
            //添加元素
            map.put("郭靖", "黄蓉");
            map.put("杨过", "小龙女");
            map.put("张无忌", "赵敏");

            //遍历Map集合
            Set<Map.Entry<String,String>> set=map.entrySet();
            for(Map.Entry<String,String> entry:set) {
                //K getKey():通过键值对对象获取键
                String key=entry.getKey();
                //V getValue():通过键值对对象获取值
                String value=entry.getValue();
                System.out.println(key+"-"+value);
            }