java成神之——集合框架之ArrayList,Lists,Sets

Posted 叶家伟的博客

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java成神之——集合框架之ArrayList,Lists,Sets相关的知识,希望对你有一定的参考价值。

集合

集合种类

List<String> list = new ArrayList<>(data); 
Set<String> set1 = new HashSet<>(data); // 值不重复
SortedSet<String> set2 = new TreeSet<>(data); // 值有序并且不重复
Set<String> set3 = new LinkedHashSet<>(data); // 值顺序固定并且不重复
Map<String, Object> map1 = new HashMap<>(map);
SortedMap<String, Object> map2 = new TreeMap<>(map);

ArrayList

声明

ArrayList是顺序表,增删慢,查询快,有序可重复集合
只能用来存储自定义应用类型和包装类型 Byte Short Integer Long Float Double Character Boolean

List list = new ArrayList();
List<String> list = new ArrayList<String>();
List<String> list = new ArrayList<>();
ArrayList<Integer> arr = new ArrayList<Integer>();

增删改查元素

List<Integer> list = new ArrayList<Integer>();
List<Integer> list1 = new ArrayList<Integer>();
list.add(1); 
list1.add(2);
list.addAll(list1);

list.add(11);
list.add(1, 33);
list.set(0, 33);
list.remove(0);
list.clear();
list.get(0)
list.size()

遍历几种方式

第一种

    List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));
    list.forEach(System.out::println);

第二种

    list.parallelStream().forEach(System.out::println);

第三种

    for (String item : list) {
        System.out.println(item);
    }

第四种

    ListIterator<String> iterator = list.listIterator();
    while(iterator.hasNext()) {
        System.out.println(iterator.next());
    }

空集合

List<String> anEmptyList = Collections.emptyList();
Map<Integer, Date> anEmptyMap = Collections.emptyMap();
Set<Number> anEmptySet = Collections.emptySet();

子集合

List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));
List<String> list1 =  list.subList(0,2); // [a, b]

不可变集合

List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c")); 
List<String> list1 = Collections.unmodifiableList(list); // 不能修改值
List<String> unmodifiableList = Collections.singletonList("Only string in the list"); // 只有一个元素的不可变集合

LinkedList

链表,增删快,查询慢
        
LinkedList<String> arr = new LinkedList<String>();
arr.add("a");
arr.addLast("c");
arr.addFirst("b");
arr.getFirst();
arr.getLast();
arr.removeFirst();
arr.removeLast();
arr.clear();

Lists

排序

方式一,实现Comparable接口

    public class User implements Comparable<User> {
        private Integer id;
        private String name;

        public User(Integer id, String name) {
            this.id = id;
            this.name = name;
        }

        @Override
        public int compareTo(User u) {
            return id.compareTo(u.id);
        }

        public void setId(Integer id) {
            this.id = id;
        }

        public Integer getId() {
            return id;
        }

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

        public String getName() {
            return name;
        }
    }

    List<User> users = new ArrayList<User>();
    users.add(new User(1, "小李"));
    users.add(new User(2, "小红"));
    Collections.sort(users);

第二种,传递Comparator接口实现

    Collections.sort(users, new Comparator<User>() {
        @Override
        public int compare(User s, User e){
            return s.getId().compareTo(e.getId());
        }
    });

第三种,lambda表达式

    Collections.sort(users, (s, e) -> s.getId().compareTo(e.getId()));

第四种,实现类sort

    users.sort((s, e) -> s.getId().compareTo(e.getId())); 

类型转换

List<Integer> nums = Arrays.asList(1, 2, 3);
List<String> strings = nums.stream().map(Object::toString).collect(Collectors.toList());

取交集

List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
list1.addAll(Arrays.asList(new Integer[]{1,2,3}));
list2.addAll(Arrays.asList(new Integer[]{1,2,4}));
list1.retainAll(list2);

移动元素

Collections.reverse(list);                  // 反转
Collections.rotate(list1, 1);               // 集合元素整体循环后移一位
Collections.shuffle(list1);                 // 重排元素

Random random = new Random(12);
Collections.shuffle(list1, random);         // 随机重排,只会随机一次

删除交集元素

List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
list1.addAll(Arrays.asList(new Integer[]{1,2,3}));
list2.addAll(Arrays.asList(new Integer[]{1,2,4}));
list1.removeAll(list2); // [3]

Sets

集合特点

Hash集合底层数据结构是散列表,所以要求元素必须不重复,避免地址对应冲突
Hash集合访问的直接是数据地址,查询元素最快,增删元素也快

HashSet集合处理地址冲突的方法使用开放定址法
HashSet是无序无重复元素集合,使用方法和ArrayList类似

LinkedHashSet集合处理地址冲突的方法使用链地址法

Set<T> set = new HashSet<T>();                              // 快速定位,随机排序
TreeSet<T> sortedSet = new TreeSet<T>();                    // 按照compareTo排序,操作慢
LinkedHashSet<T> linkedhashset = new LinkedHashSet<T>();    // 快速定位,按照插入顺序排序,备份慢

常用方法

set.add(12); 
set.clear(); 
set.contains(0);
set.isEmpty();
set.remove(0);
set.size(); 

根据set创建list

Set<String> set = new HashSet<String>();
set.add("a");
set.add("b");

方式一
    List<String> list = new ArrayList<String>();
    list.addAll(set);

方式二
    List<String> list = set.stream().collect(Collectors.toList());

以上是关于java成神之——集合框架之ArrayList,Lists,Sets的主要内容,如果未能解决你的问题,请参考以下文章

百炼成神之冒泡排序练习

java成神之——文件IO

深入理解java集合框架之---------Arraylist集合

springboot成神之——websocket发送和请求消息

java成神之——HttpURLConnection访问api

springboot成神之——拦截器