新手初学Java集合框架

时间:2021-12-04 22:55:26

Java集合框架

集合

  • 概念:对象的容器,定义了对多个对象进行操作的常用方法。可实现数组的功能。
  • 集合和数组的区别:
    • 数组长度固定,集合长度不固定
    • 数组可以存储基本类型和引用类型,集合只能存储引用类型。

测试

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
            1.添加 2.删除 3.遍历 4.判断
         */
        Collection col = new ArrayList();
        col.add("张三");
        col.add("李四");
        col.add("王五");
//        col.add("张三");
        System.out.println(col);
//        col.remove("张三");
//        System.out.println(col);
        for (Object o : col) {
            System.out.println(o);
        }
        System.out.println("------------------");
        Iterator it = col.iterator();
        while (it.hasNext()){
            String next = (String) it.next();
            System.out.println(next);
        }
        System.out.println(col.isEmpty());
        System.out.println(col.contains("张三"));

List接口

特点:有序、有下标、元素可以重复。

可以通过角标在指定位置添加查询元素。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
List list = new ArrayList();
       list.add("java");
       list.add("c++");
       list.add(1,"python");
       list.add(".net");
       System.out.println(list.size());
       System.out.println(list.toString());
       //1.for each遍历
       System.out.println("---------------");
       for (Object o : list) {
           System.out.println(o);
       }
       //2.迭代器遍历
       System.out.println("---------------");
       Iterator iterator = list.iterator();
       while (iterator.hasNext()){
           System.out.println(iterator.next());
       }
       //3.list迭代器遍历
       System.out.println("--------正序-------");
       ListIterator listIterator = list.listIterator();
       while (listIterator.hasNext()){
           System.out.println(listIterator.next());
       }
       //逆序前必须先进行正序遍历,让指针指向列表最后一个元素,才能开发遍历
       System.out.println("--------逆序-------");
       while (listIterator.hasPrevious()){
           System.out.println(listIterator.previousIndex() + ":" +listIterator.previous());
       }

添加数字等基本类型数据时,会进行自动装箱的操作。

删除数字元素需要通过下标来删除,或者将需要删除的数字转成object类或者该类型对应的包装类。

subList:返回一个子集合,含头不含尾。

List实现类

ArrayList

  • 数组存储结构,查询快、增删慢;
  • JDK1.2版本出现,运行效率快,线程不安全。
  • 源码分析:
    • DEFAULT_CAPACITY = 10 默认容量 。注意:如果没有向集合中添加任何元素时,容量为0,添加一个元素之后,容量为10。每次扩容大小都是原来的1.5倍,如添加第11个元素时,容量由10变为了15。
    • add()方法源码:为什么添加一个元素之后,容量为10。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!增长修改个数
        elementData[size++] = e;
        return true;
    }
private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
​        ensureExplicitCapacity(minCapacity);
    }
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
  • elemetnData 存放元素的数组
  • size 实际元素个数

测试代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
ArrayList arrayList = new ArrayList();
       Student s1 = new Student("张三",18);
       Student s2 = new Student("李四",18);
       Student s3 = new Student("王五",18);
       arrayList.add(s1);
       arrayList.add(s2);
       arrayList.add(s3);
       System.out.println(arrayList.toString());
       //删除元素(需要重写equals方法)
       arrayList.remove(new Student("李四",18));
       System.out.println(arrayList.size());
public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;
       Student student = (Student) o;
       return age == student.age && Objects.equals(name, student.name);
   }

Vector

  • 数组存储结构,查询快,增删慢;
  • JDK1.0版本出现,运行效率慢、线程安全;
  • 枚举器遍历
?
1
2
3
4
5
6
7
8
9
10
Vector vector = new Vector();
        vector.add("java");
        vector.add("python");
        vector.add(".net");
        System.out.println(vector.toString());
        //枚举器遍历
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()){
            System.out.println(elements.nextElement());
        }

LinkedList:

  • 双向链表存储结构,增删快,查询慢。

泛型:

  • 时JDK1.5中引入的一个新特性,其本质是参数化类型,把类型作为参数传递;
  • 常见形式由泛型类、泛型接口、泛型方法;
  • 好处:
    • 提高代码的重用性
    • 防止类型转换异常,提高代码的安全性

泛型集合:参数化类型、类型安全的集合,强制集合元素的类型必须一致。

特点:

  • 编译时即可检查,而非运行时抛出异常。
  • 访问时,不必类型转换。
  • 不同泛型之间引用不能相互赋值,泛型不存在多态。

Set接口

特点:无序、无下标、元素不可重复

方法:全部继承自Collection中的方法。

Set实现类

HashSet

  • 存储结构:哈希表(数组+链表+红黑树)
  • 基于HashCode实现元素不重复
    • 根据hashcode计算保存的位置,如果此位置为空,则直接保存。如果不为空,执行下一步。
  • 当存入元素的哈希码相同时,会调用equals进行确认,如果为true,则拒绝后者存入。否则,则生成链表。
