JAVA复习[集合]_entrylist.sort-优快云博客

本文链接：https://blog.youkuaiyun.com/2303_80137578/article/details/143452356

一、字符串转变为int

①直接得到int类型

int i = Integer.parseInt(String e);

②得到Integer类型，再转变为init类型

String s = "123";

Integer e = Integer.valueOf(s);

int i = e.intValue();

或者一步到位int number = Integer.valueOf(s).intValue();

二、集合类

1、List<E>接口

【添加集合】 addAll(int index,Collection<? extends E> c)【把给定集合的所有元素插到目标位置，后面的元素被自动挤到后面去了】

【排序】sort(Comparator<? super E> c)

ex 【

List<String> list;

list.sort(new Comparetor<String>){

@Override

public int compare(String o1,String o2){

int int1 = Integer.parseInt(o1);

int int2 = Integer.parseInt(o2);

return int2-int1;//降序就2-1,升序就1-2默认升序

}

】

【获取对应下标位置元素】E get(int index);

【替换对应下标位置的元素】E set(int index，E e)LinkedList才能用

【在对应位置插入元素】void add(int index,E e)

【移除对应位置元素】E remove(int index)

移除时使用equals方法

【查询元素第一次出现的下标】int indexOf(E e)

【查询元素最后一次出现的下标】int lastIndexOf(E e)

【迭代器】ListIterator<E> listIterator();

Iterator<E> iterator();

【返回指定范围内的List子集】List<E> subList(int fromIndex,int toIndex)

【List的实现类】

①ArrayList<E>

【容量字段】size；

【添加】add(E e)

【使用】List<String> list = new ArrayList<>();

【只读的List】List<String> list = Arrays.asList("A","B");

【初始化的List】List<String> list = new ArrayList<>(Arrays.asList("A","B"));

或者

List<String> list = new ArrayList<String>() {{ //使用匿名内部类（匿名内部类在Java8无法使用钻石运算符，但是之后的版本可以）
add("A");
add("B");
add("C");
}};

②LinkedList<E>

和ArrayList基本相同，除了当做List的实现类，还能用作双端队列

【集合类支持Foreach语法】【forEach()方法接受的是一个实现了Consumer接口的对象或者一个Lambda表达式/方法引用】【forEach()是void方法，Consumer接口代表了一个接受单个输入参数且不返回结果的操作】

List<String> list = new ArrayList<>():

for(String s:list){

system.out.println(s);

}

或者【e是占位符，代表list中的当前元素】

list.forEach(e->{

【想对e执行的代码】

}

)

list.forEach(System.out::println)

2、Map<K,V>映射

三个主要实现类

①HashMap不维护插入顺序

②LinkedHashMap维护插入顺序

③TreeMap 保证映射按照key的自然顺序排序【对key比较】

不写比较器默认升序

 TreeMap<Integer,String> set = new TreeMap<>();

添加比较器改为降序【Comparator为有一个待实现方法的接口，可lambda】

 TreeMap<Integer,String> set = new TreeMap<>((a, b) -> b - a);

【获取当前存储的键值对数量】int size();

【是否为空】boolean isEmpty();

【查看Map中是否包含指定的键】boolean containsKey(Object key);

【查看Map中是否包含指定的值】boolean containsValue(Object value)；

【通过给定的键，返回其映射的值】V get(Object key);

//-------- 修改相关操作 -------

【向Map中添加新的映射关系，也就是新的键值对】V put(K key, V value);

【根据给定的键，移除其映射关系，也就是移除对应的键值对】V remove(Object key);
//-------- 批量操作 -------

【根据给定的键，移除其映射关系，也就是移除对应的键值对】void putAll(Map<? extends K, ? extends V> m);

【清空整个Map】void clear();
//-------- 其他视图操作 ----

【返回Map中存放的所有键，以Set形式返回】Set<K> keySet();

【返回Map中存放的所有值】Collection<V> values();

【返回所有的键值对，这里用的是内部类Entry在表示】Set<Map.Entry<K, V>> entrySet()；

【这个是内部接口Entry，表示一个键值对】
interface Entry<K,V> {
//获取键值对的键
K getKey();

//获取键值对的值
V getValue();

//修改键值对的值
V setValue(V value);

//判断两个键值对是否相等
boolean equals(Object o);

//返回当前键值对的哈希值
int hashCode();

3、Set<E> 集合

三个主要实现类

①HashSet 不维护插入顺序

②LinkedHashSet 维护插入顺序

③TreeSet在元素插入时进行排序

不加比较器默认升序

 TreeSet<Integer> set = new TreeSet<>();

添加比较器改为降序【Comparator为有一个待实现方法的接口，可lambda】

 TreeSet<Integer> set = new TreeSet<>((a, b) -> b - a);

【方法】int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);

//添加元素只有在当前Set集合中不存在此元素时才会成功，如果插入重复元素，那么会失败
boolean add(E e);

//这个同样是删除指定元素
boolean remove(Object o);是什么类型Object就是什么

boolean containsAll(Collection<?> c);

//同样是只能插入那些不重复的元素
boolean addAll(Collection<? extends E> c);

boolean retainAll(Collection<?> c);
boolean removeAll(Collection<?> c);
void clear();
boolean equals(Object o);
int hashCode();

-->HashSet<E>【无法维持插入的顺序】

-->LinkedHashSet<E>【可以维持插入的顺序】

-->TreeSet<E>【不按照插入的顺序排序->而是根据数的大小排序->可以指定排序的方式comparator】

TreeSet<Integer> set = new TreeSet<>((a, b) -> b - a);//降序

4、迭代器

-->>起始时指向第一个元素之前

【判断迭代器是否有至少一个元素】boolean hasNext();

【返回迭代器指向的下一个元素】E next();

【移除上一个被遍历的元素】void remove()

【逆向迭代器】Iterator<E> descendingIterator();

【正向迭代器】Iterator<E> iterator();

5、Queue

三、集合的排序

①List的排序：

1.Collections.sort(List<E> list); 只有集合类List才能使用

2. list.sort(Comparator<? super E>);

②Map<K,V>映射的排序

1.对Key的排序

第一种：使用List来排序

import java.util.*;
class Main{
public static void main(String[] args) {
    Map<String,Integer> map = new HashMap<>();
    map.put("2023089",1);
    map.put("2023001",2);
    map.put("2023032",3);
    List<String> list = new ArrayList<>(map.keySet());//得到Key的集合，装到list中去
    Collections.sort(list);
    for(String str : list){
    System.out.println(str+":"+map.get(str));
    }
}
}

第二种：使用TreeMap

import java.security.KeyStore;
import java.util.*;
class Main{
public static void main(String[] args) {
    Map<String,Integer> map = new HashMap<>();
    map.put("2023089",1);
    map.put("2023001",2);
    map.put("2023032",3);
   Map<String,Integer> sortedMap = new TreeMap<>(map);
for(Map.Entry<String,Integer> entry : sortedMap.entrySet()){
    System.out.println(entry.getKey()+" "+entry.getValue());
}
}
}

②对value排序

import java.util.*;
import java.util.stream.Collectors;

public class SortMapByValue {
    public static void main(String[] args) {
        // 创建一个示例Map
        Map<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("apple", 5);
        unsortedMap.put("banana", 3);
        unsortedMap.put("cherry", 7);
        unsortedMap.put("date", 2);

        // 打印原始Map
        System.out.println("Original Map: " + unsortedMap);

        // 将Map转换为List<Map.Entry<String, Integer>>
        List<Map.Entry<String, Integer>> entryList = new ArrayList<>(unsortedMap.entrySet());

        // 对List进行排序，使用Comparator比较值
        entryList.sort(Map.Entry.comparingByValue());

        // 构建排序后的Map，使用LinkedHashMap保持顺序
        Map<String, Integer> sortedMap = new LinkedHashMap<>();
        for (Map.Entry<String, Integer> entry : entryList) {
            sortedMap.put(entry.getKey(), entry.getValue());
        }

        // 打印排序后的Map
        System.out.println("Sorted Map by Value: " + sortedMap);
    }
}