Java基础之集合

Java基础之集合

Collection接口思维导图

1、List序列

List是有序、可重复的集合；

1.1 常用方法

1.  add(Object obj)：添加元素；

2.  add(int i,Object o)：在指定位置处添加元素；

3.  addAll(Collection c)：把一个集合内的元素依次添加到当前集合；

4.  addAll(int i,Collection c)：把一个集合内的元素添加到当前集合的指定位置；

5.  size()：返回序列的长度；

6.  get(int i)：返回指定位置上的元素；

7  set(int i,Object o)：修改指定位置的元素，返回被修改的原对象；

8  remove(int i)：删除指定位置的元素，返回指定位置的元素；

9.  remove(Object o)：删除指定的对象，删除成功返回true；

10.  removeAll(Collection c)：从列表中移除指定集合中包含的其所有元素，删除成功返回true；

11. clear()：清除集合中的所有元素；

12. contains(Object o)：判断集合中是否包含指定的元素，包含返回true；

13.indexOf(Object o)：返回指定元素在集合中第一次出现的下标；

14.astIndexOf(Object o)：返回指定元素在集合中最后一次出现的下标；

15.isEmpty()：当且仅当集合长度为0时，返回true；

16. subList(int start,int end)；截取集合，下标从start开始（包含），到end结束（不包含），返回一个新的集合；

实例：

1.2 添加

//获得List对象       List list = new ArrayList();       //依次添加       list.add("tom");       list.add("jack");       list.add("Lily");       list.add(3,"宋小宝");       List list2 = new ArrayList();       list2.add("张三");       list2.add("李四");       list2.add("王五"); //    list.add(list2); // list.addAll(list2);//list集合中添加另一个集合的元素       list.addAll(2, list2);

1.3 for遍历

//使用for循环遍历       for (inti = 0;i <list.size();i++) {         Object obj = list.get(i);       }             //使用foreach循环遍历       for (Objectobj :list) {         System.out.println(obj);       }

迭代器遍历：

//使用Iterator迭代器遍历       Iterator it = list.iterator();       while(it.hasNext()){         Object obj = it.next();         System.out.println(obj);       }

 

1.4 修改

//修改       Object o = list.set(0, "汤姆");//返回被修改的对象       System.out.println(o+"被修改了");

 

1.5 删除

//根据下标删除       Object o = list.remove(0);       System.out.println(o+"被删除了");       //根据对象删除       booleanb =list.remove("tom");       System.out.println(b);       //删除指定集合中的所有元素       List list3 = new ArrayList();       list3.add("tom");       list3.add("宋小宝");       list3.add("王五");       booleanb =list.removeAll(list3);       System.out.println(b);

 

1.6 泛型实例

Student s1 = new Student();       s1.name ="tom";       Student s2 = new Student();       s2.name ="jack";       Student s3 = new Student();       s3.name ="Lily";       Person p = new Person();       p.name ="张三";       //泛型，规定当前的集合只能存某种类型       List<Student> list = new ArrayList<Student>();       list.add(s1);       list.add(s2);       list.add(s3);       //遍历       for (Studentstudent :list) {         System.out.println(student.name);       } //使用迭代器遍历       Iterator<Student> it = list.iterator();       while(it.hasNext()){         Student s = it.next();         System.out.println(s.name);       }

 

1.7 集合与数组的转换实例

String[] str = {"tom","jack","Lzly","rose","Ljly","1"};       //把数组转为集合       List<String> list = Arrays.asList(str);       //把集合转为数组       Object[] obj = list.toArray();

1.8 集合排序实例

String[] str = {"tom","jack","Lzly","rose","Ljly","1"};       //把数组转为集合       List<String> list = Arrays.asList(str);       Collections.sort(list);//自然升序       Collections.reverse(list);//将集合元素倒置       Collections.shuffle(list);//随机排序             for (Strings :list) {         System.out.println(s);       }

1.9 使用排序算法对集合排序

List<Integer> list = new ArrayList<Integer>();       list.add(3);       list.add(1);       list.add(5);       list.add(2);       list.add(9);       list.add(7);             System.out.println("===========排序前==========");       for (Objectobject :list) {         System.out.print(object+" ");       }       System.out.println();       System.out.println("===========排序后==========");       for(inti = 1 ;i <list.size() ;i++){         for(intj = 0 ;j <list.size() -i;j++){            inta = (int)list.get(j);            intb = (int)list.get(j+1);            if(a >b){               list.set(j,b);               list.set(j+1,a);            }         }       }       //遍历       for (Objectobject :list) {         System.out.print(object+" ");       }       System.out.println();

 

2、Set集合

Set是不可重复，无序的集合；

2.1 常用方法

1.  add(Object o)：添加元素，添加成功返回true，重复添加，返回false；

2.  addAll(Collection c)：把一个集合内的元素添加到当前集合；

3.  contians(Object o)：判断集合中是否包含指定元素，包含返回true；

