遍歷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();
}
}