Java基础之集合

最新推荐文章于 2023-04-02 23:11:58 发布

icanhaha

最新推荐文章于 2023-04-02 23:11:58 发布

阅读量462

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/icanhaha/article/details/22290805

版权

Java基础专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1. Java集合框架图

一、set:无序，不可重复 HashSet LinkedHashSet TreeSet

HashSet:

1）HashSet是Set的最典型实现

2）HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取和查找性能。

3）根据HashCode的值来存储元素，所以不能保证元素的排列顺序

4）HashCode中不能有重复元素，判定两个元素相等的标准：equals()方法返回true

5）如果两个对象通过equals()方法返回true，这两个对象的HashCode也应当相同。

6）HashSet 不是线程安全的

7）集合元素可以使 null

	/*
	  * HashSet
	  * 输出结果：
	  * Card{shape=CC, size=60}
	  * Card{shape=DD, size=70}
	  * Card{shape=BB, size=50}
	  * Card{shape=AA, size=40}
	  */
	 Collection coll = new HashSet();
	 coll.add(new Card("AA",40));
	 coll.add(new Card("BB",50));
	 coll.add(new Card("CC",60));
	 coll.add(new Card("DD",70));
	 Iterator iterator = coll.iterator();
	 while(iterator.hasNext()){
		 System.out.println(iterator.next());
	 }

LinkedHashSet

1）LinkedHashSet 是 HashSet 的子类

2）LinkedHashSet 集合根据元素的 hashCode 3）值来决定元素的存储位置，但它同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的。

4）LinkedHashSet 性能插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。

5）LinkedHashSet 不允许集合元素重复。

         /*
          * LinkedHashSet
          * 输出结果：
          * Card{shape=AA, size=40}
          * Card{shape=BB, size=50}
          * Card{shape=CC, size=60}
          * Card{shape=DD, size=70}
          */
         Collection coll = new LinkedHashSet();
         coll.add(new Card("AA",40));
         coll.add(new Card("BB",50));
         coll.add(new Card("CC",60));
         coll.add(new Card("DD",70));
         Iterator iterator = coll.iterator();
         while(iterator.hasNext()){
             System.out.println(iterator.next());
         }

TreeSet

1）TreeSet 是 SortedSet 接口的实现类，TreeSet 可以确保集合元素处于排序状态。

Comparator comparator()

Object first()

Object last()

Object lower(Object e)

Object higher(Object e)

SortedSet subSet(fromElement, toElement)

SortedSet headSet(toElement)

SortedSet tailSet(fromElement)

2）TreeSet 支持两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。

3）自然排序：默认情况下TreeSet要求集合中的元素必须实现Comparable接口。TreeSet会调用每个元素的compareTo()方法去和每个已经有的元素去比较，进而决定当前元素在集合中的位置。

4）定制排序：如果需要实现定制排序，则需要在创建 TreeSet 集合对象时，提供一个 Comparator 接口的实现类对象。由该 Comparator 对象负责集合元素的排序逻辑

	 /*
      * TreeSet -- 自然排序
      * 运行结果：
      * Card{shape=FF, size=50}
      * Card{shape=CC, size=30}
      * Card{shape=BB, size=40}
      * Card{shape=AA, size=20}
      */
	 TreeSet treeSet = new TreeSet();
	 treeSet.add(new Card("AA",20));
	 treeSet.add(new Card("CC",30));
	 treeSet.add(new Card("BB",40));
	 treeSet.add(new Card("FF",50));
	 Iterator iterator = treeSet.iterator();
	 while(iterator.hasNext()){
		 System.out.println(iterator.next());
	 }	
	
	
	/*
      * TreeSet -- 定制排序
      * 运行结果：
	  * Card{shape=FF, size=50}
	  * Card{shape=BB, size=40}
	  * Card{shape=CC, size=30}
	  * Card{shape=AA, size=20}
      */	
	Comparator comparator = new Comparator() {
		@Override
		public int compare(Object o1, Object o2) {
			if(o1 instanceof Card && o2 instanceof Card){
				Card c1 = (Card)o1;
				Card c2 = (Card)o2;
				return -c1.getSize() + c2.getSize();
			}
			return 0;
		}
	};
	 
	 TreeSet treeSet = new TreeSet(comparator);
	 treeSet.add(new Card("AA",20));
	 treeSet.add(new Card("CC",30));
	 treeSet.add(new Card("BB",40));
	 treeSet.add(new Card("FF",50));
	 Iterator iterator = treeSet.iterator();
	 while(iterator.hasNext()){
		 System.out.println(iterator.next());
	 }

二、List 有序可重复。 ArrayList（数组） LinkedList（链表）

1）List 代表一个元素有序、且可重复的集合，集合中的每个元素都有其对应的顺序索引

2）List 允许使用重复元素，可以通过索引来访问指定位置的集合元素。

3）List 默认按元素的添加顺序设置元素的索引。

4）List 集合里添加了一些根据索引来操作集合元素的方法

void add(int index, Object ele)

