Java笔记_基础_集合

集合

迭代器:

Iterator<E>

可以遍历所有单列集合
创建迭代器之后不能改变原集合长度

方法	返回值	说明
Collection对象.iterator()	构造方法	返回一个迭代器对象 默认索引指向0
hasNext()	boolean	判断当前指向索引是否有内容
next()	Object	返回当前索引内容并将索引指向下一个索引

增强for

底层为迭代器

for(Object o: Collection c){ //c 为集合对象 o 为集合内的元素对象
	System.out.println(o)
}

单列:

(interface) Collection<E>

方法	返回值	说明
add(Object obj)	void	添加元素
addAll(Collection c)	void	添加另一个集合中的数据
clear()	void	清空集合
size()	int	获取集合长度
remove(Object obj)	boolean	删除元素
removeif(Object obj)	boolean	根据(lambda表达式条件)删除元素
contains(Object obj)	boolean	判断集合中是否存在该元素
isEmpty()	boolean	判断集合是否为空

(interface) List<E>

可重复,有序,有索引

方法	返回值	说明
add(int i, Object obj)	void	将元素添加至该索引处,其原本元素索引加一
remove(int i)	Object	删除该索引元素 返回被删除元素
set(int i,Object obj)	Object	修改该索引元素 返回被修改元素
get(int i)	Object	查询该索引元素

ArrayList<E>

底层为数组,查找快,增删改慢

import java.util.List;
import java.util.ArrayList;

public class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc"); //向 list 依次添加 "aaa" "bbb" "ccc"
        getList(list); //调用 getList方法 将 list 集合元素依次打印

        if(list.contains("aaa")){ //判断 list 中是否有 "aaa"
            list.remove("aaa"); //删除 "aaa"
        }
        getList(list);

        list.add(0,"ddd"); //将 "ddd" 添加至0索引,原有元素依次后移
        list.set(1,"eee"); //将 1 索引处原有的 "bbb" 修改为 "eee"
        getList(list);
    }

    public static void getList(List list){ //将 list 集合元素依次打印
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("============================");
    }
}

运行结果:

aaa
bbb
ccc
============================
bbb
ccc
============================
ddd
eee
ccc
============================

LinkedList<E>

底层为链表式,查找慢,增删改快

方法	返回值	说明
addFirst(Object obj)	boolean	在开头插入指定元素
addLast(Object obj)	boolean	在末尾追加指定元素
getFirst()	Object	获取第一个元素
getLast()	Object	获取最后一个元素
removeFirst()	Object	删除并返回第一个元素
removeLast()	Object	删除并返回最后一个元素

import java.util.List;
import java.util.LinkedList;

public class Demo {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc"); //向 list 依次添加 "aaa" "bbb" "ccc"
        getList(list); //调用 getList方法 将 list 集合元素依次打印

        list.addFirst("abc");
        list.addLast("cba");
        getList(list);

        System.out.println(list.getFirst());
        System.out.println(list.getLast());
    }

    public static void getList(List list){ //将 list 集合元素依次打印
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("============================");
    }
}

运行结果:

aaa
bbb
ccc
============================
abc
aaa
bbb
ccc
cba
============================
abc
cba

(interface) Set<E>

可以去除重复,无序,无索引,只能用迭代器遍历

TreeSet<E>

底层为红黑树,可以将元素按照一定规则排序

import java.util.Set;
import java.util.TreeSet;

public class Demo {
    public static void main(String[] args) {
        TreeSet<String> set = new TreeSet<>();
        set.add("ccc");
        set.add("aaa");
        set.add("bbb");
        set.add("aaa"); //重复元素无效
        getSet(set);
    }

    public static void getSet(Set set) { //将 set 集合元素依次打印
        for (Object o : set) { //Set集合无索引 故使用 增强for
            System.out.println(o);
        }
        System.out.println("============================");
    }
}

运行结果(有序):

aaa
bbb
ccc
============================

HashSet<E>

根据哈希表结构进行排序(混乱排序) -> 数组 + 链表 + 黑红树

