迭代演算法java

1. 在java中「迭代」是什麼意思

重復的反饋某一過程（操作）叫迭代，

在java中，就是循環重復的進行某一操作，比如一個程序要累加1到100的和，
那麼只要定義一個變數sum，讓它重復的進行累加操作:
int sum =0;
for( int i=1; i<=100; i++ ){

sum = sum +i;

}
其中執行一次sum = sum + i ;就稱之為一次迭代，每一次迭代得到的結果（sum + i 的和）會作為下一次迭代的初始值（結果賦值給sum變數後，這個變數又作下一次迭代的初始值）；這就是迭代與普通循環的區別。

2. Java演算法設計：迭代器實現排序（求各位大佬各抒己見）

public static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int e = arr.length - 1; e > 0; e--) {
for (int i = 0; i < e; i++) {
if (arr[i] > arr[i + 1]) {
swap(arr, i, i + 1);
}
}
}
}

3. java中什麼叫「迭代」，什麼叫「迭代器」

迭代
通俗點說 叫 一個個數過去，
實現這樣一個個數過去功能的東西，叫迭代器。

java迭代器 較多使用在容器中，如數組鏈表 ArrayList(反正就是能裝東西的玩意兒)
舉個例子：
//我們先往鏈表中裝東西
ArrayList a = new ArrayList();
a.add("東西1");
a.add("東西2");
//從鏈表中取東西怎麼辦呢，自然就用到了迭代器
//用法是這樣的
Iterator iter = a.iterator() ; //iter迭代器對象，可以用它來數了
while(iter.hasNext()){ //先往左數，如果有東西就執行{}里的語句
String m = (String)iter.next(); //數到什麼就拿出來 賦值給m
System.out.println(m); //拿出m用一下，即列印
}

4. JAVA迭代是什麼意思

JAVA中的迭代分為迭代器還是演算法。
不知你想知道哪種
如果是迭代器的話，那沒什麼好說的，就是封裝一個類而已。
如果是演算法，下面附上代碼，研究下便理解。
/**
*Filsename: SortArray.java
*Task: 數組的迭代插入排序演算法
*/
public class SortArray{
public static void main(String[] args)
{
int array[]={8,9,1,4,2,3,0,6,5,7};
display(array);
insertionSort(array,array.length);
display(array);
}
public static void insertionSort(int[] a,int n)
{
for(int unsorted=1;unsorted<n;unsorted++)
{
insertInOrder(a[unsorted],a,0,unsorted-1);
}
}
private static void insertInOrder(int num,int[] a,int first,int last)
{
while(first<=last&&num<a[last])
{
a[last+1]=a[last];
last--;
}
a[last+1]=num;
}
public static void display(int[] a)
{
for(int i=0;i<a.length;i++)
System.out.print(a[i]+" ");
System.out.println();
}
}

5. java中」遍歷「，」迭代「是什麼意思

我認為迭代是遍歷的一種吧,遍歷是查找的意思吧
迭代器模式(Iterator pattern)
一、 引言
迭代這個名詞對於熟悉Java的人來說絕對不陌生。我們常常使用JDK提供的迭代介面進行java collection的遍歷：
Iterator it = list.iterator();
while(it.hasNext()){
//using 「it.next();」do some businesss logic
}
而這就是關於迭代器模式應用很好的例子。
二、 定義與結構
迭代器（Iterator）模式，又叫做游標（Cursor）模式。GOF給出的定義為：提供一種方法訪問一個容器（container）對象中各個元素，而又不需暴露該對象的內部細節。
從定義可見，迭代器模式是為容器而生。很明顯，對容器對象的訪問必然涉及到遍歷演算法。你可以一股腦的將遍歷方法塞到容器對象中去；或者根本不去提供什麼遍歷演算法，讓使用容器的人自己去實現去吧。這兩種情況好像都能夠解決問題。
然而在前一種情況，容器承受了過多的功能，它不僅要負責自己「容器」內的元素維護（添加、刪除等等），而且還要提供遍歷自身的介面；而且由於遍歷狀態保存的問題，不能對同一個容器對象同時進行多個遍歷。第二種方式倒是省事，卻又將容器的內部細節暴露無遺。
而迭代器模式的出現，很好的解決了上面兩種情況的弊端。先來看下迭代器模式的真面目吧。
迭代器模式由以下角色組成：
1) 迭代器角色（Iterator）：迭代器角色負責定義訪問和遍歷元素的介面。
2) 具體迭代器角色（Concrete Iterator）：具體迭代器角色要實現迭代器介面，並要記錄遍歷中的當前位置。
3) 容器角色（Container）：容器角色負責提供創建具體迭代器角色的介面。
4) 具體容器角色（Concrete Container）：具體容器角色實現創建具體迭代器角色的介面——這個具體迭代器角色於該容器的結構相關。
迭代器模式的類圖如下：

