JavaSE-集合

集合类提供一种存储空间可变的存储模型，存储数据的容量可以随时发生改变，比如​​ArrayList​​。

集合按照存储的结构可以分为两类，分别是单列集合​​java.util.Collection​​和双列集合​​java.util.Map​​，这里就先来讲讲​​collection​​集合。

​​List​​的特点是存储的元素有序，元素可以重复。而​​set​​的特点是元素无序、存储的元素不可重复。​​List​​的接口主要实现类有​​ArrayList ​​和​​LinkedList​​,​​Set​​接口的主要实现类有​​HashSet​​和​​TreeSet​​；​​Map​​集合主要有​​HashMap​​

JavaSE-集合_键值对

JavaSE-集合_java_02

Collection

* `public boolean add(E e)`：  把给定的对象添加到当前集合中 。
* `public void clear()` :清空集合中所有的元素。
* `public boolean remove(E e)`: 把给定的对象在当前集合中删除。
* `public boolean contains(E e)`: 判断当前集合中是否包含给定的对象。
* `public boolean isEmpty()`: 判断当前集合是否为空。
* `public int size()`: 返回集合中元素的个数。
* `public Object[] toArray()`: 把集合中的元素，存储到数组中。


简单使用下这个几个方法

public static void main(String[] args) {

        Collection<String> c = new ArrayList<String>();

        c.add("zh1z3ven");
        c.add("agou");
        c.add("cafei");
        c.add("xiaoming");

        System.out.println(c);
        Boolean a = c.isEmpty();
        System.out.println(a);

        int a2 = c.size();
        System.out.println(a2);
        
        c.remove(2);
        System.out.println(c);

        Boolean a3 = c.contains("cafei");
        System.out.println(a3);

    }


Iterator迭代器

java给我们提供了​​Iterator​​接口，也就是迭代器，该接口也是集合的一种。也是集合专用的一种遍历方式。

Iterator<String> it = col.iterator();


集合的​​iterator()​​方法返回该集合元素的一个迭代器对象，之后就可以通过此对象的​​hashNext()​​和​​next()​​遍历这个集合。

​​next()​​:返回迭代的下一个元素。

​​hasNext()​​:如果仍有元素可以迭代，则返回 true，否则返回false。

public static void main(String[] args) {

        Collection<String> col = new ArrayList<String>();

        col.add("Hello");
        col.add("World");
        col.add("Java");

        System.out.println(col);

        Iterator<String> it = col.iterator();

        while (it.hasNext()){
            System.out.println(it.next());
        }
    }


List

​​List​​接口是​​Collection​​的子接口，

​​List​​接口里面允许出现重复元素得，在程序中可以通过索引来访问。

​​List​​接口存储的数据是有序的。

​​List​​的特有方法

void add(int index, Element) 在指定位置插入指定的元素
E remove(int index) 删除指定位置处的元素，返回被删除的元素
E set(int index, Element) 修改指定位置处的元素，返回被修改的元素
E get(int index) 返回指定位置处的元素
public static void main(String[] args) {
      List<String> list = new ArrayList<>();

      list.add("Hello");
      list.add("World");
      list.add("Java");

      System.out.println(list);

      list.add(1,"agou");
      System.out.println(list);

      list.remove(1);
      System.out.println(list);
        
    }
    //
[Hello, World, Java]
[Hello, agou, World, Java]
[Hello, World, Java]


LinkedList

LinkedList集合特有方法

public void addFirst(E e) 在该列表开头插入指定的元素
public void addLast(E e)  将指定元素追加到此列表末尾
public E getFirst() 返回此列表第一个元素
public E getLast()  返回次列表末尾元素
public E removeFirst() 删除并返回此列表第一个元素
public E removeLast() 删除并返回此列表最后一个元素


set

set接口也是继承了Collection接口，也是单列集合。

set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

HashSet

无序，不保证元素的迭代顺序

不包含重复元素的集合

HashSet<String> hashSet = new HashSet<>();


简单例子

public static void main(String[] args) {
        HashSet<String> hashSet = new HashSet<>();

        hashSet.add("hello");
        hashSet.add("world");
        hashSet.add("java");

        //迭代器循环
        Iterator<String> iterator = hashSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //foreach循环
        for (String s : hashSet
             ) {
            System.out.println(s);
        }

    }


LinkedHashSet

上面提到HashSet是无序的，如果想要有序，就需要用到LinkedHashSet

Collections类

