Java集合类的使用心得

一、Set（不重复）

常用结构：SortedSet是个接口，TreeSet是它的唯一实现类，其中的元素是有序的。

// 不重复，按一定的顺序排列(HashSet，基于哈希表)
Set<String> set = new HashSet<>();
// SortedSet(含TreeSet，基于二叉树)按自然顺序升序排列
SortedSet<String> sortedSet = new TreeSet<>();
// 不重复，按原来顺序排列
Set<String> linkedHashSet = new LinkedHashSet<>();

常用方法：

set.add("值");
set.clear();
set.remove();
Object[] obj = set.toArray();
String[] strings = set.toArray(new String[set.size()]);

使用心得：

1. Set要取任意位置的值，可以转换成List：List<String> setToList = new ArrayList<>(set);
2. Set一般会利用它的不重复性来判断值是否存在，if(set.add("值"))；
3. 只利用不重复性时用HashSet，要考虑到按原来顺序排列用LinkedHashSet，要对值进行排序用SortedSet。

二、List（随机访问）

常用结构：

// 按原来顺序排列
List<Integer> list = new ArrayList<>();
// 双向链表
LinkedList<String> linkedList = new LinkedList<>();
// List没有Sorted List，可以通过Collections.sort()排序列表

常用方法：

/** ArrayList */
list.add("值")；
list.add((int)index, "值");
list.remove("值"); // 删除一个最开始出现的“值”
list.remove((int)index);
list.get((int)index);
list.set((int)index, "值");
list.contains("值");
list.indexOf("值"); // 还有lastIndexOf()

/** LinkedList */
// 不指定索引，则将元素添加到链表的最后
linkedList.add(Object element)
linkedList.add(int index, Object element)
// 把链表当初栈或者队列来处理
linkedList.addFirst(Object element)
linkedList.addLast(Object element)

linkedList.removeFirst(); // end同理，remove()方法效果与removeFirst()相同
linkedList.removeFirstOccurrence("值");

linkedList.get((int)index);
linkedList.getFirst(); // getLast()同理

linkedList.set((int)index, "值"); // 替换指定位置
linkedList.indexOf("值"); // lastIndexOf()同理
linkedList.subList(start, end);

List使用心得：

1. 如果涉及到“栈”、“队列”、“链表”等操作，应该考虑用List；
2. 注意有set()方法的存在，随机访问。

ArrayList使用心得：

1. 序号从0开始;
2. 通过索引存储，存储的值可以相同；
3. 如需替换某个值，应结合remove和add两个方法；
4. List内可以存对象，此外的操作可以同样用数组实现。

LinkedList使用心得：

1. 可以通过First和Last来实现堆、栈的数据结构。

• Stack
  常用方法：

Stack<String> stack = new Stack<>();

push()，将元素推入栈中（数组的末尾）
peek()，取出栈顶元素，不执行删除（返回数组末尾的元素）
pop()，取出栈顶元素，并将该元素从栈中删除（取出数组末尾的元素，然后将该元素从数组中删除）
empty()，判断堆是否为空
search()，返回基于堆顶部元素的位置，从1开始（如堆顶元素为1）

三、Map（对应关系）

常用结构：

// 键按hashcode()的顺序排列
Map<String, Integer> map = new HashMap<>();
// 键按自然顺序升序排列，不允许null
SortedMap sortedMap = new TreeMap();
// 键按原来顺序排列
LinkedHashMap<String, Integer> map = new LinkedHashMap<>();

// 针对键自定义顺序，这里改成了降序，也可以新建一个Comparator对象，这里引用对象
SortedMap<Integer, String> sortedMap = new TreeMap<>(new Comparator<Integer>() {
   @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
});

常用方法：

map.put("键","值");
map.remove("键"); // 返回的是对应的值，remove("键","值")返回的是布尔值
map.get("键"); // 返回的是对应的值

map.containsKey("键")；
map.keySet().contains("键"); // value().contains()类似

map.entrySet().iterator();
map.keySet().iterator();
map.value().iterator();

使用心得：

1. 重复时，put()方法会覆盖原来的值，且键可以为null；
2. 分别获得当前键值的键与值

Iterator iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry entry = (Map.Entry) iterator.next();
    System.out.println(entry.getKey() + ":" + entry.getValue());
}

3. 通过值获得相应的键

Set<Entry<Integer, String>> entries = map.entrySet();
for (Entry entry : entries) { // 或Map.Entry
	if (val.equals(entry.getValue())) {
		System.out.println(entry.getKey());
	}
}

4. 对HashMap进行排序，自定义SortedMap的比较逻辑

// 自定义比较器
class ValueComparator implements Comparator<String> {
    Map<String, Integer> base;

    public ValueComparator(Map<String, Integer> base) {
        this.base = base;
    }

    public int compare(String a, String b) {
        if (base.get(a) >= base.get(b)) {
            return -1;
        } else {
            return 1;
        } // returning 0 would merge keys
    }
}

// 在代码中添加如下实现代码
ValueComparator vc = new ValueComparator(map);
TreeMap<String, Integer> sortedMap = new TreeMap<String, Integer>(vc);
sortedMap.putAll(map);

四、数组

实际开发之中，会更多的使用数组概念，而直接使用，99%情况下都只是做一个 for 循环输出。出现二位数组的几率并不高。

五、类型转化

变量名定义

int i;
Integer integer;
String str；
char[] chars;
Set set;
List list;
String[] strs;

1. Integer与int

integer = Integer.valueOf(i);
i = integer.intValue();

2. String与int

i = Integer.parseInt(str);
str = String.valueOf(i);

3. String与char[]

chars = str.toCharArray();
str = String.valueOf(chars); // toString()方法得到的是类名加地址

4. set与list

set = new HashSet<>(list);
list = new ArrayList<>(set);

5. String[]与list

// 或list = Arrays.asList(Arrays.copyOf(strs, strs.length));
list = new ArrayList<>(Arrays.asList(strs));

strs = list.toArray(new String[list.size()]);

6. String[]与set

set = new HashSet<>(Arrays.asList(strs));
strs = set.toArray(new String[set.size()]);

总结：

1. set与list可以通过new天然互转；
2. String.valueOf(…)可以将基本数据类型转换成String；
3. toArray()方法可以将一个Collection转化为数组，但一定要注意初始化长度。
4. Arrays工具类
   asList()接收的参数是一个泛型的变长参数，而基本数据类型无法泛型化，应使用封装类数组。且得到的ArrayList是Arrays的一个内部类，没有add方法，使用时会报Unsupported Operation Exception。

// 将数组转化成List
Arrays.asList(T… data) 

Arrays.sort(); // 多态
// 使用二分法查找数组内指定元素的索引值，但是先要排序sort
Arrays.binarySearch(Object[] array, Object key);
Arrays.binarySearch(Object[] array, int fromIndex, int toIndex, Object obj);

// 拷贝数组
Arrays.copyOf(T[] original, int newLength); 
Arrays.copyOfRange(T[] original, int from, int to); // 如果超过原数组长度，会用null进行填充