常用结构: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()]);
使用心得:
List<String> setToList = new ArrayList<>(set);
if(set.add("值"))
;常用结构:
// 按原来顺序排列
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使用心得:
ArrayList使用心得:
LinkedList使用心得:
Stack<String> stack = new Stack<>();
push(),将元素推入栈中(数组的末尾)
peek(),取出栈顶元素,不执行删除(返回数组末尾的元素)
pop(),取出栈顶元素,并将该元素从栈中删除(取出数组末尾的元素,然后将该元素从数组中删除)
empty(),判断堆是否为空
search(),返回基于堆顶部元素的位置,从1开始(如堆顶元素为1)
常用结构:
// 键按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();
使用心得:
Iterator iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry) iterator.next();
System.out.println(entry.getKey() + ":" + entry.getValue());
}
Set<Entry<Integer, String>> entries = map.entrySet();
for (Entry entry : entries) { // 或Map.Entry
if (val.equals(entry.getValue())) {
System.out.println(entry.getKey());
}
}
// 自定义比较器
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;
integer = Integer.valueOf(i);
i = integer.intValue();
i = Integer.parseInt(str);
str = String.valueOf(i);
chars = str.toCharArray();
str = String.valueOf(chars); // toString()方法得到的是类名加地址
set = new HashSet<>(list);
list = new ArrayList<>(set);
// 或list = Arrays.asList(Arrays.copyOf(strs, strs.length));
list = new ArrayList<>(Arrays.asList(strs));
strs = list.toArray(new String[list.size()]);
set = new HashSet<>(Arrays.asList(strs));
strs = set.toArray(new String[set.size()]);
总结:
new
天然互转;// 将数组转化成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进行填充