List、Set、Map遍历方法以及常用方法归纳

一、List/Set/Map 遍历方法归纳

1.List 常见的3种遍历方法

List<String> list = new ArrayList<String>();  
        list.add("java111");  
        list.add("java222");  
        list.add("java333");  
        list.add("java444");  
        list.add("java555");  
  
        // 遍历方式1 ，使用iterator  
        Iterator<String> it = list.iterator();  
        while (it.hasNext()) {  
            String value = it.next();  
            System.out.println(value);  
        }  
  
        // 遍历方法2 ， 使用传统for循环进行遍历。  
        for (int i = 0, size = list.size(); i < size; i++) {  
            String value = list.get(i);  
            System.out.println(value);  
        }  
  
        // 遍历方法3 ， 使用增强for循环进行遍历。  
        for (String value : list) {  
            System.out.println(value);  
        }
  • 其中的add方法返回值是boolean类型
  •  基本返回值都是true(因为通过源码我们可以看到它通过是否修改原有集合来返回true或者false，而多数情况下，List内容可以重复，所以相当于它的内容始终在改变，所以返回为true)
List<String> list=new ArrayList<>(); 
    System.out.println(list.add("a"));
    //true
    System.out.println(list.add("a"));
    //true
    System.out.println(list.add("a"));
    //true
    System.out.println(list.add("b"));
    //true
View Code

2.Set常见的2种遍历方法

Set<String> set = new HashSet<String>();  
        set.add("JAVA");  
        set.add("C");  
        set.add("C++");  
        // 重复的加不进去。  
        set.add("JAVA");  
        set.add("JAVASCRIPT");  
  
        //set集合遍历方法1，使用iterator  
        Iterator<String> it = set.iterator();  
        while (it.hasNext()) {  
            String value = it.next();  
            System.out.println(value);  
        }  
          
        //set集合遍历方法2，使用增强for循环。  
        for(String s: set){  
            System.out.println(s);  
        }

因为Set分支的特点是无序且不可重复，因此通过add方法添加相同的值时，第一次返回为true，后面再加相同元素的话就会返回false，因为元素重复

Set<String> set=new TreeSet<>();
    System.out.println(set.add("a"));
    //true
    System.out.println(set.add("a"));
    //false
    System.out.println(set.add("a"));
    //false
View Code

