Lxxilyd's blog

外观

JCF中的常用接口

1997字约7分钟

java

2024-10-24

JCF

1.两个类

Collections

Arrays

2.增强for循环（foreach）

只能使用在数组或者是实现了Iterable接口的对象

底层会使用Iterable接口，得到Iterator对象，实际上会调用next（）进行循环

只能使用在数组或实现了Iterable接口的对象（大多为集合）

3. 8个接口

List

Comparable

Comparator

Queue

方法：

add()、offer()、remove()、poll()、element()、peek()

Set

Iterable

Iterator

Map

类

ArrayList、Vector、PriorityQueue、LinkedList、HashSet、TreeSet、Stack、HasshMap

Vector类

实现了List接口底层是数组实现，可随机访问，线程安全

Set接口的实现类

Set集合元素不可重复，若添加重复，其内容不会改变

hashSet

底层实现为散列表

常用方法

add(V value) 添加元素

remove(V value) 删除指定元素

size()获取长度

hashCode
1.定义

hashcode是对象的一个int类型的哈希值（散列值）是由对象的hashCode()方法产生，

用来在hash实现的存储结构中确定对象的存储位置（Bucket）

hash算法应该高效，相对平均的利用存储位置

2.hash算法的三个原则

1.一致性。同一对象多次调用得到的hashcode值应该相同

2.obj1.equals(obj2)为true是两对象的hashcode值必须相同

3.obj1.equals(obj2)为false是两对象的hashcode值可相同也可不相同（相当于生活中的姓）

3.equals重写的原则

1.自反性 ：对于任何非空的参考值x ， x.equals(x)应该返回true 。

它是对称的 ：对于任何非空引用值x和y ， x.equals(y)应该返回true当且仅当y.equals(x)回报true 。

2.传递性 ：对于任何非空引用值x ， y和z ，如果x.equals(y)回报true个y.equals(z)回报true ，然后x.equals(z)应该返回true 。

3.一致性 ：对于任何非空引用值x和y ，多次调用x.equals(y)始终返回true或始终返回false ，没有设置中使用的信息equals比较上的对象被修改。

对于任何非空的参考值x ， x.equals(null)应该返回false 。

TreeSet

底层实现TreeMap（红黑树）

常用方法

与hashSet类似

红黑树
1.树

一种数据结构，0-1个前驱节点，0-n个后继节点

节点：所有子节点个数称为节点数

树的度：最大子节点的度（子节点的个数）

查找二叉树

树上的节点有序

左子树所有节点都小于根节点

所有右子树的节点都大于根节点

红黑树

红黑树是一种平衡二叉查找树的变体，它的左右子树高差有可能大于 1，所以红黑树不是严格意义上的平衡二叉树（AVL），但 对之进行平衡的代价较低， 其平均统计性能要强于 AVL 。

由于每一棵红黑树都是一颗二叉排序树，因此，在对红黑树进行查找时，可以采用运用于普通二叉排序树上的查找算法，在查找过程中不需要颜色信息。

特征

性质1. 结点是红色或黑色。

性质2. 根结点是黑色。

性质3. 所有叶子都是黑色。（叶子是NIL结点）

性质4. 每个红色结点的两个子结点都是黑色。（从每个叶子到根的所有路径上不能有两个连续的红色结点）

性质5. 从任一节结点其每个叶子的所有路径都包含相同数目的黑色结点。

从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。结果是这个树大致上是平衡的。因为操作比如插入、删除和查找某个值的最坏情况时间都要求与树的高度成比例，这个在高度上的理论上限允许红黑树在最坏情况下都是高效的，而不同于普通的二叉查找树。

image-20210929112149209

​

迭代器（Iterator）

常用方法

1.hasNext();判断是否有下一个元素

2.next();获取下一个元素

3.remove(); 从底层集合中删除此迭代器返回的最后一个元素。

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

import java.util.Iterator;

