java-其他集合

LinkedList

List接口

LinkedList也实现了List接口，可以使用add,remove等方法

双向链表

LinkedList实现了双向链表接口，具有addFirst和addLast方法，可以在链表的头部和尾部插入结点

队列

LinkedList也实现了队列接口，有offer和poll方法，分别是入队和出队

package 集合框架;

import java.util.LinkedList;
import java.util.Queue;
import 集合框架.words;

public class LinkedList练习 {

    public static void main(String[] args) {
        Queue<words> q=new LinkedList<words>();
        q.offer(new words('a'));
        q.offer(new words('b'));
        q.offer(new words('c'));
        System.out.println(q.poll());
        System.out.println(q.poll());
        System.out.println(q.poll());
    }
}

 

 

---

HashMap

存储方式

HashMap的存储方式是键值对，前者是键key，后者是值value。get函数需要传递进去一个键，从而得到一个值。键不能重复但是值可以重复。

package 集合框架;

import java.util.HashMap;

public class HashMap练习 {

    public static void main(String[] args) {
        HashMap<String,Integer> h=new HashMap();
        h.put("aaa", 1);
        h.put("bbb", 2);
        h.put("ccc", 3);
        System.out.println(h.get("aaa"));
    }
}

 

---

HashSet

存储方式

HashSet中的元素不能重复，如果重复add进去，也不会存储下来

package 集合框架;

import java.util.HashSet;

public class HashSet练习 {
    public static void main(String[] args) {
        HashSet<String> h=new HashSet();
        h.add("aaa");
        h.add("aaa");
        for(String s:h)
        {
            System.out.println(s);
        }
    }
}

 

 存储顺序

HashSet存储的元素没有任何顺序，在不同的JVM版本中所能看到的同一个HashSet的顺序也不相同。

遍历

因为HashSet本身无序，并且没有类似键值对相对应的关系，因此没有get函数。

如果想遍历HashSet，只能通过迭代器或者增强型for循环（参考上面“存储方式”中的代码）

HashSet和HashMap的关系

HashSet中，封装了一个HashMap，而传递到HashSet中的值，作为被封装的HashMap中的“key”进行存储，它对应的“value”是一个命名为PRESENT的static的Object对象。

---

Collection和Collections

Collection是 Set List Queue和 Deque的接口
Queue: 先进先出队列
Deque: 双向链表

 

 Collections是一个容器的工具类，提供多种方法

 reverse反转

package 集合框架;

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

public class Collections练习 {
    public static void main(String[] args) {
        List<Integer> l=new ArrayList();
        for(int i=1;i<=10;i++)
        {
            l.add(i);
        }
        System.out.println("集合为"+l);
        Collections.reverse(l);
        System.out.println("反转后集合为"+l);
    }
}

 

 

 shuffle混淆

package 集合框架;

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

public class Collections练习 {
    public static void main(String[] args) {
        List<Integer> l=new ArrayList();
        for(int i=1;i<=10;i++)
        {
            l.add(i);
        }
        System.out.println("集合为"+l);
        Collections.shuffle(l);
        System.out.println("混淆后集合为"+l);
    }
}

 

 

 sort排序

package 集合框架;

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

public class Collections练习 {
    public static void main(String[] args) {
        List<Integer> l=new ArrayList();
        for(int i=1;i<=10;i++)
        {
            l.add(i);
        }
        System.out.println("集合为"+l);
        Collections.shuffle(l);
        System.out.println("混淆后集合为"+l);
        Collections.sort(l);
        System.out.println("排序后集合为"+l);
    }
}

 

 swap交换

package 集合框架;

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

public class Collections练习 {
    public static void main(String[] args) {
        List<Integer> l=new ArrayList();
        for(int i=1;i<=10;i++)
        {
            l.add(i);
        }
        System.out.println("集合为"+l);
        Collections.swap(l, 0, 9);
        System.out.println("交换后集合为"+l);
    }
}

 

 rotate滚动

package 集合框架;

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

public class Collections练习 {
    public static void main(String[] args) {
        List<Integer> l=new ArrayList();
        for(int i=1;i<=10;i++)
        {
            l.add(i);
        }
        System.out.println("集合为"+l);
        Collections.rotate(l, 3);
        System.out.println("滚动三个单位后集合为"+l);
    }
}

 

 synchronizedList线程安全化

package 集合框架;

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

public class Collections练习 {
    public static void main(String[] args) {
        List<Integer> l=new ArrayList();
        List<Integer> safel=(List<Integer>)Collections.synchronizedList(l);
    }
}

（2021.2.21 目前还没深入研究线程安全的问题，等我研究明白了回来补充这部分的内容）