List集合类方法的使用

时间 2019-12-05
原文原文链接
Java代码  收藏代码
import java.util.ArrayList;  
import java.util.Iterator;  
import java.util.LinkedList;  
//import java.awt.List;  
import java.util.List;     //当出现下面的错误时，是由于少了这句，多了上面注释的一句，请看仔细  
    //The type List is not generic; it cannot be parameterized with arguments <String>  
  
  
public class TestList {  
      
  
  public static void  main(String args[]){  
        
        
      List<String> l = new ArrayList<String>();// 利用ArrayList类实例化List集合  
      List<String> l2 = new LinkedList<String>();// 利用LinkedList类实例化List集合  
  
      //add(int index, Object obj)方法和set(int index, Object obj)方法的区别  
      String a = "A", b = "B", c = "C", d = "D", e = "E";  
      List<String> list = new LinkedList<String>();       //LinkedList  链式 至关于下表从0开始的  
      list.add(a);                                   //add()方法  
      list.add(e);  
      list.add(d);  
      list.set(1, b);      // 将索引位置为1的对象e修改成对象b  
      list.add(2, c);      // 将对象c添加到索引位置为2的位置  
      Iterator<String> it = list.iterator();    //遍历时的方式*****方法1  
      while (it.hasNext()) {  
      System.out.println(it.next());  
      }  
        
      for(int i = 0; i < list.size(); i++) {  //遍历时的方式*****方法2  
          System.out.println(list.get(i));    // 利用get(int index)方法得到指定索引位置的对象  
         }  
  
        
      //indexOf(Object obj)方法和lastIndexOf(Object obj)方法的区别  
      System.out.println("开始：");  
      String aa = "A", bb = "B", cc = "C", dd = "D", repeat = "Repeat";  
      List<String> list2 = new ArrayList<String>();  
      list2.add(aa); // 索引位置为 0  
      list2.add(repeat); // 索引位置为 1  
      list2.add(bb); // 索引位置为 2  
      list2.add(repeat); // 索引位置为 3  
      list2.add(cc); // 索引位置为 4  
      list2.add(repeat); // 索引位置为 5  
      list2.add(dd); // 索引位置为 6  
      System.out.println(list2.indexOf(repeat));  
      System.out.println(list2.lastIndexOf(repeat));  
      System.out.println(list2.indexOf(bb));  
      System.out.println(list2.lastIndexOf(bb));  
      System.out.println("结束！");  
  
//subList(int fromIndex, int toIndex)方法  
//在使用subList(int fromIndex, int toIndex)方法截取现有List集合中的部分对象生成新的List集合时，  
//须要注意的是，新生成的集合中包含起始索引位置表明的对象，可是不包含终止索引位置表明的对象  
      // list a b c d e  
      list = list.subList(1, 3);// 利用从索引位置 1 到 3 的对象从新生成一个List集合  
      for (int i = 0; i < list.size(); i++) {  
      System.out.println(list.get(i));  
      }  
      
      List list22 = new LinkedList();  
      list22 = list.subList(0,1);  //b  
  
      list22.add(aa);  
      list22.add("zhang");  
      list22.add("guang");   //此时 list22 为  B A zhang guang  
      list22.set(0, a);  
      list22.set(1, b);      //此时 list22 为  A B zhang guang  
      for (int i = 0; i < list22.size(); i++) {  
      System.out.println(list22.get(i));  
      }  
      System.out.println("*********************************");  
      List list33 = new LinkedList();  
      list33=list22.subList(1, 3);  
      list22.addAll(list33);                 //总体加list时要用addAll()方法  
      for (int i = 0; i < list22.size(); i++) {  
          System.out.print(list22.get(i)+"\t.");  //get()方法  
          }  
        
//    list33.clear();  
//    for (int i = 0; i < list33.size(); i++) {  
//        System.out.println(list33.get(i));  
//        }  
      System.out.println(list22.contains(a));          // contains()方法  
      //System.out.println(list22.containsAll(list33));  // containsAll()方法  
        
      list22.remove(0);  
      for (int i = 0; i < list22.size(); i++) {  
          System.out.print(list22.get(i)+"\t.");  //get()方法  
          }  
        
      System.out.println("\n"+list22.size());  //size()  
        
      Object[] str = list22.toArray();      //toArray()方法 为Object类型  
      for(int i=0;i<str.length;i++){  
          System.out.print(str[i]+"\t");  
      }  
       System.out.println("\n"+list22+"\t");  //请看直接输出的格式！！！！  
      //run：[B, zhang, guang, B, zhang]   
      //System.out.println(list33+"\t");  
        
  }  
}
遍历List集合的三种方法
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
方法一：
超级for循环遍历
for(String attribute : list) {
  System.out.println(attribute);
}
方法二：
对于ArrayList来讲速度比较快, 用for循环, 以size为条件遍历:
for(int i = 0 ; i < list.size() ; i++) {
  system.out.println(list.get(i));
}
方法三：
集合类的通用遍历方式, 从很早的版本就有, 用迭代器迭代
Iterator it = list.iterator();
while(it.hasNext()) {
  System.ou.println(it.next);
}
例子：
package package1;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;


