Java集合框架及其排序

一、集合与数组的对比

　　使用array存储对象时具有一些弊端，而java集合就像一种容器，可以动态的把多个对象的引用放入容器中。

　　数组的弊端：长度一旦设定，就不可改变；数组里的元素的个数不可知。

二、集合概况

　　|---Collection集合

　　　|---List接口：有序，可重复序列。

　　　　|---ArrayList集合（List的主要表现形式）

　　　　|---LinkedList

　　　　|---Vector

　　   |---Set接口：无序，不可重复。

　　　　|---TreeSet

　　　　|---HashSet

　　|---Map集合：key-->value 键值对

三、Collection常用方法

 

1.size():返回集合元素的个数
        
2.add():向集合中添加新元素
        
3.addAll():将形参collection中的元素复制到当前集合中
        
4、isEmpty():判断当前集合是否为空
        
5、clear():清空当前集合
    
6、contains(Object obj):判断集合中是否包含obj元素
        
7、containsAll(Collection col):判断当前集合中是否包含col集合中的所有元素。
8、retainAll():取当前集合和参数集合的交集，并保留给当前集合
        
9、remove(Object obj):删除当前集合中的第一次出现的obj，

10、removeAll(Collection coll):删除当前集合中在参数集合中也包含的元素。    
    
11、equals():比较此 collection 与指定对象是否相等

12、toArray():将当前结合转化成数组

13、hashCode():

14、iterator():返回一个Iterator接口实现类的对象。

 

　　注意：如果像集合中添加自定义类型时，比较对象是否相等，必须重写equals()方法。

四、集合的遍历

　　（1）for(int)

　　（2）增强for()

　　（3）迭代器Iterator，hasNext()，next()。

五、List

　　特点：有序可重复的代码。

　　常用方法：

　　　（1）void add(int index,Object obj);

　　　（2）boolean addAll(int index,Collection coll);

　　　（3）Object get(int index);

　　　（4）int indexOf(Object obj);

　　　（5）int lastOf(Object obj);

　　　（6）Object remove(int index);

　　　（7）Object set(int index,Object obj);

　　　（8）List subList(int fromIndex,int toIndex);

六、集合框架结构

 

 

 

七、集合工具类（Collections）

　　里面提供了常用的方法，其中就有sort(),用来给集合排序，既然能使用sort对集合进行排序，说明元素是之间是可以比较大小的，必须重写接口里的CompareTo(Object obj)方法，这个方法是用来进行元素之间的比较的。

　　this>obj　　返回>0的数

　　this<obj　　返回<0的数

　　this=obj　　返回0

　

　　Comparable-----compareTo(Object a)

　　Comparator-----compare(Object a,Object b)　　　

　　 

import org.junit.Test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;


public class Te {
    @Test
    public void test() throws Exception{
        List<Cell> list = new ArrayList<>();
        Cell cell1 = new Cell("1das",11);
        Cell cell2 = new Cell("1das",13);
        Cell cell3 = new Cell("1das",9);
        list.add(cell1);
        list.add(cell2);
        list.add(cell3);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
    }
}
class Cell implements Comparable{
    String name;
    int age;
    public Cell(){}
    public Cell(String name,int age){
        this.name = name;
        this.age = age;
    }
    public int compareTo(Object a){
        Cell c = new Cell();
        if(a instanceof Cell){
            c = (Cell) a;
        }
        return this.age-c.age;
    }

    @Override
    public String toString() {
        return "Cell{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

import org.junit.Test;

import java.util.*;

public class Te {
    @Test
    public void test() throws Exception{
        List<Cell> list = new ArrayList<>();
        Cell cell1 = new Cell("2das",11);
        Cell cell2 = new Cell("1das",11);
        Cell cell3 = new Cell("1das",9);
        list.add(cell1);
        list.add(cell2);
        list.add(cell3);
        Cell cell = new Cell();
        System.out.println(list);
        Collections.sort(list,cell);
        System.out.println(list);
    }
}
class Cell implements Comparator {
    String name;
    int age;
    public Cell(){}
    public Cell(String name,int age){
        this.name = name;
        this.age = age;
    }
    public int compare(Object a,Object b){
        Cell c = new Cell();
        Cell c1 = new Cell();
        if(a instanceof Cell){
            c = (Cell) a;
        }
        if(b instanceof Cell){
            c1 = (Cell) b;
        }
        if(c1.age!=c.age)
            return c.age-c1.age;
        else
            return c.name.compareTo(c1.name);
    }

    @Override
    public String toString() {
        return "Cell{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

 

import org.junit.Test;

import java.util.*;

public class Te {
    @Test
    public void test() throws Exception{
        Map<String,Integer> map = new HashMap<>();
        map.put("aa",11);
        map.put("ab",31);
        map.put("ad",38);
        map.put("ac",7);
        for(Iterator<Map.Entry<String,Integer> > i = map.entrySet().iterator();i.hasNext(); ){
            Map.Entry<String,Integer> c = i.next();
            System.out.println(c.getKey()+" "+c.getValue());
        }
        List<Map.Entry<String,Integer> >list = new ArrayList<>(map.entrySet());

        Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                return o2.getValue()-o1.getValue();//按value值从大到小排序
            }
        });
        System.out.println("--------------------------------------");
       for(Map.Entry<String,Integer> i:list){
           System.out.println(i.getKey()+"  "+i.getValue());
       }
    }
}

　　总结：HashMap是无序的，TreeMap默认是升序的，是对Key进行升序排序，当我们有对Value进行排序的需求时可以看上述代码。

 

图片略丑啊，哈哈哈，今天为大家更新了集合的内容，如果觉得对你有帮助的话，就请点点赞吧！！！