java容器总结

#个人对java容器的一些总结#

List

首先导入3个包：

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

常用的方法：

①添加元素，add()：

public static void main(String[] args) {
        List list = new ArrayList();
        list.add("芙卡洛斯");
        list.add("芙芙");
        list.add("芙芙");
        System.out.println(list);
}
输出结果为：[芙卡洛斯, 芙芙, 芙芙]

②删除元素remove() ：

public static void main(String[] args) {
        List list = new ArrayList();
        list.add("芙卡洛斯");
        list.add("芙芙");
        list.add("芙芙");
        list.remove(1);//或者list.remove("芙芙");
        System.out.println(list);
  }

输出结果：[芙卡洛斯, 芙芙]

③list的大小(装了多少元素)，size():

public static void main(String[] args) {
        List list = new ArrayList();
        list.add("芙卡洛斯");
        list.add("芙芙");
        list.add("芙芙");
        System.out.println(list.size());
  }

结果为：3

④查询元素，get():

public static void main(String[] args) {
        List list = new ArrayList();
        list.add("芙卡洛斯");
        list.add("芙芙");
        list.add("芙芙");
        Object object = list.get(0);
        System.out.println((String)object);
    }

结果：芙卡洛斯

⑤是否包含某个元素，contains():

public static void main(String[] args) {
        List list = new ArrayList();
        list.add("芙卡洛斯");
        list.add("芙芙");
        list.add("芙芙");
        System.out.println(list.contains("芙卡洛斯"));
        System.out.println(list.contains("芙宁娜"));
    }

结果：true  false

⑥遍历元素：

public static void main(String[] args) {
        List list = new ArrayList();
        list.add("芙卡洛斯");
        list.add("芙芙");
        list.add("芙芙");
        for(int i = 0; i < list.size(); i ++) {
            System.out.println(list.get(i));
        }
    }

结果：芙卡洛斯
芙芙
芙芙

List可以存储重复数据，而且顺序按照输入顺序。

 

LinkedList和ArrayList的使用基本一样。

Set集合

特点：没有重复元素。

常见的有HashSet(无序的，乱的，不重复元素)，TreeSet(默认进行从小到大排序，不重复元素).....

常用的方法：

①添加元素，add();

②删除元素，remove();

③元素个数，size();

④是否包含元素，contains();

⑤不能使用get()查找元素。

导包：import java.util.Set;
import java.util.TreeSet;
import java.util.HashSet;
 

add():

public static void main(String[] args) {
        Set hset = new HashSet();
        Set tset = new TreeSet();
        hset.add(1);
        hset.add(123);
        hset.add(4);
        hset.add(-10);
        
        tset.add(1);
        tset.add(123);
        tset.add(4);
        tset.add(-10);
        
        System.out.println(hset);
        System.out.println(tset);
    }

结果：[1, 4, -10, 123]
[-10, 1, 4, 123]

remove():

public static void main(String[] args) {
        Set hset = new HashSet();
        Set tset = new TreeSet();
        hset.add(1);
        hset.add(123);
        hset.add(4);
        hset.add(-10);
        
        tset.add(1);
        tset.add(123);
        tset.add(4);
        tset.add(-10);
        hset.remove(4);
        tset.remove(123);
        System.out.println(hset);
        System.out.println(tset);
    }

结果：[1, -10, 123]
[-10, 1, 4]

size():

public static void main(String[] args) {
        Set hset = new HashSet();
        Set tset = new TreeSet();
        hset.add(1);
        hset.add(123);
        hset.add(4);
        hset.add(-10);
        
        tset.add(1);
        tset.add(123);
        tset.add(4);
        tset.add(-10);
        System.out.println(hset.size());
        System.out.println(tset.size());
    }

结果：4
4

contains():

public static void main(String[] args) {
        Set hset = new HashSet();
        Set tset = new TreeSet();
        hset.add(1);
        hset.add(123);
        hset.add(4);
        hset.add(-10);
        
        tset.add(1);
        tset.add(123);
        tset.add(4);
        tset.add(-10);
        System.out.println(hset.contains("123"));
        System.out.println(tset.contains(1));
    }

结果：false
true

Map容器

类似于电话簿中  名字->电话

在map中 key -> value

两个常见类：HashMap（不排序），TreeMap（排序，根据key）

常见的方法：

①map.put(key,value);

②map.remove(key);

③map.size();

④map.containsKey();

⑤出现相同key会替换数据

⑥keySet()，所有的key打包为set集合;

⑦get(key)，通过key查找元素；

导包：import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

map.put(key,value):

