遍历Java

A. java如何遍历数组

int[] is = new int[1,12,4,546]
for(int i=0; i<is.length; i++){
System.out.println(int[i] + "");
}
这就是一个最简单的遍历数组，遍历数组通俗点就是说把数组中的每个数都读一遍（部分有if条件+break的则可能不会完全遍历），你可以对于数组中的每个数进行处理，亦或者是找到数组中那个你需要的数。

B. java中的“遍历”是什么意思

1. “遍历”跟循环是一个意识
2. java中有很多集合元素，如List， 对其“遍历”可以获得子元素，进行下一步操作

C. 什么是树的遍历java

树遍历方法:有先序遍历、中序遍历、后序遍历以及广度优先遍历四种遍历树的方法

Demo:

publicclassThreeLinkBinTree<E>{

publicstaticclassTreeNode{

Objectdata;
TreeNodeleft;
TreeNoderight;
TreeNodeparent;

publicTreeNode(){

}

publicTreeNode(Objectdata){
this.data=data;
}

publicTreeNode(Objectdata,TreeNodeleft,TreeNoderight,TreeNodeparent){
this.data=data;
this.left=left;
this.right=right;
this.parent=parent;
}

}

privateTreeNoderoot;

//以默认的构造器创建二叉树
publicThreeLinkBinTree(){
this.root=newTreeNode();
}

//以指定根元素创建二叉树
publicThreeLinkBinTree(Edata){
this.root=newTreeNode(data);
}

/**
*为指定节点添加子节点
*
*@paramparent需要添加子节点的父节点的索引
*@paramdata新子节点的数据
*@paramisLeft是否为左节点
*@return新增的节点
*/
publicTreeNodeaddNode(TreeNodeparent,Edata,booleanisLeft){

if(parent==null){
thrownewRuntimeException(parent+"节点为null，无法添加子节点");
}
if(isLeft&&parent.left!=null){
thrownewRuntimeException(parent+"节点已有左子节点，无法添加左子节点");
}
if(!isLeft&&parent.right!=null){
thrownewRuntimeException(parent+"节点已有右子节点，无法添加右子节点");
}

TreeNodenewNode=newTreeNode(data);
if(isLeft){
//让父节点的left引用指向新节点
parent.left=newNode;
}else{
//让父节点的left引用指向新节点
parent.right=newNode;
}
//让新节点的parent引用到parent节点
newNode.parent=parent;
returnnewNode;
}

//判断二叉树是否为空
publicbooleanempty(){
//根据元素判断二叉树是否为空
returnroot.data==null;
}

//返回根节点
publicTreeNoderoot(){
if(empty()){
thrownewRuntimeException("树为空，无法访问根节点");
}
returnroot;
}

//返回指定节点（非根节点）的父节点
publicEparent(TreeNodenode){
if(node==null){
thrownewRuntimeException("节点为null，无法访问其父节点");
}
return(E)node.parent.data;
}

//返回指定节点（非叶子）的左子节点，当左子节点不存在时返回null
publicEleftChild(TreeNodeparent){
if(parent==null){
thrownewRuntimeException(parent+"节点为null，无法添加子节点");
}
returnparent.left==null?null:(E)parent.left.data;
}

//返回指定节点（非叶子）的右子节点，当右子节点不存在时返回null
publicErightChild(TreeNodeparent){
if(parent==null){
thrownewRuntimeException(parent+"节点为null，无法添加子节点");
}
returnparent.right==null?null:(E)parent.right.data;
}

//返回该二叉树的深度
publicintdeep(){
//获取该树的深度
returndeep(root);
}

//这是一个递归方法：每一棵子树的深度为其所有子树的最大深度+1
privateintdeep(TreeNodenode){
if(node==null){
return0;
}
//没有子树
if(node.left==null&&node.right==null){
return1;
}else{
intleftDeep=deep(node.left);
intrightDeep=deep(node.right);
//记录其所有左、右子树中较大的深度
intmax=leftDeep>rightDeep?leftDeep:rightDeep;
//返回其左右子树中较大的深度+1
returnmax+1;
}
}

//实现先序遍历
//1、访问根节点
//2、递归遍历左子树
//3、递归遍历右子树
publicList<TreeNode>preIterator(){
returnpreIterator(root);
}

privateList<TreeNode>preIterator(TreeNodenode){

List<TreeNode>list=newArrayList<TreeNode>();
//处理根节点
list.add(node);

//递归处理左子树
if(node.left!=null){
list.addAll(preIterator(node.left));
}

//递归处理右子树
if(node.right!=null){
list.addAll(preIterator(node.right));
}

returnlist;

}

//实现中序遍历
//1、递归遍历左子树
//2、访问根节点
//3、递归遍历右子树
publicList<TreeNode>inIterator(){
returninIterator(root);
}

privateList<TreeNode>inIterator(TreeNodenode){

List<TreeNode>list=newArrayList<TreeNode>();

//递归处理左子树
if(node.left!=null){
list.addAll(inIterator(node.left));
}

//处理根节点
list.add(node);

//递归处理右子树
if(node.right!=null){
list.addAll(inIterator(node.right));
}

returnlist;

}

//实现后序遍历
//1、递归遍历左子树
//2、递归遍历右子树
//3、访问根节点
publicList<TreeNode>postIterator(){
returnpostIterator(root);
}

privateList<TreeNode>postIterator(TreeNodenode){

List<TreeNode>list=newArrayList<TreeNode>();

//递归处理左子树
if(node.left!=null){
list.addAll(postIterator(node.left));
}

//递归处理右子树
if(node.right!=null){
list.addAll(postIterator(node.right));
}

//处理根节点
list.add(node);

returnlist;

}

//实现广度优先遍历
//广度优先遍历又称为按层遍历，整个遍历算法先遍历二叉树的第一层（根节点），再遍历根节点的两个子节点（第二层），以此类推
publicList<TreeNode>breadthFirst(){

Queue<TreeNode>queue=newArrayDeque<TreeNode>();
List<TreeNode>list=newArrayList<TreeNode>();
if(root!=null){
//将根元素加入“队列”
queue.offer(root);
}
while(!queue.isEmpty()){
//将该队列的“队尾”的元素添加到List中
list.add(queue.peek());
TreeNodep=queue.poll();
//如果左子节点不为null，将它加入“队列”
if(p.left!=null){
queue.offer(p.left);
}
//如果右子节点不为null，将它加入“队列”
if(p.right!=null){
queue.offer(p.right);
}
}
returnlist;
}

}

