java二叉树遍历递归

1. 用java语言实现二叉树的层次遍历的非递归算法及查找算法。

先序非递归算法
【思路】
假设：T是要遍历树的根指针，若T != NULL
对于非递归算法，引入栈模拟递归工作栈，初始时栈为空。
问题：如何用栈来保存信息，使得在先序遍历过左子树后，能利用栈顶信息获取T的右子树的根指针？
方法1：访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。
方法2：访问T->data后，将T->rchild入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T->rchild，出栈，遍历以该指针为根的子树。
【算法1】
void PreOrder(BiTree T, Status ( *Visit ) (ElemType e))

{ // 基于方法一
InitStack(S);
while ( T!=NULL || !StackEmpty(S)){
while ( T != NULL ){
Visit(T->data) ;
Push(S,T);
T = T->lchild;
}
if( !StackEmpty(S) ){
Pop(S,T);
T = T->rchild;
}
}
}
【算法2】
void PreOrder(BiTree T, Status ( *Visit ) (ElemType e))

{ // 基于方法二
InitStack(S);
while ( T!=NULL || !StackEmpty(S) ){
while ( T != NULL ){
Visit(T->data);
Push(S, T->rchild);
T = T->lchild;
}
if ( !StackEmpty(S) ){
Pop(S,T);
}
}
}
进一步考虑：对于处理流程中的循环体的直到型、当型+直到型的实现。

中序非递归算法
【思路】
T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。
问题：如何用栈来保存信息，使得在中序遍历过左子树后，能利用栈顶信息获取T指针？
方法：先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。
【算法】
void InOrder(BiTree T, Status ( *Visit ) (ElemType e))
{
InitStack(S);
while ( T!=NULL || !StackEmpty(S) ){
while ( T != NULL ){
Push(S,T);
T = T->lchild;
}
if( !StackEmpty(S) ){
Pop(S, T);
Visit(T->data);
T = T->rchild;
}
}
}
进一步考虑：对于处理流程中的循环体的直到型、当型+直到型的实现。

后序非递归算法
【思路】
T是要遍历树的根指针，后序遍历要求在遍历完左右子树后，再访问根。需要判断根结点的左右子树是否均遍历过。
可采用标记法，结点入栈时，配一个标志tag一同入栈(0：遍历左子树前的现场保护，1：遍历右子树前的现场保护)。
首先将T和tag(为0)入栈，遍历左子树；返回后，修改栈顶tag为1，遍历右子树；最后访问根结点。 [Page]
typedef struct stackElement{
Bitree data;
char tag;
}stackElemType;
【算法】
void PostOrder(BiTree T, Status ( *Visit ) (ElemType e))
{
InitStack(S);
while ( T!=NULL || !StackEmpty(S) ){
while ( T != NULL ){
Push(S,T,0);
T = T->lchild;
}
while ( !StackEmpty(S) && GetTopTag(S)==1){
Pop(S, T);
Visit(T->data);
}
if ( !StackEmpty(S) ){
SetTopTag(S, 1); // 设置栈顶标记
T = GetTopPointer(S); // 取栈顶保存的指针
T = T->rchild;
}else break;
}
}

2. java数据结构二叉树查找结点操作，递归调用求详细讲解

这是先序遍历树的代码，什么是先序遍历呢，一种按照根-左子树-右子树的顺序遍历树就是先序遍历。
CBTType TreeFindNode(CBTType treeNode,String data){
CBTType ptr;
if(treeNode==null){//输入根节点为空时
return null;
}else{
if(treeNode.data.equals(data)){//根节点等于要查找的数据时
return treeNode;
}else{
if((ptr=TreeFindNode(treeNode.left,data))!=null){//从左子树查找，为什么可以用TreeFindNode表示呢？
return ptr;
}else if((ptr=TreeFindNode(treeNode.right,data))!=null){//从右子树查找
return ptr;
}else{
return null;
}
}
}
}
从左子树查找，为什么可以用TreeFindNode表示呢？因为，左子树也可以按照先序遍历的顺序查找的，所以当然可以用TreeFindNode表示，如果你想左子树用中序遍历查找，那么就不可以用TreeFindNode表示。
上述例子的查找过程：
1 --根（2，4，5）--左（3，6，7）--右
2--根（4）--左（5）--右
4--根
5--根
返回

