集合的应用（增删改查及排序）

1.List

增删改查

类

public class KeCheng
{

    public String id;//声明变量课程的id
    public String name;//声明变量课程的名称
    
    public KeCheng(String id,String name)
    {
        this.id=id;
        this.name=name;
        
    }
}

 

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class Demo1
{

    public List kc;//声明对象kc属于list类型
    
    public Demo1()
    {
        this.kc=new ArrayList();//等价于List kc=new ArrayList();
    }
    public static void main(String[] args)
    {
        Demo1 demo1 =new Demo1();
        demo1.add();//添加
        demo1.show();//查阅
        //demo1.delall();//删除
        demo1.set();//修改
        System.out.println("======删除、修改后======");
        //demo1.zqshow();//查阅
        demo1.itshow();//查阅
    }

    //集合的添加:
    public void add()
    {
        KeCheng k1=new KeCheng("1","书法鉴赏" );
        KeCheng k2=new KeCheng("2","野外生存" );
        KeCheng k3=new KeCheng("3","动漫欣赏" );
        KeCheng[] k4={k1,k2};//创建数组，等价于KeCheng[] k4={new KeCheng("1","书法鉴赏" ),new KeCheng("2","野外生存" )}
        kc.add(k1);//个体添加
        kc.add(k2);
        kc.add(0, k3);//个体规定位置添加，原集合往后顺延一位。
        kc.addAll(Arrays.asList(k4));//数组的添加。数组，用类Arrays直接调取里面的静态asList方法，返回的是list类型。
        kc.addAll(0, Arrays.asList(k4));//数组规定位置的添加。原集合往后顺延。
    }
    
    //查阅集合内容:for循环
    public void show()
    {
        for (int i = 0; i < kc.size(); i++)
        {
            KeCheng k=(KeCheng) kc.get(i);//用kc.get(下标)调取集合里类的对象，强转为类的类型，
            System.out.println(k.id+"、"+k.name);//用类的对象调取类的属性。
        }
    }
    
    //查阅集合内容:增强for循环
    public void zqshow()
    {
        for (Object obj : kc)
        {
            KeCheng k1=(KeCheng) obj;//用增强for循环遍历出集合里类的对象，强转为类的类型，
            System.out.println(k1.id+"、"+k1.name);//用类的对象调取类的属性。
        }
    }
    
    //查阅集合内容:集合提供的Iterator
    
    public void itshow()
    {
        Iterator it=kc.iterator();
        //必须有这一步！如果直接写成kc.iterator().hasNext()，则无线循环打印第一个。
        while (it.hasNext())//用上面对象it调取Iterator的方法.   
        {
             KeCheng it1 = (KeCheng) it.next();
                //用上面对象it调取Iterator的方法. 遍历出集合里类的对象，强转为类的类型。
             System.out.println(it1.id+"、"+it1.name);//用类的对象调取类的属性。
        }
    }
    
    //修改set
    public void set()
    {
        kc.set(0, new KeCheng("2","野外生存" ));//new一个新的对象，替换指定位置的对象。
    }
    
    //删除 remove
    
    public void del()
    {
        KeCheng k2=(KeCheng) kc.get(6);
            //只能删除从集合例调取的对象！而不是new一个新的对象！！！
        kc.remove(k2);
            //不论上述调取的对象在哪位置，只能删除集合里第一个出现的此对象。
    }
    
    //删除 removeall
    
    public void delall()
    {
        KeCheng[] k2={(KeCheng) kc.get(5),(KeCheng) kc.get(6)};
            //只能删除从集合例调取的对象！而不是new一个新的对象！！！
        kc.removeAll(Arrays.asList(k2));
            //集合里所有的调取对象都会删除！！！
    }
    
    
}

排序

package www.itxm.net;
 
public class Person {
    private String id;
    private String name;
    private int age;
     
