无论什么语言，集合应当是我们最常用的一种类型啦，大体上分为有序列表、map、sey、队列
首先先来看一下有序列表，
List内部跟数组一样也是按照先后顺序排放的，但对于增删，非常方便，list的实现大多是使用ArrayList实现的,先来看一下List的源码，这里面有一个<E>，这个就是泛型，java是面向对象语言，他在运行期间，才会将我们的类进行初始化，因此，就利用这一特性，我们输入指定的引用类型，注意必须是引用类型，基本类型不是类，JVM在编译是，会把它当作object，然后再运行期间就会帮我们转化为指定的类型
// 一个接口
public interface List<E> extends Collection<E> {
int size(); // 大小
boolean isEmpty(); // 是否为空
boolean contains(Object o); // 是否包含
Iterator<E> iterator(); // 是否可迭代
Object[] toArray(); // 转化为数组，返回就是object[]
<T> T[] toArray(T[] a); // 转化为数组，返回就是指定的类型[]
boolean add(E e); // 增加，返回true，false
boolean remove(Object o); // 删除，返回bollean
boolean containsAll(Collection<?> c); // 包含
boolean addAll(Collection<? extends E> c);// 添加
boolean addAll(int index, Collection<? extends E> c); // 添加指定位置
boolean removeAll(Collection<?> c); // 删除
@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();
for (Object e : a) {
i.next();
i.set((E) e);
}
} // 拍讯，因此想要排序，必须实现Comparator接口
void clear(); // 情况
boolean equals(Object o); // 判断是否相等
int hashCode(); // 获取这个code， 返回值int
E get(int index);// 获取指定下表的对象
E set(int index, E element);// 重置
void add(int index, E element); // 添加
E remove(int index); // 删除
int indexOf(Object o); // 获取某个对象的下表
int lastIndexOf(Object o); // 获取最后一个对象的下表
@SuppressWarnings("unchecked") // 这个传入为空，就会报错
static <E> java.util.List<E> of() {
return (java.util.List<E>) ImmutableCollections.ListN.EMPTY_LIST;
}
static <E> java.util.List<E> of(E e1, E e2, E e3, E e4, E e5) { // 初始化指定的列表
return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5);
}
}
那么，我们来看一下上面提到的一些方法吧
import java.util.*;
import java.util.List;
public class HelloWorld {
public static void main(String[] args) throws Exception {
// List<int> s = new ArrayList<>(); // java: 意外的类型 需要: 引用 找到: int
List<String> s = new ArrayList<>();
System.out.println(s.isEmpty()); // true判断是否为空
s.add("a"); // 添加
// s.add(1); // java: 不兼容的类型: int无法转换为jåava.lang.String, 因为已经指定类型，所以只能传入指定类型的
s.add("b");
System.out.println(s.add("c")); // true
System.out.println(s.size()); // 3
System.out.println(s); // [a, b, c]
System.out.println(s.contains("a")); // true 包含关系
List<String> s1 = List.of("d", "e"); // 这个返回的只是一个只读的List，因为List只是一个接口
// s1.add("m"); // java.lang.UnsupportedOperationException
List<String> s2 = List.of("f", "g");
s.addAll(s1);
System.out.println(s); // [a, b, c, d, e] 插入一个对象
s.addAll(3, s2);
System.out.println(s); // [a, b, c, f, g, d, e] 在指定位置插入
s.remove("f");
System.out.println(s); // [a, b, c, g, d, e] 删除
System.out.println(s.get(1)); // b 获取指定下表的元素
// String[] m = s.toArray(); // java: 不兼容的类型: java.lang.Object[]无法转换为java.lang.String[]，这个是因为不支持的，随意这个运行之前就是object
String[] m1 = new String[3];
String[] m2 = new String[9];
String[] m3 = s.toArray(m1); // 可以这样转化,List会把值赋值给传入对象，但是如果数字不够长，List会为他生成新的对象
String[] m4 = s.toArray(m2); // 可以这样转化,
for (String i : m1) {
System.out.println(i);
} // null null null 数组不够长,我们应该清楚，数组扩容之后，会生成一个新对象，愿对象就会被清空
for (String i : m3) {
System.out.println(i);
} // a b c g d e 这个就是被扩容之后的新对象，所以要记得写返回值
for (String i : m2) {
System.out.println(i);
} // a b c g d e null null null 这个数组定义的够长，所有值是传进去了
for (String i : m4) {
System.out.println(i);
} // a b c g d e null null null
// 一般情况下，我们肯定希望正好，可以结合上size或者直接为0
String[] m5 = s.toArray(new String[0]);
String[] m6 = s.toArray(new String[s.size()]);
for (String i : m5) {
System.out.println(i);
} // a b c g d e 正好
for (String i : m6) {
System.out.println(i);
} // a b c g d e 正好
// List 的循环，for each的方法帮助我们封装了迭代，原始应该是这样的
for (Iterator<String> ss = s.iterator(); ss.hasNext(); ) {
String sss = ss.next();
System.out.println(sss);
} // a b c g d e
// 如上面所说，for帮助我们做了封装，所以可以直接这样写
for (String ss : s) {
System.out.println(ss);
} // a b c g d e
}
}
说完了List，接下来我们来看一下map，map是key-value的一种数据结构，他的方法类是HashMap，源码感觉差不太多，都是一些接口定义了一些方法，我们直接看使用，map的实现方法是它使用一个比较大的数组，来存储所有的value，然后计算key的值（hascode），然后根据这个作为索引，将value存储在指定位置，因此如果想用使用自己的类来dingyikey，必须实现equalshenhascode这两个方法，因为这个不常用，就不再展示，但我们既然知道这个原理，就能想象的到map是无序的。接下来看一下map的常用操作
import java.util.*;
public class HelloWorld {
public static void main(String[] args) throws Exception {
Map<String, Integer> s = new HashMap<>();
s.put("a", 1); // 添加
s.put("b", 2);
s.put("c", 3);
System.out.println(s.put("d", 4)); // null
System.out.println(s.put("d", 4)); // 4 如果重复，就会把原来的值替换，并抛出原来的值
System.out.println(s.get("a")); // 1 获取
System.out.println(s.containsKey("f")); // false
System.out.println(s.getOrDefault("f", 1)); // 1 如果获取失败，就会给出默认值
System.out.println(s.remove("f")); // null 删除
System.out.println(s.remove("a")); // 1 如果有删除，就会返回值
// 循环所有的key
for (String key : s.keySet()) {
System.out.println(key);
System.out.println(s.get(key));
}
// 循环所有的key-value
for (Map.Entry<String, Integer> ss : s.entrySet()) {
System.out.println(ss);
System.out.println(ss.getKey() + ss.getValue());
}
}
}
另外还有一种实现map的方法是枚举map，如果对于一些比较少的，可以直接使用这个类型，它并非使用key的code进行安排缩阴的，而是直接使用key，因此效率会更高
import java.time.DayOfWeek;
import java.util.*;
public class HelloWorld {
public static void main(String[] args) throws Exception {
Map<DayOfWeek, String> map = new EnumMap<>(DayOfWeek.class);
map.put(DayOfWeek.MONDAY, "星期一");
map.put(DayOfWeek.WEDNESDAY, "星期二");
map.put(DayOfWeek.FRIDAY, "星期五");
System.out.println(map.get(DayOfWeek.FRIDAY)); // 星期五
System.out.println(map); // {MONDAY=星期一, WEDNESDAY=星期二, FRIDAY=星期五}
}
}
既然上面提到的map是无序的，就如同python中dict是无序的，但还是有有序字典OrderDict，因此java也肯定有有序map，他实现的接口是SortMap， 实现类是TreeMap，但是如果要使用自己的定义的类作为key，请记得要实现compare方法
import java.util.Comparator;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
public class HelloWorld {
public static void main(String[] args) throws Exception {
SortedMap<String, Integer> s = new TreeMap<>(); // 初始化一个有序map
s.put("a", 1); // 添加
s.put("b", 2);
s.put("c", 3);
System.out.println(s); // {a=1, b=2, c=3}
// 循环打印
for (Map.Entry<String, Integer> ss : s.entrySet()) {
System.out.println(ss);
} // a=1 b=2 c=3
// 初始化一个带我们自定义排序方法的有序map，查看结构跟上面相反
SortedMap<String, Integer> s1 = new TreeMap<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return -o1.compareTo(o2);
}
});
s1.put("a", 1);
s1.put("b", 2);
s1.put("c", 3);
System.out.println(s1); // {c=3, b=2, a=1}
for (Map.Entry<String, Integer> ss : s1.entrySet()) {
System.out.println(ss);
} // c=3 b=2 a=1
}
}
然后我们再来看一下set，集合，他最出名的不就是去重，他有两个实现类，一个是HashSet无序，另外一个是TreeSet有序，而有序集合里面的元素如果没有实现compaer接口，需要初始化时传入一个自定义的比较，跟有序集合类似，就不再赘述
import java.util.*;
public class HelloWorld {
public static void main(String[] args) throws Exception {
// 无序集合
Set<String> s = new HashSet<>();
s.add("c");
s.add("b"); // 添加
s.add("a");
System.out.println(s); // [a, b, c]
System.out.println(s.contains("a")); // true 包含
System.out.println(s.remove("d")); // false 删除，没有删除，返回false
System.out.println(s.remove("a")); // true
System.out.println(s); // [b, c]
for (String ss : s) {
System.out.println(ss);
} // b c
// 有序集合
Set<String> s1 = new TreeSet<>();
s.add("a");
s.add("b");
s.add("c");
System.out.println(s); // [a, b, c]
for (String ss : s) {
System.out.println(ss);
} // a b c
}
}
接下来看一下队列，队列分为几种，一个是FIFO--Queue，另外一个是有优先级的 PriorityQueue，而这个是必须实现compaer接口，否则没办法选择优先级， 还有双端队列 -- Deque
我们来看一下实例
import java.util.*;
public class HelloWorld {
public static void main(String[] args) throws Exception {
// FIFO队尾进，队首出
Queue<String> q1 = new LinkedList<>(); // 这个 LinkedList 也实现了List接口，根据需要选择，这个就是链表，但是作为List来用，没有特许需求的话，有点吗，他是按照链表来存储的
// 两端均可进可出
Deque<String> q2 = new LinkedList<>();
// 根据默认的或自定义对比方法，出队列,String有compaer方法，我只是自定义了一个反序的
Queue<String> q3 = new PriorityQueue<>(new Comparator<String>() {
public int compare(String a, String b) {
return -a.compareTo(b);
}
});
// add 添加方法，如果添加失败就报错,比如队列满了
// FIFO添加对象方法
q1.add("a");
q1.add("b");
q1.add("c");
System.out.println(q1); // [a, b, c]
for (String qq : q1) {
System.out.println(qq);
} // a b c
// 双端队列添加方法
q2.addFirst("a");
q2.addFirst("b");
q2.addLast("d");
q2.addLast("c");
System.out.println(q2); // [b, a, d, c]
for (String qq : q2) {
System.out.println(qq);
} // b a d c
// 优先级队列添加方法
q3.add("a");
q3.add("b");
q3.add("c");
System.out.println(q3); // [c, a, b]
for (String qq : q3) {
System.out.println(qq);
} // c a b
// offer 添加方法，会返回boolean值，告知是否添加成功，不会报错
q1.offer("a");
q1.offer("b");
System.out.println(q1.offer("c")); // true
System.out.println(q1); // [a, b, c, a, b, c]
for (String qq : q1) {
System.out.println(qq);
} // a b c
// 双端队列添加方法
q2.offerFirst("a");
q2.offerFirst("b");
q2.offerLast("d");
q2.offerLast("c");
System.out.println(q2); // [b, a, b, a, d, c, d, c]
for (String qq : q2) {
System.out.println(qq);
} // b a b a d c d c
// 优先级队列添加方法
q3.offer("a");
q3.offer("b");
q3.offer("c");
System.out.println(q3); // [c, b, c, a, a, b]
for (String qq : q3) {
System.out.println(qq);
} // c b c a a b
// 获取首元素并删除
// 删除失败会报错
Queue<Integer> i = new LinkedList<>();
// i.remove(); // java.util.NoSuchElementException
q1.remove();
System.out.println(q1); // [b, c, a, b, c]
q2.removeFirst();
System.out.println(q2); // [a, b, a, d, c, d, c]
q2.removeLast();
System.out.println(q2); // [a, b, a, d, c, d]
q3.remove();
System.out.println(q3); // [c, b, b, a, a]
// 删除失败不会报错，会返回false 或者 null
System.out.println(i.poll());
System.out.println(q1.poll()); // b
System.out.println(q1); // [c, a, b, c]
q2.pollFirst();
System.out.println(q2); // [b, a, d, c, d]
q2.pollLast();
System.out.println(q2); // [b, a, d, c]
q3.poll();
System.out.println(q3); // [b, a, b, a]
// 取首元素但是不会删除
// 删除失败会报错
System.out.println("----");
// i.element(); // java.util.NoSuchElementException
System.out.println(q1.element()); // c
System.out.println(q1); // [c, a, b, c]
q1.element();
System.out.println(q1); // [c, a, b, c]
q2.getFirst();
System.out.println(q2); // [b, a, d, c]
System.out.println(q2.getFirst()); // b
System.out.println(q2); // [b, a, d, c]
System.out.println(q2.getLast()); // c
System.out.println(q2); // [b, a, d, c]
q2.getLast();
System.out.println(q2); // [b, a, d, c]
q3.element();
System.out.println(q3); // [b, a, b, a]
q3.element();
System.out.println(q3); // [b, a, b, a]
// 删除失败不会报错，会返回false 或者 null
System.out.println(i.peek()); // null
System.out.println(q1.peek()); // c
System.out.println(q1); // [c, a, b, c]
System.out.println(q1.peek()); // c
System.out.println(q1); // [c, a, b, c]
System.out.println(q2.peekFirst()); // b
System.out.println(q2); // [b, a, d, c]
q2.peekFirst();
System.out.println(q2); // [b, a, d, c]
System.out.println(q2.peekLast()); // c
System.out.println(q2); // [b, a, d, c]
q2.peekLast();
System.out.println(q2); // [b, a, d, c]
q3.peek();
System.out.println(q3); // [b, a, b, a]
q3.peek();
System.out.println(q3); // [b, a, b, a]
// 双端队列还有 pop 的 取出队首且删除的犯法，但取不到就会报错
System.out.println(q2.pop()); // b
System.out.println(q2.pop()); // a
System.out.println(q2.pop()); // d
System.out.println(q2.pop()); // c
//System.out.println(q2.pop()); // java.util.NoSuchElementException
// 还有push增加方法
q2.push("a");
q2.push("b");
System.out.println(q2);
// 因此我们可以使用Deque来模拟栈
Deque<String> q4 = new LinkedList<>();
// 模拟压栈
q4.push("a");
q4.push("b");
// 模拟出栈
System.out.println(q4); // [b, a]
System.out.println(q4.pop()); // b 删除队首，并跑操
System.out.println(q4); // [a]
System.out.println(q4.peek()); // a 只取队首的值，不删除
System.out.println(q4); // [a]
}
}
我们确实是可以使用Deque来模拟栈的
原文地址：https://www.cnblogs.com/yangshixiong/p/12172253.html
时间： 2024-11-06 09:59:43