在遍历列表时需要验证数据的正确性，每遍历一次就要根据name查询数据库数据效率很慢，代码如下：
 
//获得第一个表单的迭代器
Iterator<org.apache.poi.ss.usermodel.Row> rows = sheet.rowIterator();
// 去除标题首行
rows.next();
int rownum = 1;
while (rows.hasNext()) {
   rownum++;
   Row row = rows.next();
   companyInfo = new CompanyInfo(row);
   Map map = nyCompanyDao.getCompanyByName(companyInfo.getName);
   if (null == map|| map.get("c_companyid") == null || "".equals(map.get("c_companyid").toString())) {
      continue;
   }
}

 
 后改为在循环外查询出符合条件的所有数据放到Map里，然后在列表遍历时判断Map是否存在相同的key值，这样效率会快很多。代码如下：
 
List<Map<String, Object>> list = nyCompanyDao.getCompanyList();
Map<String, Object> cMap = new HashMap<>();
if (null != list && list.size() > 0) {
    for (Map map : list) {
	cMap.put(map.get("companyName").toString(), map.get("companyId"));
    }
}
while (rows.hasNext()) {
    rownum++;
    Row row = rows.next();
    companyInfo = new CompanyInfo(row);
    if (!cMap.containsKey(companyInfo.getName())) {
	continue;
    }
}
 
 但是不适合查询的表数据量太大的。
 
 
 
 
 
 
 
 
 
 
 
 

1._遍历方式
 
其实遍历的就两种,对象和数组.只是哪个遍历适用于哪个而已
 
for
for增强
foreach
迭代(Iterable)
Arrays.toString
 
2._数组遍历
 
package com.demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

public class demo {
    public static void main(String[] args) {
        // 数组遍历方式
        String[] arrs = {"a", "b", "c"};

        // 第一种方法
        for (int i = 0; i < arrs.length; i++) {
            System.out.println(arrs[i]);
        }
        System.out.println("================");
        // 第二种方式
        for (String str : arrs) {
            System.out.println(str);
        }
        System.out.println("================");
        // 第三种方式
        System.out.println(Arrays.toString(arrs));

    }
}

 
2._list
 
方法名
描述
void add(int index,E element)
在此集合中的指定位置插入指定的元素
E remove(int index)
删除指定索引处的元素，返回被删除的元素
E set(int index,E element)
修改指定索引处的元素，返回被修改的元素
E get(int index)
返回指定索引处的元素
package com.entify;

import java.util.ArrayList;
import java.util.Iterator;

public class Demo {
    public static void main(String[] args) {
        // 对象遍历方式
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");

        //第一种方式
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("================");
        // 第二种方式
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("================");
        // 第三种方式
        Iterator<String> iterator = list.iterator();
        if (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        System.out.println("================");
        // 第四种方式
        list.forEach(item -> System.out.println(item));
        list.forEach(System.out::println); // 第四种方式第二种写法


    }
}

 
3._set
 
  A:添加功能
    boolean add(E e);
    boolean addAll(Collection<? extends E> c);

    B:删除功能
    boolean remove(Object o);
    boolean removeAll(Collection<?> c);
    void clear();

    C:长度功能
    int size();

    D:判断功能
    boolean isEmpty();
    boolean contains(Object o);
    boolean containsAll(Collection<?> c);
    boolean retainAll(Collection<?> c); 

    E:获取Set集合的迭代器：
    Iterator<E> iterator();

    F:把集合转换成数组
    Object[] toArray();
    <T> T[] toArray(T[] a);
    
    //判断元素是否重复，为子类提高重写方法
    boolean equals(Object o);
    int hashCode();
 
package com.entify;

import java.util.HashSet;
import java.util.Iterator;

public class Demo {
    public static void main(String[] args) {
        HashSet<String> set=new HashSet<String>();
        set.add("b");
        set.add("b");
        set.add("a");
        set.add("c");
        System.out.println(set);//[a, b, c]

        // 第一种方式
        for (String str : set) {
            System.out.println(str);
        }
        System.out.println("================");
        // 第二种方式
        Iterator it = set.iterator();
        while (it.hasNext()) {
            String str =(String) it.next();
            System.out.println(str);
        }
        // 第三种方式
        set.forEach(item -> System.out.println(item));
        set.forEach(System.out::println); // 第四种方式第二种写法


    }
}

 
4._map
 
方法名
说明
V put(K key,V value)
添加元素
V remove(Object key)
根据键删除键值对元素
void clear()
移除所有的键值对元素
boolean containsKey(Object key)
判断集合是否包含指定的键
boolean containsValue(Object value)
判断集合是否包含指定的值
boolean isEmpty()
判断集合是否为空
int size()
集合的长度，也就是集合中键值对的个数
V get(Object key)
根据键获取值
Set keySet()
获取所有键的集合
Collection values()
获取所有值的集合
Set<Map.Entry<K,V>> entrySet()
获取所有键值对对象的集合
package com.entify;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class Demo {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(2,"b");
        map.put(1,"b");
        map.put(1,"a");
        map.put(4,"b");
        map.put(3,"c");
        System.out.println(map);  // {1=a, 2=b, 3=c, 4=b}


        // JDK1.4中
        // 遍历方法一 hashmap entrySet() 遍历
        Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<Integer, String> data = it.next();   // 依次获取每行的数据
            Object key = data.getKey();
            Object value = data.getValue();
            System.out.println("key=" + key + " value=" + value);
        }
        System.out.println("==============================");