3.Map 常见的4种遍历方法

 1 关于Map类型集合的遍历，keySet()与entrySet()方法：
 2 [java] view plaincopy
 3 //增强For循环  
 4 public class MapTest {  
 5   
 6     public static void main(String[] args) {  
 7         // 创建一个HashMap对象,并加入了一些键值对。  
 8         Map<String, String> maps = new HashMap<String, String>();  
 9         maps.put("111", "java111");  
10         maps.put("222", "java222");  
11         maps.put("333", "java333");  
12         maps.put("444", "java444");  
13         maps.put("555", "java555");  
14           
15         // 传统的遍历map集合的方法1; keySet()  
16         //traditionalMethod1(maps);  
17         // 传统的遍历map集合的方法2; entrySet()  
18         //traditionalMethod2(maps);  
19         // 使用增强For循环来遍历map集合方法1; keySet()  
20         //strongForMethod1(maps);  
21         // 使用增强For循环来遍历map集合方法2; entrySet()  
22         strongForMethod2(maps);  
23     }  
24   
25     private static void strongForMethod2(Map<String, String> maps) {  
26         Set<Entry<String, String>> set = maps.entrySet();  
27         for (Entry<String, String> entry : set) {  
28             String key = entry.getKey();  
29             String value = entry.getValue();  
30             System.out.println(key + " : " + value);  
31         }  
32     }  
33   
34     private static void strongForMethod1(Map<String, String> maps) {  
35         Set<String> set = maps.keySet();  
36         for (String s : set) {  
37             String key = s;  
38             String value = maps.get(s);  
39             System.out.println(key + " : " + value);  
40         }  
41     }  
42   
43     // 使用entrySet()方法，获取maps集合中的每一个键值对，  
44     private static void traditionalMethod2(Map<String, String> maps) {  
45         Set<Map.Entry<String, String>> sets = maps.entrySet();  
46         // 取得迭代器遍历出对应的值。  
47         Iterator<Entry<String, String>> it = sets.iterator();  
48         while (it.hasNext()) {  
49             Map.Entry<String, String> entry = (Entry<String, String>) it.next();  
50             String key = entry.getKey();  
51             String value = entry.getValue();  
52             System.out.println(key + " : " + value);  
53         }  
54     }  
55   
56     // 使用keySet()方法，获取maps集合中的所有键，遍历键取得所对应的值。  
57     private static void traditionalMethod1(Map<String, String> maps) {  
58         Set<String> sets = maps.keySet();  
59         // 取得迭代器遍历出对应的值。  
60         Iterator<String> it = sets.iterator();  
61         while (it.hasNext()) {  
62             String key = it.next();  
63             String value = maps.get(key);  
64             System.out.println(key + " : " + value);  
65         }  
66     }  
67 }
View Code
 1 关于Map类型集合的遍历，keySet()与entrySet()方法：
 2 [java] view plaincopy
 3 //增强For循环  
 4 public class MapTest {  
 5   
 6     public static void main(String[] args) {  
 7         // 创建一个HashMap对象,并加入了一些键值对。  
 8         Map<String, String> maps = new HashMap<String, String>();  
 9         maps.put("111", "java111");  
10         maps.put("222", "java222");  
11         maps.put("333", "java333");  
12         maps.put("444", "java444");  
13         maps.put("555", "java555");  
14           
15         // 传统的遍历map集合的方法1; keySet()  
16         // 使用keySet()方法，获取maps集合中的所有键，遍历键取得所对应的值。   
17         Set<String> sets = maps.keySet();  
18         // 取得迭代器遍历出对应的值。  
19         Iterator<String> it = sets.iterator();  
20         while (it.hasNext()) {  
21             String key = it.next();  
22             String value = maps.get(key);  
23             System.out.println(key + " : " + value);  
24         }  
25 
26         // 使用增强For循环来遍历map集合方法1; keySet()  
27         Set<String> set = maps.keySet();  
28         for (String key : set) {    
29             System.out.println(key + " : " + maps.get(key));  
30         }  
31       
32         // 传统的遍历map集合的方法2; entrySet()  
33         // 使用entrySet()方法，获取maps集合中的每一个键值对，  
34         Set<Map.Entry<String, String>> sets = maps.entrySet();  
35         // 取得迭代器遍历出对应的值。  
36         Iterator<Entry<String, String>> it = sets.iterator();  
37         while (it.hasNext()) {  
38             Map.Entry<String, String> entry = (Entry<String, String>) it.next();  
39             String key = entry.getKey();  
40             String value = entry.getValue();  
41             System.out.println(key + " : " + value);  
42         }  
43         
44         // 使用增强For循环来遍历map集合方法2; entrySet()  
45         Set<Entry<String, String>> set = maps.entrySet();  
46         for (Entry<String, String> entry : set) {  
47             String key = entry.getKey();  
48             String value = entry.getValue();  
49             System.out.println(key + " : " + value);  
50         }  
51 
52         //通过maps.values()遍历所有的value，但不能遍历key
53         for (String v : maps.values()) {
54             System.out.println("value= " + v);
55         }
56 
57     }  
58 }

在Map中添加元素使用put方法，在返回值问题上，因为Map中是以键值对存在，因此当一个键值是第一次被添加时返回值为null，否则返回为上一次添加的value

Map<String, String> map=new TreeMap<>();
    System.out.println(map.put("k1", "v1"));
    //null
    System.out.println(map.put("k1", "v1"));
    //v1
    System.out.println(map.put("k2", "v2"));
    //null
    System.out.println(map.put("k2", "v2"));
    //v2
    System.out.println(map.put("k3", "v3"));
    //null
    System.out.println(map.put("k3", "v3"));
    //v3
View Code

二、常用方法总结

List

Set

小技巧：由于Set集合中不允许存在重复值，因此可以使用Set集合中的addAll()方法，将Collection集合添加到Set集合中并除掉重复值。

Map

三、去掉List集合重复值的四种方法

一种是用遍历list集合判断后赋给另一个list集合，一种是用赋给set集合再返回给list集合。 
但是赋给set集合后，由于set集合是无序的，原先的顺序就打乱了。所以我又想着能不能用set的特性进行去重又不打乱顺序呢？

//set集合去重，不打乱顺序

 1   public static void main(String[] args){
 2          List<String> list  =   new  ArrayList<String>(); 
 3          list.add("aaa");
 4          list.add("bbb");
 5          list.add("aaa");
 6          list.add("aba");
 7          list.add("aaa");
 8          Set set = new  HashSet(); 
 9          List newList = new  ArrayList(); 
10          for (String cd:list) {
11             if(set.add(cd)){
12                 newList.add(cd);
13             }
14         }
15          System.out.println( "去重后的集合： " + newList); 
16       }
View Code

//遍历后判断赋给另一个list集合

 1      public static void main(String[] args){
 2          List<String> list  =   new  ArrayList<String>(); 
 3          list.add("aaa");
 4          list.add("bbb");
 5          list.add("aaa");
 6          list.add("aba");
 7          list.add("aaa");
 8 
 9          List<String> newList = new  ArrayList<String>(); 
10          for (String cd:list) {
11             if(!newList.contains(cd)){
12                 newList.add(cd);
13             }
14         }
15          System.out.println( "去重后的集合： " + newList); 
16       }
View Code

