java map按照value排序_Java集合

人生那么长，我们都要有胆量为自己做一次选择！

简介

• 由若干个确定的元素所构成的整体就是集合，比如：String[] 就可以看作是一种集合
• 集合相对于数组来说，数组初始化后大小不可变，数组只能按照索引顺序存取。

Collection

• Java标准库自带的集合类，是除了Map外所有其它集合类的跟接口，Java主要提供了一下几种结合
  • List：一种有序列表的集合
  • Set： 一种保证没有重复元素的集合
  • Map：一种通过键值查找的映射表集合

• Java集合统一使用Iterator进行遍历

 List<String> list = new ArrayList<>(); //  只能存放String类型

List

• List是最基础的一种集合，是一种有序列表。List的行为和数组集合完全相同
• List允许添加重复元素，还允许添加null

 List<String> list = new ArrayList<>();
 list.add("a");
 list.add(null);
 list.add("a");
 System.out.println(list); // ["a",null,"a"]

• List接口方法：
  • boolean add(E e) 添加一个元素
  • boolean add(int index,E e) 指定位置加一个元素
  • int remove(int index) 删除指定位置的元素
  • int remove(Object e) 删除指定元素
  • E get(int index) 获取指定索引的元素
  • int size() 获取集合大小
  • boolean contains(Object o) 判断List中是否包含某个指定的元素
  • int indexOf(Object o) 可以返回某个元素的索引，如果元素不存在，则返回-1

• ArrayList，List接口的实现类，通常来说ArrayList使用场景多一些
• LinkedList，List接口的实现类，是通过链表的形式实现的，一般不推荐使用
• JDK9+还可以使用of方法创建List

 List<String> list = List.of("a","b"); //JDK9+
 List<String> list = Arrays.asList("a","b"); //JDK9以下
 //-----循环获取
 for (int i=0; i<list.size(); i++) {
   String s = list.get(i);
   System.out.println(s); // a ,b
 }

• List遍历不推荐使用 get(i)方式，因为这种方式只有ArrayList是高效的，换成LinkedList，索引越大访问速度越慢
• List集合的循环一般使用Iterator进行循环，这是一种通用的高效方式

 List<String> list = Arrays.asList("a","b");
 for (Iterator<String> it = list.iterator(); it.hasNext();){
   String s = it.next();
   System.out.println(s);
 }

• 上述代码还可以写成for each循环方式，因为这种方式在编译的时候会自动转化为Iterator

 List<String> list = Arrays.asList("a","b");
 for (String s : list){
   System.out.println(s);
 }

• List转化为Array的几种方式

 // 通过toArray()方法直接返回一个Object[]的数组，但是很显然Object类型并不是我们想要的
 List<String> list = Arrays.asList("a","b");
 Object[] array = list.toArray();
 for (Object o : array){
   System.out.println(o);
 }
 // 可以通过toArray(T[])传入一个类型相同的Array，List内部会自动把元素复制到传入的Array中
 String[] array = (String[]) list.toArray(new String[list.size()]);

Map

• Map<k,v>也是一个接口，是一种键值映射表，最长使用的是hashMap，可以使用put<K key,V value>存放进Map，通过V get(K key)方式取出对应的value。如果key不存在则返回null

 Map<String,String> map = new HashMap<>();
 map.put("姓名","猿氏凯");
 map.put("年龄","18");
 System.out.println(map.get("姓名"));

• Map中，key不可以重复，但是value没有限制
• Map的遍历也可以使用Iterator或者for each

 for(Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();iterator.hasNext();){
   Map.Entry<String, String> entry = iterator.next();
   System.out.println(entry.getKey() + entry.getValue());
 }
 for(String m : map.keySet()){
   System.out.println(m+map.get(m));
 }

HashMap

• HashMap之所以能根据key直接拿到value，是因为它内部通过空间换时间的方法，用一个大数组储存所有value，并根据key计算value应该保存在哪个索引

 Map<String,String> map = new HashMap<>();
 map.put("a","a-value");
 map.put("b","b-value");
 System.out.println(map.get("a"));
 System.out.println(map.get(new String("a")));

• HashMap内部判断key值是否等于原来存入key的方式是根据equals，如果key是其他自定义类必须重写equals方法和hasCode方法

EnumMap