public class SetTest {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Set set = new HashSet();
		// HsahSet
		// add(V value) 添加元素
		set.add(1);
		set.add('a');
		set.add(3);
		set.add('b');
		System.out.println(set);
		// remove(V value) 删除指定元素
		set.remove(1);
		set.remove('b');
		System.out.println(set);
		// size()获取长度
		System.out.println(set.size());
		// TreeSet
		Set set2 = new TreeSet();
		// add(V value) 添加元素
		set2.add(1);
		set2.add(2);
		set2.add(3);
		set2.add(4);
		System.out.println(set2);
		// remove(V value) 删除指定元素
		set2.remove(1);
		set2.remove(3);
		System.out.println(set2);
		// size()获取长度
		System.out.println(set2.size());
		// Set集合元素不可重复
		set2.add(2);
		System.out.println(set2);
		// 不可重复是因为会事先比较hashCode
		// 重写hashCod方法
		TreeSet<Student1> set3 = new TreeSet();
		set3.add(new Student1("test", 1001));
		set3.add(new Student1("test", 1002));
		set3.add(new Student1("test", 1003));
		set3.add(new Student1("test1", 1001));
		System.out.println(set3);
		// Iterator迭代器
		Iterator<Student1> iterator = set3.iterator();
		// hasNext()方法判断是否有下一个元素,next();获取下一个元素
		// 元素的迭代输出
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		// remove()从底层集合中删除此迭代器返回的最后一个元素。
		iterator.remove();
		System.out.println(set3);
	}
	
}
class Student1 implements Comparable{
	private String name;
	private int code;
	
	
	public Student1(String name, int code) {
		super();
		this.name = name;
		this.code = code;
	}


	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}


	public int getCode() {
		return code;
	}


	public void setCode(int code) {
		this.code = code;
	}


	@Override
	public String toString() {
		return "Student [name=" + name + ", code=" + code + "]";
	}
	
	@Override
	public int hashCode() {
		// TODO Auto-generated method stub
		return super.hashCode();
//		return this.code;
	}

	@Override
	public int compareTo(Object o) {
		// TODO Auto-generated method stub
		return this.hashCode() - o.hashCode();
	}
}
/*
结果为：
[1, a, b, 3]
[a, 3]
2
[1, 2, 3, 4]
[2, 4]
2
[2, 4]
[Student [name=test, code=1001], Student [name=test1, code=1001], Student [name=test, code=1002], Student [name=test, code=1003]]
Student [name=test, code=1001]
Student [name=test1, code=1001]
Student [name=test, code=1002]
Student [name=test, code=1003]
[Student [name=test, code=1001], Student [name=test1, code=1001], Student [name=test, code=1002]]
*/

Map接口实现的类

HashMap

常用方法

1.put(K,V) 为Map集合添加对应键值的元素

再次put相同键值时会覆盖之前的

2.get(key) 获取对应键值的元素

3.remove(Object key) 如果存在（从可选的操作），从该Map中删除一个键的映射

4.replace(K key, V value) 只有当目标映射到某个值时，才能替换指定键的条目

5.size() 返回此地图中键值映射的数量。

6.keySet() 返回此Map中的键的Set集合

7.remove(Object key, Object value) 当值与键都符合条件时删除

import java.util.HashMap;
import java.util.Map;

public class MapTest {
	public static void main(String[] args) {
		Map students = new HashMap<String, Student>();
		Student s3 = new Student("3", 3);
		// put(K,V) 为Map集合添加对应键值的元素
		students.put("1", new Student("zhangs", 1001));
		students.put("2", new Student("lis", 1002));
		students.put("3", new Student("wangmz", 1003));
		students.put("4", new Student("hhh", 1004));
		
		System.out.println(students);
		// 再次put时会覆盖之前的
		students.put("3", s3);
		System.out.println(students);
		// get(key) 获取对应键值的元素
		System.out.println(students.get("2"));
		// remove(Object key) 如果存在（从可选的操作），从该Map中删除一个键的映射
		System.out.println(students.remove("4"));
		System.out.println(students);
		// replace(K key, V value) 只有当目标映射到某个值时，才能替换指定键的条目
		students.replace("2", new Student("test", 1000));
		System.out.println(students.get("2"));
		// size() 返回此地图中键值映射的数量。 
		System.out.println(students.size());
		// keySet() 返回此Map中的键的Set集合
		System.out.println(students.keySet());
		// remove(Object key, Object value) 当值与键都符合条件时删除
		students.remove("3", s3);
		System.out.println(students);
	}
}

class Student{
	private String name;
	private int code;
	
	
	public Student(String name, int code) {
		super();
		this.name = name;
		this.code = code;
	}


	@Override
	public String toString() {
		return "Student [name=" + name + ", code=" + code + "]";
	}
	
}
/*
输出为：
{1=Student [name=zhangs, code=1001], 2=Student [name=lis, code=1002], 3=Student [name=wangmz, code=1003], 4=Student [name=hhh, code=1004]}
{1=Student [name=zhangs, code=1001], 2=Student [name=lis, code=1002], 3=Student [name=3, code=3], 4=Student [name=hhh, code=1004]}
Student [name=lis, code=1002]
Student [name=hhh, code=1004]
{1=Student [name=zhangs, code=1001], 2=Student [name=lis, code=1002], 3=Student [name=3, code=3]}
Student [name=test, code=1000]
3
[1, 2, 3]
{1=Student [name=zhangs, code=1001], 2=Student [name=test, code=1000]}

*/

底层实现为散列表