Java 入门学习记录（八）
集合的概念
集合就是对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能
与数组的区别：
- 数组长度固定，集合长度不固定
- 数组可以存储基本类型与引用类型，集合只能存储引用类型
Collection：该体系结构的根接口，代表一组对象，称为 “集合”
List：有序，有下标，元素可重复
Set：无序，无下标，元素不能重复
Collection 接口
特点：代表一组任意类型的对象，无序，无下标，元素不重复
方法：
booleanadd(Object obj)// 添加一个对象booleanaddAll(Collection c)// 将一个集合中的所有对象添加到此集合中voidclear()// 清空此集合中的所有对象booleancontains(Object o)// 检查此集合中是否包含 o 对象booleanequals(Object o)// 比较此集合是否与指定对象相等booleanisEmpty()// 判断此集合是否为空booleanremove(Object o)// 在此集合中移除 o 对象intsize()// 返回此集合中的元素个数Object[]toArray()// 将此集合转换成数组
使用一
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo {
public static void main(String[] args) {
Collection collection = new ArrayList();
// 添加元素
collection.add("Apple");
collection.add("123");
collection.add("你好");
System.out.println("元素个数: " + collection.size());
System.out.println(collection);
// 删除元素
collection.remove("Apple");
System.out.println(collection);
// *****遍历元素*****
// 1. 使用 enhanced for
for (Object object : collection) {
System.out.println(object);
}
// 2. 使用迭代器（专门用来遍历集合的方式）
Iterator iterator = collection.iterator();
while (iterator.hasNext()) {
String s = (String)iterator.next();
System.out.println(s);
iterator.remove(); // 迭代器迭代中无法使用 collection 的方法，会产生并发修改异常，若想删除当前元素，使用迭代器中的元素
}
System.out.println(collection);
// 判断包含
collection.add("Apple");
System.out.println(collection.contains("fruits"));
System.out.println(collection.contains("Apple"));
}
}
下面是输出
使用二
保存对象的信息
先创建一个 Student 类，内部含有
private int age;
private String name;
然后创建构造器，getter 和 setter，重写 toString()
import java.util.ArrayList;
import java.util.Collection;
/*
* Collection 保存对象信息
*/
public class Demo1 {
public static void main(String[] args) {
// 创建对象
Collection collection = new ArrayList();
Student s1 = new Student(12, "ShenyanWu");
Student s2 = new Student(14, "SYW");
Student s3 = new Student(15, "SYWu");
// 添加数据
collection.add(s1);
collection.add(s2);
collection.add(s3);
System.out.println(collection);
// 删除
collection.remove(s1);
System.out.println(collection);
}
}
下面是输出
List 接口与实现类
特点：有序、有下标、元素可以重复
方法：
void add(int index, E element)将指定的元素插入此列表中的指定位置。
boolean addAll(int index, Collection c)将指定集合中的所有元素插入到此列表中的指定位置。
Object get(int index)返回此列表中指定位置的元素。
List subList(int fromIndex, int toIndex)返回此列表中指定的 fromIndex （含）和 toIndex 之间的视图。
使用一
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class Demo2 {
public static void main(String[] args) {
List list = new ArrayList();
// 添加元素
list.add("Apple");
list.add("banana");
list.add("123");
System.out.println("元素个数： " + list.size());
System.out.println(list);
// 删除元素
list.remove("Apple");
System.out.println(list);
// 遍历 1
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
} // 返回 Object 类型
// 遍历 2
for (Object object : list) {
System.out.println(object);
}
// 遍历 3
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
// 遍历 4
ListIterator iterator1 = list.listIterator();
while (iterator1.hasNext()) {
System.out.println(iterator1.nextIndex() + ":" + iterator1.next());
}
// 从后往前
while (iterator1.hasPrevious()) {
System.out.println(iterator1.previousIndex() + ":" + iterator1.previous());
}
// 判断
System.out.println(list.contains("321"));
System.out.println(list.isEmpty());
// 获取位置
System.out.println(list.indexOf("banana"));
}
}
下面是输出
使用二
import java.util.ArrayList;
import java.util.List;
public class Demo3 {
public static void main(String[] args) {
List list = new ArrayList();
// 添加了基本类型，相当于自动装箱后添加进 list
list.add(10);
list.add(20);
list.add(30);
list.add(40);
list.add(50);
System.out.println(list);
// 删除操作
list.remove(0); // 这里面的参数是 Index
list.remove((Object) 20);
list.remove(new Integer (20)); // 整数缓存
// 可以用 new 删除是因为如下代码，使用的整数已经被缓存，优先查找，引用的地址相同
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1.equals(integer2)); // true
// subList，返回子集合
System.out.println("-------subList------------");
list.add(10);
list.add(20);
System.out.println(list);
System.out.println(list.subList(1, 3)); // 含头不含尾
}
}
下面是输出结果
List 实现类
ArrayList
- 数组结构实现，查询快、增删慢；
- 运行效率快，线程不安全
ArrayList 的使用
先创建一个 Student 类，设置有构造器，参数为 age name ，创建 getter 和 setter，重写 toSting() 方便打印查看结果，然后对这个类的对象使用 ArrayList 存储使用，如下
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
/**
* ArrayList 的使用
* 存储结构：数组，查找遍历速度快，增删慢
*/
public class Demo4 {
public static void main(String[] args) {
// 创建集合
ArrayList<Object> arrayList = new ArrayList<>();
// 添加元素
Student s1 = new Student(20, "SYW");
Student s2 = new Student(18, "飞宝");
Student s3 = new Student(17, "舍长");
arrayList.add(s1);
arrayList.add(s2);
arrayList.add(s3);
System.out.println(arrayList);
// 删除元素
System.out.println("******使用 new 是否可以删除？******");
arrayList.remove(new Student(18, "飞宝"));
System.out.println(arrayList);
System.out.println("******正常 remove 删除******");
arrayList.remove(s2);
System.out.println(arrayList);
// 遍历元素 【重点】
System.out.println("------ 使用 iterator 遍历 ------");
Iterator<Object> iterator = arrayList.iterator();
while (iterator.hasNext()) {
Student s = (Student) iterator.next();
System.out.println(s);
}
System.out.println("------ 使用 listIterator 遍历 ------");
ListIterator<Object> objectListIterator = arrayList.listIterator();
while (objectListIterator.hasNext()) {
Student s = (Student) objectListIterator.next();
System.out.println(s);
}
System.out.println("------ 使用 listIterator 逆向遍历 ------");
while (objectListIterator.hasPrevious()) {
Student s = (Student) objectListIterator.previous();
System.out.println(s);
}
// 判断
System.out.println(arrayList.contains(s1));
System.out.println(arrayList.contains(new Student(20, "SYW")));
// 查找
System.out.println(arrayList.indexOf(s3));
}
}
运行结果
可以发现在其方法中使用 new 创建的对象无法进行 remove 或者 遍历，这是因为 Student 中的 equals() 方法比较的是其地址，这两个对象地址并不相同，要想使其能够使用 new 进行对象操作，可以重写方法 equals()
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (obj instanceof Student) {
Student student = (Student) obj;
if (this.name.equals(student.getName()) && this.age == student.getAge()) {
return true;
}
}
return false;
}
重写后的运行结果
源码分析小贴士：默认容量 10，初始大小 0，每次扩容上一次的 1.5 倍
Vector
- 数组结构实现，查询快、增删慢；
- 运行效率慢，线程安全
Vector 的使用
import java.util.Enumeration;
import java.util.Vector;
public class Demo5 {
public static void main(String[] args) {
// 创建集合
Vector<Object> objects = new Vector<>();
// 1. 添加元素
objects.add("苹果");
objects.add("西瓜");
objects.add("草莓");
System.out.println(objects);
// 2. 删除
// objects.remove("苹果");\
// objects.remove(0);
// objects.clear();
// 3. 遍历
// 使用枚举器遍历
Enumeration<Object> elements = objects.elements();
while (elements.hasMoreElements()) {
Object o = elements.nextElement();
System.out.println(o);
}
// 之前的遍历方法也可以
// 4. 判断包含 contains
System.out.println(objects.contains("西瓜"));
// 5. 其他方法
objects.firstElement();
}
}
LinkedList
- 链表结构实现，增删快，查询慢
LinkedList 的使用
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
public class Demo6 {
public static void main(String[] args) {
LinkedList<Object> linkedList = new LinkedList<>();
// 1. 添加元素
Student s1 = new Student(20, "SYW");
Student s2 = new Student(18, "飞宝");
Student s3 = new Student(17, "舍长");
linkedList.add(s1);
linkedList.add(s2);
linkedList.add(s3);
System.out.println(linkedList);
// 2. 删除
// linkedList.remove(s1);
// linkedList.clear();
// 3. 遍历
// for 遍历
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}
// 增强 for 遍历
for (Object o : linkedList) {
System.out.println(o);
}
// Iterator
Iterator<Object> iterator = linkedList.iterator();
while (iterator.hasNext()) {
Student s = (Student) iterator.next();
System.out.println(s);
}
// listIterator 迭代器 逆序 Previous
ListIterator<Object> objectListIterator = linkedList.listIterator();
while (objectListIterator.hasNext()) {
Student s = (Student) objectListIterator.next();
System.out.println(s);
}
// 4. 判断 contains
// 5. 获取 indexOf
}
}
ArrayList 和 LinkedList 的区别
ArrayList
开辟连续空间，查询快，增删慢
LinkedList
不需要开辟连续空间，查询慢，增删快
泛型和工具类
本质是参数化类型，把类型作为参数传递
常见的形式有：泛型类、泛型接口、泛型方法
语法：<T，···> T 称为类型占位符，表示一种引用类型
好处
- 提高代码的重用性
- 防止类型转换异常，提高代码安全性
泛型类
先创建一个泛型类
public class Generic<T> {
// 创建变量
T t;
// 泛型作为方法的参数
public void show(T t) {
System.out.println(t);
}
// 泛型作为方法的返回值
public T getT() {
return t;
}
}
使用
public class test {
public static void main(String[] args) {
// 使用泛型类型创建对象
Generic<String> generic = new Generic<>();
generic.t = "hello world";
System.out.println(generic.getT());
generic.show("HELLO");
// 创建
Generic<Integer> generic1 = new Generic<>();
generic1.t = 100;
System.out.println(generic1.getT());
}
}
泛型接口
创建一个泛型接口
public interface myInterface<T> {
String name = "hello";
T server(T t);
}
使用一：通过提前声明引用类型
public class implement implements myInterface<String> {
@Override
public String server(String s) {
System.out.println(s);
return null;
}
public static void main(String[] args) {
implement implement = new implement();
implement.server("hello");
}
}
使用二：通过实例化时传递，，与泛型类使用相同
public class implement<T> implements myInterface<T> {
@Override
public T server(T s) {
System.out.println(s);
return null;
}
public static void main(String[] args) {
implement<String> implement = new implement();
implement.server("hello");
}
}
泛型方法
public class Method {
public <T> void show() {
System.out.println("泛型方法");
}
public <T> T show1(T t) {
System.out.println("泛型方法" + t);
return t;
}
}
调用时取泛型决于参数类型
Method method = new Method();
method.show1("hello world");
method.show1(200);
method.show1(2.33);
泛型集合
参数化类型、类型安全的集合，强制集合元素的类型必须一致
特点
- 编译时即可检查，而非运行时抛出异常
- 访问时，不必类型转换（拆箱）
- 不同泛型之间引用不能相互赋值，泛型不存在多态
public class Demo7 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
// arrayList.add(100);
// arrayList.add(200);
Iterator<String> iterator = arrayList.iterator();
}
}
方便类型限制
Set 接口与实现类
特点：无序、无下标、元素不可重复
方法：继承于 Collection
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Demo8 {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("苹果");
set.add("华为");
set.add("小米");
System.out.println(set);
// 删除
// set.remove("小米");
// 遍历
for (String s: set) {
System.out.println(s);
}
System.out.println("------迭代器遍历------");
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
// 判断 contains
}
}
有 2 个重要实现类：HashSet、 TreeSet
HashSet
基于 HashCode 计算元素存放位置
当存入元素的哈希码相同时，会调用 equals() 进行确认，如果结果为 true，则拒绝后者存入
使用一
import java.util.HashSet;
/**
* HashSet的使用
* 存储结构：（数组+链表 红黑树）
*/
public class Demo9 {
public static void main(String[] args) {
HashSet<String> hashSet = new HashSet<>();
// 添加元素
hashSet.add("苹果");
hashSet.add("小米");
hashSet.add("华为");
hashSet.add("OnePlus");
System.out.println(hashSet);
// 删除元素 remove()
// foreach 遍历
// Iterator<String> 遍历
// 判断 contains()
}
}
使用二
public class Demo9 {
public static void main(String[] args) {
HashSet<Person> people = new HashSet<>();
Person p1 = new Person("David", 12);
Person p2 = new Person("Mike", 13);
Person p3 = new Person("Susan", 14);
people.add(p1);
people.add(p2);
people.add(p3);
System.out.println(people);
people.add(new Person("Mike",13));
}
}
new Person("Mike",13) 要使得这句话不会继续添加进去集合，需要重写 equals() hashCode()两个方法，来比较两个对象中的内容是否相同
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
TreeSet
基于排序顺序实现元素不重复
实现类 SortedSet 接口，对集合元素自动排序
元素对象类型必须实现 Comparable 接口，指定排序规则
通过 CompareTo 方法确定是否为重复元素
import java.util.TreeSet;
public class Demo10 {
public static void main(String[] args) {
TreeSet<String> treeSet = new TreeSet<>();
// 添加元素
treeSet.add("aaa");
treeSet.add("bbb");
treeSet.add("ccc");
System.out.println(treeSet);
// 删除元素 remove()
// 遍历 foreach Iterator
// 包含 contains
}
}
保存数据，要求保存的对象元素需要能实现 Comparable 接口才行
import java.util.TreeSet;
public class Demo10 {
public static void main(String[] args) {
TreeSet<Person> treeSet = new TreeSet<>();
Person s1 = new Person(12, "张三");
Person s2 = new Person(14, "SYW");
Person s3 = new Person(15, "李四");
// 添加元素
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
System.out.println(treeSet);
}
}
Person implements Comparable // 先比较字符串后比较整数大小
@Override
public int compareTo(Person o) {
int n1 = this.getName().compareTo(o.getName());
int n2 = this.getAge() - o.getAge();
return n1 == 0? n2: n1;
}
其余增删遍历等操作相同
Comparator 接口
实现定制比较（比较器），使用匿名内部类
TreeSet<Person> treeSet = new TreeSet<>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
int n1 = o1.getAge() - o2.getAge();
int n2 = o1.getName().compareTo(o2.getName());
return n1 == 0? n2: n1;
}
});
Map 接口与实现类
方法：
V put(K key, V value) // 将对象存入到集合中，关联键值。 key 重复则覆盖原值
Object get(Object key) // 根据键获取对应的值
Set // 返回所有的 key
Collection values() // 返回包含所有值的 Collection 集合
Set<Map.Entry<K, V>> // 键值匹配的 Set 集合
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class map {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("ZH-CN", "中国");
map.put("UK", "英国");
map.put("USA", "美国");
System.out.println(map);
// 删除 remove()
// 遍历 keySet()
Set<String> keySet = map.keySet();
for (String s: keySet) {
System.out.println(s + " = " + map.get(s));
}
// 遍历 entrySet()
Set<Map.Entry<String, String>> entrySet = map.entrySet(); // 元素为一个映射
for (Map.Entry<String, String> entry : entrySet) {
System.out.println(entry.getKey() + " " + entry.getValue());
}
// 判断 containsKey() containsValue()
}
}
Output：
HashMap
线程不安全，运行效率快，允许用 null 作为 key 或 value
默认容量 16，默认加载因子 0.75
import java.util.HashMap;
public class Demo11 {
public static void main(String[] args) {
HashMap<Student, String> hashMap = new HashMap<>();
Student s1 = new Student(20, "SYW");
Student s2 = new Student(18, "飞宝");
Student s3 = new Student(17, "舍长");
hashMap.put(s1, "100");
hashMap.put(s2, "101");
hashMap.put(s3, "102");
hashMap.put(new Student(18, "飞宝"), "101");
System.out.println("元素个数 " + hashMap.size());
System.out.println(hashMap);
// 遍历 foreach keySet() entrySet()
}
}
和之前相同，
new的对象不添加进去需要重写hashCode()和equals()
源码分析
贴一部分源码展示
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
private static final long serialVersionUID = 362498820763181265L;
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* The maximum capacity, used if a higher value is implicitly specified
* by either of the constructors with arguments.
* MUST be a power of two <= 1<<30.
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* The load factor used when none specified in constructor.
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* The bin count threshold for using a tree rather than list for a
* bin. Bins are converted to trees when adding an element to a
* bin with at least this many nodes. The value must be greater
* than 2 and should be at least 8 to mesh with assumptions in
* tree removal about conversion back to plain bins upon
* shrinkage.
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* The bin count threshold for untreeifying a (split) bin during a
* resize operation. Should be less than TREEIFY_THRESHOLD, and at
* most 6 to mesh with shrinkage detection under removal.
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* The smallest table capacity for which bins may be treeified.
* (Otherwise the table is resized if too many nodes in a bin.)
* Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
* between resizing and treeification thresholds.
*/
static final int MIN_TREEIFY_CAPACITY = 64;
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
表示初始的容量，节点数，数组初始容量，加载因子等等
再贴一个 put() 方法源码
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
关于扩容在最后几行的 if (++size > threshold) resize(); ，resize() 中扩容为原来 2 倍，左移 1 位
小总结：
- HashMap 刚创建时，table 为 null，为了节省空间，当添加第一个元素时，table 容量调整为 16
- 当元素个数大于阈值 ( 16* 0.75= 12) 时，会进行扩容，扩容后的大小为原来的 2 倍。目的是为了减少调整元素的个数
- JDK 1.8 当每个链表长度大于 8，并且元素个数大于等于 64 时，会调整为红黑树，目的提高执行效率
- JDK 1.8 当链表长度小于 6 时，调整成链表
- JDK 1.8 以前，链表时头插入，JDK 1.8 以后时尾插入
Hashtable
JDK 1.0 版本，线程安全，运行效率慢；不允许 null 作为 key 或者 value
Properties
Hashtable 的子类，要求 key 和 value 都是 String。通常用于配置文件的读取
TreeMap
实现了 SortedMap 接口（Map 的子接口），可以对 key 进行自动排序
Collections 工具类
集合工具类，定义了除了存取以外的集合常用方法
方法：
public static void reverse(List<?> list) // 反转集合中元素的顺序
public static void shuffle(List<?> list) // 随机重置集合元素的顺序（随机打乱顺序）
public static void sort(List list) // 升序排序（元素类型必须实现 Comparable 接口）
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class Demo12 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(20);
list.add(5);
list.add(12);
list.add(30);
list.add(6);
// sort 排序
System.out.println("排序之前 " + list);
Collections.sort(list);
System.out.println("排序之后 " + list);
// binarySearch 二分查找
int a = Collections.binarySearch(list, 20);
System.out.println(a); // 存在返回下标
int b = Collections.binarySearch(list, 2);
System.out.println(b); // 没有返回 -1
// copy 复制
List<Integer> dest = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
dest.add(null);
} // copy 的 dest 需要大小和源列表大小相同
Collections.copy(dest, list);
System.out.println(dest);
// reverse 反转
System.out.println("反转之前 " + list);
Collections.reverse(list);
System.out.println("反转之后 " + list);
// shuffle 打乱
System.out.println("打乱之前 " + list);
Collections.shuffle(list);
System.out.println("打乱之后 " + list);
// list 转成数组
Integer[] retArr = list.toArray(new Integer[0]);
System.out.println("转换的数组 " + retArr);
// 数组转成集合
String[] testArr = {"华为", "苹果", "小米"};
List<String> list1 = Arrays.asList(testArr);
// 集合是一个受限集合，不能添加和删除，因为数组长度固定
// 基本类型数组转集合时，需要变成包装类
Integer[] arr = {1, 2, 3, 4, 5};
List<Integer> list2 = Arrays.asList(arr);
System.out.println("基本类型包装类多个对象 " + list2);
int[] arr1 = {1, 2, 3, 4, 5};
List<int[]> list3 = Arrays.asList(arr1);
System.out.println("被认为数组对象，仅一个元素 " + list3);
}
}
输出：
扫一扫
236
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