從結構上可以看出，迭代器模式在客戶與容器之間加入了迭代器角色。迭代器角色的加入，就可以很好的避免容器內部細節的暴露，而且也使得設計符號「單一職責原則」。
注意，在迭代器模式中，具體迭代器角色和具體容器角色是耦合在一起的——遍歷演算法是與容器的內部細節緊密相關的。為了使客戶程序從與具體迭代器角色耦合的困境中脫離出來，避免具體迭代器角色的更換給客戶程序帶來的修改，迭代器模式抽象了具體迭代器角色，使得客戶程序更具一般性和重用性。這被稱為多態迭代。
三、 舉例
由於迭代器模式本身的規定比較鬆散，所以具體實現也就五花八門。我們在此僅舉一例，根本不能將實現方式一一呈現。因此在舉例前，我們先來列舉下迭代器模式的實現方式。
1．迭代器角色定義了遍歷的介面，但是沒有規定由誰來控制迭代。在Java collection的應用中，是由客戶程序來控制遍歷的進程，被稱為外部迭代器；還有一種實現方式便是由迭代器自身來控制迭代，被稱為內部迭代器。外部迭代器要比內部迭代器靈活、強大，而且內部迭代器在java語言環境中，可用性很弱。
2．在迭代器模式中沒有規定誰來實現遍歷演算法。好像理所當然的要在迭代器角色中實現。因為既便於一個容器上使用不同的遍歷演算法，也便於將一種遍歷演算法應用於不同的容器。但是這樣就破壞掉了容器的封裝——容器角色就要公開自己的私有屬性，在java中便意味著向其他類公開了自己的私有屬性。
那我們把它放到容器角色里來實現好了。這樣迭代器角色就被架空為僅僅存放一個遍歷當前位置的功能。但是遍歷演算法便和特定的容器緊緊綁在一起了。
而在Java Collection的應用中，提供的具體迭代器角色是定義在容器角色中的內部類。這樣便保護了容器的封裝。但是同時容器也提供了遍歷演算法介面，你可以擴展自己的迭代器。
好了，我們來看下Java Collection中的迭代器是怎麼實現的吧。
//迭代器角色，僅僅定義了遍歷介面
public interface Iterator {
boolean hasNext();
Object next();
void remove();
}
//容器角色，這里以List為例。它也僅僅是一個介面，就不羅列出來了
//具體容器角色，便是實現了List介面的ArrayList等類。為了突出重點這里指羅列和迭代器相關的內容
//具體迭代器角色，它是以內部類的形式出來的。AbstractList是為了將各個具體容器角色的公共部分提取出來而存在的。
public abstract class AbstractList extends AbstractCollection implements List {
……
//這個便是負責創建具體迭代器角色的工廠方法
public Iterator iterator() {
return new Itr();
}
//作為內部類的具體迭代器角色
private class Itr implements Iterator {
int cursor = 0;
int lastRet = -1;
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size();
}
public Object next() {
checkForComodification();
try {
Object next = get(cursor);
lastRet = cursor++;
return next;
} catch(IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch(IndexOutOfBoundsException e) {
throw new ();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ();
}
}
至於迭代器模式的使用。正如引言中所列那樣，客戶程序要先得到具體容器角色，然後再通過具體容器角色得到具體迭代器角色。這樣便可以使用具體迭代器角色來遍歷容器了……
四、 實現自己的迭代器
在實現自己的迭代器的時候，一般要操作的容器有支持的介面才可以。而且我們還要注意以下問題：
在迭代器遍歷的過程中，通過該迭代器進行容器元素的增減操作是否安全呢？
在容器中存在復合對象的情況，迭代器怎樣才能支持深層遍歷和多種遍歷呢？
以上兩個問題對於不同結構的容器角色，各不相同，值得考慮。
五、 適用情況
由上面的講述，我們可以看出迭代器模式給容器的應用帶來以下好處：
1) 支持以不同的方式遍歷一個容器角色。根據實現方式的不同，效果上會有差別。
2) 簡化了容器的介面。但是在java Collection中為了提高可擴展性，容器還是提供了遍歷的介面。
3) 對同一個容器對象，可以同時進行多個遍歷。因為遍歷狀態是保存在每一個迭代器對象中的。
由此也能得出迭代器模式的適用范圍：
1) 訪問一個容器對象的內容而無需暴露它的內部表示。
2) 支持對容器對象的多種遍歷。
3) 為遍歷不同的容器結構提供一個統一的介面（多態迭代）。