    public Person(String id, String name, int age) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    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;
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
public class PersonSort {
    public static void main(String[] args) {
        List<Person> plist = new ArrayList<Person>(); 
        //创建3个Person对象，年龄分别是32、20、25，并将他们依次放入List中 
        Person p1 = new Person("0001","zhangsan",32);
        Person p2 = new Person("0002","lisi",20);
        Person p3 = new Person("0003","wangwu",25);
        plist.add(p1);
        plist.add(p2);
        plist.add(p3);
        System.out.println("排序前的结果："+plist);
        Collections.sort(plist, new Comparator<Person>(){
            /*
             * int compare(Person p1, Person p2) 返回一个基本类型的整型，
             * 返回负数表示：p1 小于p2，
             * 返回0 表示：p1和p2相等，
             * 返回正数表示：p1大于p2
             */
            public int compare(Person p1, Person p2) {
                //按照Person的年龄进行升序排列
                if(p1.getAge() > p2.getAge()){
                    return 1;
                }
                if(p1.getAge() == p2.getAge()){
                    return 0;
                }
                return -1;
            }
        });
        System.out.println("排序后的结果："+plist); 
    }
}

数组转换为List

String[] array = {"a","b","c"};

//第一种方法：使用原生方式，拆分数组
List<String> resultList = new ArrayList<>(array.length);
for (String s : array) {
    resultList.add(s);
}

//第二种方法：Arrays.asList()
List<String> resultList= new ArrayList<>(Arrays.asList(array));

//第三种方法：Collections.addAll()
List<String> resultList = new ArrayList<>(array.length);
Collections.addAll(resultList,array);

2.Map

遍历

1、通过获取所有的key按照key来遍历

for (Integer in : map.keySet()) {
    String str = map.get(in);//得到每个key多对用value的值
}

2、通过Map.entrySet使用iterator遍历key和value

Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
     Map.Entry<Integer, String> entry = it.next();
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

3、通过Map.entrySet遍历key和value，推荐，尤其是容量大时

for (Map.Entry<Integer, String> entry : map.entrySet()) {
    //Map.entry<Integer,String> 映射项（键-值对）  有几个方法：用上面的名字entry
    //entry.getKey() ;entry.getValue(); entry.setValue();
    //map.entrySet()  返回此映射中包含的映射关系的 Set视图。
    System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

4、通过Map.values()遍历所有的value，但不能遍历key

for (String v : map.values()) {
    System.out.println("value= " + v);
}

修改

public class Demo {
    public static void main(String[] args) {
        Map<Integer,Integer> m = new HashMap<Integer,Integer>();
        m.put(1, 1);
        print(m);
        m.put(1, 2);
        print(m);
    }
 
    private static void print(Map<Integer, Integer> m) {
        for(Map.Entry<Integer, Integer> mm : m.entrySet())
            System.out.println("K: "+mm.getKey()+",V: "+mm.getValue());
    }
}
 
//供参考，重新放一个相同的key,会自动覆盖value的。

删除

private void removeMapValueTest() {
        Map<String, Object> map = new HashMap<>();// 创建map
        // 模拟添加数据
        map.put("a1", "1");
        map.put("a2", "2");
        map.put("b1", "11");
        map.put("b2", "22");
        map.put("c1", "111");
        map.put("c2", "222");
        LogUtil.e("mapOriginal",map.toString());// 打印原始map

        Iterator<String> iterator = map.keySet().iterator();// map中key（键）的迭代器对象
        while (iterator.hasNext()){// 循环取键值进行判断
            String key = iterator.next();// 键
            if(key.startsWith("a")){
                iterator.remove();// 移除map中以a字符开头的键对应的键值对
            }
        }

        LogUtil.e("mapRemove",map.toString());// 打印移除键值对后的map
    }

3.set

Set集合中的增添改查是类似于list中的，只不过不能添加到指定位置，因为Set集合是无序的，也没有get方法。历遍元素只能使用迭代器或者for each来循环历遍
 

具体方法为：

增：add();

addAll();

删：remove(object):

removeAll(Collection<?> obj):

改：没有自带的更改方法，但是我们可以组合查，删，增，的方法自己写出一个改。

 

查：contains（object）;

size():获取Set集合长度