Java基础之集合

最新推荐文章于 2023-06-18 12:25:56 发布

yhy_

最新推荐文章于 2023-06-18 12:25:56 发布

阅读量224

点赞数

本文链接：https://blog.csdn.net/weixin_36222137/article/details/59540022

版权

java集合可分为Collection和Map两种体系。

Collection接口：

|——List接口：存储有序的，可以重复的元素
* ** |——ArrayList（主要的实现类）、LinkedList（对于频繁的插入、删除操作）、Vector（古老的实现类、线程安全的）
|——Set接口：存储无序的，不可重复的元素
* * ** |——HashSet、LinkedHashSet、TreeSet

Map接口：具有映射关系”key-value对“的集合

Colletion接口常用方法


public class TestCollection {
    @Test
    public void testCollection3() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(new String("AA"));
        coll.add(new Date());
        coll.add("BB");
        coll.add(new Person("MM", 23));

        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add(new String("AA"));
        // 10.removeAll(Collection coll):从当前集合中删除包含在coll中的元素。
        coll.removeAll(coll1);
        System.out.println(coll);
        //11.equals(Object obj):判断集合中的所有元素是否完全相同
        Collection coll2 = new ArrayList();
        coll2.add(123);
        coll2.add(new String("AA1"));
        System.out.println(coll1.equals(coll2));
        //12.hashCode():
        System.out.println(coll.hashCode());
        System.out.println();
        //13.toArray() :将集合转化为数组
        Object[] obj = coll.toArray();
        for(int i = 0;i < obj.length;i++){
            System.out.println(obj[i]);
        }
        System.out.println();
        //14.iterator():返回一个Iterator接口实现类的对象,进而实现集合的遍历！
        Iterator iterator = coll.iterator();
        //方式一：不用
        /*System.out.println(iterator.next());
        System.out.println(iterator.next());
        System.out.println(iterator.next());*/
        //方式二：不用
//      for(int i = 0;i < coll.size();i++){
//          System.out.println(iterator.next());
//      }
        //方式三：使用
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    @Test
    public void testCollection2() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(new String("AA"));
        coll.add(new Date());
        coll.add("BB");
        // Person p = new Person("MM",23);
        coll.add(new Person("MM", 23));
        System.out.println(coll);
        // 6.contains(Object obj):判断集合中是否包含指定的obj元素。如果包含，返回true，反之返回false
        // 判断的依据：根据元素所在的类的equals()方法进行判断
        // 明确：如果存入集合中的元素是自定义类的对象。要求：自定义类要重写equals()方法！
        boolean b1 = coll.contains(123);
        b1 = coll.contains(new String("AA"));
        System.out.println(b1);
        boolean b2 = coll.contains(new Person("MM", 23));
        System.out.println(b2);
        // 7.containsAll(Collection coll):判断当前集合中是否包含coll中所有的元素
        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add(new String("AA"));

        boolean b3 = coll.containsAll(coll1);
        System.out.println("#" + b3);
        coll1.add(456);
        // 8.retainAll(Collection coll):求当前集合与coll的共有的元素，返回给当前集合
        coll.retainAll(coll1);
        System.out.println(coll);
        // 9.remove(Object obj):删除集合中的obj元素。若删除成功，返回true。否则，返回false
        boolean b4 = coll.remove("BB");
        System.out.println(b4);

    }

    @Test
    public void testCollection1() {
        Collection coll = new ArrayList();
        // 1.size():返回集合中元素的个数
        System.out.println(coll.size());
        // 2.add(Object obj):向集合中添加一个元素
        coll.add(123);
        coll.add("AA");
        coll.add(new Date());
        coll.add("BB");
        System.out.println(coll.size());
        // 3.addAll(Collection coll):将形参coll中包含的所有元素添加到当前集合中
        Collection coll1 = Arrays.asList(1, 2, 3);
        coll.addAll(coll1);
        System.out.println(coll.size());
        // 查看集合元素
        System.out.println(coll);
        // 4.isEmpty():判断集合是否为空
        System.out.println(coll.isEmpty());
        // 5.clear():清空集合元素
        coll.clear();
        System.out.println(coll.isEmpty());
    }
}

arraylist 常用方法
//ArrayList：List的主要实现类

 * List中相对于Collection，新增加的方法
 *  void add(int index, Object ele):在指定的索引位置index添加元素ele
    boolean addAll(int index, Collection eles)
    Object get(int index):获取指定索引的元素
    Object remove(int index):删除指定索引位置的元素
    Object set(int index, Object ele):设置指定索引位置的元素为ele
    int indexOf(Object obj):返回obj在集合中首次出现的位置。没有的话，返回-1
    int lastIndexOf(Object obj)：返回obj在集合中最后一次出现的位置.没有的话，返回-1
    List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex结束的左闭右开一个子list

    List常用的方法：增(add(Object obj)) 删(remove) 改(set(int index,Object obj))
                查(get(int index)) 插(add(int index, Object ele)) 长度(size())

注意:list集合判断重复元素只需要重写equals方法如使用coll.contains（）

