Java编程004

16. foreach循环的使用
foreach循环是for循环的一种简写格式，只用于遍历数据集合或数组。格式为
for(Type e：collection){
//对变量的操作
}
e的类型为数组中元素值的类型，collection为要遍历的数组或集合，也可以是迭代器。

import java.util.ArrayList;
import java.util.List;

public class UseForeach {
    public static void main(String[] args) {
        List<String>list=new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        System.out.print("foreach遍历集合：\n\t");
        for (String string : list) {
            System.out.print(string);
        }
        System.out.println();
        String[] strs = new String[list.size()];
        list.toArray(strs);
        System.out.print("foreach遍历数组：\n\t");
        for (String string : strs) {
            System.out.print(string);

        }
    }
}

17 .循环体的过滤器

continue语句可以放弃本次循环体的剩余代码，不执行它们而开始下一轮的循环。本例利用continue语句实现了循环体过滤器，可以过滤老鹰字符串。

public class CycFilter {
    public static void main(String[] args) {
        String[] array=new String[]{"白鹿","丹顶鹤","火烈鸟","老鹰","布谷鸟","乌鸦","喜鹊","老鹰","百灵鸟"};
        int EagleCount=0;
        for (String string : array) {
            if(string.equals("老鹰")){
                System.out.println("发现一只老鹰，已捕获");
                EagleCount++;
                continue;
            }
            System.out.println("搜索鸟类，发现了：" + string);
        }
        System.out.print("一共有："+EagleCount+"?");
    }
}

搜索鸟类，发现了：白鹿
搜索鸟类，发现了：丹顶鹤
搜索鸟类，发现了：火烈鸟
发现一只老鹰，已捕获
搜索鸟类，发现了：布谷鸟
搜索鸟类，发现了：乌鸦
搜索鸟类，发现了：喜鹊
发现一只老鹰，已捕获
搜索鸟类，发现了：百灵鸟
一共有：2?

18. 循环的极限
程序为死循环，要注意取值范围

public class CycUtMost {
    public static void main(String[] args) {
        int end=Integer.MAX_VALUE;
        int start=end-50;
        int count=0;
        //当整数类型到最大值再加1会回到整数类型的最小值，所以永远不可能大于end变量
        for (int i = start; i <= end; i++) {
            count++;
        }
        System.out.println("本次循环次数为：" + count);
    }

}

19.冒泡排序
俩俩比较相邻的对象，若反序，则交换，直到没有反序的记录为止。

package paixu;

public class Bubble {
    public static void main(String[] args) {
        int[] a = {10, 23, 11, 56, 45, 26, 59, 28, 84, 79};
        int temp;
        System.out.println("初始排列为：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+"  ");
        }
        //进行俩俩比较
        //外层循环，决定一共走几趟
        for (int i = 0; i < a.length-1; i++) {
            //内层循环，开始逐个比较
            for (int j = 0; j <a.length - i-1; j++) {//因为冒泡是把每轮循环中较大的数飘到后面
                if (a[j] > a[j + 1]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
        System.out.println("\n" + "排好的数组为：");
        for (int i = 0; i <a.length; i++) {
            System.out.print(a[i]+"  ");
            }

    }
}

20. 快速排序
    快速排序之所比较快，因为相比冒泡排序，每次交换是跳跃式的。每次排序的时候设置一个基准点，将小于等于基准点的数全部放到基准点的左边，将大于等于基准点的数全部放到基准点的右边。这样在每次交换的时候就不会像冒泡排序一样每次只能在相邻的数之间进行交换，交换的距离就大的多了。因此总的比较和交换次数就少了，速度自然就提高了。当然在最坏的情况下，仍可能是相邻的两个数进行了交换。因此快速排序的最差时间复杂度和冒泡排序是一样的都是O(N2)，它的平均时间复杂度为O(NlogN)。其实快速排序是基于一种叫做“二分”的思想。

public class QuickSort {
    public static void quickSort(int[] arr, int low, int high) {
        int i,j,temp,t;
        if (low > high) {
            return ;
        }
        i=low;
        j=high;
        //temp为基准位
        temp = arr[low];
        while (i < j) {
            //右边向左递减
            while(temp<=arr[j]&&i<j){
                j--;
            }
            //再看左边，向右递增
            while (temp >= arr[i] && i < j) {
                i++;
            }
            //满足条件则交换
            if (i < j) {
                t=arr[j];
                arr[j]=arr[i];
                arr[i]=t;
            }
        }
        //最后将基准位与i和j相等的的位置的数字交换
        arr[low]=arr[i];
        arr[i]=temp;
        //递归调用左半数组
        quickSort(arr, low, j - 1);
        //递归调用右半数组
        quickSort(arr, j + 1, high);
    }
    public static void main(String[] args){
        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        quickSort(arr, 0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"  ");
        }
    }

}