        // JDK1.5中,应用新特性For-Each循环
        // 遍历方法二
        for (Map.Entry<Integer, String> data : map.entrySet()) {
            Object key = data.getKey();
            Object value = data.getValue();
            System.out.println("key=" + key + " value=" + value);
        }
        System.out.println("===============================11");



        // 遍历方法三 hashmap keySet() 遍历
        for (Iterator i = map.keySet().iterator(); i.hasNext();) {
            Object obj = i.next();
            System.out.println(obj);// 循环输出key
            System.out.println("key=" + obj + " value=" + map.get(obj));
        }
        for (Iterator i = map.values().iterator(); i.hasNext();) {
            Object obj = i.next();
            System.out.println(obj);// 循环输出value
        }
        System.out.println("===============================11");


        // 遍历方法四 treemap keySet()遍历
        for (Object o : map.keySet()) {
            System.out.println("key=" + o + " value=" + map.get(o));
        }
        System.out.println("===============================11");
        
    }
}

 
stream遍历
 
https://blog.csdn.net/weixin_44797182/article/details/120298300
 
6._Enumeration遍历
 
通过Enumeration的源码分析可得，Enumeration有两个方法：
 （1）boolean hasMoreElements();//是否还有元素，如果有返回true，否则表示至少含有一个元素
 （2）E nextElement();//如果Enumeration枚举对象还有元素，返回对象只能的下一个元素，否则抛出NoSuchElementException异常。
 
简单示例：
 
public class TestEnumeration{
public static void main(String[] args){
        Vector v = new Vector();
        v.addElement("Lisa");
        v.addElement("Billy");
        v.addElement("Mr Brown");
        Enumeration e = v.elements();//返回Enumeration对象
        while(e.hasMoreElements()){
            String value = (String)e.nextElement();//调用nextElement方法获得元素
            System.out.print(value);
        }
    }
}
 

public static void main(String[] args) {
 List list = new ArrayList();
 list.add(“aa”);
 list.add(“bb”);
 list.add(“aa”);
 list.add(“cc”);
HashSet set = new HashSet<>(list);
 Boolean result = set.size() == list.size() ? true : false;
 System.out.println(result);
 }
 
list中aa元素重复，所以运行结果是：false
 
 
 
 
 
 
 
 
 
                            ---------------长按二维码关注程序媛小姐姐公众号有更多彩蛋哦---------------
 
                                             

遍历List集合的三种方式
 
List集合在Java日常开发中是必不可少的，只要懂得运用各种各样的遍历集合方法就可以大大提高我们开发的效率，适当使用各种方法才会使我们开发事半功倍。
 　　我总结了三种List集合的遍历方式，下面一一来介绍。
 
首先创建一个集合
 
 ArrayList<String> names = new ArrayList<String>();
        names.add("第一个");
        names.add("第二个");
        names.add("第三个");
        names.add("第四个");
        names.add("第五个");
        
 
使用for循环遍历集合
 
 for (int i = 0; i <names.size() ; i++) {
            String temp = names.get(i);//获取集合的每一项
            System.out.println(temp);
            if( "第三个".equals(temp))//将“第三个”删除
            {
               names.remove(temp);
            }
        }
        System.out.println(names);
 
		注意：
					1.当使用for循环删除同样的相邻集合元素，只会删除第一个，原因：当删除集合元素时，首先将集合元素的下标整个上移一位，然后for循环的变量i会加1，这样第二个重复的元素不会删除。
					2.在遍历过程可以修改集合的长度。
 
使用foreach遍历集合
 
 for (String temp:names) {
         if("itcast".equals(temp))
         {
             names.add("TEST");
         }
      }
       System.out.println(names);
 
	注意：使用foreach在遍历集合时，不能对集合的长度进行修改，否则会抛出 ConcurrentModificationException异常
 
使用迭代器遍历集合
 
//创建迭代器
        Iterator<String> it = names.iterator();
         while (it.hasNext()) {
            String itname = it.next();
            //这里使用若是集合里有空指针：itname.equals("itcast")回报异常
            //变量与常量判断时，将常量放在前面，为了预防出现空指针问题
            if ("第一个".equals(itname)) {
                //删除集合中的“第一个”元素
                 it.remove();
                //names.remove(itname);
            }
        }
        System.out.println(names);
 
注意： 迭代器在遍历中不能使用修改集合长度的list集合方法，不过若要删除可以使用迭代器的remove方法
 
我是小白，如有不足，欢迎大家指正