D. 在java中集合的遍历是怎样遍历的

import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
//集合遍历
public class TestHashSet{
public static void main(String[] args) {
HashSet h = new HashSet();
h.add("1st");
h.add("2nd");
h.add(new Integer(3));
h.add(new Double(4.0));
h.add("2nd"); // 重复元素, 未被加入
h.add(new Integer(3)); // 重复元素,未被加入
h.add(new Date());
System.out.println("开始: size=" + h.size());
Iterator it = h.iterator();
while(it.hasNext()){
Object o = it.next();
System.out.println(o);
}
}
}

E. JAVA遍历数组

你好，很高兴为你解答。
if(e==i.length) 根本无法判断是否是最后一个。你执行一下这段代码，什么都输出不了。
e是指在数组i中的元素，在这个例子中，都是1。

F. Java遍历

因为第一个length是String类的一个方法，下面附上源码

第二处的length则是数组的一个属性。一个是属性一个是方法不可混为一谈。

G. 字符串如何遍历java

1、String s="abcde";
for(int i=0;i<s.length();i++)
{
char c=s.charAt(i);
System.out.print(c+" ");//输出a b c d e，获取字符串
}
2：for(String x : s){

System.out.print(s+" ");//输出a b c d e，获取字符串
}
3、Arrays.asList(s).stream().forEach(x -> System.out.println(x));

推荐使用3.然后自己去了解一下jdk1.8+的stream

H. Java中的遍历

用多层嵌套吧
中间用if()语句判断是否相同。
自己试试吧

I. Java数组遍历

因为是随机生成的数组，所以可能数组中没有小于10的数字，这时处理后的数组和之前一样看不到效果。多试几次就好了。

importjava.util.Random;

publicclassDemo{
publicstaticvoidmain(String[]args){
Randomrandom=newRandom();
int[]arr=newint[5];

for(inti=0;i<arr.length;i++){
arr[i]=random.nextInt(46)+5;
}

System.out.print("随机生成的数组：");
printArr(arr);

arr=getNewArr(arr);
System.out.print("处理之后的数组：");
printArr(arr);

}

privatestaticint[]getNewArr(int[]arr){
for(inti=0;i<arr.length;i++){
if(arr[i]<10){
arr[i]=0;
}
}
returnarr;
}

privatestaticvoidprintArr(int[]arr){
for(inti:arr){
System.out.print(i+"");
}
System.out.println();
}
}