day03,day04_数组,循环(上)
break和continue的使用范围:
continue只能用于循环结构,也就是说只要有continue,肯定存在循环.
break用在switch语句和循环结构中.
break和continue单独存在时,下面不可以有任何语句,因为执行不到(会报错)
函数重载(overload)
同一个类中允许存在一个以上的同名函数,只要它们的 参数类型/参数个数/参数类型顺序 不同,跟 返回类型 无关.
Java中的数组:
首先了解下:
在函数中定义的一些 基本类型的变量(short,int,char,long,double,byte,boolean,float),和 对象的引用变量(int[ ] x等) 都是在函数的栈内存中分配,
当在一段代码块(也就是一堆花括号{ }之间)定义一个变量时,Java就在栈中为这个变量分配内存空间,当超过变量的作用域后,Java会自动释放掉为该变量
所分配的内存空间,该内存空间可以立即被另作他用.
堆内存用来存放由 new创建的对象和数组 ,在堆中分配内存,由JVM的自动垃圾回收器来管理.在堆中产生了一个数组或对象后,还可以在栈中定义一个特殊
的变量,让栈中的这个变量的取值 等于 数组 或 对象在堆内存中的首地址,栈中的这个变量就成了数组或对象的引用变量,以后就可以在程序中使用栈中的引用
变量来访问堆中的数组或对象,引用变量相当于是为数组或对象起的一个名称(叫代号也行).
引用变量是普通的变量,定义时在栈中分配,引用变量在程序运行到其作用域之外后被释放.
而数组和对象本身在 堆 中 分配,即使程序运行到使用new产生数组和对象的语句所在的代码块之外,数组和对象本身占据的内存不会被释放,数组和对象在没有引用
变量指向它时,才会变为垃圾,不能再被使用,但仍然占据内存空间不放,在随后一个不确定的时间被 垃圾回收器 收走(释放掉).这也是Java比较占内存的原因.
以上摘自张孝祥老师的<Java就业培训教程>
举例:
int[ ] x;//定义了一个数组x,这条语句的执行完后的内存状态如下
x=new int [3];//数组初始化,内存状态如下
然后测试一下各种类型数组的默认值:
class ArrayTest { public static void main(String[] args) { //int,double,float,char型数组默认值 int[] n=new int[3]; System.out.println("int "+n[1]);//0 char[] c=new char[3]; System.out.println("char "+c[1]);//ASCII码为0的空字符:'\0' float[] f=new float[3]; System.out.println("float "+f[1]);//0.0f(加f为了说明是float型) double[] d=new double[3]; System.out.println("double "+d[1]);//0.0 boolean[] b=new boolean[3]; System.out.println("boolean "+b[1]);//false } }
import java.util.*; class sort { /* 冒泡排序:(从小到大,从零趟开始为了操作方便) 算法思想: 相邻两个数比较,两两比较得到的较大数不断后移, 最终每趟最大沉底. 示例:下标 0 1 2 3 4 i 5 3 7 9 1 3 5 7 9 1 5>3交换 第零趟: 3 5 7 9 1 5<7不动 3 5 7 9 1 7<9不动 3 5 7 1 9 9>1交换-->9为最大,arr[4]为9 共比较4(arr.length-0(趟数)-1)次 第一趟: 3 5 7 1 -->9不用在参与比较 3 5 7 1 3<5不动 3 5 7 1 5<7不动 3 5 1 7 7>1交换-->7为次大,arr[3]为7 共比较3(arr.length-1-1)次 第二趟: 3 5 1 -->7不用再参与比较 3 5 1 3<5不动 3 1 5 5>1交换-->arr[2]为5 共比较2(arr.length-2-1)次 第三趟: 3 1 -->5不用再参与比较 1 3 3>1交换-->arr[1]为3 共比较1(arr.length-3-1)次 共走了4(arr.length-1)趟 最后一定剩余一个数字1,不用再参与比较,肯定最小 */ //交换 public static void swap(int[] b,int i,int j) { int temp=b[i]; b[i]=b[j]; b[j]=temp; } //冒泡排序 public static void bubbleSort(int[] a) { 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]) swap(a,j,j+1); } /* 选择排序:(从小到大) 算法思想: 每一趟从待排序的数据元素中选出最小（或最大）的一个元素， 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 示例:下标 0 1 2 3 4 5 3 7 9 1 i 3 5 7 9 1 5>3交换 第零趟: 3 5 7 9 1 3<7不动 3 5 7 9 1 3<9不动 1 5 7 9 3 3>1交换-->此时arr[0]为1,并且最小 共比较4(arr.length-0-1)次 5 7 9 3 5<7不动 第一趟: 5 7 9 3 5<9不动 3 7 9 5 3<5交换-->此时arr[1]为3,次小 共比较3(arr.length-1-1)次 第二趟: 7 9 5 7<9不动 5 9 7 5<7交换-->此时arr[2]为5. 共比较2(arr.length-2-1)次 第三趟: 7 9 9>7交换-->此时arr[3]为7. 共比较1(arr.length-3-1)次 共走了4(arr.length-1)趟,最后剩余一个9,为最大,arr[4]为9 */ //选择排序 public static void selectSort(int[] b) { for(int i=0;i<b.length-1;++i)//控制趟数 for(int j=i+1;j<b.length;++j)//共比较(arr.length-1)-(i+1)+1 if(b[i]>b[j]) //即arr.length-i-1 swap(b,i,j); } //选择排序第二种写法: public static void selectSort_2(int[] c) { int k=0; for(int i=0;i<c.length-1;++i) { k=i; for(int j=i+1;j<c.length;++j) if(c[k]>c[j]) k=j; if(k!=i) swap(c,k,i); } } /* 这种写法和上面最大区别是: k中每次存放较小元素的下标,直到一趟走完 此时k中存放这一趟最小元素下标 这时在和第i个位置的元素交换 */ //打印数组 public static void showArray(int[] arr) { System.out.print("["); for(int i=0;i<arr.length;++i) if(i!=arr.length-1) System.out.print(arr[i]+","); else System.out.println(arr[i]+"]"); } //Test public static void main(String[] args) { int[] arr={7,3,9,11,1,6,5}; int[] arr_2={6,2,3,1,11}; int[] arr_3={9,8,10,2,11,3}; bubbleSort(arr); System.out.println("bubbleSort: "); showArray(arr); selectSort(arr_2); System.out.println("slectSort: "); showArray(arr_2); selectSort(arr_3); System.out.println("selectSort_2: "); showArray(arr_3); //Arrays.sort(arr_2);实际开发中使用 //showArray(arr_2); } }
运行结果:
最大值与最小值:
class MaxMin { //相当于冒泡/选择排序的一趟 //可以一次遍历同时找出最大值和最小值 public static void main(String[] args) { int max,min; int[] arr={3,2,1,6,9,5}; max=min=arr[0];//max和min的初始值可以为数组中任何两个值,但下面的循环必须从下标0(i=0)开始 for(int i=1;i<arr.length;++i) if(arr[i]>max) max=arr[i]; else if(arr[i]<min) min=arr[i]; System.out.println("max="+max+",min="+min); } }
运行结果:
