Java基础（十二）-集合
集合
用于存储一组数据的大小不定的容器。
Collection<E>
集合的顶级接口
Collection<E>---E表示泛型
Collection<String> c;---表示集合中存储的是String类型---由于泛型的限定，集合中只能存储引用类型的数据
// 表示元素类型是String类型
Collection<String> c = new ArrayList<String>();
// 添加元素
c.add("adf");
// 将集合转化为Object类型的数组
Object[] os = c.toArray();
// 将集合转化为对应类型的数组
/*
* 在底层会判断传入的数组的大小是否大于等于元素的个数
* 如果大于等于了元素个数，则直接使用传入的数组来存储元素，最后返回传入的数组。
* 如果小于元素个数，底层只会根据传入对的类型来创建一个和元素个数等大的数组
*/
String[] ss = c.toArray(new String[0]);
for (String s : ss) {
System.out.println(s);
}
// 获取元素个数---集合中元素的个数和集合的大小是两个概念
System.out.println(c.size());
//清空集合
c.clear();
// 判断是否一个空集合
System.out.println(c.isEmpty());
// 遍历集合
for (String s : c) {
System.out.println(s);
}
// 删除元素---在删除这个元素之前会首先判断这个元素是否存在。
c.remove("adg");
// 判断指定的元素是否存在
System.out.println(c.contains("jkl"));
List<E>
保证元素的存入顺序---元素是有序的，可以存储重复元素---元素有序可重复
元素存在下标，所以可以通过下标来获取和操作对应的元素
List<String> list = new ArrayList<String>();
// 添加元素
list.add("abc");
list.add("def");
list.add("ghi");
// list.add(10, "xyz");
// 移除指定下标位置上的元素
list.remove(2);
// 替换指定下标上的元素
list.set(1, "opq");
// 获取指定下标位置上的元素
System.out.println(list.get(3));
// 获取指定元素在列表中第一次出现的位置
// 如果元素不存在，则返回-1
System.out.println(list.indexOf("ad"));
// 向列表的指定下标上插入指定的元素
list.add(1, "mno");
// 判断两个列表是否一致
List<String> list2 = new ArrayList<String>();
list2.add(new String("abc"));
list2.add("def");
list2.add("ghi");
list2.add("jkl");
list2.add("abc");
// 在比较两个集合是否一致的时候，实际上依次调用对应位置上的元素的equals来比较两个元素是否一致。
System.out.println(list.equals(list2));
ArrayList
基于数组的。默认初始容量是10，每次是在上一次的基础上扩容一半。 10 -> 15 -> 22内存空间连续。是一个线程不安全的集合.增删元素比较慢，查询元素较快
练习：数组来实现一个简易版的ArrayList，元素是String，实现add/remove/set/get/indexOf/contains/isEmpty/size/toString方法
public class ListExer {
// 存储元素
private String[] data;
// 记录已经存储的元素个数
private int size = 0;
public ListExer() {
data = new String[10];
}
public ListExer(int capacity) {
// 需要判断容量是否符合事实
if (capacity < 0) {
capacity = 10;
}
data = new String[capacity];
}
private void grow() {
if (data.length <= 1) {
data = Arrays.copyOf(data, data.length + 1);
return;
}
data = Arrays.copyOf(data, data.length + (data.length >> 1));
}
public void add(String s) {
// 判断是否需要扩容
if (size >= data.length) {
this.grow();
}
data[size] = s;
size++;
}
public void add(int index, String s) {
// 判断下标是否越界
if (index > size) {
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
}
// 判断是否需要扩容
if (size >= data.length) {
this.grow();
}
// 插入元素
// for (int i = size - 1; i >= index; i--) {
// data[i + 1] = data[i];
// }
System.arraycopy(data, index, data, index + 1, size - index);
data[index] = s;
size++;
}
public void remove(String s) {
// 获取这个元素第一次出现的下标
int index = this.indexOf(s);
// 判断这个下标是否存在
if (index != -1) {
this.remove(index);
}
}
private void out(int index) {
// 判断下标越界
if (index >= size) {
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
}
}
public void remove(int index) {
this.out(index);
// for (int i = index; i < size - 1; i++) {
// data[i] = data[i + 1];
// }
System.arraycopy(data, index + 1, data, index, size - index - 1);
size--;
}
public void set(int index, String s) {
this.out(index);
data[index] = s;
}
public String get(int index) {
this.out(index);
return data[index];
}
public boolean contains(String s) {
return this.indexOf(s) != -1;
}
public boolean isEmpty() {
return size <= 0;
}
public int indexOf(String s) {
for (int i = 0; i < size; i++) {
if (s == data[i] || s != null && s.equals(data[i])) {
return i;
}
}
return -1;
}
public int size() {
return size;
}
public String toString() {
StringBuilder sb = new StringBuilder("[");
for (int i = 0; i < size; i++) {
sb.append(data[i]).append(", ");
}
String str = sb.toString();
if (str.length() > 1) {
str = str.substring(0, str.length() - 2);
}
return str += "]";
}
public static void main(String[] args) { ListExer le = new ListExer(3); le.add("a");
le.add("b");
le.add("c"); le.add(0,"e"); le.remove(0);
System.out.println(le); }
}
LinkedList
基于链表实现的。内存空间是不连续的。增删元素相对较快，查询元素较慢。是一个线程不安全的集合
面试题：
ArrayList 和 LinkedList 有什么区别？
ArrayList和LinkedList都实现了List接口，有以下的不同点：
1、ArrayList是基于索引的数据接口，它的底层是数组。它可以以O(1)时间复杂度对元素进行随机访问。与此对应，LinkedList是以元素列表的形式存储它的数据，每一个元素都和它的前一个和后一个元素链接在一起，在这种情况下，查找某个元素的时间复杂度是O(n)。
2、相对于ArrayList，LinkedList的插入，添加，删除操作速度更快，因为当元素被添加到集合任意位置的时候，不需要像数组那样重新计算大小或者是更新索引。
3、LinkedList比ArrayList更占内存，因为LinkedList为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素。
Vector
基于数组的。默认的初始容量是10，每次扩容一倍。内存空间连续。增删元素较慢，查询元素相对较快。是一个线程安全的集合。---是Java中最早的集合。
Stack
栈。---遵循先进后出的原则。最先放入的元素---栈底元素，最后放入的元素---栈顶元素。将元素放入栈中---入栈/压栈；将元素从栈中取出---出栈/弹栈
练习：
1. 用Vector来实现Stack
public class StackExer1 { private Vector<String> v = new Vector<>(); public StackExer1() { } public boolean empty() { return v.isEmpty(); } public String peek() { // 判断栈是否为空 if (v.isEmpty()) { throw new EmptyStackException(); } return v.get(v.size() - 1); } public String pop() { String str = this.peek(); // 移除栈顶元素 v.remove(v.size() - 1); return str; } public void push(String str) { v.add(str); } public int search(String str) { for (int i = v.size() - 1; i >= 0; i--) { if (str == v.get(i) || str != null && str.equals(v.get(i))) { return v.size() - i; } } return -1; } }
2. 用数组实现Stack
public class StackExer2 { private String[] data = new String[10]; private int size = 0; public StackExer2() { } public boolean empty() { return size <= 0; } public String peek() { if (size <= 0) { throw new EmptyStackException(); } return data[size - 1]; } public String pop() { String str = this.peek(); size--; return str; } public void push(String s) { if (size >= data.length) { data = Arrays.copyOf(data, data.length * 2); } data[size] = s; size++; } public int search(String str) { for (int i = size - 1; i >= 0; i--) { if (str == data[i] || str != null && str.equals(data[i])) { return size - i; } } return -1; } }
Queue
队列---先进先出
线性集合：List,Queue
Set
散列集合---元素不可重复，不保证元素顺序---Set中的元素无序不可重复
HashSet---默认初始容量是16，加载因子是0.75f，每次扩容一倍。是一个线程不安全的集合
Iterator
迭代器---用于迭代遍历集合。通过指针的挪动来获取对应的元素，通过标记这个元素是佛可用来确定是否删除这个元素---不允许直接增删原集合
foreach---本质上也是在做迭代遍历。---如果一个对象能够使用增强for循环，那么这个对象对应的类必须实现Iterable。---JDK1.5的特性之一
Collections
是一个操作集合的工具类
Comparator
比较器---重写compare方法，将比较规则写到compare方法中---根据返回值的正负来确定大小：如果返回值是正数，表示第一个参数排到第二个参数之后；反之表示第一个参数排到第二个参数之前
如果没有指定排序规则，这个时候要求集合中的元素对应的类必须实现Comparable,比较规则是写在compareTo方法中
练习：
疯狂值（一组数字，排列顺序，两个为一组相减，值最大，输出这组数字）
5 15 20 35 50 70
20 50 5 70 15 35 -> 215
35 15 70 5 50 20 -> 215
方法一 集合：
public class CrazyExer1 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
// 获取输入的数字个数
int number = s.nextInt();
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < number; i++) {
list.add(s.nextInt());
}
s.close();
// 需要对集合进行排序
Collections.sort(list);
int sum1 = sort(list);
Collections.reverse(list);
int sum2 = sort(list);
System.out.println(sum1 > sum2 ? sum1 : sum2 );
// 5 10 15 20 50 70 80
}
public static int sort(List<Integer> list) {
// 存储排序之后的结果
List<Integer> result = new ArrayList<Integer>();
// 先放入集合的最后一位
result.add(list.get(list.size() - 1));
// 标记存放的情况
// 0->前小
// 1->后小
// 2->前大
// 3->后大
int i = 0;
for (int start = 0, end = list.size() - 2; start <= end;) {
if (i == 0) {
result.add(0, list.get(start));
start++;
} else if (i == 1) {
result.add(list.get(start));
start++;
} else if (i == 2) {
result.add(0, list.get(end));
end--;
} else {
result.add(list.get(end));
end--;
i = -1;
}
i++;
}
// 记录和
int sum = 0;
for (int j = 0; j < result.size() - 1; j++) {
sum += Math.abs(result.get(j) - result.get(j + 1));
}
return sum;
}
}
方法二 数组：
public class CrazyExer2 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int number = s.nextInt();
int[] arr = new int[number];
for (int i = 0; i < number; i++) {
arr[i] = s.nextInt();
}
s.close();
// 数组排序
Arrays.sort(arr);
int sum1 = sort(arr);
for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
int sum2 = sort(arr);
System.out.println(sum1 > sum2 ? sum1 : sum2);
}
private static int sort(int[] arr) {
int[] result = new int[arr.length];
int mid = arr.length / 2;
result[mid] = arr[arr.length - 1];
int i = 0;
int offset = 1;
for (int start = 0, end = arr.length - 2; start <= end;) {
if (i == 0) {
result[mid - offset] = arr[start];
start++;
} else if (i == 1) {
result[mid + offset] = arr[start];
start++;
offset++;
} else if (i == 2) {
result[mid - offset] = arr[end];
end--;
} else {
result[mid + offset] = arr[end];
end--;
offset++;
i = -1;
}
i++;
}
int sum = 0;
for (int j = 0; j < result.length - 1; j++) {
sum += Math.abs(result[j] - result[j + 1]);
}
return sum;
}
}
泛型
参数化类型---ParameterizedType---JDK1.5出现的
List list = new ArrayList();---底层以Object类型来存储
泛型的擦除---用具体类型来替换泛型的过程---发生在了编译期
泛型的继承
// ? 表示泛型的通配符 // 遍历元素类型是数值类型的集合---泛型不向下兼容 // ? extends 类/接口 表示传入这个类/接口本身或者其子类/子接口元素 // 泛型的上限 public static void it(List<? extends Number> list) { // 能向这个集合添加元素么？--不行,除了null // list.add(new Integer(4)); list.add(null); for (Number number : list) { System.out.println(number); } } // String及其父类 // ? super 类/接口 表示传入这个类/接口及其父类/父接口元素 // 泛型的下限---同一个泛型不能既规定上限又规定下限 public static void it2(List<? super String> list) { }
使用泛型好处:
1.将运行时期出现问题类型转换异常ClassCastException移到了编译时期。方便解决问题并且减少了运行时间
2.避免了强制转换麻烦。
映射---Map<K,V>
Map是Java中映射的顶级接口。K-Key---键，V-Value---值---存储的时候是一个键对应了一个值---键值对---要求键必须唯一，值随意。---一个map中存储了很多的键值对。
Map不是集合，但是它是集合框架中的一员。
Map.Entry---代表键值对的接口---内部接口
Entry---每一个entry对象代表了一个键值对。
一个map对象实际上是由多个entry对象组成的。
问题：如何遍历一个Map？
1. 先获取所有的键，依次根据键获取值---keySet
2. 获取由键值对组成的集合/数组---entrySet
HashMap---允许键或者值为null，默认初始容量是16，加载因子是0.75f，每次扩容一倍。是一个异步式线程不安全的映射。
Hashtable---不允许键或者值为null，默认初始容量是11，加载因子是0.75f。是一个同步式线程安全的映射。
ConcurrentHashMap---异步式线程安全的映射。