4.  isEmpty()：当且仅当集合长度为0时，返回true；

5.  iterator()：返回迭代器对象，用于遍历集合；

6.  remove(Object o)：删除集合中的指定元素，删除成功返回true；

7.  removeAll(Collection c)：从列表中移除指定集合中包含的其所有元素，删除成功返回true；

8.  clear()：清除集合中的所有元素；

9.  size()：返回集合的长度；

10.  toArray()：把集合转为数组；

 

2.2 添加

//添加       Student s1 = new Student("tom");       Student s2 = new Student("jack");       Student s3 = new Student("Lily");       Student s4 = new Student("rose");             Set<Student> set = new HashSet<Student>();       set.add(s1);       set.add(s2);             //添加set集合       Set<Student> set2 = new HashSet<Student>();       set2.add(s3);       set2.add(s4);       set.addAll(set2);       //添加list集合       List<Student> list = new ArrayList<Student>();       list.add(s3);       list.add(s4);       set.addAll(list);       //添加数组       Student[] stuArray = {s3,s4};       set.addAll(Arrays.asList(stuArray));

 

2.3 遍历

//使用foreach遍历       for (Studentstu :set) {         System.out.println(stu.name);       }             //使用迭代器遍历       Iterator<Student> it = set.iterator();       while(it.hasNext()){         Student stu = it.next();         System.out.println(stu.name);       }

 

2.4 修改

//可以使用间接的方式修改       booleanb =false;       for (Studentstu :set) {         if(stu.name.equals("tom")){//找到要修改的对象            //把该对象删除            b = set.remove(stu);            if(b){               break;            }         }       }       //添加要替换的新对象       set.add(new Student("汤姆"));

 

2.5 删除

//根据对象的属性删除，使用迭代器删除       Iterator<Student> i = set.iterator();       while(i.hasNext()){         Student stu = i.next();         if(stu.name.equals("rose")){            i.remove();         }       }       //删除指定对象       booleanb =set.remove(s1);       System.out.println(b);       //删除多个对象       Student[] stuArry = {s1,s3};       booleanb =set.removeAll(Arrays.asList(stuArry));       System.out.println(b);       //清除所有元素       set.clear();       System.out.println(set.size());

 

 

 

3、Map集合

Map集合是一种键值对映射关系，Map中的键是唯一性的，即：键不能重复，值可以重复，一个键只能对应一个值，每个值可以有多个键；

常用方法：

1.  put(K key,V value)：向map集合中添加键值对，返回上一次该键对应的值，初次添加，返回null；

2.  putAll(Map<k,v>)：将一个Map集合添加到该Map集合中；

3.  size()：返回map集合中的键值对个数；

4.  get(Key k)：通过Key返回Value；

5.  keySet()：把所有的键以set集合的形式返回；

6.  isEmpty()：当且仅当Map集合中的个数为0时，返回true；

7.  containsKey(K key)：判断集合中是否包含指定的Key；

8.  containsValue(V value)：判断集合中是否包含指定的Value；

9.  clear()：清除集合中的所有键值对；

10.  remove(K key)：根据键删除集合中的对应键值对，返回被删除键值对的值；

11.values()：返回以Collection集合的形式所有的值；

12.entrySet()：把所有的键-值对，以set集合的形式返回；

 

添加：

Map<Integer,String> map = new HashMap<Integer,String>();             String s = map.put(1, "tom");       String s2 = map.put(2, "jack");       String s3 = map.put(3, "Lily");       String s4 = map.put(4, "Lily");

 

遍历：

1.使用KeySet方法遍历

//使用KeySet获得map中的所有键值对       Set<Integer> set = map.keySet();       for (Integeri :set) {         String v = map.get(i);         System.out.println("键："+i+"，值："+v);       }

2．使用entrySet方法遍历

//使用entrySet方法遍历       Set<Entry<Integer,String>> set =map.entrySet();       for (Entry<Integer, String>e :set) {         System.out.println("键："+e.getKey());         System.out.println("值："+e.getValue());       }

3.使用values遍历值

//使用values方法遍历值       Collection<String> c = map.values();       Iterator<String> it = c.iterator();       while(it.hasNext()){         String v = it.next();         System.out.println("值："+v);       }

 

5、集合中的对象排序

实例：

Student类：

public class Student implements Comparable<Student>{    public Stringid;    public Stringname;    public Integerage;    @Override    public int compareTo(Student s) {       // TODO Auto-generated method stub       return id.compareTo(s.id);    } }

Test类：

public static void main(String[] args) {       List<Student> list = new ArrayList<Student>();       list.add(new Student("1","tom",20));       list.add(new Student("3","jack",22));       list.add(new Student("2","Lily",21));       list.add(new Student("6","hanmeimei",25));       list.add(new Student("5","Lilei",24));       //按照自然升序排序       Collections.sort(list);       //反转排序       Collections.reverse(list);      }