//set去重

 1     public static void main(String[] args){
 2          List<String> list  =   new  ArrayList<String>(); 
 3          list.add("aaa");
 4          list.add("bbb");
 5          list.add("aaa");
 6          list.add("aba");
 7          list.add("aaa");
 8 
 9         Set set = new  HashSet(); 
10          List newList = new  ArrayList(); 
11          set.addAll(list);
12          newList.addAll(set);
13 
14          System.out.println( "去重后的集合： " + newList); 
15      }
View Code

//set去重(缩减为一行)

 1         public static void main(String[] args){
 2              List<String> list  =   new  ArrayList<String>(); 
 3              list.add("aaa");
 4              list.add("bbb");
 5              list.add("aaa");
 6              list.add("aba");
 7              list.add("aaa");
 8 
 9              List newList = new ArrayList(new HashSet(list)); 
10 
11              System.out.println( "去重后的集合： " + newList); 
12          }
View Code

hashset不进行排序，还有一种方法是用treeset，去重并且按照自然顺序排列，将hashset改为treeset就可以了。（原本的顺序是改变的，只是按照字母表顺序排列而已）

//去重并且按照自然顺序排列

List newList = new ArrayList(new TreeSet(list));

//for循环去重

 1 package com.fs.test;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public class Listdemo {
 7     
 8     public static void main(String[] args) {
 9         List<String> list = new ArrayList<String>();
10         
11         list.add("a");
12         list.add("c");
13         list.add("b");
14         list.add("w");
15         list.add("s");
16         list.add("a");
17         list.add("b");
18         list.add("s");
19         list.add("d");
20         list.add("c");
21         list.add("a");
22         for(int i=0;i<list.size()-1;i++) {
23             for(int j=list.size()-1;j<i;j--) {
24                 if (list.get(j).equals(list.get(i))) {
25                     list.remove(j);
26                 }
27             }
28         }
29         for (String string : list) {
30             System.out.println(string);
31         }
32     }
33 }

四.Collection,List,Set,Map等接口及Collections类的方法

一、Collection接口中的方法介绍

  • int size();返回此Collection中的元素数
  • boolean isEmpty(); 判断是否为空
  • boolean containsAll(Collection c);判断形参c所指向的集合中的所有元素是不是已经全部包含在了当前集合中，是true，不是flase
  • Iterator iterator();返回能遍历当前集合所有元素的迭代器
  • Object[] toArray();容器不是数组，不能通过下标的方式访问容器中的元素，返回一个包含此Collection中所有元素的数组。
  • bollean add(Object e)；  把e添加到当前集合中
  • boolean remove(Object o);   boolean addAll(Collection c)
  • boolean removeAll(Collection c)； 
  • void clear();
  • boolean equals(Object o);
  • int hashCode();

二、List接口ArrayList LinkedList

  • Object get(int index);
  • Object set(oint index, Object element);
  • void add(int index, Object element);
  • Object remove(int index);
  • int indexOf( Object o);
  • int lastIndexOf(Object o);

三、Set接口

  • 因为Set和List都是继承自Collection接口，所以Set和List中很多方法都是一样的。
  • List接口中有add，set，indexOf方法，但Set中只有add方法，没有set，indexOf方法，因为Set是无序不可重复的，不存在某元素具体位置这个概念

List中add与set: add 为在指定索引位置插入值,而set 为替换指定索引位置的值，所以在使用set之前要保证该指定索引位置有值（即使是空值） 

ArryList 中的 set 与 add 的区别

相同点：都是为arrayList集合设置值

不同点：.set 为替换指定索引位置的值， 而 .add 为在指定索引位置插入值

注意：1) .set(index,object)     而有   .add() 和 .add(index,object)

           2) .set 使用时必须保证该指定索引位置有值（即使是空值）               

1.通过 .add 方法为arrayList 集合增加值 (默认顺序为添加时的顺序)

    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>();
        arrayList.add("add*********0");
        arrayList.add("add*********1");
        arrayList.add("add*********2");
        arrayList.add("add*********3");
        arrayList.add("add*********4");
        for (String string : arrayList) {
            System.out.println(string);
        }
 
    }
View Code

运行结果：

2.通过 .set方法为arrayList 集合增加值，会包集合越界的错误，可以得出，.set 不能理解为增加值（实际为替换值）

public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>();
        arrayList.set(0,"set*********0");
        arrayList.set(1,"set*********1");
        arrayList.set(2,"set*********2");
        arrayList.set(3,"set*********3");
        arrayList.set(4,"set*********4");
        for (String string : arrayList) {
            System.out.println(string);
        }
 
    }