import java.util.Set;
import java.util.HashSet;

public class Demo {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("ccc");
        set.add("aaa");
        set.add("bbb");
        set.add("aaa");
        getSet(set);
    }

    public static void getSet(Set set) { //将 set 集合元素依次打印
        for (Object o : set) {
            System.out.println(o);
        }
        System.out.println("============================");
    }
}

运行结果(无序):

aaa
ccc
bbb
============================

双列:

(interface) Map<K,V>

双列,键数据(key)和值数据(value)对应成为一个键值对对象(Entry对象),键不可重复,值可以重复,一一对应

方法	返回值	说明
clear()	void	清空集合
forEach((K k, V v) -> { })	void	遍历集合并执行{}中的代码体
get(K k)	Object	查看键对应的值
size()	int	获取集合长度
put(K k, V v)	boolean	添加元素 若键相同则为修改值
remove(K k)	boolean	删除元素
containsKey(K k)	boolean	判断集合是否包含指定的键
containsValue(V v)	boolean	判断集合是否包含指定的值
isEmpty()	boolean	判断集合是否为空
keySet()	Set	获取所有键对象
entrySet()	Set<Map.Entry<K k, V v>>	获取所有键值对对象,返回Set<Map.Entry<键泛型, 值泛型>>集合

TreeMap<K,V>

底层为红黑树,可以将元素按照一定规则排序
类似 TreeSet

import java.util.Set;
import java.util.Map;
import java.util.TreeMap;

public class Demo {
    public static void main(String[] args) {
        Map<String, String> map = new TreeMap<>();
        map.put("a", "ccc");
        map.put("b", "bbb");
        map.put("c", "ccc");
        map.put("a", "aaa"); //键相同时则修改值
        getMap(map);

        Set<Map.Entry<String, String>> set1 = map.entrySet(); //遍历方式1
        for (Map.Entry<String, String> entry : set1) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
        System.out.println("============================");

        Set<String> set2 = map.keySet(); //遍历方式2
        for (String s : set2) {
            System.out.println(s + " : " + map.get(s));
        }
        System.out.println("============================");
    }

    public static void getMap(Map map) { //将 map 集合元素依次打印
        map.forEach((Object k, Object v) ->
                System.out.println(k + " : " + v)
        );
        System.out.println("============================");
    }
}

运行结果:

a : aaa
b : bbb
c : ccc
============================
a : aaa
b : bbb
c : ccc
============================
a : aaa
b : bbb
c : ccc
============================

HashMap<K,V>

根据哈希表结构进行排序(混乱排序) -> 数组 + 链表 + 黑红树
类似 HashSet

import java.util.Set;
import java.util.Map;
import java.util.HashMap;

public class Demo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("a", "ccc");
        map.put("b", "bbb");
        map.put("c", "ccc");
        map.put("a", "aaa"); //键相同时则修改值
        getMap(map);

        Set<Map.Entry<String, String>> set1 = map.entrySet(); //遍历方式1
        for (Map.Entry<String, String> entry : set1) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
        System.out.println("============================");

        Set<String> set2 = map.keySet(); //遍历方式2
        for (String s : set2) {
            System.out.println(s + " : " + map.get(s));
        }
        System.out.println("============================");
    }

    public static void getMap(Map map) { //将 map 集合元素依次打印
        map.forEach((Object k, Object v) ->
                System.out.println(k + " : " + v)
        );
        System.out.println("============================");
    }
}

运行结果:

a : aaa
b : bbb
c : ccc
============================
a : aaa
b : bbb
c : ccc
============================
a : aaa
b : bbb
c : ccc
============================

properties

纯字符串类型 双列集合
常用于配置文件

方法	返回值	说明
load(FileInputStream in)	void	直接用FileOutputStream(“文件名.properties”);配置文件读取到集合中
store(FileOutputStream out, String str)	void	直接用FileInputStream(“文件名.properties”);将集合写入配置文件中, str:注释
getProperty(String str)	String	获取元素
setProperty(String str, String str)	boolean	添加元素
stringPropertyNames()	Set	获取key集合