公告

JavaSE-Collection

Posted on 2021-03-10 23:29 MissRong 阅读(53) 评论(0) 收藏举报

JavaSE-Collection

一、List接口

1、实现类ArrayList

ArrayList是一个用数组实现的列表，也是最常用的集合。元素可重复，有序。

它允许任何符合规则的元素插入甚至包括null，每一个ArrayList都有一个初始容量（10），该容量代表了数组的大小。

在每次向容器中增加元素的同时都会进行容量检查，当快溢出时，就会进行扩容操作（构建一个新的更大的数组并将之前的内容拷贝到新书组中）。

所以如果明确所插入元素的多少，最好指定一个初始容量值，避免过多的进行扩容操作而浪费时间、效率。

ArrayList的默认扩容扩展后数组大小为：(原数组长度*3)/2+1，ArrayList是一个非线程安全的列表。

public static void main(String[] args) {
        //1、集合的创建与添加元素
        List<Integer> arrayList = new ArrayList();
        arrayList.add(11);
        arrayList.add(12);
        arrayList.add(13);
        arrayList.add(0, 14);
        //2、遍历集合元素
 //（1）iter快捷码--for each
        for (Integer i : arrayList) {
            System.out.println(i);
        }
        //（2）JDK1.8新增的遍历操作，::后面接要使用的方法
        arrayList.forEach(System.out::println);
        //3、是否存在某个元素
        System.out.println(arrayList.contains(2));
        //4、获取指定位置的元素
        System.out.println(arrayList.get(0));
        //5、获取指定元素的位置
        System.out.println(arrayList.indexOf(11));
        //6、判断集合是否为空
        System.out.println(arrayList.isEmpty());
        //7、移除某个元素
 //（1）指定位置的：
        arrayList.remove(3);
        arrayList.forEach(System.out::println);
        //（2）指定元素-两种表达方式：
        arrayList.remove((Integer) 11);
        arrayList.forEach(System.out::println);
        arrayList.remove(new Integer(12));
        arrayList.forEach(System.out::println);
    }

2、实现类LinkedList

LinkedList与ArrayList不同，LinkedList是一个双向链表。

所以它除了有ArrayList的基本操作方法外还额外提供了get，remove，insert方法在LinkedList的首部或尾部。

由于实现的方式不同，LinkedList不能随机访问。

在列表中索引的操作将从开头或结尾遍历列表（从靠近指定索引的一端），查询速度慢，但是插入和删除操作较快。

与ArrayList一样，LinkedList也是非同步的。如果多个线程同时访问一个List，则必须自己实现访问同步。

在JDK1.2之前没有完整的集合框架。只有一些简单的可以自扩展的容器类，比如Vector，Stack，Hashtable等。

保留之前的那些容器类库主要是为了向下兼容的目的。但在平时使用中还是应该尽量少用。

Vector与ArrayList相似，但是Vector是同步的。所以说Vector是使用数组实现的线程安全的列表。

它的操作与ArrayList几乎一样。Vector在进行默认规则扩容时，新数组的长度 = 原始数组长度 * 2。

二、Set接口

1、HashSet

HashSet堪称查询速度最快的集合，因为其内部是以HashCode来实现的。

它内部元素的顺序是由哈希码来决定的，所以它不保证set的迭代顺序；特别是它不保证该顺序恒久不变。

集合元素的hashCode方法返回的哈希值对HashSet而言非常重要，因为HashSet会优先使用这个哈希值来判定两个元素是否相同并确定元素的位置。

如果想不添加重复类元素的话，需要重写equals()和hashCode()。

    public static void main(String[] args) {
        //1、Set的创建和增加元素
        HashSet<String> set = new HashSet<>();
        set.add("11");
        set.add("12");
        set.add("12");
        set.add("13");
        set.add("14");
        //2、输出Set的大小
        System.out.println(set.size());
        //3、删除个别元素，返回值为Boolean
        set.remove("12");
        //4.输出Set集合
        System.out.println(set);
        //5、判断个别元素是否存在
        System.out.println(set.contains("13"));
    }

2、TreeSet

基于TreeMap，生成一个总是处于排序状态的set，内部以TreeMap来实现。

它是使用元素的自然顺序对元素进行排序，或者根据创建Set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。

TreeSet要求元素实现Comparable接口，String类实现了Comparable接口,因此TreeSet会对字符串按照字典顺序来排序。

public static void main(String[] args) {
        //1、TreeSet的创建与增添元素
        TreeSet<Integer> treeSet = new TreeSet<>();
        treeSet.add(5);
        treeSet.add(2);
        treeSet.add(1);
        treeSet.add(4);
        //2、打印集合
        treeSet.forEach(System.out::println);
        System.out.println(treeSet);
        //3、正序打印
        Iterator<Integer> iterator = treeSet.iterator();
        //4、倒序打印
        Iterator<Integer> integerIterator = treeSet.descendingIterator();
        while (integerIterator.hasNext()) {
            System.out.println(integerIterator.next());
        }
    }

1）根据 String 和 int 类型属性进行比较的写法：

（1）String类型属性---用compareTo()

   @Override
    public int compareTo(User o) {
        //按照名字(String)排序
        return this.name.compareTo(o.name);
    }

（2）int类型属性---用减号“-”

    @Override
    public int compareTo(Students o) {
        // 按照学号(int)排序
        return this.sno-o.sno;
    }

2）XXX implement Comparable<>{}、XXX implement Comparator<>{}

3）匿名内部类、Lambda

