Java 对象集合

最新推荐文章于 2024-05-07 16:33:32 发布

Silvester123

最新推荐文章于 2024-05-07 16:33:32 发布

阅读量5.1k

点赞数 1

分类专栏： Java

本文链接：https://blog.csdn.net/Silvester123/article/details/81635986

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

java 对象集合

1.JDK中对象集合和相关接口

JDk中主要集合类型主要分为以下四种;

set:无序不可重复集合
list:有序可重复集合
map:具有映射关系集合
queue：具有队列性质集合

集合相关接口和类：

这里写图片描述

Collection是JDK中集合类型上层接口，很多相关接口和集合类都派生自它。

对象集合的一个限制：Java集合不能保存原始数据类型的数据，传入原始数据类型将转换为包装类

集合主要操作：

遍历集合中元素
按照内容在集合中查找元素
向集合中插入或删除元素

遍历操作：

1.使用迭代器对象(Iterator)

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class TestMain {

    public static void main(String[] args) {
        Collection books = new HashSet();
        books.add("One book");
        books.add("Two book");
        books.add("Three book");
        //获取books集合对应的迭代器
        Iterator it = books.iterator();
        while(it.hasNext())
        {
            String book = (String)it.next();
            System.out.println(book);
        }
        System.out.println("集合中的元素为："+books);
    }
}

Iterator接口定义了三个方法：

public Iterator<E> {
    boolean hasNext(); // return true if the iteration has more elements
    E next(); // return the next element in the iteration
    void remove(); // remove the last element returned by the iterator
}

所有实现了Collection接口的集合对象，都提供了一个iterator()方法,因此可以像上述方式遍历

如果非要在遍历时非要删除集合中的元素，则必须通过迭代器对象的remove方法，而不能通过集合对象直接删除

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class TestMain {

    public static void main(String[] args) {
        //创建一个集合
        Collection books = new HashSet();
        books.add("One book");
        books.add("Two book");
        books.add("Three book");
        //获取books集合对应的迭代器
        Iterator it = books.iterator();
        while(it.hasNext())
        {
            String book = (String)it.next();
            System.out.println(book);
            if (book.equals("Three book"))
            {
                //使用Iterator迭代过程中，通过它来移除集合元素是安全的
                it.remove();//是it.remove()不是books.remove()
            }
        }
        System.out.println("移除元素之后："+books);
    }
}

2.foreach：

这个比较简单，但要注意当使用foreach循环遍历集合时，注意不要再向集合中追加或删除元素，否则，会引发 ConcurrentModificationException

2.list和queue

List可以看成是一种动态改变大小的数组，接口方法如下：

这里写图片描述

注意，List只是一个接口，并不是类！！！

List为变量名，其真实对象需要是实现该接口的子类如ArrayList

ArrayList:可以看成一个动态数组

除了ArrayList，JDK中还有另一个类Vector同样实现了List接口，两者功能基本一样，但前者不是线程安全的。

下面实例以List接口变量名ArrayList为真实对象：

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

public class TestMain {

    public static void main(String[] args) {
        List<String> books = new ArrayList();
        //向books集合中添加三个元素
        books.add(new String("One book"));
        books.add(new String("Two book"));
        books.add(new String("Three book"));
        System.out.println(books);
        //将新字符串对象插入在第二个位置
        books.add(1 , new String("new book"));
        for (int i = 0 ; i < books.size() ; i++ )
        {
            System.out.println(books.get(i));
        }
        //删除第三个元素
        books.remove(2);
        System.out.println(books);
        //判断指定元素在List集合中位置：输出1，表明位于第二位
        System.out.println(books.indexOf(new String("new book")));
        //将第二个元素替换成新的字符串对象
        books.set(1, new String("new book2"));
        System.out.println(books);
        //将books集合的第二个元素（包括）到第三个元素（不包括）截取子集合
        System.out.println(books.subList(1 , 2));
    }
}

List中的indexOf(Object o)和lastIndexOf(Object o)方法：传入的类需要实现equal方法，即需要能够判断两个对象的内容是否完全一致。

固定大小List：定义于Arrays类的内部类ArrayList,是一个固定长度的List集合，只能遍历访问，不能增加和删除元素，否则，会引发 UnsupportedOperationException。

Stack:JDK中提供了现成的堆栈类——Stack，注意它派生自Vector，所以它是线程安全的。