boolean addAll(int index, Collection eles)

Object get(int index)

int indexOf(Object obj)

int lastIndexOf(Object obj)

Object remove(int index)

Object set(int index, Object ele)

List subList(int fromIndex, int toIndex)

三、Map 键值对 HashMap TreeMap

Map 用于保存具有映射关系的数据，因此 Map 集合里保存着两组值，一组值用于保存 Map 里的 Key，另外一组用于保存 Map 里的 Value

Map 中的 key 和 value 都可以是任何引用类型的数据

Map 中的 Key 不允许重复，即同一个 Map 对象的任何两个 Key 通过 equals 方法比较中返回 false

Key 和 Value 之间存在单向一对一关系，即通过指定的 Key 总能找到唯一的，确定的 Value。

TreeMap

TreeMap 存储 Key-Value 对时，需要根据 Key 对 key-value 对进行排序。TreeMap 可以保证所有的 Key-Value 对处于有序状态。

TreeMap 的 Key 的排序：

自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException

定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现 Comparable 接口

LinkedHashMap

LinkedHashMap 是 HashMap 的子类
LinkedHashMap 可以维护 Map 的迭代顺序：迭代顺序与 Key-Value 对的插入顺序一致

Properties

Properties 类是 Hashtable 的子类，该对象用于处理属性文件
由于属性文件里的 key、value 都是字符串类型，所以 properties 里的 Key 和 Value 都是字符串类型的

四、比较

List、Map、Set

List 以特定次序来持有元素，可有重复元素。

Set 无法拥有重复元素,内部排序。

Map 保存key-value值，value可多值。

HashSet、TreeSet

HashSet是由一个hash表来实现的，因此，它的元素是无序的。add()，remove()，contains()方法的时间复杂度是O(1)。

TreeSet是由一个树形的结构来实现的，它里面的元素是有序的(可排序的)。因此，add()，remove()，contains()方法的时间复杂度是O(logn)。

ArrayList 、 Vector

ArrayList 和 Vector 是 List 接口的两个典型实现

Vector是一个古老的集合，通常建议使用 ArrayList

ArrayList 是线程不安全的，而 Vector 是线程安全的。

即使为保证 List 集合线程安全，也不推荐使用 Vector

ArrayList、Vector和LinkedList

1）ArrayList和Vector都是使用数组方式存储数据，允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢。

2）LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

HashMap && Hashtable

HashMap 和 Hashtable 是 Map 接口的两个典型实现类

Hashtable 是一个古老的 Map 实现类，不建议使用

Hashtable 是一个线程安全的 Map 实现，但 HashMap 是线程不安全的。

Hashtable 不允许使用 null 作为 key 和 value，而 HashMap 可以

五、操作集合的工具类：Collections、Arrays

Collections

Collections 是一个操作 Set、List 和 Map 等集合的工具类

Collections 中提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

排序操作：

reverse(List)：反转 List 中元素的顺序

shuffle(List)：对 List 集合元素进行随机排序

sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序

sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序

swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素

Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素

Object min(Collection)

Object min(Collection，Comparator)

int frequency(Collection，Object)：返回指定集合中指定元素的出现次数

boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题

synchronizedCollection(Collection<T> c) 返回指定 collection 支持的同步（线程安全的）collection。

Arrays:

asList(T... a) :返回一个受指定数组支持的固定大小的列表。

六、Enumeration、Iterator

Enumeration速度是Iterator的2倍，同时占用更少的内存。但是，Iterator远远比Enumeration安全，因为其他线程不能够修改正在被iterator遍历的集合里面的对象。

同时，Iterator允许调用者删除底层集合里面的元素，这对Enumeration来说是不可能的。

应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。

七、Comparable、 Comparator

Comparable

public class Person implements Comparable{
    String name;
    int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    @Override
    public int compareTo(Object o) {
        if(o instanceof Person){
            Person p = (Person)o;
            if(this.age<p.age){
                return -1;
            }else if(this.age == p.age){
                return 0;
            }else{
                return 1;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        Person p1 = new Person("aa",20);
        Person p2 = new Person("aa",30);
        System.out.println(p1.compareTo(p2));
    }
}

Comparator

public class PersonComparator implements Comparator{
    @Override
    public int compare(Object o1, Object o2) {
        if(o1 instanceof Person && o2 instanceof Person){
            Person p1 = (Person)o1;
            Person p2 = (Person)o2;
            if(p1.age > p2.age){
                return 1;
            }else if(p1.age == p2.age){
                return 0;
            }
            else{
                return -1;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        List<Person> personList = new ArrayList<Person>();
        Person p1 = new Person("aa",20);
        Person p2 = new Person("bb",50);
        Person p3 = new Person("cc",40);
        Person p4 = new Person("dd",70);
        personList.add(p1);
        personList.add(p2);
        personList.add(p3);
        personList.add(p4);
        Collections.sort(personList,new PersonComparator());
        for(Person p : personList){
            System.out.println(p);
        }
    }
}