注：这种形式的话，写Comparator接口会简单一些

        TreeSet<User> set = new TreeSet<>(new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o1.name.compareTo(o2.name);
            }
        });

        Set<Student> set=new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getSno()-o2.getSno();
            }
        });

        //创建一个比较器-按照Key值，从大到小排序
        Map<Integer,Student> map=new TreeMap<Integer,Student>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                if(o1.intValue()>o2.intValue()) {
                    return -1;
                }else if(o1.intValue()<o2.intValue()) {
                    return 1;
                }else
                    return 0;
            }
        });

在已实现接口Comparable的类（就是implement Comparable<该类名>）中，

自定义类必须要重写的方法-compareTo()，不重写就会抛异常。

使用TreeSet进行比较的时候,自定义类(像这里的User)中不需要重写equals()方法和HashCode()方法.

三、Map接口

1、HashMap

HashMap是基于哈希表的Map接口的非同步实现，继承自AbstractMap，AbstractMap是部分实现Map接口的抽象类。

和Vector类似，Map体系也有一个自JDK1.2之前遗留的集合工具：Hashtable，它的操作接口和HashMap相同；

和HashMap的区别在于：Hashtable是线程安全的，而HashMap是非线程安全的。

(null，null)是可以存储的。

HashMap是无序的。

public static void main(String[] args) {
        //1、创建HashMap，添加元素
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("xiaoli", 21);
        hashMap.put("xiaozhang", 22);
        hashMap.put("xiaohong", 22);
        //2、可以直接输出集合
        System.out.println(hashMap);
        //3、得到指定Key的Value
        Integer age = hashMap.get("xiaohong");
        System.out.println(age);
        //4、获得所有Key的集合
        for (String s : hashMap.keySet()) {
            System.out.println(s + "-->" + hashMap.get(s));
        }
        //5、判断是否存在指定的Key
        System.out.println(hashMap.containsKey("xiaohong"));
        //6、判断是否存在指定的Value
        System.out.println(hashMap.containsValue(25));
        //7、replace
        hashMap.replace("xiaohong", 23);
        System.out.println(hashMap);
        hashMap.replace("xiaoli", 21, 29);
        System.out.println(hashMap);
        //8、forEach()方法遍历
        hashMap.forEach((k, v) -> {
            System.out.println(k + "-->" + v);
        });
        //9、entrySet()方法遍历
        for (Map.Entry<String, Integer> ageTmp : hashMap.entrySet()) {
            System.out.println(ageTmp.getKey() + "-->" + ageTmp.getValue());
        }
        //10、迭代器遍历
        Iterator<Map.Entry<String, Integer>> iterators = hashMap.entrySet().iterator();
        while (iterators.hasNext()) {
            Map.Entry<String, Integer> next = iterators.next();
            System.out.println(next.getKey() + "," + next.getValue());
        }
    }

LinkedHashMap

LinkedHashMap继承自HashMap，它主要是用链表实现来扩展HashMap类。

HashMap中条目是没有顺序的，但是在LinkedHashMap中元素既可以按照它们插入的顺序排序，

也可以按它们最后一次被访问的顺序排序。

2、TreeMap

TreeMap基于红黑树数据结构的实现，键值可以使用Comparable或Comparator接口来排序。

TreeMap继承自AbstractMap，同时实现了接口NavigableMap，而接口NavigableMap则继承自SortedMap。

SortedMap是Map的子接口，使用它可以确保图中的条目是排好序的。

在实际使用中，如果更新Map时不需要保持图中元素的顺序，就使用HashMap，

如果需要保持Map中元素的插入顺序或者访问顺序，就使用LinkedHashMap，

如果需要使图按照键值排序，就使用TreeMap。

作为HashMap的Key（如果是自定义的类）必须重写equals方法，同时也要重写hashCode方法。（虽然有时他不会出错）

TreeMap实现了Map和SortMap接口，其操作和HashMap相同，但他是有序的。

TreeMap内部将按照元素的Key的大小顺序排序，TreeMap和TreeSet一样，要求Key实现了Comparable接口，或者在构造TreeMap时提供一个Comarator的实例。

实现接口，重写compareTo() 的写法，和TreeSet类似

（1）匿名内部类：

        //按照键User的name进行排序
        TreeMap<User, String> treeMap = new TreeMap<>(new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o1.username.compareTo(o2.username);
            }
        });

String类型的从大到小排序就是：return o2.username.compareTo(o1.username);

int 类型的从大到小排序就是：

        //创建一个比较器-按照Key值，从大到小排序
        Map<Integer,Student> map=new TreeMap<Integer,Student>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                if(o1.intValue()>o2.intValue()) {
                    return -1;
                }else if(o1.intValue()<o2.intValue()) {
                    return 1;
                }else
                    return 0;
            }
        });

（2）Lambda表达式：

正序：

TreeMap<User, String> treeMap = new TreeMap<>((o1, o2) -> o1.username.compareTo(o2.username));

还可以：

TreeMap<User, String> treeMap = new TreeMap<>(Comparator.comparing(o -> o.username));

//String、Integer均可
TreeMap<Integer, String> treeMap = new TreeMap<>(Comparator.naturalOrder());

倒序：

TreeMap<User, String> treeMap = new TreeMap<>((o1, o2) -> o2.username.compareTo(o1.username));

（3) 类实现接口-implement：

public class User implements Comparable<User>{

public class User implements Comparator<User>{

刷新页面返回顶部

MissRong

现时的明艳， 源于曾经奋斗的泪泉和牺牲的血雨。

公告