import java.util.Stack;

public class TestMain {

    public static void main(String[] args) {
        Stack<String> names = new Stack<>();
        names.push("Raymond");
        names.push("David");
        System.out.println("Top of stack: " + names.peek());
        names.pop();
        System.out.println("Top of stack: " + names.peek());
        names.push("Cynthia");
        System.out.println("Top of stack: " + names.peek());
        //如果堆栈为空，再次pop会抛出EmptyStackException
        if (!names.empty()) {
           names.pop();
        }
        System.out.println("Top of stack: " + names.peek());
        names.pop();
        if (!names.empty()) {
           System.out.println("Top of stack: " + names.peek());
        } else {
           System.out.println("Stack empty.");
        }
    }
}

LinkedList更多参考：https://www.cnblogs.com/skywang12345/p/3308807.html

Queue接口代表的是“经典”的队列，JDK中还扩充定义了另一个Deque接口，代表“双向队列”，用途更广。

这里写图片描述

PriorityQueue:非线程安全，无容量限制。允许元素重复。其顺序由元素自己（如果实现了Comparable接口）或 Compartor提供，会将它所包容的元素自动排序。

import java.util.PriorityQueue;

public class TestMain {

    public static void main(String[] args) {
        PriorityQueue pq = new PriorityQueue();
        //下面代码依次向pq中加入四个元素
        pq.offer(6);
        pq.offer(-3);
        pq.offer(9);
        pq.offer(0);
        pq.offer(110);
        //输出pq队列，并不是按元素的加入顺序排列，而是按元素的二叉树顺序排列
        System.out.println(pq);
        //访问队列第一个元素，其实就是队列中最小的元素：-3
        System.out.println(pq.peek());

        pq.poll();
        System.out.println("\n 移除队列中的head元素之后");
        System.out.println(pq);
        pq.remove(9);
        System.out.println("\n 移除队列中的元素9之后");
        System.out.println(pq);
    }
}

CurrentLinkedQueue:这是一个线程安全的（FIFO：First In First Out）的容量不限的队列。其内部使用一种基于 “CAS（Compare and Swap）”的算法，能保证访问它的线程总能完成它要执行的操作而不会被提前中断

BlockingQueue接口:此接口派生自Queue，最适合于实现生产者-消费者问题

Deque接口：双向队列。既像Queue，又像Stack。

3.Map

这里写图片描述

Map集合给每个元素定义了一个Key，通过Key来访问对象
要求每个对象的Key应该不一样，否则，会带来混乱

Map接口成员：

这里写图片描述

HashMap:

使用put(Key,Value)方法追加元素，使用get(Key)方法提取元素
通过HashMap对象的keySet()方法引用其Key的集合，通过其values()方法引用其Value的集合。Key和Value之间的对应关系，是通过HashMap内部的一个Map.Entry对象集合实现的，HashMap对象的entrySet方法引用这一对象集合

HashMap简单使用(遍历):

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class TestMain {

    public static void main(String[] args) {
        HashMap<String, Integer> hm = new HashMap<>();
        for (int i = 1; i < 10; i++) {
            hm.put("Key" + i, i);
        }
        // 使用KeySet遍历集合
        Set<String> keySet = hm.keySet();

        for (String key : keySet) {

            System.out.println(key + ":" + hm.get(key));
            // 循环遍历过程中，不允许移除元素，否则，引发ConcurrentModificationException
        }

        System.out.println("\n使用Iterator遍历并移除元素");
        Set<Map.Entry<String, Integer>> entrySet = hm.entrySet();
        Iterator<Map.Entry<String, Integer>> itor = entrySet.iterator();
        while (itor.hasNext()) {
            Map.Entry<String, Integer> entry = itor.next();
            if(entry.getValue() % 2!=0){
                itor.remove();
                System.out.println(entry.getKey() + ":" + entry.getValue()+" is removed");
            }
            else{
                System.out.println(entry.getKey() + ":" + entry.getValue());    
            }
        }
    }
}

HashMap可以使用null作为key，且只会有一个null作key的键值对，多的会覆盖掉。

HashTable:HashMap和HashTable两者功能基本一样，但HashTable是线程安全的

Map集合对Key要求：

用作Key的对象必须覆盖hashCode和equals方法
Key相等：两个对象的hashCode一致，并且equals方法返回true
Value相等：equals方法返回true