public static void main(String[] args) {
        Map hmap = new HashMap();
        Map tmap = new TreeMap();
        hmap.put("G.E.M", "邓紫棋");
        hmap.put("jay", "周杰伦");
        hmap.put("JJ", "林俊杰");
        
        tmap.put("G.E.M", "邓紫棋");
        tmap.put("jay", "周杰伦");
        tmap.put("JJ", "林俊杰");
        System.out.println(hmap);
        System.out.println(tmap);
    }

结果：{JJ=林俊杰, G.E.M=邓紫棋, jay=周杰伦}
{G.E.M=邓紫棋, JJ=林俊杰, jay=周杰伦}

map.remove(key):

public static void main(String[] args) {
        Map hmap = new HashMap();
        Map tmap = new TreeMap();
        hmap.put("G.E.M", "邓紫棋");
        hmap.put("jay", "周杰伦");
        hmap.put("JJ", "林俊杰");
        
        tmap.put("G.E.M", "邓紫棋");
        tmap.put("jay", "周杰伦");
        tmap.put("JJ", "林俊杰");
        hmap.remove("jay");
        tmap.remove("G.E.M");
        System.out.println(hmap);
        System.out.println(tmap);
    }

结果：{JJ=林俊杰, G.E.M=邓紫棋}
{JJ=林俊杰, jay=周杰伦}

map.size():

public static void main(String[] args) {
        Map hmap = new HashMap();
        Map tmap = new TreeMap();
        hmap.put("G.E.M", "邓紫棋");
        hmap.put("jay", "周杰伦");
        hmap.put("JJ", "林俊杰");
        
        tmap.put("G.E.M", "邓紫棋");
        tmap.put("jay", "周杰伦");
        tmap.put("JJ", "林俊杰");
        System.out.println(hmap.size());
        System.out.println(tmap.size());
    }

结果：3
3

containsKey():

public static void main(String[] args) {
        Map hmap = new HashMap();
        Map tmap = new TreeMap();
        hmap.put("G.E.M", "邓紫棋");
        hmap.put("jay", "周杰伦");
        hmap.put("JJ", "林俊杰");
        
        tmap.put("G.E.M", "邓紫棋");
        tmap.put("jay", "周杰伦");
        tmap.put("JJ", "林俊杰");
        System.out.println(hmap.containsKey("jay"));
        System.out.println(tmap.containsValue("邓紫棋"));
    }

结果：true
true

出现相同key：

public static void main(String[] args) {
        Map hmap = new HashMap();
        Map tmap = new TreeMap();
        hmap.put("G.E.M", "邓紫棋");
        hmap.put("jay", "周杰伦");
        hmap.put("JJ", "林俊杰");
        hmap.put("JJ", "JJ");

        System.out.println(hmap);
    }

结果：{JJ=JJ, G.E.M=邓紫棋, jay=周杰伦}

keySet():
 

public static void main(String[] args) {
        Map hmap = new HashMap();
        Map tmap = new TreeMap();
        hmap.put("G.E.M", "邓紫棋");
        hmap.put("jay", "周杰伦");
        hmap.put("JJ", "林俊杰");

        System.out.println(hmap.keySet());
    }

结果：[JJ, G.E.M, jay]

get(key):

public static void main(String[] args) {
        Map hmap = new HashMap();
        Map tmap = new TreeMap();
        hmap.put("G.E.M", "邓紫棋");
        hmap.put("jay", "周杰伦");
        hmap.put("JJ", "林俊杰");
        System.out.println(hmap.get("JJ"));
    }

结果：林俊杰

迭代器Iterator

遍历时迭代器

导入包：import java.util.Iterator;

Set集合的使用：

public static void main(String[] args) {
        Set hset = new HashSet();
        hset.add(1);
        hset.add(123);
        hset.add(4);
        hset.add(-10);
        Iterator it = hset.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }

结果:1
4
-10
123

Map：

方法一：

public static void main(String[] args) {
        Map hmap = new HashMap();
        hmap.put("G.E.M", "邓紫棋");
        hmap.put("jay", "周杰伦");
        hmap.put("JJ", "林俊杰");
        Set set = new HashSet();
        set = hmap.keySet();
        Iterator it = set.iterator();
        while(it.hasNext()) {
            String key = (String) it.next();
            System.out.println(hmap.get(key));
        }
    }

方法二：（需要导入包import java.util.Map.Entry;）

public static void main(String[] args) {
        Map hmap = new HashMap();
        hmap.put("G.E.M", "邓紫棋");
        hmap.put("jay", "周杰伦");
        hmap.put("JJ", "林俊杰");
        Set set = hmap.entrySet();
        Iterator it = set.iterator();
        while(it.hasNext()) {
            Entry entry = (Entry) it.next();
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }

还可以使用增强for循环