• 如果Map的key值是enum类型，推荐使用EnumMap，既保证速度，也不浪费时间

 Map<DayOfWeek, String> map = new EnumMap<>(DayOfWeek.class);
 map.put(DayOfWeek.MONDAY, "星期一");
 map.put(DayOfWeek.TUESDAY, "星期二");
 map.put(DayOfWeek.WEDNESDAY, "星期三");
 map.put(DayOfWeek.THURSDAY, "星期四");
 map.put(DayOfWeek.FRIDAY, "星期五");
 map.put(DayOfWeek.SATURDAY, "星期六");
 map.put(DayOfWeek.SUNDAY, "星期日");
 System.out.println(map);
 System.out.println(map.get(DayOfWeek.MONDAY));

TreeMap

• HashMap是一种以空间换时间的映射表，他的实现原理决定了内部的key是无序的，即遍历HashMap的key时顺序是不可预测的，还有一种Map会对key进行排序，这种Map就是SortedMap（接口），他的实现类是TreeMap

 public class Main {
   public static void main(String[] args) {
     Map<String, Integer> map = new TreeMap<>();
     map.put("a", 1);
     map.put("b", 2);
     map.put("c", 3);
     for (String key : map.keySet()) {
       System.out.println(key);
     }
     // a, b, c
   }
 }

• TreeMap的Key必须实现Comparable接口

Properties

• 编写程序的时候需要读写配置文件，这个时候就需要用到Properties类

 // setting.properties
 name=root
 password=123456
 String p = "setting.properties"
 Properties props = new Properties();
 props.load(new java.io.FileInputStream(p));
 String name = props.getProperty("name");

Set

• 用于存储不重复的元素集合

 Set<String> set = new HashSet<>();
 set.add("a");
 set.add("a");// 打印会输出false
 set.contains("a");// true
 set.remove("a"); // true
 set.size(); //0

• Set和Map类似，只不过Set相当于只存入key值，Set常用于去除重复元素
• Set存入的值也要重写equals() 和 hasCode()
• HashSet是无序的
• TreeSet是有序的，他实现了SortedSet接口，可以自定义排序方法

Queue

• 队列（Queue）是一种经常使用的集合，遵循先进先出原则，存入只能从末尾传入，取出只能从头部取出

 Queue<String> queue = new LinkedList<>();
 queue.add("a"); // 失败会抛出异常
 queue.offer("a"); // 失败不会抛出异常，返回false
 queue.remove("a");// 失败会抛出异常
 System.out.println(queue.peek()); // 获取头部元素但不删除
 System.out.println(queue.poll()); // 获取头部元素并且删除，失败不会抛出异常，会返回null
 System.out.println(queue.poll());

PriorityQueue

• 用法与Queue类似，但是它不是先进先出，会按照排序规则出入，元素需要实现Comparable接口，也可以通过Comparator自定义排序算法

Deque

• 和Queue类似，但是Deqie是双头都可进出
• addLast(E e) / offerLast(E e) 添加元素到队列末尾
• E getFirst() / E peekFirst() 获取队列头元素但不删除
• E removeFirst() / E pollFirst() 获取队列头元素并且删除
• addFirst(E e) / offerFirst(E e) 添加元素到队列头
• E removeLast() / E pollLast() 获取队列末尾元素并且删除
• E getLast() / E peekLast() 获取队列末尾元素但不删除

Stack

• 栈是一种先进后出的数据结构
• push 压栈
• pop 出栈
• peek 取元素但不出栈
• 最好不要使用Stack，可以用Deque可以实现Stack的功能

Collections

• Collections是JDK提供的一个工具类

 List<String> list = Collections.emptyList(); // 创建一个空的list
 List<String> list2 = Collections.singletonList("apple"); // 创建一个list
 List<String> list3 = new ArrayList<>();
 list3.add("b");
 lilist3st1.add("c");
 Collections.sort(list3);// 排序
 Collections.shuffle(list); // 随机洗牌

• 封装成不可变List：List<T> unmodifiableList(List<? extends T> list)
• 封装成不可变Set：Set<T> unmodifiableSet(Set<? extends T> set)
• 封装成不可变Map：Map<K, V> unmodifiableMap(Map<? extends K, ? extends V> m)
• 变为线程安全的List：List<T> synchronizedList(List<T> list)
• 变为线程安全的Set：Set<T> synchronizedSet(Set<T> s)
• 变为线程安全的Map：Map<K,V> synchronizedMap(Map<K,V> m)

---

本文作者《猿氏·凯》，如果雷同，纯属抄袭····