JA V A冒泡排序从小到大和从大到小详细过程
1.从小到大的冒泡排序
for(int i=0;i { for(int j=0;j { if(a[j]>a[j+1])//如果前一位大于后一位，则交换，大的数排在后面 { int temp=a[j+1]; a[j+1]=a[j]; a[j]=temp; } } } int a[]={6,4,5,7,3} 6 4 5 7 3 (1)i<4,j<4 i=0 (第一趟，5个数两两比较4次，可确定一个最大数，剩4个数) j=0 则排序后为：4 6 5 7 3 j=1 则排序后为：4 5 6 7 3 j=2 则排序后为：4 5 6 7 3 j=3 则排序后为：4 5 6 37 (2)i<4,j<3 i=1 (第二趟，4个数两两比较3次，可确定一个最大数，剩3个数) j=0 则排序后为：4 5 6 3 7 j=1 则排序后为：4 5 6 3 7 j=2 则排序后为：4 5 3 6 7 (3)i<4,j<2 i=2 (第三趟，3个数两两比较2次，可确定一个最大数，剩2个数) j=0 则排序后为：4 5 3 6 7 j=1 则排序后为：4 3 5 6 7 (4)i<4,j<1 i=3 (第四趟，2个数两两比较1次，可确定一个最大数，剩1个数，为最小数) j=0 则排序后为：3 4 5 6 7 2.从大到小的冒泡排序 for(int i=0;i { for(int j=0;j { if(a[j] { int temp=a[j+1]; a[j+1]=a[j]; a[j]=temp; } } } int a[]={6,4,5,7,3} 6 4 5 7 3 (1)i<4,j<4 i=0 (第一趟，5个数两两比较4次，可确定一个最小数，剩4个数) j=0 则排序后为：6 4 5 7 3 j=1 则排序后为：6 5 4 7 3 j=2 则排序后为：6 5 7 4 3 j=3 则排序后为：6 5 7 4 3 (2)i<4,j<3 i=1 (第二趟，4个数两两比较3次，可确定一个最小数，剩3个数) j=0 则排序后为：6 5 7 4 3 j=1 则排序后为：6 7 5 4 3 j=2 则排序后为：6 7 5 4 3 (3)i<4,j<2 i=2 (第三趟，3个数两两比较2次，可确定一个最小数，剩2个数) j=0 则排序后为：7 6 5 4 3 j=1 则排序后为：7 6 5 4 3 (4)i<4,j<1 i=3 (第四趟，2个数两两比较1次，可确定一个最小数，剩1个数，为最大数) j=0 则排序后为：7 6 5 4 3 完整代码及运行结果： package sort; public class bubleSort { public static void main(String args[]) { int a[]={6,4,5,7,3}; System.out.println("排序前的数组为:"); for(int i=0;i { System.out.print("a["+i+"]="+a[i]+" "); } System.out.println(); System.out.println("从小到大冒泡排序后的数组为:"); for(int i=0;i { for(int j=0;j { if(a[j]>a[j+1])//如果前一位大于后一位，则交换，大的数排在后面 { int temp=a[j+1]; a[j+1]=a[j]; a[j]=temp; } } } for(int i=0;i { System.out.print("a["+i+"]="+a[i]+" "); } System.out.println(); System.out.println("从大到小冒泡排序后的数组为:"); for(int i=0;i { for(int j=0;j { if(a[j] { int temp=a[j+1]; a[j+1]=a[j]; a[j]=temp; } } } for(int i=0;i { System.out.print("a["+i+"]="+a[i]+" "); } } } 运行结果： 一填空题 1)数组的元素通过下标来访问，数组Array的长度为Array.length 。 2)数组复制时，"="将一个数组的引用传递给另一个数组。 3)JVM将数组存储在栈(堆或栈)中。 4)数组的二分查找法运用的前提条件是数组已经排序。 5)Java中数组的下标的数据类型是整型。 6)数组最小的下标是0 。 7)arraycopy()的最后一个参数指明复制元素的个数。 8)向方法传递数组参数时，传递的是数组的引用。 9)数组初始化包括数组的申明，创建和初始化。 10)数组下标访问超出索引范围时抛出数组越界异常 11)浮点型数组的默认值是0.0f 。 12)数组创建后其大小不能改变。 二选择题 1.下面错误的初始化语句是_ABD__ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e','l','l','o'}; D. char str[]={'hello'}; 2.定义了一维int型数组a[10]后，下面错误的引用是_B__ A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 3.下面的二维数组初始化语句中，正确的是____ A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 4.引用数组元素时，数组下标可以是_D___ A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 5.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为____ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是__B__ A. char str[5]="hello"; B. char str[]={'h','e','l','l','o','\0'}; C. char str[5]={"hi"}; D. char str[100]=""; 7.数组在Java中储存在 C 中 A. 栈 B. 队列 C. 堆 D. 链表 8.下面程序的运行结果是____ main() { int a[][]={{1,2,3},{4,5,6}}; System.out.printf("%d", a[1][1]); } A. 3 B. 4 C. 5 D. 6 9.下面程序的运行结果是_C___ main() { 精心整理一填空题 1)数组的元素通过下标来访问，数组Array的长度为Array.length。 2)数组复制时，"="将一个数组的引用传递给另一个数组。 3)JVM将数组存储在栈(堆或栈)中。 4)数组的二分查找法运用的前提条件是数组已经排序。 5)Java中数组的下标的数据类型是整型。 6)数组最小的下标是0。 7) 8) 9) 10) 11) 12) 1. 2. 3. 4. 5. 6. 7. 8.A. 9. 10. 11.A 12.C.charstr[5]={"hi"}; D.charstr[100]=""; 13.数组在Java中储存在C中 14.A.栈 B.队列 C.堆 D.链表 15.下面程序的运行结果是____ main(){ inta[][]={{1,2,3},{4,5,6}}; } A.3 B.4 C.5 D.6 16.下面程序的运行结果是_C___ 17.m ain(){ intx=30; int[]numbers=newint[x]; x=60; (numbers.length); } A.60 B.20 C.30 D.50 18. 19.m 20.c 21.i 22.w 23. 24.A 25.C 26. A. C.用 27. 28. A. 29. 30. A.char--'"u0000' B.Boolean--true C.float--0.0f D.int--0 31.关于数组作为方法的参数时，向方法传递的是A A.数组的引用 B.数组的栈地址 C.数组自身 D.数组的元素 32.关于数组复制，下列说法错误的是AC A."="可以实现数组复制 B.运用循环语句进行数组复制必须两个数组长度相同 C.arraycopy()方法没有给目标数组分配内存空间 D.数组复制是数组引用的传递 冒泡排序法 1.public class SortArray_01 { 2. public static void main(String args[]) { 3. int[] array = { 14, 5, 86, 4, 12, 3, 21, 13, 11, 2, 55 }; // 创建一个初始化的一维数组array 4. System.out.println("未排序的数组:"); 5. for (int i = 0; i < array.length; i++) { // 遍历array数组中的元素 6. System.out.print(" " + array[i]); // 输出数组元素 7. if ((i + 1) % 5 == 0) // 每5个元素一行 8. System.out.println(); 9. } 10. int mid; // 定义一个中间变量， 起到临时存储数据的作用 11. for (int i = 0; i < array.length; i++) { // 执行冒 泡排序法 12. for (int j = i; j < array.length; j++) { 13. if (array[j] < array[i]) { 14. mid = array[i]; 15. array[i] = array[j]; 16. array[j] = mid; 17. } 18. } 19. } 20. System.out.println("\n使用冒泡法排序后的数组:"); 21. for (int i = 0; i < array.length; i++) { // 遍历排好序的array数组中的元素 22. System.out.print(" " + array[i]); // 输出数组元素 23. if ((i + 1) % 5 == 0) 24. System.out.println(); // 每5 个元素一行 25. } 26. } 27.} 数组递增排序 JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。 快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。 冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。 选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。 插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。 <1>利用Arrays带有的排序方法快速排序 import java.util.Arrays; publicclass Test2{ publicstaticvoid main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //进行排序 for(int i: a){ System.out.print(i); } } } <2>冒泡排序算法 publicstaticint[] bubbleSort(int[] args){//冒泡排序算法 for(int i=0;i /* 数组排序 */ public class BubbleSort { public static void main(String[] args){ int[] arr = {1,25,36,21,24,12,39,87}; System.out.println("排序前："); String str = array2string(arr); System.out.println(str); bubblesort(arr); System.out.println("排序后："); String str2 = array2string(arr); System.out.println(str2); } /*冒泡排序*/ public static void bubblesort(int[] arr){ for(int x=0;x 全排列一维数组.java 有时候,我们要对一个一维数组进行全排列,这个时候就要用到全排列的算法了,下面是一种全排列的算法.希望对你有用. public class全排列一维数组{ public static void main(String[] args){ String[]A={"1","2","3","4","5","6","7"}; String[][]B=quanpl(A);//创建一个二维数组存放A的全排列;并将数组A的第i种排列存放在二维数组B的第i行中 for(int i=0;i 一填空题 1)数组的元素通过来访问，数组Array的长度为。 2)数组复制时，"="将一个数组的传递给另一个数组。 3)没有显式引用变量的数组称为数组。 4)JVM将数组存储在 (堆或栈)中。 5)数组的二分查找法运用的前提条件是数组已经。 6)矩阵或表格一般用维数组表示。 7)如果把二维数组看成一维数组，那么数组的元素是数组。 8)Java中数组的下标的数据类型是。 9)不用下标变量就可以访问数组的方法是。 10)数组最小的下标是。 11)arraycopy()的最后一个参数指明。 12)向方法传递数组参数时，传递的是数组的。 13)线性查找法的平均查找长度为。 14)数组初始化包括。 15)数组下标访问超出索引范围时抛出异常 16)浮点型数组的默认值是。 17)对象型数组的默认值是。 18)对象类型的数组虽然被默认初始化，但是并没有构造函数。 19)二维数组的行的长度不同。 20)数组创建后其大小改变。 二选择题 1.下面错误的初始化语句是___ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e','l','l','o'}; D. char str[]={'hello'}; 2.定义了一维int型数组a[10]后，下面错误的引用是___ 3. A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 4.下面的二维数组初始化语句中，正确的是____ 5. A. float b[2][2]={,,,}; B. int a[][]={{1,2},{3,4}}; 6. C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 7.引用数组元素时，数组下标可以是____ 8. A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 9.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为____ A. 24 B. 25 C. 18 D. 17 10.下列初始化字符数组的语句中，正确的是____ 11.A. char str[5]="hello"; B. char str[]={'h','e','l','l','o','\0'}; 12.C. char str[5]={"hi"}; D. char str[100]=""; 本文由我司收集整编，推荐下载，如有疑问，请与我司联系 java 中数组常见的排序问题整理 2016/03/13 0 span > 1.选择排序：选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的 起始位置，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。 如图所示：数组array 有5 个元素 首先，array[0]与array[1]比较大小，如果array[0] array[1],则将两元素互换位置，然后再将array[0]与array[2]进行比较，一次进行下去，当第一轮循环完成，则 array[0]是数组中最小的元素。然后开始拿array[1]与array[2]进行比较，依次下去， 比较到最后即可。 程序代码实现如下： public void SelectionSort(int[] array){for(int i=0;i array.length-1;i++){for(int j=i+1;j array.length;j++){int temp;if(array[i] array[j]){temp = array[i];array[i]=array[j];array[j]=temp;}}}}2.冒泡排序：它重复地走访过要排序的数 列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作 是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。下面用一张图 来详细说明冒泡的原理。如图： 数组array 有五个元素，int[] array={7,5,12,9,2}; 第一步还是和选择排序一样，先是array[0]和array[1]进行比较，如果array[0] array[1],两个元素互换位置，即array[0]=5,array[1]=7；第二步，array[1]和array[2]进行比较大小，array[1] array[2],位置不变；第三步，array[2]和array[3]比较，array[2] array[3],位置互换；array[3]与array[4]比较，array[3] array[4],位置互换，第一轮循环结束，我们会发现，数组的最后一个元素是数组中最大的。第一轮循环完成后的数 组变成如下图所示： 接下来继续又从array[0]和array[1]开始比较，重复下去。第一轮比较得出了最 import java.util.Random; /** * * * 排序算法的分类如下： * 1.插入排序（直接插入排序、折半插入排序、希尔排序）； * 2.交换排序（冒泡泡排序、快速排序）； * 3.选择排序（直接选择排序、堆排序）； * 4.归并排序； * 5.基数排序。 * * 关于排序方法的选择： * (1)若n较小(如n≤50)，可采用直接插入或直接选择排序。 * 当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插人，应选直接选择排序为宜。 * (2)若文件初始状态基本有序(指正序)，则应选用直接插人、冒泡或随机的快速排序为宜； * (3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。 * * */ public class SortTest { /** * 初始化测试数组的方法 * @return 一个初始化好的数组 */ public int[] createArray() { Random random = new Random(); int[] array = new int[10]; for (int i = 0; i < 10; i++) { array[i] = random.nextInt(100) - random.nextInt(100);//生成两个随机数相减，保证生成的数中有负数 } System.out.println("-----------原始序列-----------------"); printArray(array); return array; } /** * 打印数组中的元素到控制台 * */ public void printArray(int[] source) { for (int i : source) { System.out.print(i + " "); } System.out.println(); } /** * 交换数组中指定的两元素的位置 * * * */ private void swap(int[] source, int x, int y) { int temp = source[x]; source[x] = source[y]; source[y] = temp; } /** * 冒泡排序----交换排序的一种 * 方法：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其他的数进行类似操作。 * 性能：比较次数O(n^2),n^2/2；交换次数O(n^2),n^2/4 * * @param source 要排序的数组 * @param sortType 排序类型 java排序算法大全 为了便于管理，先引入个基础类： package algorithms; public abstract class Sorter java排序123 为了便于管理，先引入个基础类： package algorithms; public abstract class Sorter Java在原数组中插入一个元素，并按升序排列 1.效果图 2.源代码 package LianXi; import java.util.Arrays; import java.util.Scanner; public class ChanRuYuanSu { /** @描述： * @方法名称：main---->shangji_3_p162_.java * @作者：Java - wangzhe * @创建日期：2016-6-26下午06:08:01 * @param args * @param args */ public static void main(String[] args) { Scanner input = new Scanner(System.in); //原数组 int num[]=new int[]{1,4,6,8}; //新建数组 int nums[]=new int [num.length+1]; //将原数组排序 Arrays.sort(num); //遍历原数组至新数组 for (int i = 0; i < num.length; i++) { nums[i]=num[i]; } //友好提示要插入的新数字 System.out.print("请输入您要插入的新数字："); //接受用户输入 int num1= input.nextInt(); //插入的数组在新数组中的下标 int index =num.length; //for循环遍历找到要插入数字的下标 for (int i = 0; i < nums.length; i++) { if (num1 public class Sort_Suan { /** *@param args *对数组进行排序冒泡排序、选择排序、插入排序、希尔排序、数组排序*五种排序的方法 */ public static void main(String[] args) { // TODO Auto-generated method stub int a[] = new int[7]; a[0]=12; a[1]=8; a[2]=5; a[3]=6; a[4]=9; a[5]=4; a[6]=11; int temp; System.out.print("这是原数组："); for(int n:a){ System.out.print("n="+n+" "); } /** *冒泡排序: *具体实现如下： **/ for(int mi=0;mi for(int xj=xi+1;xj 数组的重要性，在前面的文章中，已经详细介绍过；而排序又是对数据的处理，而我们非常清楚编写程序的目的，就是为了处理数据。并且在实际开发应用中排序也是很常见的应用。 因为是对前面章节的补充，所以概念我也就不写了，遇到数组概念懂的，看看前面的文章。 选择排序： 选择排序是最简单的排序算法，策略是搜索整个数组，比较相邻元素，如果两元素间的相对大小次序不对，则交换它们（这里我们会用到数组的下标来处理）其结果是最大值移动到数组的最后一个位置上，（这里会用到双层for循环来处理），然后第二遍遍历数组元素将第二大值移动到倒数第二个位置上，重复该过程，直到将所有位置移动到正确位置上。 看代码： import java.util.*; //这里会用到JDK里的类库，会用到数组中的几个方法 public class arrSort { public static void main(String[] args) { //首先定义数组,使用了静态初始化 // int [] arr = {12, 32, 45, 50, 2, 20}; //下面这个数组专门用于二分查找法案例的讲解 int[] arr = {12,32,34,57,89,100,108}; //把方法写完后，我们再回到这行文字 //下面输出未排序前的数组元素用到简洁foreach循环 for (int temp :arr) { System.out.print(" "temp); } //因为程序是从main方法开始逐行执行的 //所以我开始调用方法 selectSort(arr); //因为方法声明了static，所以可以在主方法中直接调用，并传入了一个数组 Java数组排序 学习目的：不是为了在工作中使用（这三个算法性能不高），而是为了练习for循环和数组 ? 在工作中Java API提供了现成的优化的排序方法，效率很高，以后工作中直接使用即可 ? 选择排序、冒泡排序、插入排序等排序算法在公司笔试题中会经常出现，所以是很有必要掌握的 选择排序原理： ? 将数组中每个元素与第一个元素比较，如果这个元素小于第一个元素，则交换这两个元素 ? 循环第1条规则，找出最小元素，放于第1个位置 ? 经过n-1轮比较完成排序 简单而言，每轮都找到最小的放到前面。例：{8 , 2 , 3 , 7 , 1}的排序过程如下所示： 数组：ary={8 , 2 , 3 , 7 , 1} 第1轮：ary={1 | 8 , 3 , 7 , 2} 第2轮：ary={1 , 2 | 8 , 7 , 3} 第3轮：ary={1 , 2 , 3 | 8 , 7} 第4轮：ary={1 , 2 , 3 , 7 | 8} 第5轮：ary={1 , 2 , 3 , 7 | 8} 过程分析: ? i 代表第一个数据的位置 ? j 代码后部每一个数据的位置 ary i j ary[i ] ary[j]ary[i]>ary[j][i]交换 [j]第1轮 {8|2,3,7,1} [0] [1] 8 2 true8<->2 {2|8,3,7,1} [0] [2] 2 3 false -- {2|8,3,7,1} [0] [3] 2 7 false -- {2|8,3,7,1} [0] [4] 2 1 true2<->1 {1,8|3,7,2} 第2轮 {1,8|3,7,2} [1] [2] 8 3 true8<->3 {1,3|8,7,2} [1] [3] 3 7 false -- {1,3|8,7,2}[1] [4] 3 2 true3<->2 {1,2,8|7,3} 第3轮 {1,2,8|7,3} [2] [3] 8 7 true8<->7 {1,2,7|8,3} [2] [4] 7 3 true7<->3 {1,2,3,8|7} 第4轮 {1,2,3,8|7} [3] [4] 8 7 true8<->7 {1,2,3,7|8} 第5轮 {1,2,3,7,8|} [4] -- 8 -- -- -- Java字符串数组排序运行效果图： 初始无序： 升序后： 降序后： 源码： import java.awt.EventQueue; import java.awt.GridBagConstraints; import java.awt.GridBagLayout; import java.awt.Insets; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.BoxLayout; import javax.swing.DefaultListModel; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JList; import javax.swing.JPanel; import javax.swing.JScrollPane; import javax.swing.UIManager; import javax.swing.border.EmptyBorder; import java.awt.Color; public class UserSort extends JFrame { private JPanel contentPane; private JList sourceList; private String[] names = new String[] { "lzw", "anti", "zzk", "lyf", "liuxin", "dongdayong", "gulili", "coolBoy", "newgirl", "myBoy", "redsky", "pankaihua", "blueBoy" }; Java数组排序总结(冒泡,选择,插入,希尔) public class SortAll { /** * 冒泡排序，选择排序，插入排序，希尔（Shell）排序 Java的实现 * 2008.11.09 * @author YangL. （https://www.doczj.com/doc/388311536.html,） */ public static void main(String[] args) { int[] i = { 1, 5, 6, 12, 4, 9, 3, 23, 39, 403, 596, 87 }; System.out.println("----冒泡排序的结果："); maoPao(i); System.out.println(); System.out.println("----选择排序的结果："); xuanZe(i); System.out.println(); System.out.println("----插入排序的结果："); chaRu(i); System.out.println(); System.out.println("----希尔（Shell）排序的结果："); shell(i); } // 冒泡排序 public static void maoPao(int[] x) { for (int i = 0; i < x.length; i++) { for (int j = i + 1; j < x.length; j++) { if (x[i] > x[j]) { int temp = x[i]; x[i] = x[j]; x[j] = temp; } } } for (int i : x) { System.out.print(i + " "); } } // 选择排序 public static void xuanZe(int[] x) { for (int i = 0; i < x.length; i++) { int lowerIndex = i; // 找出最小的一个索引 for (int j = i + 1; j < x.length; j++) { if (x[j] < x[lowerIndex]) { lowerIndex = j; } } // 交换 int temp = x[i]; x[i] = x[lowerIndex]; x[lowerIndex] = temp; } for (int i : x) { System.out.print(i + " "); } } // 插入排序 public static void chaRu(int[] x) { for (int i = 1; i < x.length; i++) {// i从一开始，因为第一个数已经是排好序的啦for (int j = i; j > 0; j--) { if (x[j] < x[j - 1]) { int temp = x[j]; x[j] = x[j - 1]; x[j - 1] = temp; } 数组与选择排序算法 一、概念 数组是一种数据结构，是用来存储同一数据类型的数值的集合。通过数组的下标可以访问数组的每一个元素。例如，整型数组a[i]用来存储整型数据，i就是下标。数组的下标是从0开始计数的。 在声明数组的时候，需要指明数组的数据类型和数组变量的名字。例如，下面就是声明整型数组的格式。 int a[]或int[]a 这条语句只是声明了数组，但是还没有对数组分配内存，即没有进行实例化。如果需要实例化，则必须使用new关键字。例如 int a[]=new int[100] 该语句声明了整型数组，且数组中可以存储100个整型数据。 只有对数组进行了实例化，才可以对数组的每个元素进行赋值。例如，a[3]=5，表示给数组的第4个元素赋值。 小技巧：可以使用循环给数组元素全部或部分元素赋值，例如： for(int i=0;i<=99;i++) a[i]=i; 注意1：如果试图访问元素a[100]，则发生数组越界的异常，显示信息的关键字为： array index out of bounds 注意2：Java中允许长度为0的数组的存在。例如在编写一个返回值为数组的方法时，如果返回值为为空，则允许返回长度（即数组元素）为0的数组。例如：new int[0] 二、数组的初始化即匿名数组 在Java中提供了一种创建数组并同时实例化的操作方式，这是一种数组实例化的简化形式。例如： int a[]={3,4,6,11,12} 用这种形式，还可以创建匿名数组，例如： new int[]{3,4,6,11,12} 用这种方式进行数组的实例化，数组元素的个数就是大括号中元素的个数。 小技巧：用这种方式可以在不增加变量名的情况下重新初始化一个数组。例如，下面的两种格式，效果是一样的。 格式一：传统的变量赋值格式 int a[],b[] a=new int[]{4,7,9,10,33}; b=a; 格式二：简化形式 int b[]; b=new int[]{4,7,9,10,33}; 三、for each循环与数组 从JDK5.0开始，引入了一种新的循环格式，即fo reach循环，这种循环常常与数组一起使用。下面是格式：Java数组练习题(带答案)
Java数组测习题(带答案)
JAVA数组的排序方法实例
JAVA中运用数组的四种排序方法
JAVA基础练习程序 数组冒泡排序
java全排列一维数组
java数组练习题目
java中数组常见的排序问题整理
java各种数组排序(插入,交换,选择,归类,基数排序)
java排序算法大全
java排序123
Java在原数组中插入一个元素,并按升序排列
java类实现数组的冒泡选择插入希尔等五种排序
对JAVA数组排序的补充
Java数组排序
Java字符串数组排序
Java数组排序总结(冒泡,选择,插入,希尔) 递归算法的复杂度
JAVA数组入门与选择排序算法讲义
相关主题
文本预览