conections是集合的工具类。

- public static <T> boolean addAll(Collection<T> c, T... elements)  `:往集合中添加一些元素。
- `public static void shuffle(List<?> list) 打乱顺序`:打乱集合顺序。
- `public static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序。
- `public static <T> void sort(List<T> list，Comparator<? super T> )`:将集合中元素按照指定规则排序。
public static void main(String[] args) {

        //addAll()
        ArrayList<String> arrayList = new ArrayList<>();

        Collections.addAll(arrayList, "hello","world","java","agou");

        Iterator<String> iterator = arrayList.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println("================================");
        //sort()
        ArrayList<Integer> integers = new ArrayList<>();

        Collections.addAll(integers, 11,22,12,45,67453,213,123456);

        System.out.println(integers);

        Collections.sort(integers);

        System.out.println(integers);
    }


Map

在​​ Collection​​中，元素都是单个存在的。

而map中的集合，元素是成对存在的（类似于python中的字典）

每个元素都由键和值组成，通过键可以找到对应的值。

Map接口中的方法

public V put(K key, V value) : 把指定的键与指定的值添加到Map集合中。
public V remove(Object key) : 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的
值。
public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
public Set<K> keySet() : 获取Map集合中所有的键，存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)


Map接口中的集合都有两个泛型变量,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量的数

据类型可以相同，也可以不同。

public static void main(String[] args) {

        HashMap<Integer, String> stringIntegerHashMap = new HashMap<Integer, String>();

        //put() 添加元素
        stringIntegerHashMap.put(1, "xiaoming");
        stringIntegerHashMap.put(2, "xiaohong");
        stringIntegerHashMap.put(3, "xiaobai");
        stringIntegerHashMap.put(4, "agou");
        stringIntegerHashMap.put(5, "zhendegou");

        System.out.println(stringIntegerHashMap);

        //size() 获取长度
        System.out.println(stringIntegerHashMap.size());

        //remove() 删除指定key所对应的value
        stringIntegerHashMap.remove(3);
        System.out.println(stringIntegerHashMap);

        //get() 获取指定key对应的value
        System.out.println(stringIntegerHashMap.get(4));
    }


HashMap循环遍历value

map里面提供了一个获取所以键值的方法keyset。

public class HashMapKeySetDemo {
    public static void main(String[] args) {

        HashMap<Integer, String> integerStringHashMap = new HashMap<>();

        integerStringHashMap.put(1,"xiao");
        integerStringHashMap.put(2,"a");
        integerStringHashMap.put(3,"gou");

        Set<Integer> integers = integerStringHashMap.keySet();
      
        for (int key : integers
             ) {
            String value = integerStringHashMap.get(key);
            System.out.println(value);
        }
    }
}


HashMap循环遍历Key Value

Set<Map.Entry<String, String>> entries = map.entrySet();


Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

public K getKey()：获取Entry对象中的键。

public V getValue()`：获取Entry对象中的值。
public class HashMapEntrySetDemo {
    public static void main(String[] args) {

        HashMap<Integer, String> integerStringHashMap = new HashMap<>();

        integerStringHashMap.put(1,"xiao");
        integerStringHashMap.put(2,"a");
        integerStringHashMap.put(3,"gou");

        Set<Map.Entry<Integer, String>> entries = integerStringHashMap.entrySet();

        for (Map.Entry<Integer, String> entry : entries) {

            int key = entry.getKey();
            String value = entry.getValue();
            System.out.println("Key:" + key + " " + "Value:" + value);
        }
    }
}
Key:1 Value:xiao
Key:2 Value:a
Key:3 Value:gou


LinkedHashMap

Hashmap的存放是无序的，如果需要有序存储数据的话，就需要用到LinkedHashMap。

public class LinkedHashMapDemo {
    public static void main(String[] args) {

        LinkedHashMap<Integer, String> integerStringLinkedHashMap = new LinkedHashMap<>();

        integerStringLinkedHashMap.put(1, "xiao");
        integerStringLinkedHashMap.put(2, "bei");
        integerStringLinkedHashMap.put(3, "bei");

        Set<Map.Entry<Integer, String>> entries = integerStringLinkedHashMap.entrySet();

        for (Map.Entry<Integer, String> entry : entries
             ) {
            String value = entry.getValue();
            int key = entry.getKey();
            System.out.println("Key:" + key + " " + "Value:" + value);
        }
    }
}


 


所有内容仅限于维护网络安全学习参考