View Code

运行结果：

3.通过 .set方法为arrayList 索引0处增加值，.set 会替换掉原来该位置的值

public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>();
        arrayList.add("add*********0");
        arrayList.add("add*********1");
        arrayList.add("add*********2");
        arrayList.add("add*********3");
        arrayList.add("add*********4");
        arrayList.set(0,"set***set***0");
        for (String string : arrayList) {
            System.out.println(string);
        }
 
    }
View Code

运行结果：

4.通过 .add方法为arrayList 索引0处增加值，.add 会在该位置插入该值，原有的值以及后面所有的值后移一个索引

public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>();
        arrayList.add("add*********0");
        arrayList.add("add*********1");
        arrayList.add("add*********2");
        arrayList.add("add*********3");
        arrayList.add("add*********4");        
        arrayList.add(0,"add***add***0");
        for (String string : arrayList) {
            System.out.println(string);
        }
 
    }
View Code

运行结果：

https://blog.csdn.net/qq_36474549/article/details/83342351

四、Map接口

  • Object put(Object key,Object value);
  • Object get(Object key);  
  • boolean isEmpty();
  • void clear();
  • int size();
  • boolean containsKey(Object key);
  • boolean containsValue(Object value);

注意一个Map的一个Map.Entry接口，其中含有getKey(),getValue方法

(1) Object getKey(): 返回条目的关键字

       (2) Object getValue(): 返回条目的值

       (3) Object setValue(Object value): 将相关映像中的值改为value，并且返回旧值

此处再说两种图的遍历方法： 

 1 Map map = new HashMap();
 2            Irerator iterator = map.entrySet().iterator();
 3            while(iterator.hasNext()) {
 4                    Map.Entry entry = iterator.next();
 5                    Object key = entry.getKey();
 6             } 
 7 
 8 Map map = new HashMap(); 
 9            Set  keySet= map.keySet();
10            Irerator iterator = keySet.iterator;
11            while(iterator.hasNext()) {
12                    Object key = iterator.next();
13                    Object value = map.get(key);
14          }
15 
16  Map map = new HashMap();
17       Collection c = map.values();
18       Iterator iterator = c.iterator();
19       while(iterator.hasNext()) {
20              Object value = iterator.next(); 
21      }

五、Collections类的方法

      Collection接口的实现类，比如ArrayList，LinkedList本身并没有提供排序、倒置和查找的方法，这些方法由Collections类来实现，该类有很多 static public 方法，可以直接对Collections接口的实现类进行操作。

  1. void sort(List); 对List容器内元素进行排序
  2. void shuffle(List);  对List容器内对象进行随机排序
  3. void reverse(List);  对List容器内对象进行逆序排序
  4. rotate(List list,int m)方法的使用(含义：集合中的元素向后移m个位置，在后面被遮盖的元素循环到前面来)
  5. void fill(List, Object)；用一个特定的对象重写整个List容器
  6. nCopies(int n,Object o)方法的使用(含义：返回大小为n的List，List不可改变,其中的所有引用都指向o)
  7. enumeration(Collection)方法的使用(含义：为参数生成一个旧式的Enumeration)
  8. void copy(List dest, List src); 讲src List容器的内容拷贝到dest List容器中
  9. swap(List list,int i,int j)方法的使用(含义：交换集合中指定元素索引的位置)
  10. int binarySearch(List ,Object);  对顺序的List容器，采用折半查找的方法查找特定对象
  11. max(Collection),max(Collection,Comparator)方法的使用(前者采用Collection内含自然比较法，后者采用Comparator进行比较)
  12. min(Collection),min(Collection,Comparator)方法的使用(前者采用Collection内含自然比较法，后者采用Comparator进行比较)
  13.  indexOfSubList(List list,List subList)方法的使用(含义：查找subList在list中首次出现位置的索引)。
  14. lastIndexOfSubList(List source,List target)方法的使用与上例方法的使用相同，在此就不做介绍了
  15. replaceAll(List list,Object old,Object new)方法的使用(含义：替换批定元素为某元素,若要替换的值存在刚返回true,反之返回false)
  16. list(Enumeration e)方法的使用(含义：返回使用Enumeration生成的ArrayList,用来转换遗留的老代码)

 

https://www.cnblogs.com/MyhobbyBoKe/articles/6917122.html

https://blog.csdn.net/zgs921364401/article/details/81699508

https://www.cnblogs.com/xiaoxiaohui2015/p/5836387.html

https://blog.csdn.net/weixin_43166475/article/details/85628425

https://blog.csdn.net/a3060858469/article/details/78151242

posted @ 2019-07-13 01:54  andy_mz  阅读(168)  评论(0)    收藏  举报