java集合杂记

类集

java对数据结构的成熟实现

三大接口

Lterator: 迭代器,对所有数据结构最优的获取方式

collection :进行单值存储的集合,如数组

Map: 双值存储的方式,如钥匙对

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2LakyQ8u-1591722166927)(C:\Users\17243\AppData\Roaming\Typora\typora-user-images\image-20200609230734104.png)]

常见的数据结构

栈: 先进后出,只在尾部操作

队列: 先进先出

数组:查找方便,操作慢

链表: 存下一个元素的地址,查找慢

二叉树: 会存下左右俩边的地址,代表性有红黑二叉树

图: 由节点和边构成,节点,边都可以有权值,边还可以有方向

collection

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JyrBCKAd-1591722166929)(C:\Users\17243\AppData\Roaming\Typora\typora-user-images\image-20200608220258803.png)]

一般使用它的子类 List和Set,List用于允许重复的单值,Set用于不允许c重复的单值

List详解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lFyQqAl7-1591722166932)(C:\Users\17243\AppData\Roaming\Typora\typora-user-images\image-20200608220930921.png)]

对Collectionl已有的扩充

List实现类

List子类: ArrayList(95%),LinkList(1%),Vector(4%),前俩使用最多

基于动态数组实现

Vector线程安全,排队操作,但是慢,ArrayList早期版本

ArrayList线程不安全,多人同时操作

基于双向链表实现

LinkList

ArrayList

数组结构存储, 增加删除慢,查找快

ArryList 空构造方法长度其实是0,传值时才会变长

Vector详解

增加删除慢,查找快

四个构造方法

Vector()扩容增量可自定义,如果是0默认翻一番)

LInkList详解

增加删除快,查找慢

可以看成队列,栈,队列有特定的addFrist(),removeFirst(),addLast(),removeLast()

对于栈还有push()方法和pop()方法

迭代器

Lterator 迭代器List,Set都可以用

LiskLtertor迭代器主要对List,是Lterator的子类

iterator, 理解为有个指针,next()控制指针下移,并且等于这个数据,previous()控制指针上移,并且等于这个数据,注意指针初始是在第一个数组的上面

forEach(增强for循环)

用于迭代数组或集合(集合只能是Collection下的)

语法

for(数据类型 变量名:集合或数组名){}

Set集合(没有相同元素)

没有get() 只能迭代器或者toArray()

元素随机存储,不能以下标操控

HashSet()

实质是散列函数

map双值存储的哈希表,hashset底层还是调用map的

存储没有顺序,先add不一定先输出

TreeSet

实质是二叉树存储,底层是调用treemap的

快速失败,集合改了,迭代器随着集合变

安全失败,集合改了,但是备份了一份,迭代器随着备份变(一般是安全失败)

集合内顺序按ascell码大小排序,与输入无关,若自定义单值,需要在自定义的里面实现Comparable,及里面的所有抽象方法----compareTo

例子

package com.home;


import com.sun.source.tree.Tree;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;
import java.util.TreeSet;

public class Iterator1 {
    public static void main(String[] args) {
        TreeSet<Person> set = new TreeSet<>();
        Person person1 = new Person("z", 16);
        Person person2 = new Person("w", 18);
        set.add(person1);
        set.add(person2);
        for (Person s : set
        ) {
            System.out.println(s);
        }
   /*     Iterator<String> iterator=set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
*/


    }


    static  class Person implements Comparable<Person> {
        private String name;
        private int age;

        @Override
        public int compareTo(Person p) {
            if (this.age > p.age) {
                return 1;
            }
            if (this.age == p.age) {
                return 0;
            }else {return -1;}
        }

        public Person(String name, int age) {


            this.age = age;
            this.name = name;
        }

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

        public void setAge(int age) {
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            Person person = (Person) o;
            return age == person.age &&
                    Objects.equals(name, person.name);
        }

        @Override
        public int hashCode() {

            return Objects.hash(name, age);
        }

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

Map==Mapping

map一次存俩,称为键值对,每对键值对的键不同

keySet(): 对键遍历 values()对值遍历,变成单值存储的集合

put(key,value)添加一对键值对,此函数返回值若添加与原有不同为null,若有相同,返回被值为原来的值

remove(k,v)删除,若不匹配无法删除,返回值当删除成功就是被删的值,失败就是null,该用法可以看成取出,但是是取完就没了那种一次性的

HashMap

哈希表实现