上述特性对HashTable的containsValue()方法返回值的影响如实例：

import java.util.*;

public class TestMain {

    public static void main(String[] args) {
        Hashtable ht = new Hashtable();
        ht.put(new MyKey(60000) , "key值为60000所对应的Value");
        ht.put(new MyKey(87563) , "Key值为87563所对应的Value");
        ht.put(new MyKey(1232) , new B());
        System.out.println(ht);
        //只要两个对象通过equals比较返回true，Hashtable就认为它们是相等的value。
        //因为Hashtable中有一个B对象，它与任何对象通过equals比较都相等，所以下面输出true。
        System.out.println(ht.containsValue("测试字符串"));
        //只要两个A对象的count属性相等，它们通过equals比较返回true，且hashCode相等
        //Hashtable即认为它们是相同的key，所以下面输出true。
        System.out.println(ht.containsKey(new MyKey(87563)));
        //下面语句可以删除最后一个key-value对
        ht.remove(new MyKey(1232));
        for (Object key : ht.keySet())
        {
            System.out.print(key + "---->");
            System.out.print(ht.get(key) + "\n");
        }
    }
}
class MyKey
{
    int value;
    public MyKey(int count)
    {
        this.value = count;
    }
    public boolean equals(Object obj)
    {
        if (obj == this)
        {
            return true;
        }
        if (obj != null &&  obj.getClass() == MyKey.class)
        {
            MyKey a = (MyKey)obj;
            if (this.value == a.value)
            {
                return true;
            }
        }
        return false;
    }
    public int hashCode()
    {
        return this.value;
    }
    public String toString(){
        return "MyKey:"+this.value;
    }
}
class B
{
    public boolean equals(Object obj)
    {
        return true;
    }
}

Properties类：派生自HashTable，可以方便地处理“属性-值”对，并且可以很方便地将其保存到文件中

NavigableMap接口：，保证在遍历集合时，一定是按照升序进行的

实现NavigableMap接口最常用的类型是 TreeMap，它的用法与标准的Map没什么两样

TreeMap的独特之处在于：它内部基于红黑树（red-black tree）对Key进行排序。因此，它的元素是“有序”的。

import java.util.*;

public class TestMain {

    public static void main(String[] args) {
        TreeMap tm = new TreeMap();
        tm.put(new R(3) , "Key值为3的value");
        tm.put(new R(-5) , "Key值为-5的value");
        tm.put(new R(9) , "Key值为9的value");
        System.out.println("TreeMap集合中的所有元素：\n"+tm);
        //返回该TreeMap的第一个Entry对象
        System.out.println("\n第一个Entry对象："+tm.firstEntry());
        //返回该TreeMap的最后一个key值
        System.out.println("最后一个key值:"+tm.lastKey());
        //返回该TreeMap的比new R(2)大的最小key值。
        System.out.println("比new R(2)大的最小key值:"+tm.higherKey(new R(2)));
        //返回该TreeMap的比new R(2)小的最大的key－value对。
        System.out.println("比new R(2)小的最大的key－value对:"+tm.lowerEntry(new R(2)));
        //返回该TreeMap的子TreeMap
        System.out.println("该TreeMap的子TreeMap:"+tm.subMap(new R(-1) , new R(4)));
    }
}

//R类，重写了equals方法，如果value属性相等返回true
//重写了compareTo(Object obj)方法，如果value属性相等返回0;
class R implements Comparable
{
    int value;
    public R(int value)
    {
        this.value = value;
    }
    public String toString()
    {
        return "R(value属性:" + value + ")";
    }
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (obj != null && obj.getClass() == R.class)
        {
            R r = (R)obj;
            if (r.value == this.value)
            {
                return true;
            }
        }
        return false;
    }
    public int compareTo(Object obj)
    {
        R r = (R)obj;
        if (this.value > r.value)
        {
            return 1;
        }
        else if (this.value == r.value)
        {
            return 0;
        }
        else
        {
            return -1;
        }
    }
}

JDK中提供了以下Map类型实现多线程环境下的安全访问：

ConcurrentHashMap
ConcurrentNavigableMap
ConcurrentSkipListMap

4.Set

Set也是一种Collection，其中不允许有重复元素。Set通过调用对象的equals方法确定两个对象是否相同。

HashSet原理：