3. 用java怎么构造一个二叉树呢

二叉树的相关操作，包括创建，中序、先序、后序（递归和非递归），其中重点的是java在先序创建二叉树和后序非递归遍历的的实现。
package com.algorithm.tree;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.concurrent.LinkedBlockingQueue;

public class Tree<T> {

private Node<T> root;

public Tree() {
}

public Tree(Node<T> root) {
this.root = root;
}

//创建二叉树
public void buildTree() {

Scanner scn = null;
try {
scn = new Scanner(new File("input.txt"));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
root = createTree(root,scn);
}
//先序遍历创建二叉树
private Node<T> createTree(Node<T> node,Scanner scn) {

String temp = scn.next();

if (temp.trim().equals("#")) {
return null;
} else {
node = new Node<T>((T)temp);
node.setLeft(createTree(node.getLeft(), scn));
node.setRight(createTree(node.getRight(), scn));
return node;
}

}

//中序遍历(递归)
public void inOrderTraverse() {
inOrderTraverse(root);
}

public void inOrderTraverse(Node<T> node) {
if (node != null) {
inOrderTraverse(node.getLeft());
System.out.println(node.getValue());
inOrderTraverse(node.getRight());
}
}

//中序遍历(非递归)
public void nrInOrderTraverse() {

Stack<Node<T>> stack = new Stack<Node<T>>();
Node<T> node = root;
while (node != null || !stack.isEmpty()) {
while (node != null) {
stack.push(node);
node = node.getLeft();
}
node = stack.pop();
System.out.println(node.getValue());
node = node.getRight();

}

}
//先序遍历(递归)
public void preOrderTraverse() {
preOrderTraverse(root);
}

public void preOrderTraverse(Node<T> node) {
if (node != null) {
System.out.println(node.getValue());
preOrderTraverse(node.getLeft());
preOrderTraverse(node.getRight());
}
}

//先序遍历（非递归）
public void nrPreOrderTraverse() {

Stack<Node<T>> stack = new Stack<Node<T>>();
Node<T> node = root;

while (node != null || !stack.isEmpty()) {

while (node != null) {
System.out.println(node.getValue());
stack.push(node);
node = node.getLeft();
}
node = stack.pop();
node = node.getRight();
}

}

//后序遍历(递归)
public void postOrderTraverse() {
postOrderTraverse(root);
}

public void postOrderTraverse(Node<T> node) {
if (node != null) {
postOrderTraverse(node.getLeft());
postOrderTraverse(node.getRight());
System.out.println(node.getValue());
}
}

//后续遍历(非递归)
public void nrPostOrderTraverse() {

Stack<Node<T>> stack = new Stack<Node<T>>();
Node<T> node = root;
Node<T> preNode = null;//表示最近一次访问的节点

while (node != null || !stack.isEmpty()) {

while (node != null) {
stack.push(node);
node = node.getLeft();
}

node = stack.peek();

if (node.getRight() == null || node.getRight() == preNode) {
System.out.println(node.getValue());
node = stack.pop();
preNode = node;
node = null;
} else {
node = node.getRight();
}

}

}

//按层次遍历
public void levelTraverse() {
levelTraverse(root);
}

public void levelTraverse(Node<T> node) {

Queue<Node<T>> queue = new LinkedBlockingQueue<Node<T>>();
queue.add(node);
while (!queue.isEmpty()) {

Node<T> temp = queue.poll();
if (temp != null) {
System.out.println(temp.getValue());
queue.add(temp.getLeft());
queue.add(temp.getRight());
}

}

}

}

//树的节点

class Node<T> {

private Node<T> left;
private Node<T> right;
private T value;

public Node() {
}
public Node(Node<T> left,Node<T> right,T value) {
this.left = left;
this.right = right;
this.value = value;
}

public Node(T value) {
this(null,null,value);
}
public Node<T> getLeft() {
return left;
}
public void setLeft(Node<T> left) {
this.left = left;
}
public Node<T> getRight() {
return right;
}
public void setRight(Node<T> right) {
this.right = right;
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}

}
测试代码：
package com.algorithm.tree;

public class TreeTest {

/**
* @param args
*/
public static void main(String[] args) {
Tree<Integer> tree = new Tree<Integer>();
tree.buildTree();
System.out.println("中序遍历");
tree.inOrderTraverse();
tree.nrInOrderTraverse();
System.out.println("后续遍历");
//tree.nrPostOrderTraverse();
tree.postOrderTraverse();
tree.nrPostOrderTraverse();
System.out.println("先序遍历");
tree.preOrderTraverse();
tree.nrPreOrderTraverse();

//
}

}

4. 用java怎么构造一个二叉树

二叉树的相关操作，包括创建，中序、先序、后序（递归和非递归），其中重点的是java在先序创建二叉树和后序非递归遍历的的实现。
package com.algorithm.tree;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.concurrent.LinkedBlockingQueue;

public class Tree {

private Node root;

public Tree() {
}

public Tree(Node root) {
this.root = root;
}

//创建二叉树
public void buildTree() {

Scanner scn = null;
try {
scn = new Scanner(new File("input.txt"));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
root = createTree(root,scn);
}
//先序遍历创建二叉树
private Node createTree(Node node,Scanner scn) {

String temp = scn.next();

if (temp.trim().equals("#")) {
return null;
} else {
node = new Node((T)temp);
node.setLeft(createTree(node.getLeft(), scn));
node.setRight(createTree(node.getRight(), scn));
return node;
}

}

//中序遍历(递归)
public void inOrderTraverse() {
inOrderTraverse(root);
}

public void inOrderTraverse(Node node) {
if (node != null) {
inOrderTraverse(node.getLeft());
System.out.println(node.getValue());
inOrderTraverse(node.getRight());
}
}

//中序遍历(非递归)
public void nrInOrderTraverse() {

Stack<Node> stack = new Stack<Node>();
Node node = root;
while (node != null || !stack.isEmpty()) {
while (node != null) {
stack.push(node);
node = node.getLeft();
}
node = stack.pop();
System.out.println(node.getValue());
node = node.getRight();

}

}
//先序遍历(递归)
public void preOrderTraverse() {
preOrderTraverse(root);
}

public void preOrderTraverse(Node node) {
if (node != null) {
System.out.println(node.getValue());
preOrderTraverse(node.getLeft());
preOrderTraverse(node.getRight());
}
}

//先序遍历（非递归）
public void nrPreOrderTraverse() {

Stack<Node> stack = new Stack<Node>();
Node node = root;

while (node != null || !stack.isEmpty()) {

while (node != null) {
System.out.println(node.getValue());
stack.push(node);
node = node.getLeft();
}
node = stack.pop();
node = node.getRight();
}

}

//后序遍历(递归)
public void postOrderTraverse() {
postOrderTraverse(root);
}

public void postOrderTraverse(Node node) {
if (node != null) {
postOrderTraverse(node.getLeft());
postOrderTraverse(node.getRight());
System.out.println(node.getValue());
}
}

//后续遍历(非递归)
public void nrPostOrderTraverse() {

Stack<Node> stack = new Stack<Node>();
Node node = root;
Node preNode = null;//表示最近一次访问的节点

while (node != null || !stack.isEmpty()) {

while (node != null) {
stack.push(node);
node = node.getLeft();
}

node = stack.peek();

if (node.getRight() == null || node.getRight() == preNode) {
System.out.println(node.getValue());
node = stack.pop();
preNode = node;
node = null;
} else {
node = node.getRight();
}

}

}

//按层次遍历
public void levelTraverse() {
levelTraverse(root);
}

public void levelTraverse(Node node) {

Queue<Node> queue = new LinkedBlockingQueue<Node>();
queue.add(node);
while (!queue.isEmpty()) {

Node temp = queue.poll();
if (temp != null) {
System.out.println(temp.getValue());
queue.add(temp.getLeft());
queue.add(temp.getRight());
}

}

}

}

//树的节点

class Node {

private Node left;
private Node right;
private T value;

public Node() {
}
public Node(Node left,Node right,T value) {
this.left = left;
this.right = right;
this.value = value;
}

public Node(T value) {
this(null,null,value);
}
public Node getLeft() {
return left;
}
public void setLeft(Node left) {
this.left = left;
}
public Node getRight() {
return right;
}
public void setRight(Node right) {
this.right = right;
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}

}
测试代码：
package com.algorithm.tree;

public class TreeTest {

/**
* @param args
*/
public static void main(String[] args) {
Tree tree = new Tree();
tree.buildTree();
System.out.println("中序遍历");
tree.inOrderTraverse();
tree.nrInOrderTraverse();
System.out.println("后续遍历");
//tree.nrPostOrderTraverse();
tree.postOrderTraverse();
tree.nrPostOrderTraverse();
System.out.println("先序遍历");
tree.preOrderTraverse();
tree.nrPreOrderTraverse();

//
}

}

5. java 递归 算 二叉树 层级

层次遍历从方法上不具有递归的形式，所以一般不用递归实现。当然了，非要写成递归肯定也是可以的，大致方法如下。 void LevelOrder(BTree T, int cnt) { BTree level = malloc(sizeof(struct BTNode)*cnt); if(level==NULL) return; int i=0,rear=0; if(cnt==0) return; for(i=0; i<cnt; i++){ printf("%c ",T[i].data); if(T[i].lchild) level[rear++]=*T[i].lchild; if(T[i].rchild) level[rear++]=*T[i].rchild; } printf("\n"); LevelOrder(level, rear); free(level); } 补充一下，在main里面调用的时候就得用LevelOrder(T,1)了。

6. 假设二叉树以二叉链表作为存储结构，试设计一个计算二叉树叶子结点树的递归算 法 要求用递归算法啊

• 叶子节点：没有孩子节点的节点

下面我给出两种求解思路，其中就包括你要的递归求解。Java版的示例代码如下：

packagecn.zifangsky.tree.binarytree.questions;

importorg.junit.Test;

importcn.zifangsky.queue.LinkQueue;
importcn.zifangsky.tree.binarytree.BinaryTreeNode;

/**
*求二叉树中叶子节点的个数
*@authorzifangsky
*
*/
publicclassQuestion2{

	/**
	*通过递归遍历获取叶子节点个数
	*
	*@时间复杂度O(n)
	*@paramroot
	*@return
	*/
	(BinaryTreeNode<Integer>root){
		if(root==null){
			return0;
		}else{
			if(root.getLeft()==null&&root.getRight()==null){//叶子节点
				return1;
			}else{//左子树叶子节点总数+右子树叶子节点总数
				(root.getLeft())+getNumberOfLeavesByPreOrder(root.getRight());
			}
		}

	}
	
	
	/**
	*使用层次遍历获取二叉树叶子节点个数
	*
	*@时间复杂度O(n)
	*@paramroot
	*/
	(BinaryTreeNode<Integer>root){
		intcount=0;//叶子节点总数
		LinkQueue<BinaryTreeNode<Integer>>queue=newLinkQueue<>();
		if(root!=null){
			queue.enQueue(root);
		}
		
		while(!queue.isEmpty()){
			BinaryTreeNode<Integer>temp=queue.deQueue();//出队
			//叶子节点：左孩子节点和右孩子节点都为NULL的节点
			if(temp.getLeft()==null&&temp.getRight()==null){
				count++;
			}else{
				if(temp.getLeft()!=null){
					queue.enQueue(temp.getLeft());
				}
				if(temp.getRight()!=null){
					queue.enQueue(temp.getRight());
				}
			}
		}
		returncount;
	}
	
	
	/**
	*测试用例
	*/
	@Test
	publicvoidtestMethods(){
		/**
		*使用队列构造一个供测试使用的二叉树
		*1
		*23
		*4567
		*89
		*/
		LinkQueue<BinaryTreeNode<Integer>>queue=newLinkQueue<BinaryTreeNode<Integer>>();
		BinaryTreeNode<Integer>root=newBinaryTreeNode<>(1);//根节点
		
		queue.enQueue(root);
		BinaryTreeNode<Integer>temp=null;
		for(inti=2;i<10;i=i+2){
			BinaryTreeNode<Integer>tmpNode1=newBinaryTreeNode<>(i);
			BinaryTreeNode<Integer>tmpNode2=newBinaryTreeNode<>(i+1);
			
			temp=queue.deQueue();
			
			temp.setLeft(tmpNode1);
			temp.setRight(tmpNode2);
			
			if(i!=4)
				queue.enQueue(tmpNode1);
			queue.enQueue(tmpNode2);
		}

		System.out.println("叶子节点个数是："+getNumberOfLeavesByPreOrder(root));
		System.out.println("叶子节点个数是："+getNumberOfLeavesByQueue(root));
		
	}

}

输出如下：

叶子节点个数是：5
叶子节点个数是：5

附：上面代码中用到的两个类的定义：

i）BinaryTreeNode.java：

packagecn.zifangsky.tree.binarytree;

/**
*二叉树的单个节点定义
*@authorzifangsky
*
*@param<K>
*/
publicclassBinaryTreeNode<KextendsObject>{
	privateKdata;//数据
	privateBinaryTreeNode<K>left;//左孩子节点
	privateBinaryTreeNode<K>right;//右孩子节点
	
	publicBinaryTreeNode(Kdata){
		this.data=data;
	}

	publicBinaryTreeNode(Kdata,BinaryTreeNode<K>left,BinaryTreeNode<K>right){
		this.data=data;
		this.left=left;
		this.right=right;
	}

	publicKgetData(){
		returndata;
	}

	publicvoidsetData(Kdata){
		this.data=data;
	}

	publicBinaryTreeNode<K>getLeft(){
		returnleft;
	}

	publicvoidsetLeft(BinaryTreeNode<K>left){
		this.left=left;
	}

	publicBinaryTreeNode<K>getRight(){
		returnright;
	}

	publicvoidsetRight(BinaryTreeNode<K>right){
		this.right=right;
	}

}

ii）LinkQueue.java：

packagecn.zifangsky.queue;

importcn.zifangsky.linkedlist.SinglyNode;

/**
*基于单链表实现的队列
*@authorzifangsky
*@param<K>
*/
publicclassLinkQueue<KextendsObject>implementsQueue<K>{
	privateSinglyNode<K>frontNode;//队首节点
	privateSinglyNode<K>rearNode;//队尾节点
	
	publicLinkQueue(){
		frontNode=null;
		rearNode=null;
	}
	
	/**
	*返回队列是否为空
	*@时间复杂度O(1)
	*@return
	*/
	@Override
	publicbooleanisEmpty(){
		return(frontNode==null);
	}
	
	/**
	*返回存储在队列的元素个数
	*@时间复杂度O(n)
	*@return
	*/
	@Override
	publicintsize(){
		intlength=0;
		SinglyNode<K>currentNode=frontNode;
		while(currentNode!=null){
			length++;
			currentNode=currentNode.getNext();
		}
		
		returnlength;
	}
	
	/**
	*入队：在链表表尾插入数据
	*@时间复杂度O(1)
	*@paramdata
	*/
	@Override
	publicvoidenQueue(Kdata){
		SinglyNode<K>newNode=newSinglyNode<K>(data);
		
		if(rearNode!=null){
			rearNode.setNext(newNode);
		}
			
		rearNode=newNode;
		
		if(frontNode==null){
			frontNode=rearNode;
		}
	}
	
	/**
	*出队：删除表头节点
	*@时间复杂度O(1)
	*@return
	*/
	@Override
	publicKdeQueue(){
		if(isEmpty()){
			thrownewRuntimeException("QueueEmpty!");
		}else{
			Kresult=frontNode.getData();
			
			if(frontNode==rearNode){
				frontNode=null;
				rearNode=null;
			}else{
				frontNode=frontNode.getNext();
			}
			
			returnresult;
		}
	}

	/**
	*返回队首的元素，但不删除
	*@时间复杂度O(1)
	*/
	@Override
	publicKfront(){
		if(isEmpty()){
			thrownewRuntimeException("QueueEmpty!");
		}else{
			returnfrontNode.getData();
		}
	}

	/**
	*遍历队列
	*@时间复杂度O(n)
	*@return
	*/
	@Override
	publicvoidprint(){
		SinglyNode<K>tmpNode=frontNode;
		while(tmpNode!=null){
			System.out.print(tmpNode.getData()+"");
			tmpNode=tmpNode.getNext();
		}
	}
	
	/**
	*删除整个队列
	*@时间复杂度O(1)
	*@return
	*/
	@Override
	publicvoiddeleteQueue(){
		frontNode=null;
		rearNode=null;
	}

}

iii）SinglyNode.java：

packagecn.zifangsky.linkedlist;

/**
*单链表的定义
*
*@authorzifangsky
*@param<K>
*/
publicclassSinglyNode<KextendsObject>{
	privateKdata;//数据
	privateSinglyNode<K>next;//该节点的下个节点

	publicSinglyNode(Kdata){
		this.data=data;
	}

	publicSinglyNode(Kdata,SinglyNode<K>next){
		this.data=data;
		this.next=next;
	}

	publicKgetData(){
		returndata;
	}

	publicvoidsetData(Kdata){
		this.data=data;
	}

	publicSinglyNode<K>getNext(){
		returnnext;
	}

	publicvoidsetNext(SinglyNode<K>next){
		this.next=next;
	}

	@Override
	publicStringtoString(){
		return"SinglyNode[data="+data+"]";
	}

}

7. java二叉树中序遍历 的递归算法没有看懂。。search(data.getLeft());之后不就回到最左边的一个

最左边的节点是没有左子树和右子树的。
if(data.getLeft()!=null){ // 这里getLetf()为null

search(data.getLeft());
}
System.out.print(data.getObj()+","); //只有这句是执行的！

if(data.getRight()!=null){ // 这里getRight()为null

search(data.getRight());
}

然后就会退到上一个节点的遍历函数了。

8. java Map 怎么遍历

关于java中遍历map具体有四种方式，请看下文详解。

1、这是最常见的并且在大多数情况下也是最可取的遍历方式，在键值都需要时使用。

Map<Integer, Integer> map = newHashMap<Integer, Integer>();

for(Map.Entry<Integer, Integer> entry : map.entrySet()) {

System.out.println("Key = "+ entry.getKey() + ", Value = "+ entry.getValue());

}

2、在for-each循环中遍历keys或values。

如果只需要map中的键或者值，你可以通过keySet或values来实现遍历，而不是用entrySet。

Map<Integer, Integer> map = newHashMap<Integer, Integer>();

for(Integer key : map.keySet()) {

System.out.println("Key = "+ key);

}

for(Integer value : map.values()) {

System.out.println("Value = "+ value);

}

该方法比entrySet遍历在性能上稍好（快了10%），而且代码更加干净。

3、使用Iterator遍历

使用泛型：

Map<Integer, Integer> map = newHashMap<Integer, Integer>();

Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();

while(entries.hasNext()) {

Map.Entry<Integer, Integer> entry = entries.next();

System.out.println("Key = "+ entry.getKey() + ", Value = "+ entry.getValue());

}

不使用泛型：

Map map = newHashMap();

Iterator entries = map.entrySet().iterator();

while(entries.hasNext()) {

Map.Entry entry = (Map.Entry) entries.next();

Integer key = (Integer)entry.getKey();

Integer value = (Integer)entry.getValue();

System.out.println("Key = "+ key + ", Value = "+ value);

}

4、通过键找值遍历（效率低）

Map<Integer, Integer> map = newHashMap<Integer, Integer>();

for(Integer key : map.keySet()) {

Integer value = map.get(key);

System.out.println("Key = "+ key + ", Value = "+ value);

}

假设Map中的键值对为1=>11,2=>22,3=>33,现用方法1来遍历Map代码和调试结果如下：

(8)java二叉树遍历递归扩展阅读：

1、HashMap的重要参数

HashMap 的实例有两个参数影响其性能：初始容量 和加载因子。容量是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。

加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。

在Java编程语言中，加载因子默认值为0.75，默认哈希表元为101。

2、HashMap的同步机制

注意，此实现不是同步的。 如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。

（结构上的修改是指添加或删除一个或多个映射关系的任何操作；以防止对映射进行意外的异步访问，如下：

Map m = Collections.synchronizedMap(new HashMap(...));