//如果Person类没重写equals 返回false。反之返回turn
coll.contains(new Person("得得"，23))
coll.contains(new Person("得得"，23))

hashset
* Set:存储的元素是无序的，不可重复的！
* 1.无序性：无序性！= 随机性。真正的无序性，指的是元素在底层存储的位置是无序的。
* 2.不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去。
*
* 说明：要求添加进Set中的元素所在的类，一定要重写equals()和hashCode()方法。进而保证Set中元素的不可重复性！
*
* Set中的元素时如何存储的呢？使用了哈希算法。
* 当向Set中添加对象时，首先调用此对象所在类的hashCode()方法，计算此对象的哈希值，此哈希值
* 决定了此对象在Set中的存储位置。若此位置之前没有对象存储，则这个对象直接存储到此位置。若此位置
* 已有对象存储，再通过equals()比较这两个对象是否相同。如果相同，后一个对象就不能再添加进来。万一返回false呢，都存储。（不建议如此）
* >要求：hashCode()方法要与equals()方法一致。

Hashmap
/*
* Object put(Object key,Object value):向Map中添加一个元素 Object remove(Object
* key):按照指定的key删除此key-value void putAll(Map t) void clear():清空 Object
* get(Object key)：获取指定key的value值。若无此key，则返回null boolean containsKey(Object
* key) boolean containsValue(Object value) int size():返回集合的长度 boolean
* isEmpty() boolean equals(Object obj)
*
* HashMap： 1.key是用Set来存放的，不可重复。value是用Collection来存放的，可重复
* 一个key-value对，是一个Entry。所有的Entry是用Set存放的，也是不可重复的。
* 2.向HashMap中添加元素时，会调用key所在类的equals()方法，判断两个key是否相同。若相同则只能添加进后添加的那个元素。
*/

/*
     * 如何遍历Map Set keySet() Collection values() Set entrySet()
     */
    @Test
    public void test2() {
        Map map = new HashMap();
        map.put("AA", 213);
        map.put("BB", 45);
        map.put(123, "CC");
        map.put(null, null);
        map.put(new Person("DD", 23), 89);

        // 1.遍历key集。
        Set set = map.keySet();
        for (Object obj : set) {
            System.out.println(obj);
        }
        // 2.遍历value集
        Collection values = map.values();
        Iterator i = values.iterator();
        while (i.hasNext()) {
            System.out.println(i.next());
        }
        // 3.如何遍历key-value对。
        // 方式一：
        Set set1 = map.keySet();
        for (Object obj : set1) {
            System.out.println(obj + "----->" + map.get(obj));
        }
        // 方式二：
        Set set2 = map.entrySet();
        for (Object obj : set2) {
            Map.Entry entry = (Map.Entry) obj;
            // System.out.println(entry.getKey() + "---->" + entry.getValue());
            System.out.println(entry);
        }
    }

Collections操作list的工具类

reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

public class SortTest {  



    public static void main(String[] args) {  
        List<String> lists = new ArrayList<String>();  
        List<A> list = new ArrayList<A>();  
        List<B> listB = new ArrayList<B>();  
        lists.add("5");  
        lists.add("2");  
        lists.add("9");  
        //lists中的对象String 本身含有compareTo方法，所以可以直接调用sort方法，按自然顺序排序，即升序排序  
        Collections.sort(lists);  

        A aa = new A();  
        aa.setName("aa");  
        aa.setOrder(1);  
        A bb = new A();  
        bb.setName("bb");  
        bb.setOrder(2);  
        list.add(bb);  
        list.add(aa);  
        //list中的对象A实现Comparable接口  
        Collections.sort(list);  

        B ab = new B();  
        ab.setName("ab");  
        ab.setOrder("1");  
        B ba = new B();  
        ba.setName("ba");  
        ba.setOrder("2");  
        listB.add(ba);  
        listB.add(ab);  
        //根据Collections.sort重载方法来实现  
        Collections.sort(listB,new Comparator<B>(){  
            @Override  
            public int compare(B b1, B b2) {  
                return b1.getOrder().compareTo(b2.getOrder());  
            }  

        });  

        System.out.println(lists);  
        System.out.println(list);  
        System.out.println(listB);  

    }  

}  

class A implements Comparable<A>{  
    private String name;  
    private Integer order;  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  

    public Integer getOrder() {  
        return order;  
    }  
    public void setOrder(Integer order) {  
        this.order = order;  
    }  
    @Override  
    public String toString() {  
        return "name is "+name+" order is "+order;  
    }  
    @Override  
    public int compareTo(A a) {  
        return this.order.compareTo(a.getOrder());  
    }  

}  

class B{  
    private String name;  
    private String order;  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public String getOrder() {  
        return order;  
    }  
    public void setOrder(String order) {  
        this.order = order;  
    }  
    @Override  
    public String toString() {  
        return "name is "+name+" order is "+order;  
    }  
}  

打印的结果为：  
 [2, 5, 9]  
[name is aa order is 1, name is bb order is 2]  
[name is ab order is 1, name is ba order is 2]