6. java中什麼叫迭代，什麼叫迭代器

迭代：

是重復反饋過程的活動，其目的通常是為了逼近所需目標或結果。每一次對過程的重復稱為一次「迭代」，而每一次迭代得到的結果會作為下一次迭代的初始值。

重復執行一系列運算步驟，從前面的量依次求出後面的量的過程。此過程的每一次結果，都是由對前一次所得結果施行相同的運算步驟得到的。例如利用迭代法*求某一數學問題的解。

對計算機特定程序中需要反復執行的子程序*(一組指令)，進行一次重復，即重復執行程序中的循環，直到滿足某條件為止，亦稱為迭代。

迭代器（Iterator）模式：

又叫做游標模式，它的含義是，提供一種方法訪問一個容器對象中各個元素，而又不需暴露該對象的內部細節。

注意：Java的集合框架的集合類，有的時候也稱為容器。

從定義上看，迭代器是為容器而生，它本質上就是一種遍歷的演算法。因為容器的實現千差萬別，很多時候不可能知道如何去遍歷一個集合對象的元素。Java為我們提供了使用迭代的介面，Java的所有集合類丟失進行迭代的。

簡單的說，迭代器就是一個介面Iterator，實現了該介面的類就叫做可迭代類，這些類多數時候指的就是java.util包下的集合類。

總結：

迭代器，提供一種訪問一個集合對象各個元素的途徑，同時又不需要暴露該對象的內部細節。java通過提供Iterator和Iterable倆個介面來實現集合類的可迭代性，迭代器主要的用法是：首先用hasNext（）作為循環條件，再用next（）方法得到每一個元素，最後在進行相關的操作。

(6)迭代演算法java擴展閱讀

首先，創建了一個List的集合對象，並放入了倆個字元串對象，然後通過iterator()方法得到迭代器。iterator()方法是由Iterable介面規定的，ArrayList對該方法提供了具體的實現，在迭代器Iteartor介面中，有以下3個方法：

1、hasNext()該方法英語判斷集合對象是否還有下一個元素，如果已經是最後一個元素則返回false

2、next()把迭代器的指向移到下一個位置，同時，該方法返回下一個元素的引用

3、remove() 從迭代器指向的Collection中移除迭代器返回的最後一個元素，該操作使用的比較少。

注意：從Java5.0開始，迭代器可以被foreach循環所替代，但是foreach循環的本質也是使用Iterator進行遍歷的。

7. java里遞歸和迭代分別是什麼演算法啊

迭代是普通的循環。
例：求從1加到10
int sum=0
for(int i=0;i<= 10;i++){
sum=sum+i;
}

遞歸是指一個函數直接或間接調用自己。
好比:從前有個廟廟里有個大和尚和小和尚，大和尚叫小和尚講故事，小和尚說從前有個廟廟里有個大和尚和小和尚,小和尚叫大和尚講故事,大和尚說從前....

遞歸的特點：
必有三個條件：
1. 間接或直接調用自己。
2. 一定要有退出的條件（比方說大和尚口乾了不聽故事了）。否則就是死循環
3。要有邏輯體（想要做的事）;

public int sum(int x){
if(x<=0){
return x;
}
return x+sum(x-1);
}
int s=10;
int total=sum(s);

該例中，sum函數總是調用自己，return x+sum(x-1);
sum有退出條件， x<=0

最後的結果是把 10+9+8+7+... 1 返回

在很多種情況下，迭代和遞歸都可以完成相同的功能， 不過遞歸有些功能迭代就完成不了。 並且代碼沒有遞歸簡潔，熟練使用遞歸後能提高代碼質量。

8. java用迭代的演算法實現階乘

int num=1;
Scanner sc=new Scanner(system.in);
system.out.print("輸入一個正整數");
int n=sc.nextInt();
String str=num+"*";
for( int i=2;i<=n;i++){
str=str+i+"*";
if(i==n){
str=str+i;
}
num=num*i;//num*=i;這一步有兩種實現,但是後面的運行速度比前面的要快!
}
system.out.println(str+"="+num);

效果是,你輸入5:顯示1*2*3*4*5=120