HashSet将对象的哈希码作为访问对象的“索引（index）”。
当向HashSet存入一个对象时，它会同时调用hashCode()和equals()两个方法确定此对象是否己在集合中，如果发现己经有了，则不会把此对象加入到集合中
HashSet中每个存储元素的“Slot（槽）”通常被称为“bucket”，如果有多个元素的hashCode相等，但它们 equals()方法返回False，这就导致同一个槽中放置多个元素，这会导致性能下降
HashSet在内部包容一个HashMap，以对象的 hashCode作为这一Map的Key

import java.util.*;

public class TestMain {

    public static void main(String[] args) {
        HashSet books = new HashSet();
        //分别向books集合中添加2个A对象，2个B对象，2个C对象
        books.add(new A());
        books.add(new A());//hash值不同，故可以添加，位于不同槽
        books.add(new B());
        books.add(new B());//hash值相同，但equal返回false,可添加位于同一个槽
        books.add(new C());
        books.add(new C());//hash值相同，equal返回true，故不可再添加
        //输出：[B@1, B@1, C@2, A@15db9742, A@6d06d69c]
        System.out.println(books);
    }
}
//类A的equals方法总是返回true,但没有重写其hashCode()方法
class A
{
    public boolean equals(Object obj)
    {
        return true;
    }
}
//类B的hashCode()方法总是返回1,但没有重写其equals()方法
class B
{
    public int hashCode()
    {
        return 1;
    }
}
//类C的hashCode()方法总是返回2
class C
{
    public int hashCode()
    {
        return 2;
    }
    public boolean equals(Object obj)
    {
        return true;
    }
}

使用HashSet集合(TreeSet类似)保存对象时要注意,尽量不要修改对象的属性值，否则，可能会出现很奇怪的现象。推荐在HastSet中保存不可变类的实例。

LinkedHashSet:派生自HashSet，也是按照对象的hashCode来保存，但它同时使用双向链表来维护对象的顺序,当遍历LinkedHashSet时，将按插入顺序来显示集合中的对象

SortedSet接口:SortedSet保证总是按照升序方式访问集合中的数据。使用SortedSet的一个最大好处是：如果合并两个这样的集合，合并之后，集合仍然是有序的。JDK中的TreeSet实现了SortedSet接口。

TreeSet:

在任何时刻访问TreeSet时，总能得到一个”己经排好序的对象集合”,TreeSet内部调用compareTo(Object obj)方法来比较集合中各个对象的大小，然后在内部使用红黑树进行排序
TreeSet要求其元素必须实现Comparable接口，并且应该是同一个类型的，否则，将引发ClassCastException

import java.util.*;

public class TestMain {

    public static void main(String[] args) {
        TreeSet nums = new TreeSet();
        //向TreeSet中添加四个Integer对象
        nums.add(5);
        nums.add(2);
        nums.add(10);
        nums.add(-9);
        //输出集合元素，看到集合元素已经处于排序状态
        System.out.println("集合元素:"+nums);
        //输出集合里的第一个元素
        System.out.println("集合里的第一个元素:"+nums.first());
        //输出集合里的最后一个元素
        System.out.println("集合里的最后一个元素:"+nums.last());
        //可以输出指定元素的“前一个”和“后一个”
        System.out.println("10之前的那个元素是："+nums.lower(10));
        System.out.println("10之后的那个元素是："+nums.higher(10));
        //返回小于4的子集，不包含4
        System.out.println("返回小于4的子集，不包含4:"+nums.headSet(4));
        //返回大于5的子集，如果Set中包含5，子集中还包含5
        System.out.println("返回大于5的子集:"+nums.tailSet(5));
        //返回大于等于-3，小于4的子集。
        System.out.println("返回大于等于-3，小于4的子集:"+nums.subSet(-3 , 4));
    }
}

参考：

金旭亮Java编程系列(大部分内容摘自该教程)

Silvester123

关注

1
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
Java 对象集合

java 对象集合1.JDK中对象集合和相关接口JDk中主要集合类型主要分为以下四种;set:无序不可重复集合list:有序可重复集合map:具有映射关系集合queue：具有队列性质集合集合相关接口和类：Collection是JDK中集合类型上层接口，很多相关接口和集合类都派生自它。对象集合的一个限制：Java集合不能保存原始数据类型的数据，传入原始数据类...
复制链接

扫一扫