public class demo2 {
public static void main(String[] args) {
	//定义数组
	String[] str= {"hello你好","喂，你好","哈哈哈哈"};
	//定义集合
	List<String> list=new ArrayList<String>();
	//把数组添加在集合中
	for(int i=0;i<str.length;i++) {
		list.add(str[i]);
	}
	//遍历集合
	ListIterator<String> iterator=list.listIterator();
	while (iterator.hasNext()) {
		System.out.println(iterator.next());
	}
	System.out.println("-------反向迭代--------");
	while (iterator.hasPrevious()) {
		System.out.println(iterator.previous());
	}
}
}
结果：
hello你好
喂，你好
哈哈哈哈
-------反向迭代--------
哈哈哈哈
喂，你好
hello你好  
--------------------------------------经常使用方法--------------------------------------------
l 增长元素方法

l add(Object e)：向集合末尾处，添加指定的元素

l add(int index, Object e)：向集合指定索引处，添加指定的元素，原有元素依次后移

l 删除元素删除

l remove(Object e)：将指定元素对象，从集合中删除，返回值为被删除的元素

l remove(int index)：将指定索引处的元素，从集合中删除，返回值为被删除的元素

l 替换元素方法

l set(int index, Object e)：将指定索引处的元素，替换成指定的元素，返回值为替换前的元素

l 查询元素方法

l get(int index)：获取指定索引处的元素，并返回该元素
--------------------Map集合：---------------------------------------------
Map<String,Object> hashMap = new HashMap<>();
        //添加元素到 Map 中
        hashMap.put("key1", "value1");
        hashMap.put("key2", "value2");
        hashMap.put("key3", "value3");
        hashMap.put("key4", "value4");
        hashMap.put("key5", "value5");
         
        //删除 Map 中的元素,经过 key 的值
        hashMap.remove("key1");
         
        //经过 get(key) 获得 Map 中的value
        Object str1 = hashMap.get("key1");
         
        //能够经过 添加 方法来修改 Map 中的元素
        hashMap.put("key2", "修改 key2 的 Value");
         
        //经过 map.values() 方法获得 Map 中的 value 集合
        Collection<Object> value = hashMap.values();
        for(Object obj : value){
            //System.out.println(obj);
        }
         
        //经过 map.keySet() 获得 Map 的key 的集合，而后 经过 get(key) 获得 Value
        Set<String> set = hashMap.keySet();
        for(String str : set){
            Object obj = hashMap.get(str);
            //System.out.println(str+"="+obj);
        }
         
        //经过 Map.entrySet() 获得 Map 的 Entry集合，而后遍历
        Set<Map.Entry<String, Object>> entrys = hashMap.entrySet();
        for(Map.Entry<String, Object> entry: entrys){
            String key = entry.getKey();
            Object value2 = entry.getValue();
            System.out.println(key+"="+value2);
        }
         
        System.out.println(hashMap);