?
1
2
3
public HashSet(){
  map = new HashMap<>();
}

测试代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
HashSet<Student> set = new HashSet<>();
        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",18);
        Student s3 = new Student("王五",18);
        set.add(s1);
        set.add(s2);
        set.add(s3);
//        set.add(new Student("李四",18));
        System.out.println(set.size());
        System.out.println(set.toString());
//        set.remove(new Student("李四",18));
//        System.out.println(set.size());
//        System.out.println(set.toString());
        for (Student student : set) {
            System.out.println(student);
        }
        System.out.println("====================");
        Iterator<Student> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
public int hashCode() {
        return Objects.hash(name, age);
    }

hashcode重写方法中加入31的原因

1.31是一个质数,减少散列冲突

2.31提高执行效率

TreeSet

  • 存储结构:红黑树
  • 基于排列顺序实现元素不重复
  • 实现了SortedSet接口,对集合元素自动排序
  • 元素对象的类型必须实现Comparable接口,指定排列规则
  • 通过CompareTo方法确定是否为重复元素

测试代码:使用TreeSet集合实现字符串按照长度进行排序

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
​        @Override
        public int compare(String o1, String o2) {
             int n1 = o1.length() - o2.length();
             int n2 = o1.compareTo(o2);
             return n1==0?n2:n1;
         }
        treeSet.add("zhangSan");
        treeSet.add("wkf");
        treeSet.add("asd");
        treeSet.add("abc");
        treeSet.add("ljCv");
        treeSet.add("liSi");
        treeSet.add("wanG");
​        System.out.println(treeSet.toString());
        System.out.println(treeSet.size());

Map接口

特点:

1.用于储存任意键值对(Key,Value)

2.键:无序、无下标、不允许重复

3.值:无序、无下标、允许重复

遍历:

  • keySet()方法遍历:拿到key的set集合。
  • entrySet()方法遍历:将map封装成entry键值对集合。

测试代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Map<String, String> map = new HashMap<>();
        map.put("wkf","666");
        map.put("qwe","678");
        map.put("kfc","999");
        map.put("asd","694");
        Set<String> keySet = map.keySet();
        for (String s : keySet) {
            System.out.println(s + "=" + map.get(s));
        }
        System.out.println("===================");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getKey() +"=" + entry.getValue() );
        }

HashMap

  • JDK1.2版本,线程不安全,运行效率快;允许用null作为key或是value。
  • 构造一个具有默认初始容量16和默认加载因子0.75的空HashMap。
    • 加载因子:比如当前集合容量为100,那么当数据存储到第75个位置是进行扩容操作。
  • 源码分析
?
1
2
3
4
5
6
7
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // hashMap初始容量大小16
static final int MAXIMUM_CAPACITY = 1 << 30;//hashMap的数组最大容量
static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认加载因子
static final int TREEIFY_THRESHOLD = 8;//jdk1.8开始,当链表长度大于8时,调整成红黑树
static final int UNTREEIFY_THRESHOLD = 6;//jdk1.8开始,当链表长度小于6时,调整成链表
static final int MIN_TREEIFY_CAPACITY = 64;//jdk1.8开始,当链表长度大于8时,并且集合元素个数大于等于64时调整成红黑树
transient Node<K,V>[] table;//哈希表中的数组

总结:

  • HashMap刚创建时,table是null,为了节省空间,当添加第一个元素时,table容量调整为16
  • 当元素个数大于阈值(16*0.75=12)时,会进行扩容,扩容后大小为原来的两倍。目的是减少调整元素的个数
  • jdk1.8开始,当链表长度大于8时,并且集合元素个数大于等于64时调整成红黑树,目的是提高执行效率
  • jdk1.8开始,当链表长度小于6时,调整成链表
  • jdk1.8以前,链表时头插入,jdk1.8以后是尾插入

Hashtable

  • JDK1.0版本,线程安全,运行效率慢;不允许null作为key或是value
  • Properties:
    • Hashtable的子类,要求key和value都是String,通常用于配置文件的读取。

TreeMap

  • 实现了SortedMap接口(是Map的子接口),可以对key自动排序。

Collections工具类

  • sort():升序排列
  • copy():复制
  • binarySearch():二分查找
    • Collections.binarySearch(list,需要查找的值);
  • reverse():反转
  • shuffle():打乱集合中的元素
  • list转成数组:
    • list.toArray(new Integer[0]);
  • 数组转成集合
    • Arrays.asList(names);
    • 集合是一个受限集合,不能添加 和

总结

本篇文章就到这里了,希望能给您带来帮助,也希望您能够多多关注服务器之家的更多内容!

原文链接:https://www.cnblogs.com/wkf123/p/14966681.html